8.Python【非序列】- 字典-阿里云开发者社区

认识字典

映射（mapping）属于可变对象，它将哈希值（hashable）映射到任意对象。目前，Python 仅有一种映射类型：字典（dict）。字典的键可以是任意不可变值（也称哈希值）。对于可变对象，如列表、字典、集合或其他可变类型的值不可以用作键。

当数字类型用作键时，遵循数字比较的一般规则：如果两个数值相等，如1和1.0，则两个值可以用来索引同一字典项目。注意，由于浮点数的精度问题，不建议使用浮点数作为字典的键。

字典具有如下特点：

字典是无序的数据结构，内部数据随机排列。
字典是可变的数据类型。可以任意添加、删除或更新字典内的数据，字典对象会自动伸缩，确保内部数据无缝隙排列在一起。
通过映射访问内部数据，不能通过下标索引访问内部数据。支持迭代操作。
内部数据统称为项目，每个项目都由键和值组成。

键名必须是哈希值，即确保键名唯一性、不可变性。值可以为任意类型的数据。
字典的宇面值：使用大括号包含所有元素，元素之间使用逗号分隔，每个元素的键和值之间使用冒号分隔。

构造字典

使用大括号作为起始和终止标识符，其中包含0个或多个项目，项目之间通过逗号分隔，项目由键和值组成，键与值之间通过冒号分隔，字典字面值的语法格式如下：

{键1:值1,键2:值2,键3:值3,...,键n:值n}

键必须是唯一的，值可以不唯一。如果键重复，则最后一个键映射的值有效。
键必须是不可变的，如数字、字符串或者元组，不能够使用列表、字典、集合等可变类型的对象。
值可以是任意类型的数据，可以是简单值或复合值，也可以是不可变的值或可变的值。
如果不包含键和值的元素，则为空字典。

dict1 = {'a':1,'b':'a'} # 字符串字典
dict2 = {} # 定义空字典

使用dict()函数构造字典，语法如下：

dict(**kwarg)
dict(mapping,**kwarg)
dict(iterable,**kwarg)

参数 mapping 和 iterable 是可选的位置参数，设置映射对象和可选代对象：参数kwarg 是可以为空的关键字参数。dict()函数返回一个新字典。具体说明如下：

如果没有参数，将创建一个空字典。例如，dict1 = dict()。
如果参数为映射对象，将创建一个与映射对象相同键值对的字典。
如果参数为可迭代对象，则可迭代对象中的每一项必须是刚好包含两个元素的可迭代对象，其中第一个元素将成为新字典的一个键，第二个元素将成为其对应的值。

如果一个键出现一次以上，该键的最后一个值将成为其在新字典中对应的值。
如果给出了关键字参数，则关键字参数及其值被加入到基于位置参数创建的字典。
如果要加入的键己存在，来自关键字参数的值将替代来自位置参数的值。

dict1 = dict(a='a',b=True,c=3)
print(dict1) # 输出 {'a':'a','b':True,'c':3}
dict2 = dict([('one',1),('two',2),('three',3)]) # 通过可迭代对象
print(dict2) # 输出 {'one':1,'two':2,'three':3}
list1 = ['a','b','c','d']
enum = enumerate(list1) # 转换为索引序列
dict3 = dict(enum) # 转换为字典
print(dict3) # 输出 {0:'a',1:'b',2:'c',3:'d'}
t1 = (1,2,3)
t2 = ('a','b','c')
dict4 = dict(zip(t1,t2))  # 将两个元组合并为一个字典
print(dict4) # 输出 {1:'a',2:'b',3:'c'}

使用dict.fromkeys()函数可以根据一个可迭代对象创建一个新字典，语法格式如下：

dict.fromkeys(iterable[,value])

dict 表示字典对象，参数 iterable 表示一个可迭代对象，可迭代对象的元素将被设置为字典的键，value 为可选参数，设置每个键的初始值，默认值为None。该函数返回一个新的字典对象。

dict1 = dict.fromkeys(range(3),False) # 以元组内数字为键，以False为默认值定义字典
print(dict1) # 输出{0:False,1:False,2:False}

字典推导式

字典推导式使用大括号进行标识，推导的表达式必须包含键和值两部分，并由冒号分隔，语法格式如下：

{键表达式:值表达式 for 一个或一组变量 in 可迭代对象}
{键表达式:值表达式 for 一个或一组变量 in 可迭代对象 if 条件表达式}

