一篇文章教你掌握python数据类型的底层实现一篇文章教你掌握python数据类

1. 列表

1.1 复制
1.2 列表的底层实现 - 浅拷贝
1.3 浅拷贝 - 示例

1. 新增元素
2. 修改元素
3. 列表型元素
4. 元组型元素
5. 字典型元素
6. 小结

1.4 列表的底层实现 - 深拷贝

2. 字典

2.1 快速查找

2.2 字典的底层实现

1. 字典的创建过程
2. 字典的访问过程

2.3 小结

3. 字符串

4. 是否可变

不可变类型：数字，字符串，元组

可变类型：列表，字典，集合

总结

文章图片

1. 列表
1.1 复制
浅拷贝

list_1 = [1, [22, 33, 44], (5, 6, 7), {"name":"Alina"}]list_3 = list_1## 错误！！只是换了别名list_2 = list_1.copy() ## 浅拷贝##或者也可这样实现 ## list_1[:]## list(list_1)

对拷贝前后两个列表分别进行操作

list_2[1].append(55)print("list_1: ", list_1)print("list_2: ", list_2)

发现虽然浅拷贝了，但修改 list_2 的某些元素时，相应的 list_1 也有同样的变化

文章图片

1.2 列表的底层实现 - 浅拷贝
通过引用数组实现列表元素的存储
【一篇文章教你掌握python数据类型的底层实现】列表中存储的并不是我们看到的元素的值，而是这些元素的地址

列表所谓的连续，是在内存中连续存储元素的地址，而元素的值是在内存中分散存储的

当访问到列表的某个元素时，是按照列表中存储的元素地址去找到元素的值
直接赋值，是完完全全的没改变原列表的任何内容，就是原来的列表多了一个别名。
浅拷贝，确实是把列表拷贝了一份，也就是把列表中存储的地址全部拷贝了一份给新列表，新列表拥有一份独立的地址信息。但这些地址指向的元素和原列表是同一份元素。总结，浅拷贝只是把地址重新拷贝了一份，他们指向的内容还是同一份内容。

文章图片

1.3 浅拷贝 - 示例

文章图片

文章图片

1. 新增元素

文章图片

新增元素时，list_1 列表中新存储了一个指向元素100的地址，list_2 列表中新增了一个指向元素 ‘n' 的地址，因此互不影响。

文章图片

2. 修改元素当我们对 list_1[0]重新赋值的时候，实际是把这里原来存储的指向元素1的地址，替换成了另一个地址——指向元素10的地址，下次我们去list_1[0] 找元素的时候，会直接找到元素10，而不会再和原来的元素1有任何联系。同样的，list_2[0] 存放的地址换成了元素20的地址。

文章图片

文章图片

3. 列表型元素

文章图片

list_1[1] 和 list_2[1] 存放了同一个地址列表，这个地址列表指向的也是同一批列表元素，所以修改 list_1[1]和list_2[1]的时候，都是对这批列表元素进行修改，是同时更新的。

文章图片

4. 元组型元素元组是不可变的！！！一旦改变了，就不再是这个元组了，而是一个新的元组。

所以要对元组执行操作，都是先产生一个新元组，再在新元组上执行相应操作。在这里就是先产生了一个新的地址元组（元组内存储了元素地址），再对新元组进行修改。

文章图片

文章图片

5. 字典型元素对 list_1里的字典元素，增加一个键值对，发现 list_2 里的字典元素也增加了键值对。

和列表型元素类似，在对列表型元素操作时，地址列表本身是不变的，我们对于地址列表的内容进行操作。

在对字典型元素操作时，字典散列表本身也是不变的，我们对于字典散列表的内容进行操作，按照新增的键找到对应位置，把新增的值存进去，这个新增值的存放位置，是由字典的键决定的。

文章图片

6. 小结列表，字典类型的元素，都是可变的，可以在地址不变的情况下改变内容。

而元组，数字，字符串类型的元素，一旦内容发生变化，那么地址也必须变化。
浅拷贝之后，针对不可变元素（元组，数字，字符串）的操作都生效了

针对可变元素（列表，字典）的操作，则发生了一些混淆。
当列表中出现了可变类型的元素，我们想对列表进行一个安全的复制，使得能够独立操作而不影响原列表，那么就不能浅拷贝，而是需要深拷贝。

1.4 列表的底层实现 - 深拷贝
copy.deepcopy()

深拷贝将所有层级的相关元素全部完全的复制，避免了上述的混淆问题。

文章图片

文章图片

2. 字典
2.1 快速查找
慢 - 列表的查找

import timels_1 = list(range(1000000))ls_2 = list(range(500)) + [-10]*500start = time.time()count = 0for n in ls_2: if n in ls_1:count += 1end = time.time()print("查找{}个元素，在ls_1中有{}个，共用时{}秒".format(len(ls_2), count, round(end-start)))) # 查找1000个元素，在ls_1中有500个，共用时6.19秒

快 - 字典的查找

import timed = {i:i for i in range(1000000)}ls_2 = list(range(500)) + [-10]*500start = time.time()count = 0for n in ls_2: try:d[n]except:passelse:count += 1end = time.time()print("查找{}个元素，在ls_1中有{}个，共用时{}秒".format(len(ls_2), count, round(end-start)))# 查找1000个元素，在ls_1中有500个，共用时0秒

2.2 字典的底层实现
通过稀疏数组实现值的存储与访问

1. 字典的创建过程 1.创建一个散列表（稀疏数组，N >>n，可以动态扩充）

2.通过hash()计算键的散列值

3.根据计算的散列值确定其在散列表中的位置（个别时候有哈希冲突，解决办法是开放寻址法或链接法）

4.在该位置上存入值

d = {}# d = dict() print(hash("python"))print(hash(1024))print(hash(1.2))# -477104656440599764...# 1024# 3713081631934410656...d["age"] = 18#增加键值对之前，首先计算键的散列值hash("age")print(hash("age"))#

文章图片

2. 字典的访问过程 1.计算要访问的键的散列值

2.根据计算的散列值，按照一定的规则，确定其在散列表中的位置

3.读取该位置上存储的值（存在则返回该值，不存在则报错 KeyError）

d["age"]#访问键值对之前，首先计算键的散列值hash("age")

2.3 小结
字典数据类型，以空间换时间，内存占用大，空间利用率低，但查找速度快（稀疏数组 N >> n，否则会产生很多冲突，另外动态扩充也是）因为键在字典中显示的顺序，与实际计算出来的它在散列表中的存放位置，是两码事，因此字典表现为无序的
之前专门写过 —— Python字典及底层哈希

3. 字符串通过紧凑数组实现字符串的存储
字符串数据在内存中是连续存放的，空间利用率高
原因是：每个字符的大小是固定的，因此一个字符串的大小也是固定的，可以分配一个固定大小的空间给字符串。
同为序列类型，为什么列表采用引用数组，而字符串采用紧凑数据

虽然同为序列类型，但列表可以存储的元素类型是多种多样的，并且列表是可变的，无法预估内存空间，所以列表不能通过紧凑数组。