Python3 -- 第二章 基本数据类型

标准数据类型

Python3 中常见的数据类型有：

• Number（数字）
• String（字符串）
• bool（布尔类型）
• List（列表）
• Tuple（元组）
• Set（集合）
• Dictionary（字典）

Python3 的六个标准数据类型中：
不可变数据（3 个 ）：Number（数字）、String（字符串）、Tuple（元组）；
可变数据（3 个）：List（列表）、Dictionary（字典）、Set（集合）。

Number（数字）

Python 3 支持以下几种数字类型：
1. 整数（int）

特点：

表示任意大小的整数，无长度限制，支持正负数和零

可以用十进制、二进制（0b 前缀）、八进制（0o 前缀）或十六进制（0x 前缀）表示

x = 100          # 十进制
y = -256         # 负数
z = 0            # 零
bin_num = 0b1010  # 二进制（等于十进制 10）
oct_num = 0o12    # 八进制（等于十进制 10）
hex_num = 0xA     # 十六进制（等于十进制 10）

print(bin_num == oct_num == hex_num)  # 输出: True

2. 浮点数（float）

特点：

表示带有小数点的数值，也可以用科学计数法（e 或 E 表示 10 的幂）表示

浮点数的精度有限，可能存在舍入误差

a = 3.14       # 标准写法
b = -0.005     # 负数
c = 2.5e3      # 科学计数法（2.5 × 10³ = 2500.0）
d = 1.23e-4    # 科学计数法（1.23 × 10⁻⁴ = 0.000123）

# 浮点数精度问题
print(0.1 + 0.2)  # 输出: 0.30000000000000004（舍入误差）

3. 复数（complex）

特点：

由实部和虚部组成，虚部以 j 或 J 结尾

可以使用 complex(real, imag) 函数创建，或直接用 a+bj 表示

z1 = 3 + 4j       # 实部 3，虚部 4
z2 = complex(1, -2)  # 实部 1，虚部 -2
z3 = 2j           # 实部 0，虚部 2

# 访问实部和虚部
print(z1.real)    # 输出: 3.0
print(z1.imag)    # 输出: 4.0

# 复数运算
print(z1 + z2)    # 输出: (4+2j)

4. 布尔类型（bool）

特点：

布尔类型是特殊的整数类型，True 等价于 1，False 等价于 0

常用于条件判断和逻辑运算

x = True
y = False

print(int(x))     # 输出: 1
print(int(y))     # 输出: 0

print(3 > 2)      # 输出: True
print(3 + True)   # 输出: 4（3 + 1）

String（字符串）

1. 基础定义

用 '单引号'、"双引号" 或 '''三引号''' 包裹文本

三引号支持多行字符串

s1 = 'Hello'
s2 = """多行
字符串"""

2. 不可变性

不能直接修改字符串，操作会生成新字符串

s = "Hi"
s = s + "!"  # 创建新字符串 "Hi!"

3. 索引与切片

索引：从 0 开始，负数表示从后往前

s = "Python"
print(s[0])   # 'P'
print(s[-1])  # 'n'

切片：[开始:结束:步长]（结束位置不包含）

print(s[0:2])  # 'Py'
print(s[::-1]) # 反转：'nohtyP'

4. 常用操作

操作	示例	结果
拼接	"a" + "b"	"ab"
重复	"a"	"aaa"
成员判断	"e" in "hello"	True
长度	len("abc")	3

5. 常用方法

方法	作用	示例
upper()	转大写	"hi".upper() → "HI"
lower()	转小写	"HI".lower() → "hi"
strip()	去除首尾空白	" a ".strip() → "a"
replace(a,b)	替换子串	"hi".replace("h", "H") → "Hi"
split(sep)	按分隔符分割成列表	"a,b,c".split(",") → ["a","b","c"]
join(lst)	用字符串连接列表元素	"-".join(["a","b"]) → "a-b"
find(sub)	查找子串位置（不存在返回 -1）	"hi".find("i") → 1
count(sub)	统计子串出现次数	"hi".count("h") → 1

List（列表）

List（列表） 是 Python 中使用最频繁的数据类型。

列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串甚至可以包含列表（所谓嵌套）。

列表是写在方括号 [] 之间、用逗号分隔开的元素列表。

和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

1. 基础定义

用 [] 定义，元素用逗号分隔，可包含不同类型。

lst = [1, "apple", True]

2. 特点

可变：可修改、添加、删除元素。

有序：元素有固定位置（索引）。

可重复：允许存在相同元素。

3. 索引与切片

索引：从 0 开始，负数表示从后往前。

lst = [10, 20, 30]
print(lst[0])   # 10
print(lst[-1])  # 30

切片：[开始:结束:步长]（结束位置不包含）。

print(lst[1:3])  # [20, 30]
print(lst[::-1]) # 反转：[30, 20, 10]

4. 常用操作