a = {'a':1,'b':2}
b = {v:k for k,v in items()}
print(b) # 输出{'a':1,'b':2}
str1 = ['import', 'is','with, if, 'file', 'exception'] # 字符串列表
c = (key: val for val,key in enumerate(str1)]# 用字典推导式以字符串及其位置定义字典
print(c) # 输出为 ('import':0,'is':1,'with':2,'if':3,'file':4,'exception':5}

操作字典

访问项目

使用中括号可以直接访问字典的项目，dict 表示字典对象，key 表示键。

dict[key]

dict1 = ['a':1,'b':2,'c':3]
print(dict1['a']) # 输出 1
print(dict1['e']) # 不存在，抛出异常

使用get()方法访问项目，dict 表示字典对象，参数 key 表示键，defaullt 表示默认值。当指定的键不存在时，将返回默认值，如果没有设置默认值，将返回 None。

dict.get(key[,default])

dict1 = ['a':1,'b':2,'c':3]
print(dict1.get('d')) # 输出 None
print(dict1.get('e','你访问的键不存在')) # 输出 你访问的键不存在

遍历项目

使用 for 语句可以遍历字典包含的所有键，key 临时引用每个项目的键，dict 表示字典对象。语法格式如下：

for key in dict:
    # 处理语句块

使用key()方法可以获取字典所有键的视图对象。
使用value()方法可以获取字典所有值的视图对象。
使用items()方法可以获取字典中全部的项目的视图对象，每个项目就是一个元组。

dict1 = {'a':1,'b':2,'c':3}
print(len(dict1)) # 输出 3
for i in dict1: # 遍历键
    print('%s=%s'%(i,dict1[i])) # 输出键和值
for key in dict1.keys(): # 遍历键
    print('%s=%s'%(key,dict1[key])) # 输出键和值
for value in dict1.values(): # 遍历值
    print(value,end=' ') # 输出 1 2 3
for item in dict1.items():
    print(item) # 输出显示每个项目，('a',1) ('b',2) ('c',3)
for key,value in dict1.items():
    print('%s=%s'%(key,value) # 输出键和值

添加项目

使用等号运算符，可以快速为字典添加新的项目，语法和示例如下：

dict[key] = value

dict1 = {'a':1,'b':2,'c':3}
dict1['d'] = 4 # 不存在，则添加
dict1['a'] = 8 # 存在，则修改
print(dict1) # 输出 {'a':8,'b':2,'c':3,'d':4}

使用setdefault()方法添加一个项目，并设置默认值，dict 表示字典对象，参数key表示要添加的键，default 表示要设置的默认值，key 存在，不操作，key 不存在则新添加一个键，值为默认值。

dict.setdefault(key,default=None)

dict1 = {'a':1,'b':2,'c':3}
print(dict1.setdefault('d',4)) # 添加一个元素
print(dict1.setdefault('c',4)) # 字典包含 c 键，返回原值3
print(dict1) # {'a':1,'b':2,'c':3,'d':4}

为了确保已有键的关联值保持不变，避免覆盖原值，建议使用setdefault()方法添加项目。

修改项目

使用等号运算符，可以修改指定键的值。如果指定的键不存在，则添加一个新项目；如果指定的键存在，则修改该项目键的值。

dict1 = {'a':1,'b':2,'c':3}
dict1['d'] = 4 # 不存在，则添加
dict1['a'] = 8 # 存在，则修改
print(dict1) # 输出 {'a':8,'b':2,'c':3,'d':4}

删除项目

使用del命令可以删除对应的项目。

dict1 = {'a':1,'b':2,'c':3}
del dict1['b'] # 删除 b 键
print(dict1) # 输出 {'a':1,'c':3}

使用pop()方法可以删除指定的键，以及其对应的值，返回值为被删除的值，如果没有找到指定的 key，将返回 default 参数值。

dict.pop(key[,default])

dict1 = {'a':1,'b':2,'c':3}
print(dict1.pop('c') # 输出 3
print(dict1.pop('d','d 键不存在)) # 输出 d 键不存在

使用popitem()方法可以随机删除项目，返回键和值组成的元组。

dict1 = {'a':1,'b':2,'c':3}
while len(dict1)>0: 迭代字典
    print(dict1.popitem()) # 输出删除的键值对，以元组返回，('a',1) ('b',2) ('c',3)
print(dict1) # 空字典 {}
dict1.popitem() # 再次删除空字典，抛出异常

使用clear()方法可以快速清空字典，该方法没有参数，也没有返回值。

dict1 = {'a':1,'b':2,'c':3}
dict1.clean() # 清空字典
print(dict1) # {}

检测项目

使用in 或者 not in运算检测指定的键是否存在于字典中。

dict1 = {'a':1,'b':2,'c':3}
print('a' in dict1,'d' not in dict1) # 输出 True True

合并项目

使用update()方法可以更新字典对象。

dict1 = (a': 1, 6': 2, 'c': 3)
dict2 = ('c': 'c', 'd': 'd')
dict1.update(dict2) # 合并字典对象
dict1.update(e='e') # 合并关键字参数
dict1.update(('f','f')) # 合并可选代对象
print(dict1) # 输出为 ['a':1,'b':2,'c':'c','d':'d','e':'e','f':'f'}

使用|或|=运算符可以合并两个字典对象。

d = d|other
d |= other

dict1 = (a': 1, 6': 2, 'c': 3)
dict2 = ('c': 'c', 'd': 'd')
dict1 = dict1|dict2 # 合并字典对象
dict1 |= [('e','e'),('f','f')] # 合并可选代对象
print(dict1) # 输出为 ['a':1,'b':2,'c':'c','d':'d','e':'e','f':'f'}

复制字典

使用copy()方法快复制字典对象，该方法没有参数，返回一个字典的浅复制。

dictl = (a': 1, b': [2, 3])
dict2 = dict1.copy() # 浅复制字典对象
print(id(dict1["b"])) # 地址：1502877404928
print(id(dict2["b"])) # 地址：1502877404928

import copy
dict2 =copy.copy(dict1) # 浅复制字典对象

使用copy模块的deepcopy()函数执行深复制。

import copy
dictl = (a': 1, b': [2, 3])
dict2 = copy.deepcopy(dictl)# 深复制字典对象
print(id(dict1["b"])) # 1905310108416
print(id(dict2["6"])) # 1905310091968

删除字典

使用del命令直接删除字典。

dict1 = {'a':1,'b':2,'c':3}
del dict1
print(dict1) # 报错，没有定义该变量

8.Python【非序列】- 字典