03 | 字典、集合，你真的了解吗
字典（dict）和集合(set)在在python中被广泛使用，并且性能进行了高度优化，其重要性不言而喻。
一、字典和集合基础
字典：字典是一系列键值对组成的元素集合。在python3.7才被正式确定为有序的，而3.6之前都是无序的。其长度大小可变，元素可以任意删减和改变。
对于元组和列表，字典的性能更优，特别是对于查找、添加和删除操作，字典都能在常数时间复杂度内完成。
集合：集合没有键值对，是一系列无序的，唯一的元素组合。
下面是字典和集合的几种创建方式
d1 = {'name': 'jason', 'age': 20, 'gender': 'male'}
d2 = dict({'name': 'jason', 'age': 20, 'gender': 'male'})
d3 = dict([('name', 'jason'), ('age', 20), ('gender', 'male')])
d4 = dict(name='jason', age=20, gender='male')
d1 == d2 == d3 ==d4
True
s1 = {1, 2, 3}
s2 = set([1, 2, 3])
s1 == s2
True
这里注意：python中的字典和集合，无论是键还是值，都可以是混合型。
- 字典访问可以直接索引键，如果不存在，就会抛出异常。
- 也可以使用get(key, default)函数来进行索引。如果键不存在，调用get（）函数可以返回一个默认值'null'
- 集合并不支持索引操作，因为集合本质是一个哈希表，和列表不一样（他是无序的，没有所谓的下标）
- 想要判断一个元素是都在字典或者集合内，我们可以使用value in dict/set 来判断
# 获取dire的两种方法 d = {'name': 'jason', 'age': 20} d['name'] 'jason' d['location'] Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: 'location' d = {'name': 'jason', 'age': 20} d.get('name') 'jason' d.get('location', 'null') 'null' #获取集合的方法 s = {1, 2, 3} s[0] //是不正确的 Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'set' object does not support indexing s = {1, 2, 3} 1 in s //正确的获取方法 True 10 in s False d = {'name': 'jason', 'age': 20} 'name' in d //字典也可以用 True 'location' in d False
当然，除了创建和访问，字典和集合也同样支持增加、删除、更新等操作。
d = {'name': 'jason', 'age': 20}
d['gender'] = 'male' # 增加元素对'gender': 'male'
d['dob'] = '1999-02-01' # 增加元素对'dob': '1999-02-01'
d
{'name': 'jason', 'age': 20, 'gender': 'male', 'dob': '1999-02-01'}
d['dob'] = '1998-01-01' # 更新键'dob'对应的值
d.pop('dob') # 删除键为'dob'的元素对
'1998-01-01'
d
{'name': 'jason', 'age': 20, 'gender': 'male'}
s = {1, 2, 3}
s.add(4) # 增加元素4到集合
s
{1, 2, 3, 4}
s.remove(4) # 从集合中删除元素4
s
{1, 2, 3}
不过注意:集合的pop()操作是删除掉集合的最后一个元素，但由于其是无序的，所以我们也不知道会删除哪一个，所以慎用！
我们也会对字典或者是集合进行排序操作：
d = {'b': 1, 'a': 2, 'c': 10}
d_sorted_by_key = sorted(d.items(), key=lambda x: x[0]) # 根据字典键的升序排序
d_sorted_by_value = sorted(d.items(), key=lambda x: x[1]) # 根据字典值的升序排序
d_sorted_by_key
[('a', 2), ('b', 1), ('c', 10)]
d_sorted_by_value
[('b', 1), ('a', 2), ('c', 10)]
# 对于集合，他的排序与列表、元组很类似，直接调用sorted(set)就可以
s = {3, 4, 2, 1}
sorted(s) # 对集合的元素进行升序排序
[1, 2, 3, 4]
二、 字典和集合性能
字典和集合是进行过性能高度优化的数据结构，特别是对于查找、添加和删除操作。接下来是具体场景中的性能表现。
比如电商企业的后台，存储了每件产品的ID、名称和价格。现在的需求是，给定某件商品的ID，我们要找到其价格。
如果我们用列表来存储这些数据结构，并进行查找，相应的代码如下：
def find_product_price(products, product_id): for id, price in products: if id == product_id: return price return None products = [ (1431211312, 100), (1245464678, 456), (0879868765, 789) ] print('The price of product 465768698 is {}'.format(find_product_proce(products, 34354645456)))
假设列表中有n个元素，而查找的过程需要遍历，则时间复杂度为O（n），即使先对列表进行排序，然后进行二分查找，也会需要O（logn）的时间复杂度，况且，列表的排序还需要O(nlogn)的时间复杂度。
但是如果我们使用字典来存储这些数据，那么查找就会变得更加高效便捷，只需要O(1)的时间复杂度就可以完成，原因也很简单，刚说的，字典内部组成是一张哈希表，可以使用键的哈希值，找到其对应的值。
products[ 123456456:122, 456788098:788, 423265934:897 ] print('The price of product 123456456 is {}'.format(products[123456456]))
类似，现在的需求变成：要找到这些商品有多少种不同的价格。我们还用相同的方法来比较一下。
如果使用列表，对应的代码如下，其中，A和B是两层循环。同样假设原始列表有n个元素，那么在最坏的情况下，需要O(n^2)的时间复杂度；如果使用集合这个数据结构，由于集合是高度优化的哈希表，里面的元素不能重复，并且其添加和查找操作只需O(1)的时间复杂度，那么，总的时间复杂度只有O（n）。
代码如下：
# list version 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) products =[ (123456456, 100), (234567567, 200), (678907890, 300) ] print('number of unique price is {}'.format(find_unique_price_using_list(products))) #set version 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) products = [ (123456456, 100), (234567567, 200), (678907890, 300) ] print('number of unique price is {}'.format(find_unique_price_using_set(products)))
可能对于这些时间复杂度没有直观的认识，但是如果带入到实际生活中，比如：初始化了100，000个元素的产品，并分别计算了使用列表和集合来统计产品价格数量的运行时间：
import time 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)) ## 输出 time elapse using list: 41.61519479751587 # 计算集合版本的时间 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 set: 0.008238077163696289
可以看出相差十万的数据量，两者的速度差异就如此之大。事实上，大型企业的后台数据往往有上亿甚至数十亿级别，如果用了不合适的数据结构，就有肯恶搞造成服务器的崩溃，不但影响了用户体验，并且会给公司带来巨大的财产损失。
三、 字典和集合的工作原理
字典和集合在查找、插入和删除操作方面的优秀原因与他们内部的而数据结构密不可分，不同于其他数据结构，字典和几何的内部结构都是一张哈希表。
- 对于字典而言，这张表存储了哈希值，键和值这三个元素。
- 而对于集合来说，区别在于哈希表内没有键和值的配对，只有单一的元素了。
现在的哈希表除了字典本身的结构，会把索引和哈希值、键、值单独分开，也就是下面这样新的结构。
Indices ---------------------------------------------------- None | index | None | None | index | None | index ... ---------------------------------------------------- Entries -------------------- hash0 key0 value0 --------------------- hash1 key1 value1 --------------------- hash2 key2 value2 --------------------- ... ---------------------
接下来看几个操作的工作原理：
插入操作：每次向字典或者集合中插入一个元素，python会首先计算键的哈希值（hash(key)），再和mask = PyDicMinSize-1做操作，计算这个元素应该插入哈希表的位置 index = hash(key) & mask。如果此哈希表是空的，那么这个元素就会被插入其中。
如果这个位置被占用，python将会继续比较哈希值和键是否相等。
- 如果两者都相等，则表明元素已经存在，如果值不同，则更新值。
- 若两者中有一个不相等，这种情况下我们通常称为哈希冲突(hash collison)，意思是俩各个元素的键不相等，但是哈希值相等。这种情况下,python便会继续寻找表中空余的位置，知道找到位置为止。（通常这种情况下，都是线性查找）
查找操作:和上面的插入操作类似。python会根据哈希值，找到其应该处于的位置；然后比较哈希表这个位置中的元素的哈希值和键，与需要查找的元素是否相等。如果相等，则直接返回；如果不相等，则继续查找，知道找到空位或者抛出异常。
删除操作：python会暂时对这个位置的元素赋予一个特殊的值，等到重新调整哈希表的大小时，再将其删除。
哈希冲突的产生往往会降低字典和集合的操作速度。为了保证其高效性，字典和集合内的哈希表，通常会保证至少留有1/3的剩余空间。随着元素的不停插入，当剩余空间少于1/3时。python会重新获取更大的内存空间，扩充哈希表。不够这种情况，所有的元素位置都会被重放。但是这种情况极少会发生，在平均情况下，这仍能保证插入、查找和删除的时间复杂度为O(1)
总结： 字典和集合通常用于对元素的高校查找、去重等场景。
PS：用列表作为 Key 在这里是不被允许的，因为列表是一个动态变化的数据结构，字典当中的 key 要求是不可变的，原因也很好理解，key 首先是不重复的，如果 Key 是可以变化的话，那么随着 Key 的变化，这里就有可能就会有重复的 Key，那么这就和字典的定义相违背；如果把这里的列表换成之前我们讲过的元组是可以的，因为元组不可变
浙公网安备 33010602011771号