理解Python字典和集合的性能差异
本文为极客时间 Python核心技术与实战 专栏的学习笔记
字典
在 Python3.7+，字典被确定为有序（注意：在 3.6 中，字典有序是一个 implementation detail，在 3.7 才正式成为语言特性，因此 3.6 中无法 100% 确保其有序性），而 3.6 之前是无序的，其长度大小可变，元素可以任意地删减和改变。
相比列表和元组，字典性能更优，可以在常数时间复杂度O(1)内完成查找、添加、删除操作。
常用创建方法
>>> d1 = {'name': 'Json', 'age': 20, 'gender': 'male'}
>>> d2 = dict( {'name': 'Json', 'age': 20, 'gender': 'male'})
>>> d3 = dict([('name', 'Json'),('age', 20),('gender','male')])
>>> d4 = dict(name='Json', age=20, gender='male')
>>> d1 == d2 == d3 == d4
True
索引
使用dict[key]格式索引，如果不存在，会抛出KeyError异常。
>>> d1['name']
'Json'
>>> d1['location']
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'location'
使用get(key, default)方法不会抛出异常，此外当该键不存在时，可以指定返回的默认值。
>>> d1.get('name')
'Json'
>>> d1.get('location')
>>> d1.get('location', None)
None
判断某元素是否是字典的键：
>>> 'name' in d1 # 同d1.keys()等价
True
>>> 'name' in d1.keys()
True
>>> 'Json' in d1
False
>>> 'Json' in d1.values()
True
添加
>>> d = {'name': 'jason', 'age': 20}
>>> d['gender'] = 'male'
>>> d
{'name': 'jason', 'age': 20, 'gender': 'male'}
删除
>>> d.pop('gender')
'male'
>>> d
{'name': 'jason', 'age': 20}
排序
根据键排序
>>> d = {'b': 1, 'v': 20, 'a': 17}
>>> d_sorted_by_key = sorted(d.items(), key=lambda x: x[0])
>>> d_sorted_by_key
[('a', 17), ('b', 1), ('v', 20)]
>>> d
{'b': 1, 'v': 20, 'a': 17}
根据值排序
>>> d_sorted_by_value = sorted(d.items(), key = lambda x: x[1])
>>> d_sorted_by_value
[('b', 1), ('a', 17), ('v', 20)]
性能分析
举例：有1000万件产品，产品信息包括：产品ID、价格。现在需求是：给定某件产品的ID，找出其价格：
1.用列表来存储数据
存储结构如下：
products = [
(143121312, 100),
(432314553, 30),
(32421912367, 150)
]
那么查找需要遍历整个列表，时间复杂度为O(n)。即使先对列表排序，然后二分查找，也会需要O(logn)的时间复杂度，并且排序还需要O(nlogn)的时间。
2. 用字典存储数据
存储结构如下：
products = {
'143121312': 100,
'432314553': 30,
'32421912367': 150
}
因为字典内部结构是一张哈希表，所以可以在O(1)的时间复杂度内完成查找。
3. 效率对比
import time
import numpy
def find_product_price_list(products, product_id):
for id, price in products:
if id == product_id:
return price
return None
def find_product_price_dict(products, product_id):
for id in products.keys():
if id == product_id:
return products_dict[id]
return None
r = numpy.random.randint(0,10000000,10000000) # 生成10000000个随机数
id = [str(x) for x in r]
price = [x for x in range(20000000, 30000000)]
products_list = list(zip(id, price))
products_dict = dict(zip(id, price))
# 添加新元素
products_list.append(('111111111', 300)) # 追加到列表末尾
products_dict['111111111'] = 300
start_using_dict = time.perf_counter()
find_product_price_dict(products_dict, '111111111')
end_using_dict = time.perf_counter()
print('time elapse using dict: {}'.format(end_using_dict - start_using_dict))
start_using_list = time.perf_counter()
find_product_price_list(products_dict, '111111111')
end_using_list = time.perf_counter()
print('time elapse using list: {}'.format(end_using_list - start_using_list))
# ===========运行结果============
time elapse using dict: 0.1983588489999999
time elapse using list: 0.41368435999999953
集合
而集合和字典基本相同，唯一的区别，就是集合没有键和值的配对，是一系列无序的、唯一的元素组合。
常用创建方法
>>> s1 = {1,2,3}
>>> s2 = set([1,2,3])
>>> s1 == s2
True
索引
集合并不支持索引操作，因为集合本质上是一个哈希表，和列表不一样。
进行如下操作，Python会抛出TypeError异常。
>>> s1[0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'set' object is not subscriptable
只能判断某元素是否在集合中：
>>> 1 in s1
True
>>> 10 in s1
False
添加
>>> s = {1,2,3}
>>> s.add(4)
>>> s
{1, 2, 3, 4}
删除
>>> s.remove(4)
>>> s
{1, 2, 3}
注意：由于集合是无序的，所以无法确定pop()方法会删除哪个元素，所以谨慎使用。一般删除操作采用remove()即可。
排序
>>> s = {2,4,546,34}
>>> sorted(s)
[2, 4, 34, 546]
集合运算
常用集合运算
| 语法 | 操作 | 说明 |
|---|---|---|
| set(list1) | set(list2) | union | 包含 list1 和 list2 所有数据的新集合 |
| set(list1) & set(list2) | intersection | 包含 list1 和 list2 中共同元素的新集合 |
| set(list1) - set(list2) | difference | 在 list1 中出现但不在 list2 中出现的元素的集合 |
性能分析
还是以上面那个例子为例，现在要求计算出有多少种价格。为了节省时间，我们把产品数量降低到10万。
查找效率
1. 用列表存储数据
需要两层循环。那么，在最差情况下，需要 O(n^2) 的时间复杂度。
2. 用集合存储数据
由于集合是高度优化的哈希表，里面元素不能重复，并且其添加和查找操作只需 O(1) 的复杂度，那么，总的时间复杂度就只有 O(n)。
3. 效率对比
import time
import numpy
def find_unique_price_set(products):
unique_price_set = set()
for _, price in products:
unique_price_set.add(price)
return len(unique_price_set)
def find_unique_price_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)
r = numpy.random.randint(0,1000000,100000) # 生成100000个随机数
id = [str(x) for x in r]
price = [x for x in range(200000, 300000)]
products = list(zip(id, price))
start_using_set = time.perf_counter()
find_unique_price_set(products)
end_using_set = time.perf_counter()
print('time elapse using set: {}'.format(end_using_set - start_using_set))
start_using_list = time.perf_counter()
find_unique_price_list(products)
end_using_list = time.perf_counter()
print('time elapse using list: {}'.format(end_using_list - start_using_list))
# ===========运行结果============
time elapse using set: 0.00985934799999999
time elapse using list: 65.528253501
可以看出，仅10万数据，差距就已经很明显了。
交集、并集、差集运算
以求交集为例：
import time
list_a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 13, 34, 53, 42, 44]
list_b = [2, 4, 6, 9, 23]
intersection = []
# 列表做交集
start_using_list = time.perf_counter()
for a in list_a:
for b in list_b:
if a == b:
intersection.append(a)
end_using_list = time.perf_counter()
print(intersection)
print('time: {}'.format(end_using_list - start_using_list))
# 集合做交集
start_using_list = time.perf_counter()
intersection = list(set(list_a) & set(list_b))
end_using_list = time.perf_counter()
print(intersection)
print('time: {}'.format(end_using_list - start_using_list))
# ===========运行结果============
[2, 4, 6, 9]
time: 9.622000000000797e-06
[9, 2, 4, 6]
time: 4.169000000001782e-06
