Python3 基本数据类型详解
在 Python3 中，基本数据类型是构建复杂程序的基石。理解这些类型的特性、操作及适用场景，对写出高效且健壮的代码至关重要。本文将从底层原理到实战技巧，深入解析 Python3 的核心数据类型。
一、不可变数据类型
1. 数值类型（Number）
Python 支持四种数值类型：
int、float、complex 和 bool。整数（int）：
- 任意大小，不受位数限制（仅受内存限制）。
- 支持二进制（
0b）、八进制（0o）、十六进制（0x）表示。
a = 100 # 十进制
b = 0b1010 # 二进制，等于 10
c = 0o12 # 八进制，等于 10
d = 0xA # 十六进制，等于 10
print(type(a)) # <class 'int'>
浮点数（float）：
- 双精度 64 位（遵循 IEEE 754 标准）。
- 注意精度问题：
a = 0.1 + 0.2
print(a) # 输出 0.30000000000000004
print(a == 0.3) # False
解决方案：使用
decimal 模块或设置精度阈值：from decimal import Decimal
a = Decimal('0.1') + Decimal('0.2')
print(a) # 输出 0.3
print(a == Decimal('0.3')) # True
复数（complex）：
z = 3 + 4j
print(z.real) # 实部：3.0
print(z.imag) # 虚部：4.0
print(z.conjugate()) # 共轭复数：(3-4j)布尔（bool）：
- 仅两个值：
True和False。 - 本质是
int的子类，True等于 1，False等于 0。
print(True + 1) # 输出 2
print(isinstance(True, int)) # True
2. 字符串（str）
- 不可变序列，使用单引号、双引号或三引号定义。
- 支持切片、拼接、格式化等操作。
常用操作：
s = "Hello, Python!"
print(s[0]) # 'H'
print(s[-1]) # '!'
print(s[2:5]) # 'llo'（切片：左闭右开）
print(s.upper()) # 'HELLO, PYTHON!'
print(s.replace('Python', 'World')) # 'Hello, World!'
print('Python' in s) # True
# 字符串格式化
name = "Alice"
age = 30
print(f"{name} is {age} years old.") # f-string（Python 3.6+）
print("{} is {} years old.".format(name, age)) # format 方法
print("%s is %d years old." % (name, age)) # % 格式化
原始字符串（Raw String）：
path = r'C:\Users\Admin' # 原始字符串，反斜杠不转义
print(path) # 'C:\Users\Admin'
3. 元组（tuple）
- 不可变序列，使用小括号定义。
- 适用于存储不可变数据集合（如坐标、配置项）。
特性与操作：
t = (1, 'a', True)
print(t[1]) # 'a'
# t[1] = 'b' # 报错：元组不可变
# 单元素元组需加逗号
single = (1,)
print(type(single)) # <class 'tuple'>
# 元组解包
x, y = (10, 20)
print(x, y) # 10 20
二、可变数据类型
1. 列表（list）
- 可变序列，使用方括号定义。
- 支持动态扩容、嵌套、各种高效操作。
常用操作：
lst = [1, 2, 3, 'a']
lst.append(4) # [1, 2, 3, 'a', 4]
lst.insert(1, 'b') # [1, 'b', 2, 3, 'a', 4]
lst.pop() # 弹出最后一个元素，返回 4
lst.remove('a') # 移除第一个 'a'
print(lst.index(2)) # 返回元素 2 的索引：2
print(lst.count(2)) # 统计元素 2 的出现次数：1
# 列表切片
print(lst[1:3]) # ['b', 2]
print(lst[::-1]) # 反转列表：[2, 'b', 1]
# 列表推导式
squares = [x**2 for x in range(5)] # [0, 1, 4, 9, 16]
2. 字典（dict）
- 键值对映射，使用花括号定义。
- 键必须是不可变类型（如字符串、数字、元组），值可以是任意类型。
特性与操作：
d = {'name': 'Alice', 'age': 30}
print(d['name']) # 'Alice'
print(d.get('city', 'Beijing')) # 获取键值，不存在时返回默认值
d['age'] = 31 # 修改值
d['gender'] = 'Female' # 添加新键值对
del d['age'] # 删除键值对
print('name' in d) # 检查键是否存在：True
# 遍历字典
for key in d: # 遍历键
print(key, d[key])
for key, value in d.items(): # 遍历键值对
print(key, value)
# 字典推导式
squares = {x: x**2 for x in range(3)} # {0: 0, 1: 1, 2: 4}
3. 集合（set）
- 无序、唯一元素集合，使用花括号或
set()定义。 - 支持交集、并集、差集等数学运算。
常用操作：
s = {1, 2, 3, 3} # 自动去重，结果为 {1, 2, 3}
s.add(4) # 添加元素
s.remove(2) # 移除元素，不存在时报错
s.discard(5) # 移除元素，不存在时不报错
print(3 in s) # 检查元素是否存在：True
# 集合运算
a = {1, 2, 3}
b = {3, 4, 5}
print(a & b) # 交集：{3}
print(a | b) # 并集：{1, 2, 3, 4, 5}
print(a - b) # 差集：{1, 2}
print(a ^ b) # 对称差集：{1, 2, 4, 5}
# 集合推导式
evens = {x for x in range(10) if x % 2 == 0} # {0, 2, 4, 6, 8}
三、类型转换与常用方法
1. 类型转换
# 数值转换
int('123') # 123
float('3.14') # 3.14
complex(1, 2) # (1+2j)
# 序列转换
list('abc') # ['a', 'b', 'c']
tuple([1, 2, 3]) # (1, 2, 3)
set([1, 2, 2, 3]) # {1, 2, 3}
# 字典转换
dict([('a', 1), ('b', 2)]) # {'a': 1, 'b': 2}
2. 常用内置函数
# 长度
len('hello') # 5
len([1, 2, 3]) # 3
len({'a': 1}) # 1
# 最大值/最小值
max([1, 5, 3]) # 5
min('abc') # 'a'
# 求和
sum([1, 2, 3]) # 6
# 排序
sorted([3, 1, 2]) # [1, 2, 3]（返回新列表）
四、性能对比与最佳实践
1. 列表 vs 元组
| 特性 | 列表（list） | 元组（tuple） |
|---|---|---|
| 可变性 | 可变 | 不可变 |
| 内存占用 | 较高（需动态扩容） | 较低（固定大小） |
| 访问速度 | 略慢 | 略快 |
| 适用场景 | 动态数据、频繁修改 | 静态数据、配置项 |
性能测试：
import timeit
# 创建列表 vs 元组
list_time = timeit.timeit('[1, 2, 3]', number=1000000)
tuple_time = timeit.timeit('(1, 2, 3)', number=1000000)
print(f"列表创建时间: {list_time:.6f}s") # 约 0.08s
print(f"元组创建时间: {tuple_time:.6f}s") # 约 0.02s（快 4 倍）
2. 集合 vs 列表
- 成员检查效率：集合（O (1)）远高于列表（O (n)）。
# 测试成员检查速度
lst = list(range(10000))
s = set(range(10000))
# 检查元素 9999 是否存在
list_time = timeit.timeit('9999 in lst', setup='from __main__ import lst', number=10000)
set_time = timeit.timeit('9999 in s', setup='from __main__ import s', number=10000)
print(f"列表成员检查时间: {list_time:.6f}s") # 约 0.01s
print(f"集合成员检查时间: {set_time:.6f}s") # 约 0.0001s（快 100 倍）
五、常见误区与解决方案
1. 字符串拼接性能问题
- 错误做法：循环中使用
+拼接字符串（每次生成新对象）。
# 低效
result = ''
for i in range(1000):
result += str(i) # 每次循环创建新字符串
# 高效
result = ''.join([str(i) for i in range(1000)]) # 一次性拼接
2. 字典键不可变限制
- 错误做法：使用列表作为字典键。
# 报错：TypeError: unhashable type: 'list'
d = {[1, 2]: 'value'} # 错误
# 正确：使用元组
d = {(1, 2): 'value'} # 正确
3. 浮点数精度陷阱
- 问题：
0.1 + 0.2 != 0.3。 - 解决方案：
# 方案1：设置精度阈值 a = 0.1 + 0.2 print(abs(a - 0.3) < 1e-9) # True # 方案2：使用 decimal 模块 from decimal import Decimal a = Decimal('0.1') + Decimal('0.2') print(a == Decimal('0.3')) # True
六、总结
Python3 的基本数据类型设计兼顾了灵活性与性能：
- 不可变类型（数值、字符串、元组）适合存储常量和配置，避免意外修改。
- 可变类型（列表、字典、集合）支持动态操作，适用于数据处理和状态管理。
- 性能优化：优先使用集合进行成员检查，避免字符串循环拼接，利用推导式提高代码简洁度。
掌握这些数据类型的核心特性，能帮助开发者在编写代码时做出更合理的选择，从而提升程序的健壮性和执行效率。
浙公网安备 33010602011771号