Python 的基本数据类型与它们之间的关系

在学习 Python 时经常会接触各种“数据类型”：
int、float、str、list、dict、set ……
但这些类型之间到底有什么关系？哪些是可变的？哪些是不可变的？
它们又是如何在内存中存储和引用的？
本文将带你系统地梳理 Python 的基本数据类型体系结构，从类型分类、内存机制到相互关系，一文搞清。

---

---

一、Python 的一切皆对象（Everything is an Object）

Python 是一种面向对象的语言。
这意味着：无论是数字、字符串还是函数，本质上都是对象（object）。

x = 10
print(type(x))  # <class 'int'>s = "hello"
print(type(s))  # <class 'str'>

在 Python 中，每个对象都包含三部分信息：

属性	说明
id	对象在内存中的唯一标识（类似地址）
type	对象的类型（定义了它能做什么）
value	对象实际存储的值

---

二、Python 的主要数据类型分类

Python 的内置数据类型可以按照功能或可变性来分类。

🔹 1. 数值类型（Numeric Types）

类型	说明	示例
int	整数类型	10, -3, 0
float	浮点数类型	3.14, -0.5
complex	复数类型	3 + 4j

a = 5
b = 2.3
c = 1 + 2j

这些类型都属于不可变类型。
对它们的任何修改操作（如 a += 1）都会创建新对象。

---

🔹 2. 布尔类型（Boolean Type）

类型	说明	示例
bool	表示逻辑真值	True, False

布尔值其实是 int 的子类：

print(isinstance(True, int))  # True
print(True + True)  # 2

💡 True 的值等价于 1，False 等价于 0。

---

🔹 3. 字符串类型（String Type）

类型	说明	示例
str	文本字符串	'hello', "world"

字符串是不可变对象。
任何修改操作都会生成新字符串：

s = "hello"
print(id(s))
s += " world"
print(id(s))  # ID 不同，新对象

---

🔹 4. 序列类型（Sequence Types）

序列是有序的元素集合。包括：

类型	可变性	示例
list	✅ 可变	[1, 2, 3]
tuple	❌ 不可变	(1, 2, 3)
range	❌ 不可变	range(0, 10)

这些类型都有索引、切片、迭代等共同特征：

lst = [10, 20, 30]
print(lst[0])     # 10
print(lst[1:])    # [20, 30]
for x in lst: print(x)

---

🔹 5. 集合类型（Set Types）

类型	可变性	示例
set	✅ 可变	{1, 2, 3}
frozenset	❌ 不可变	frozenset({1, 2, 3})

集合类型是无序、去重的元素集合，用于数学运算：

a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)  # 并集 {1, 2, 3, 4, 5}
print(a & b)  # 交集 {3}

---

🔹 6. 映射类型（Mapping Type）

类型	可变性	示例
dict	✅ 可变	{'name': 'Alice', 'age': 25}

字典以“键值对”形式存储数据，是 Python 中最常用的数据结构之一。

person = {'name': 'Alice', 'age': 25}
print(person['name'])  # Alice

从 Python 3.7 开始，dict 默认保持插入顺序。关于插入顺序这一块，具体可参考理解 Python 的有序字典 OrderedDict-CSDN博客

---

三、可变对象 vs 不可变对象

在 Python 中，数据类型可以按照是否支持原地修改（in-place modification）分为两类：

分类	类型举例	是否可原地修改	常见操作效果
不可变对象	int, float, str, tuple, frozenset	❌ 否	创建新对象
可变对象	list, dict, set, bytearray	✅ 是	原地修改

示例对比：

# 不可变类型
x = 10
print(id(x))
x += 1
print(id(x))  # 变化，创建新对象# 可变类型
lst = [1, 2]
print(id(lst))
lst.append(3)
print(id(lst))  # 不变，原地修改

关于原地操作有关知识点，可参考Python 原地操作与重新赋值的区别：对比 x += 1 与 x = x +1-CSDN博客

---

四、对象引用与共享

在 Python 中，变量本质上是对象的“标签”，而不是容器。
多个变量可以指向同一个对象。

a = [1, 2, 3]
b = a
a.append(4)
print(b)  # [1, 2, 3, 4]

两者 id(a) == id(b)，说明它们引用了同一块内存。

若要复制出独立对象，需要使用：

• copy()（浅拷贝）
• deepcopy()（深拷贝）

关于Python中深拷贝与浅拷贝问题，可参考深入理解 Python 的 copy() 函数：浅拷贝与深拷贝详解-CSDN博客

---

五、类型层级与继承关系

Python 的类型系统是一个类的层级体系。
所有类型都继承自 object：

object├── int├── float├── bool├── str├── tuple├── list├── dict├── set├── frozenset└── complex

验证：

print(isinstance(10, object))     # True
print(isinstance("hello", object))# True
print(isinstance([1,2,3], object))# True

✅ 一切皆对象（Everything is an Object） 并不是一句口号，而是 Python 运行机制的根基。

---

六、类型之间的相互关系与转换

Python 提供了灵活的类型转换函数：

转换函数	示例	结果
int()	int(3.14)	3
float()	float('2.5')	2.5
str()	str(123)	'123'
list()	list('abc')	['a', 'b', 'c']
tuple()	tuple([1,2,3])	(1, 2, 3)
set()	set([1,2,2,3])	{1, 2, 3}
dict()	dict([('a', 1), ('b', 2)])	{'a': 1, 'b': 2}

这些函数底层都是调用各类型的构造函数（如 list.__init__()）。

---

七、数据类型与内存模型

Python 采用引用计数机制 + 垃圾回收（GC） 管理内存。

• 每个对象都维护一个引用计数；
• 当计数归零时，对象自动销毁；
• 可变对象在原地修改时不会改变引用；
• 不可变对象在“修改”时会创建新对象。

import sys
a = 1000
b = a
print(sys.getrefcount(a))  # 查看引用次数