操作	示例	结果
拼接	[1,2] + [3]	[1, 2, 3]
重复	[1] * 3	[1, 1, 1]
成员判断	2 in [1,2,3]	True
长度	len([1,2,3])	3

注意：

1、列表写在方括号之间，元素用逗号隔开。

2、和字符串一样，列表可以被索引和切片。

3、列表可以使用 + 操作符进行拼接。

4、列表中的元素是可以改变的。

Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 () 里，元素之间用逗号隔开
1. 基础定义

用 () 定义，元素用逗号分隔，可包含不同类型。

t = (1, "apple", True)

特殊情况：单元素元组需加逗号。

single = (1,)  # 必须加逗号！

2. 特点

不可变：创建后不能修改（增删改元素）。

有序：元素有固定位置（索引）。

可重复：允许存在相同元素。

3. 索引与切片

索引：从 0 开始，负数表示从后往前。

t = (10, 20, 30)
print(t[0])   # 10
print(t[-1])  # 30

切片：[开始:结束:步长]（结束位置不包含）。

print(t[1:3])  # (20, 30)
print(t[::-1]) # 反转：(30, 20, 10)

4. 常用操作

操作	示例	结果
拼接	(1,2) + (3,)	(1, 2, 3)
重复		(1,) * 3
成员判断	2 in (1,2,3)	True
长度	len((1,2,3))	3

5. 常用方法

方法	作用	示例
count(x)	统计 x 出现的次数	(1,2,2).count(2) → 2
index(x)	返回第一个 x 的索引	(1,2,3).index(2) → 1

6. 元组的不可变性

不能修改元素，但可以重新赋值整个元组：

t = (1, 2)
#t[0] = 100  ❌ 报错！
t = (100, 2)  ✅ 允许！

注意：

1、与字符串一样，元组的元素不能修改。

2、元组也可以被索引和切片，方法一样。

3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。

4、元组也可以使用 + 操作符进行拼接。

Set（集合）

Python 中的集合（Set）是一种无序、可变的数据类型，用于存储唯一的元素。

集合中的元素不会重复，并且可以进行交集、并集、差集等常见的集合操作。

在 Python 中，集合使用大括号 {} 表示，元素之间用逗号 , 分隔。

另外，也可以使用 set() 函数创建集合。

注意：创建一个空集合必须用 set() 而不是 { }，因为 { } 是用来创建一个空字典。

parame = {value01,value02,...}

或者

set(value)

#!/usr/bin/python3

sites = {'Google', 'Taobao', 'Runoob', 'Facebook', 'Zhihu', 'Baidu'}
print(sites)   # 输出集合，重复的元素被自动去掉

# 成员测试
if 'Runoob' in sites :
    print('Runoob 在集合中')
else :
    print('Runoob 不在集合中')


# set可以进行集合运算
a = set('abracadabra')
b = set('alacazam')

print(a)
print(a - b)     # a 和 b 的差集
print(a | b)     # a 和 b 的并集
print(a & b)     # a 和 b 的交集
print(a ^ b)     # a 和 b 中不同时存在的元素

1. 基础定义

用 {} 或 set() 定义，元素必须唯一且不可变（如数字、字符串、元组）。

s = {1, 2, 3}         # 直接创建集合
s = set([1, 2, 2, 3]) # 从列表创建（自动去重）→ {1, 2, 3}

空集合必须用 set()，因为 {} 表示空字典。

2. 特点

无序：不支持索引和切片。

元素唯一：自动去重。

可变：可以添加 / 删除元素。

3. 基本操作

操作	示例	结果
添加元素	s.add(4)	{1, 2, 3, 4}
添加多个元素	s.update([4, 5])	{1, 2, 3, 4, 5}
删除元素	s.remove(3) {1, 2}	（不存在则报错）
安全删除	s.discard(3)	不存在不报错
随机删除	s.pop()	随机删除并返回一个元素
清空集合	s.clear()	set()

Dictionary（字典）

字典（dictionary）是Python中另一个非常有用的内置数据类型。

列表是有序的对象集合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。

字典是一种映射类型，字典用 { } 标识，它是一个无序的 键(key) : 值(value) 的集合。

键(key)必须使用不可变类型。

在同一个字典中，键(key)必须是唯一的。
1. 基础定义

用 {} 定义，由 键值对（key: value） 组成，键必须唯一。

d = {
    "name": "Alice",
    "age": 25,
    "hobbies": ["reading", "coding"]
}

2. 特点

无序：3.7+ 版本后保留插入顺序，但不支持索引。

键不可变：键必须是不可变类型（如字符串、数字、元组）。

值可变：值可以是任意类型。

3. 访问值

通过键获取值，键不存在时会报错。

print(d["name"])  # "Alice"
 print(d["city"])  ❌ 报错：KeyError

安全方法：使用 get()，不存在时返回默认值。

print(d.get("city", "Unknown"))  # "Unknown"

注意：

1、字典是一种映射类型，它的元素是键值对。

2、字典的关键字必须为不可变类型，且不能重复。

3、创建空字典使用 { }。