字典和集合在 Python 被广泛使用,并且性能进行了高度优化。
基础
是一系列无序元素的组合,其长度大小可变,元素可以任意地删减和改变,这里的元素,是一对键(key)和值(value)的配对,
相对于列表和元组,字典的性能更优,主要是体现在查找、添加和删除;
和list比较,dict有以下几个特点:
查找和插入的速度极快,不会随着key的增加而变慢;
需要占用大量的内存,内存浪费多。
而list相反:
查找和插入的时间随着元素的增加而增加;
占用空间小,浪费内存很少。
字典和集合基本相同,区别在于集合没有键和值的配对,是一些列无序的、唯一的元素集合
字典基础操作
创建:
d1 = {'name': 'tom', 'age': 18, 'gender': 'male'}
d2 = dict({'name': 'tom', 'age': 18, 'gender': 'male'})
d3 = dict([('name', 'tom'), ('age', 20), ('gender', 'male')])
d4 = dict(name='jason', age=20, gender='male')
print(d1,d2,d3,d4)
print(d1['name']) #查找
d1['age'] = 20 #修改
del d1['name'] #删除
d1.pop("age")
# 合并
dic1 = {"name": "tom"}
dic2 = {"age": "18"}
dic1.update(dic2)
d1.setdefault("name") # 如果有这个值则输出,若没有则创建并使用默认值none
d1.get("name") # 如果有这个值则输出,若没有返回默认值none
# 创建一个新的字典,默认值是`123`
a = dic.fromkeys(["k1", "k2", "k3"], "123")
print(a)
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]) # 根据字典值的升序排序
集合基础操作
集合创建:
s1 = {1, 2, 3} s2 = set([1, 2, 3]) print(s1 == s2, s1, s2) # True {1, 2, 3} {1, 2, 3} n = {"alex",'eric','tony'} n.add("bill") # 添加 n.clear() #清空 n.copy() #复制 # 输出s1中存在,s2中不存在 s1 = {"alex",'eric','tony','李四','李四11'} s2 = {"alex",'eric','tony','张三'} v = s1.difference(s2) print(v) # 输出s1中存在,s2中不存在 # {'李四', '李四11'} v = s1.symmetric_difference(s2) # 输出两集合不同的元素 s1.symmetric_difference_update(s2) # 输出两个几个不同的元素并清空s1,并将不同的元素复制到s1 v = s1.intersection(s2) # 两个集合相同的元素(交集) s1.intersection_update(s2) # 取交集,然后对s1清空,然后在重新复制 v = s1.union(s2) # 并集 s1.discard('alex') # 移除 v = s1.issubset(s2) # 判断s1 是否是 s2的子集 v = s1.issuperset(s2) # s1 是否是 s2的父集 v = s1.pop() # 随机删除一个元素,并取值 s1.remove('alex') # 移除 s1.update({'alex','123123','fff'}) # 批量添加,有相同的部分不改 s = {3, 4, 2, 1} sorted(s) # 对集合的元素进行升序排序 [1, 2, 3, 4]
set运算
a = {1,2,3,4,5} b = {2,3,4,5,6} print(a.union(b)) #并集 print(a-b) #差集 print(a&b) #求交集 print(a^b) #对称差集 print(a.issubset(b)) #a是b的子集 看返回值的真假 print(a.issuperset(b)) #a是否包含b 看返回值的真假
字典和集合的性能
列表中查找
def find_product_price(products, product_id): for id, price in products: if id == product_id: return price return None products = [ (143121312, 100), (432314553, 30), (32421912367, 150) ] print('The price of product 432314553 is {}'.format(find_product_price(products, 432314553))) # 输出 The price of product 432314553 is 30
字典中查找
def find_product_price(products, product_id): for id, price in products: if id == product_id: return price return None products = [ (143121312, 100), (432314553, 30), (32421912367, 150) ] print('The price of product 432314553 is {}'.format(find_product_price(products, 432314553))) # 输出 The price of product 432314553 is 30
上面结果可以看出 字典在查找方面更优,列表查找时间复杂度为:O(n),即使使用二分查找,也需要O(logn)的时间复杂度。字典的时间复杂度为O(1).
https://www.jianshu.com/p/f31744e423eb 对O(n)的解释
列表和集合去重性能对比
import time id = [x for x in range(0, 100000)] price = [x for x in range(200000, 300000)] products = list(zip(id, price)) 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) 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) # 计算列表版本的时间 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: 54.833863215 # 计算集合版本的时间 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.009784918000001142
可以看出,仅数十万的数据,两者的差距如此之大。
字典和集合的工作原理
上面可以看出,字典和集合性能在查找、插入、和删除的性能很高效
原因在于,字典和集合的内部结构是一张哈希表。
对于字典而言,这张表存储了哈希值(hash)、键、和值,三个元素
对集合来说,哈希表内没有键和值的配对,只有单一的元素
新版本python hash涉及结构发生了改变,大幅提高了空间利用率
插入操作
每次向字典或集合插入一个元素时,Python 会首先计算键的哈希值(hash(key)),再和 mask = PyDicMinSize - 1 做与操作,计算这个元素应该插入哈希表的位置 index = hash(key) & mask。如果哈希表中此位置是空的,那么这个元素就会被插入其中。
而如果此位置已被占用,Python 便会比较两个元素的哈希值和键是否相等。
若两者都相等,则表明这个元素已经存在,如果值不同,则更新值。
若两者中有一个不相等,这种情况我们通常称为哈希冲突(hash collision),意思是两个元素的键不相等,但是哈希值相等。这种情况下,Python 便会继续寻找表中空余的位置,直到找到位置为止。
值得一提的是,通常来说,遇到这种情况,最简单的方式是线性寻找,即从这个位置开始,挨个往后寻找空位。当然,Python 内部对此进行了优化(这一点无需深入了解,你有兴趣可以查看源码,我就不再赘述),让这个步骤更加高效。
查找操作
和前面的插入操作类似,Python 会根据哈希值,找到其应该处于的位置;然后,比较哈希表这个位置中元素的哈希值和键,与需要查找的元素是否相等。如果相等,则直接返回;如果不等,则继续查找,直到找到空位或者抛出异常为止。
删除操作
对于删除操作,Python 会暂时对这个位置的元素,赋于一个特殊的值,等到重新调整哈希表的大小时,再将其删除。
不难理解,哈希冲突的发生,往往会降低字典和集合操作的速度。因此,为了保证其高效性,字典和集合内的哈希表,通常会保证其至少留有 1/3 的剩余空间。随着元素的不停插入,当剩余空间小于 1/3 时,Python 会重新获取更大的内存空间,扩充哈希表。不过,这种情况下,表内所有的元素位置都会被重新排放。
虽然哈希冲突和哈希表大小的调整,都会导致速度减缓,但是这种情况发生的次数极少。所以,平均情况下,这仍能保证插入、查找和删除的时间复杂度为 O(1)。
总结
字典和集合都是无序的数据结构,起内部的哈希表存储结构,保证了其查找、插入、删除操作的高效性。所以字典和集合通常运用在对元素的高效查找、去重等场景。
想学python的一起加入python免费教学群吧,火币网大牛手把手教学!
每天十分钟视频教学,一个月后python技能会有质飞跃!