Python（六）：dict、set

字典

• 键：不可变对象 (数、字符串、tuple)
  值：任何对象
• 字典和集合是高度优化的结构，性能比list、tuple更高
  查找、删除、插入时间复杂度：O(1)
• 字典的查找：哈希

操作

创建

# d1 == d2 == d3 ==d4
d1 = {'name': 'jason', 'age': 20, 'gender': 'male'}

d2 = dict(d1)

d3 = dict(name='jason', age=20, gender='male') 

li =[('name', 'jason'), ('age', 20), ('gender', 'male')]
d4 = dict(li)

访问、遍历元素、查找（in）

字典无序，不要下标索引、切片。

# 访问
d = {'a': 1, 'b': 2}
print(d['a'])		# 键
print(d.get('a'))   #  dist.get()：当键不存在时，不报错，输出None
print(d.get('a', 'not exit'))  	# 输出 not exit，自定义


# 遍历元素
print(d.items())		# dict_items([('a', 1), ('b', 2)])
print(d.keys())			# dict_keys(['a', 'b'])
print(d.values())		# dict_values([1, 2])
	
for k, v in d.items():
   print(k, v)
for k in d:            # 默认遍历键
    print(k)
for k in d.keys():     # 等同上
    print(k)
for v in d.values():
    print(v)


# 查找（in）
if 'a' in d.keys():
    print('exist')
if 'a' in d.values():
    print('exist')

# 查找（根据value）
new_d = {v:k for k,v in d.items()}
print(new_d[1])  # 'a'

插入、删除、更新

d = {'name': 'Amy', 'age': 20}

# 插入
d['sex'] = 'male'

# 删除
del d['sex']
d.pop('sex')		

# 更新
d['name'] = 'Jack'

排序、反转、比较、复制

Python（二十五）：排序、反转

Python（十九）：比较、深浅拷贝

---

集合

理论

1. 一系列无序的、唯一的元素组合。
2. 集合并不支持索引操作，因为集合本质上是一个哈希表，和列表不一样。
3. 查找、删除、插入时间复杂度：O(1)

操作

初始化创建

s1 = {1, 2, 3}
s2 = set([1, 2, 3])
# s1 == s2

set 有序

li = [3,2,8,9,4,4,3,2,5,5,7]
st1 = set(li)
print(st1)          # {2, 3, 4, 5, 7, 8, 9}  无序
st2 = sorted(st1, key=li.index)
print(st2)      # [3, 2, 8, 9, 4, 5, 7] 有序，按照 li 的原顺序

插入、删除

s = {1, 2, 3}

# 插入
s.add(4)
s.add(1)

# 删除
s.remove(4)

合并

st = {1,2,3}
st2 = {2,3,4}
st3 = st | st2		#{1, 2, 3, 4}	全部合并
st3 = st & st2		#{2, 3}		交集

排序、反转、比较、复制

Python（二十五）：排序、反转

Python（十九）：比较、深浅拷贝

---

字典和集合

优化：hash

1. 字典和集合是高度优化的集合，本质是哈希表，特别是对于查找、添加和删除操作。
   字典：存储了哈希值（hash）、键和值这 3 个元素

# 存储形状
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']
]

集合：只有值

3. 字典的内部组成是一张哈希表，你可以直接通过键的哈希值，找到其对应的值，查找值为O(1)
   二元组[('a',1), ('b', 2), ('c', 3)]查找值为O(n)

插入

每次向字典或集合插入一个元素时，Python 会首先计算键的哈希值（hash(key)），再和 mask = PyDicMinSize - 1 做与操作，计算这个元素应该插入哈希表的位置 index = hash(key) & mask。如果哈希表中此位置是空的，那么这个元素就会被插入其中。而如果此位置已被占用，Python 便会比较两个元素的哈希值和键是否相等。若两者都相等，则表明这个元素已经存在，如果值不同，则更新值。若两者中有一个不相等，这种情况我们通常称为哈希冲突（hash collision），意思是两个元素的键不相等，但是哈希值相等。这种情况下，Python 便会继续寻找表中空余的位置，直到找到位置为止。值得一提的是，通常来说，遇到这种情况，最简单的方式是线性寻找，即从这个位置开始，挨个往后寻找空位。当然，Python 内部对此进行了优化（这一点无需深入了解，你有兴趣可以查看源码，我就不再赘述），让这个步骤更加高效。

删除

对于删除操作，Python 会暂时对这个位置的元素，赋于一个特殊的值，等到重新调整哈希表的大小时，再将其删除。不难理解，哈希冲突的发生，往往会降低字典和集合操作的速度。因此，为了保证其高效性，字典和集合内的哈希表，通常会保证其至少留有 1/3 的剩余空间。随着元素的不停插入，当剩余空间小于 1/3 时，Python 会重新获取更大的内存空间，扩充哈希表。不过，这种情况下，表内所有的元素位置都会被重新排放。虽然哈希冲突和哈希表大小的调整，都会导致速度减缓，但是这种情况发生的次数极少。所以，平均情况下，这仍能保证插入、查找和删除的时间复杂度为 O(1)。

查找

和前面的插入操作类似，Python 会根据哈希值，找到其应该处于的位置；然后，比较哈希表这个位置中元素的哈希值和键，与需要查找的元素是否相等。如果相等，则直接返回；如果不等，则继续查找，直到找到空位或者抛出异常为止。