字典（dict）是一种非常有用的复合数据结构，是一种无序、可变的序列，字典元素由键值对组成，这些键值对之间用逗号分隔。在键值对中，键和值由冒号 “:”分隔。

Python 字典主要特征：

通过键而不是通过索引来读取元素，字典是无序的序列，不存在索引；字典是可变的，并且可以任意嵌套；字典中的键必须唯一，不能修改，类型可以是数字、字符串或者元组，不能使用列表。

定义字典

字典通过将以逗号分隔的“键值对列表括在大括号 “{}”中来定义字典。每个键与其关联的值使用冒号“:”分隔开。

格式：

d = {
    :,
    :,
      .
      .
      .
    :
}

下面定义了一个字典，该字典包含省会信息：

shenghui={"shandong":"jinan","jiangsu":"nanjing","jilin":"changchun"}

还可以使用内置函数dict()构造字典，参数应该是一系列键值对。

>>> shenghui=dict([("shandong","jinan"),("jiangsu","nanjing"),("jilin","changchun")])
>>> print(shenghui)
{'shandong': 'jinan', 'jiangsu': 'nanjing', 'jilin': 'changchun'}

#增量方式创建字典
>>> dict2={}
>>> dict2["级部"]="初一"
>>> dict2["班级"]=["一班","二班"]
>>> dict2
{'级部': '初一', '班级': ['一班', '二班']}

字典基本操作

通过在方括号"[]"中指定其相应的键，从字典中检索值。

#访问字典
>>> shenghui=dict([("shandong","jinan"),("jiangsu","nanjing"),("jilin","changchun")])
>>> shenghui["shandong"]
'jinan'
>>> shenghui["jiangsu"]
'nanjing'

#更改字典的值
>>> shenghui=dict([("shandong","jinan"),("jiangsu","nanjing"),("jilin","changchun")])
>>> shenghui["shandong"]="qingdao"
>>> shenghui["shandong"]
'qingdao'

#删除字典的键值
>>> shenghui={"shandong":"jinan","jiangsu":"nanjing","jilin":"changchun"}
>>> del shenghui["shandong"]
>>> shenghui
{'jiangsu': 'nanjing', 'jilin': 'changchun'}

字典没有索引，所以使用索引会出错。下面的示例，看起来像一个数字索引，但事实并非如此，只是字典的键使用了数字，还是使用键来访问值。

>>> dict1={0:'a',1:'b',2:'c',3:'d'}
>>> dict1[0]
'a'
>>> dict1[1]
'b'

字典相关函数方法

#keys()返回字典键的列表
>>> dict2={'级部': '初一', '班级': ['一班', '二班']}
>>> print(dict2.keys())
dict_keys(['级部', '班级'])

#items()返回一个元组列表，这些元组由字典中的键值对组成
>>> dict1={0:'a',1:'b',2:'c',3:'d'}
>>> print(dict1.items())
dict_items([(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')])

#get()访问字典中的值
>>> dict1={0:'a',1:'b',2:'c',3:'d'}
>>> print(dict1.get(1))
b

#clear()清除字典中的所有元素
>>> dict1={0:'a',1:'b',2:'c',3:'d'}
>>> dict1.clear()
>>> print(dict1)
{}

#copy()返回字典的副本
>>> dict1={0:'a',1:'b',2:'c',3:'d'}
>>> dict2=dict1.copy()
>>> print(dict2)
{0: 'a', 1: 'b', 2: 'c', 3: 'd'}

#pop()从字典中删除指定元素并返回指定的元素
>>> dict1={0:'a',1:'b',2:'c',3:'d'}
>>> m=dict1.pop(0)
>>> print(m)
a
>>> print(dict1)
{1: 'b', 2: 'c', 3: 'd'}

#popitem()从字典中删除最后插入的键值对，并将其作为元组返回。
>>> dict1={0:'a',1:'b',2:'c',3:'d'}
>>> m=dict1.popitem()
>>> print(m)
(3, 'd')
>>> print(dict1)
{0: 'a', 1: 'b', 2: 'c'}

#setdefault()返回键的值（如果键在字典中）。否则，它会在字典中插入具有默认值的键
>>> dict1={0:'a',1:'b',2:'c',3:'d'}
>>> dict1.setdefault(3)
'd'
>>> dict1.setdefault(4,'e')
'e'
>>> dict1
{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e'}

#update()使用另一个字典键值对元素更新字典
>>> dict1={0:'a',1:'b',2:'c',3:'d'}
>>> dict2={3:'dd'}
>>> dict1.update(dict2)
>>> print(dict1)
{0: 'a', 1: 'b', 2: 'c', 3: 'dd'}

#values()返回字典的值
>>> dict1={0:'a',1:'b',2:'c',3:'d'}
>>> print(dict1.values()) 
dict_values(['a', 'b', 'c', 'd'])

#fromkeys()返回具有键映射和特定值的字典
>>> d={'a','b','c','d'}
>>> print(dict1.fromkeys(d))
{'c': None, 'b': None, 'd': None, 'a': None}
>>> print(dict2.fromkeys(d,1))
{'c': 1, 'b': 1, 'd': 1, 'a': 1}

#"|"合并运算符可以合并字典,Python3.9引入
dict1={0:'a',1:'b',2:'c',3:'d'}
dict2={4:'e'}
dict3=dict1|dict2
print(dict3)
{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e'}

#"|="更新运算符更新字典,如果键重复，更新值，否则，插入新键值，Python3.9引入
dict1={0:'a',1:'b',2:'c',3:'d'}
dict2={4:'e'}
dict1|=dict2
print(dict1)
{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: 'e'}

dict1={0:'a',1:'b',2:'c',3:'d'}
dict2={3:'e'}
dict1|=dict2
print(dict1)
{0: 'a', 1: 'b', 2: 'c', 3: 'e'}