python学习10.18：深刻底层了解Python字典和集合，一眼看穿他们的本质！

字典和集合是进行过性能高度优化的 数据结构，特别是对于查找、添加和删除操做。本节将结合实例介绍它们在具体场景下的性能表现，以及与列表等其余数据结构的对比。

例如，有一个存储产品信息（产品 ID、名称和价格）的列表，如今的需求是，借助某件产品的ID找出其价格。则实现代码以下：

def find_product_price(products, product_id):
    for id, price in products:
        if id == product_id:
            return price
    return None

products = [
    (111, 100),
    (222, 30),
    (333, 150)
]

print('The price of product 222 is {}'.format(find_product_price(products, 222)))

运行结果为：

The price of product 222 is 30

在上面程序的基础上，若是列表有 n 个元素，由于查找的过程须要遍历列表，那么最坏状况下的时间复杂度就为 O(n)。即便先对列表进行排序，再使用二分查找算法，也须要 O(logn) 的时间复杂度，更况且列表的排序还须要 O(nlogn) 的时间。

但若是用字典来存储这些数据，那么查找就会很是便捷高效，只需 O(1) 的时间复杂度就能够完成，由于能够直接经过键的哈希值，找到其对应的值，而不须要对字典作遍历操做，实现代码以下：

products = {
111: 100,
222: 30,
333: 150
}

print('The price of product 222 is {}'.format(products[222]))

运行结果为：

The price of product 222 is 30

有些读者可能对时间复杂度并无直观的认识，不要紧，再给你们列举一个实例。下面的代码中，初始化了含有 100,000 个元素的产品，并分别计算出了使用列表和集合来统计产品价格数量的运行时间：

# 统计时间须要用到 time 模块中的函数，了解便可
import time

def find_unique_price_using_list(products):
    unique_price_list = []
    for _, price in products: # A
        if price not in unique_price_list: #B
            unique_price_list.append(price)
    return len(unique_price_list)

id = [x for x in range(0, 100000)]
price = [x for x in range(200000, 300000)]
products = list(zip(id, price))

# 计算列表版本的时间
start_using_list = time.perf_counter()
find_unique_price_using_list(products)
end_using_list = time.perf_counter()
print("time elapse using list: {}".format(end_using_list - start_using_list))

# 使用集合完成一样的工做
def find_unique_price_using_set(products):
    unique_price_set = set()
    for _, price in products:
        unique_price_set.add(price)
    return len(unique_price_set)

# 计算集合版本的时间
start_using_set = time.perf_counter()
find_unique_price_using_set(products)
end_using_set = time.perf_counter()
print("time elapse using set: {}".format(end_using_set - start_using_set))

运行结果为：

time elapse using list: 68.78650900000001
time elapse using set: 0.010747099999989018

能够看到，仅仅十万的数据量，二者的速度差别就如此之大。而每每企业的后台数据都有上亿乃至十亿数量级，所以若是使用了不合适的数据结构，很容易形成服务器的崩溃，不但影响用户体验，而且会给公司带来巨大的财产损失。

那么，字典和集合为何能如此高效，特别是查找、插入和删除操做呢？

字典和集合的工做原理

字典和集合能如此高效，和它们内部的数据结构密不可分。不一样于其余数据结构，字典和集合的内部结构都是一张哈希表：

• 对于字典而言，这张表存储了哈希值（hash）、键和值这 3 个元素。
• 而对集合来讲，哈希表内只存储单一的元素。

对于以前版本的 Python 来讲，它的哈希表结构以下所示：

| 哈希值 (hash)  键 (key)  值 (value)
. |           ...
0 |    hash0      key0    value0
. |           ...
1 |    hash1      key1    value1
. |           ...
2 |    hash2      key2    value2
. |           ...

这种结构的弊端是，随着哈希表的扩张，它会变得愈来愈稀疏。好比，有这样一个字典：

{'name': 'mike', 'dob': '1999-01-01', 'gender': 'male'}

那么它会存储为相似下面的形式：

entries = [
['--', '--', '--']
[-230273521, 'dob', '1999-01-01'],
['--', '--', '--'],
['--', '--', '--'],
[1231236123, 'name', 'mike'],
['--', '--', '--'],
[9371539127, 'gender', 'male']
]

显然，这样很是浪费存储空间。为了提升存储空间的利用率，如今的哈希表除了字典自己的结构，会把索引和哈希值、键、值单独分开，也就是采用以下这种结构：

Indices
----------------------------------------------------
None | index | None | None | index | None | index ...
----------------------------------------------------

Entries
--------------------
hash0   key0  value0
---------------------
hash1   key1  value1
---------------------
hash2   key2  value2
---------------------
        ...
---------------------

在此基础上，上面的字典在新哈希表结构下的存储形式为：

indices = [None, 1, None, None, 0, None, 2]
entries = [
[1231236123, 'name', 'mike'],
[-230273521, 'dob', '1999-01-01'],
[9371539127, 'gender', 'male']
]

经过对比能够发现，空间利用率获得很大的提升。

清楚了具体的设计结构，接下来再分析一下如何使用哈希表完成对数据的插入、查找和删除操做。

哈希表插入数据

当向字典中插入数据时，Python 会首先根据键（key）计算出对应的哈希值（经过 hash(key) 函数），而向集合中插入数据时，Python会根据该元素自己计算对应的哈希值（经过 hash(valuse) 函数）。

例如：

dic = {"name":1}
print(hash("name"))
setDemo = {1}
print(hash(1))

运行结果为：

8230115042008314683
1

获得哈希值（例如为 hash）以后，再结合字典或集合要存储数据的个数（例如 n），就能够获得该元素应该插入到哈希表中的位置（好比，能够用 hash%n 的方式）。

若是哈希表中此位置是空的，那么此元素就能够直接插入其中；反之，若是此位置已被其余元素占用，那么 Python 会比较这两个元素的哈希值和键是否相等：

• 若是相等，则代表该元素已经存在，再比较他们的值，不相等就进行更新；
• 若是不相等，这种状况称为哈希冲突（即两个元素的键不一样，但求得的哈希值相同）。这种状况下，Python 会使用开放定址法、再哈希法等继续寻找哈希表中空余的位置，直到找到位置。

具体遇到哈希冲突时，各解决方法的具体含义可阅读《哈希表详解》一节作详细了解。

哈希表查找数据

在哈希表中查找数据，和插入操做相似，Python 会根据哈希值，找到该元素应该存储到哈希表中的位置，而后和该位置的元素比较其哈希值和键（集合直接比较元素值）：

• 若是相等，则证实找到；
• 反之，则证实当初存储该元素时，遇到了哈希冲突，须要继续使用当初解决哈希冲突的方法进行查找，直到找到该元素或者找到空位为止。

这里的找到空位，表示哈希表中没有存储目标元素。

哈希表删除元素

对于删除操做，Python 会暂时对这个位置的元素赋于一个特殊的值，等到从新调整哈希表的大小时，再将其删除。

须要注意的是，哈希冲突的发生每每会下降字典和集合操做的速度。所以，为了保证其高效性，字典和集合内的哈希表，一般会保证其至少留有 1/3 的剩余空间。随着元素的不停插入，当剩余空间小于 1/3 时，Python 会从新获取更大的内存空间，扩充哈希表，与此同时，表内全部的元素位置都会被从新排放。

虽然哈希冲突和哈希表大小的调整，都会致使速度减缓，可是这种状况发生的次数极少。因此，平均状况下，仍能保证插入、查找和删除的时间复杂度为 O(1)。