dict常用操作

引言

• clear(): 清空字典
• copy(): 返回一个浅拷贝
• fromkeys(): 将可迭代对象中的每一个元素作为key和同一个value拼成字典
• get(): 根据key返回value，若无对应的键值对，则返回None，也可以指定默认返回值，和索引访问相比，不会产生异常。
• items()：返回一个dict_items类型，支持迭代，键值对以元组形式组织
• setdefault(): 获取key对应的value值，先调用get()，若不存在该键值对，则添加
• update(): 合并字典，或键值对元组构成的可迭代对象

  使用案例

  ```python

  1. clear()

  d = {name:”MetaTian”, age:”22”} d.clear()

2. copy()

new_dict = d.copy() new_dict[“age”] = 18

print(new_dict) print(d)

resutl:

{‘age’: 18, ‘name’: ‘MetaTian’}

{‘age’: ‘22’, ‘name’: ‘MetaTian’}

3. fromkeys()

d = dict.fromkeys(range(3), “MetaTian”) print(d)

result:

{0: ‘MetaTian’, 1: ‘MetaTian’, 2: ‘MetaTian’}

4. get()

print(d.get(2)) print(d.get(3)) print(d.get(3, “null”))

result:

MetaTian

None

null

5. items()

print(type(d.items())) print(d.items())

result:

dict_items([(0, ‘MetaTian’), (1, ‘MetaTian’), (2, ‘MetaTian’)])

6. setdefault()

d = {} value = d.setdefault(“name”, “MetaTian”) # 如果无 name 这个 key，则添加 print(value, d)

result:

MetaTian {‘name’: ‘MetaTian’}

7. update()

d1 = {1:”a”} d2 = {2:”b”}

d1.update(d2) d2.update([(3, “c”), (4, “d”)])

print(d1) print(d2)

result:

{1: ‘a’, 2: ‘b’}

{2: ‘b’, 3: ‘c’, 4: ‘d’}

<a name="0f8e751d"></a>
# set和frozenset
<a name="e4568847"></a>
## 引言
- `set`是可变集合，`frozenset`是不可变集合
- 集合中的元素**无序**，**不重复**
<a name="568d18bd"></a>
## 使用案例
```python
"""
通过 set(Iterable) 来构建出可变集合对象
通过 frozenset(Iterable) 构建不可变集合对象
"""
s = set("12345666")
fs = frozenset(['a', 'b', 'c', 'a'])    # 不可变类型，可以作为 dict 的 key
print(s)
print(fs)
# result:
# {'6', '1', '4', '5', '3', '2'}
# frozenset({'b', 'a', 'c'})
"""
向 set 中添加元素
add()
update()
"""
s1, s2 = set("123"), set("234")
s1.update(s2)
s2.add('5')
print(s1)
print(s2)
# result:
# {'1', '2', '3', '4'}
# {'2', '3', '5', '4'}
"""
集合的运算
- 差
& 交
| 并
"""
s1, s2 = set("123"), set("234")
print(s1 - s2)
print(s1 & s2)
print(s1 | s2)
# result:
# {'1'}
# {'2', '3'}
# {'3', '1', '2', '4'}

dict和set的实现原理

引言

• dict和set的查找性能远远大于list

• dict和set底层通过散列表存储，因此也要求dict的key是可哈希的，不可变对象都是可哈希的

  哈希的原理

• 以字典为例

• 存储之前要通过哈希函数来计算key的值，得到存储索引，如果得到的结果已经被使用，要处理冲突，重新计算后再进行存储
• 自定义的类通过实现__hash__()，就可以存储在dict和set中
• 因此，具体的存储顺序和元素添加的顺序可能有关