开发者

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

开发者 https://www.devze.com 2022-12-01 12:55 出处:网络 作者: 网络整理
目录1.列表1.1复制1.2列表的底层实现-浅拷贝1.3浅拷贝-示例1.新增元素2.修改元素3.列表型元素4.元组型元素5.字典型元素6.小结1.4列表的底层实现-深...
目录
  • 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. 是否可变
            • 不可变类型:数字,字符串,元组
              • 可变类型:列表,字典,集合
              • 总结

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

                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 也有同样的变化

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

                1.2 列表的底层实现 - 浅拷贝

                通过 引用数组 实现列表元素的存储

                列表中存储的并不是我们看到的元素的值,而是这些元素的地址

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

                当访问到列表的某个元素时,是按照列表中存储的元素地址去找到元素的值

                直接赋值,是完完全全的没改变原列表的任何内容,就是原来的列表多了一个别名。

                浅拷贝,确实是把列表拷贝了一份,也就是把列表中存储的地址全部拷贝了一份给新列表,新列表拥有一份独立的地址信息。但这些地址指向的元素和原列表是同一份元素。总结,浅拷贝只是把地址重新拷贝了一份,他们指向的内容还是同一份内容。

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

                1.3 浅拷贝 - 示例

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

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

                1. 新增元素

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

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

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

                2. 修改元素

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

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

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

                3. 列表型元素

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

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

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

                4. 元组型元素

                元组是不可变的!!! 一旦改变了,就不再是这个元组了,而是一个新的元组。

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

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

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

                5. 字典型元素

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

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

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

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

                6. 小结

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

                编程客栈元组,数字,字符串类型的元素,一旦内容发生变化,那么地址也必须变化。

                浅拷贝之后,针对不可变元素(元组,数字,字符串)的操作都生效了

                针对可变元素(列表,字典)的操作,则发生了一些混淆。

                当列表中出现了可变类型的元素,我们想对列表进行一个安全的复制,使得能够独立操作而不影响原列表,那么就不能浅拷贝,而是需要深拷贝。

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

                copy.deepcopy()

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

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

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

                2. 字典

                2.1 快速查找

                慢 - 列表的查找

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

                快 - 字典的查找

                import time
                
                d = {i:i for i in range(1000000)}
                ls_2 = list(range(500)) + [-10]*500
                
                start = time.time()
                count = 0
                for n in ls_2:
                	try:
                		d[n]
                    except:
                    	pass
                    else:
                    	countwww.cppcns.com += 1
                end = 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.根据计算的散列值确定其在散列表中的位置(个别时候有哈希冲突,seHrBnk解决办法是开放寻址法 或 链接法 )

                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"))
                # 
                

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

                2. 字典的访问过程

                1.计算要访问的键的散列值

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

                3.读取该位置上存储的值(存在则返回该值,不存在则报错 KeyError)

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

                2.3 小结

                字典数据类型,以空间换时间,内存占用大,空间利用率低,但查找速度快(稀疏数组 N >> n,否则会产生很多冲突,另外动态扩充也是)因为键在字典中显示的顺序,与实际计算出来的它在散列表中的存放位置,是两码事,因此字典表现为无序的

                之前专门写过 —— Python字典及底层哈希

                3. 字符串

                通过紧凑数组 实现字符串的存储

                字符串数据在内存中是连续存放的,空间利用率高

                原因是:每个字符的大小是固定的,因此一个字编程客栈符串的大小也是固定的,可以分配一个固定大小的空间给字符串。

                同为序列类型,为什么列表采用引用数组,而字符串采用紧凑数据

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

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

                4. 是否可变

                不可变类型:数字,字符串,元组

                (元组并不总是不可变的,元组内存储的元素也必须同时是不可变类型,否则该元组属于可变)

                在生命周期内保持内容不变,一旦内容变了,就不再是它了( id / 地址也变了)

                不可变对象的 += 扩充操作,实际上是创建了一个新的对象。

                x = 1
                print("x id:", id(x))
                # x id: 1407184...
                x += 2
                print("x id:", id(x))
                # x id: 204099...
                

                可变类型:列表,字典,集合

                id (地址)不变的情况下,里面的内容可以改变

                可变对象的 += 操作,实际是在原对象的基础上直接修改

                ls = [1,2,3]
                print("ls id:", id(ls))
                # ls id: 2040991750856
                ls += [4,5]
                print("ls id:", id(ls))
                # ls id: 2040991750856
                

                总结

                本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

                0

                精彩评论

                暂无评论...
                验证码 换一张
                取 消

                关注公众号