python容器之字典详解

字典与列表类似，也是可变序列，不过不同的是字典是无序的可变序列，它的元素是通过键值对的形式存放的，键是唯一的，值是可变的。

字典的主要特征：

• 通过键而不是通过索引来访问
• 字典是无序的可变序列
• 字典是可变的，而且可以任意嵌套
• 字典的键必须是唯一且不可变的

一：字典的创建

字典的定义形式为：字典变量名 ={key:value,....}。

这里面key代表索引值，而value代表映射的值，通过大括号将其括起来进行字典的定义。

1.1，使用{}或者函数dict()创建

>>> dictx={} #直接生成一个空字典 dictx
>>> dict3 = dict() #创建一个空字典dict3,生成空字典建议使用工厂函数list

1.2，通过将包含双值子序列的序列转换成字典

通过将key和value作为一个序列类型（元组或列表）创建一个字典

a = (('李宁','一切皆有可能'),('python','编程改变世界'))
a也可以是以下形式：
a = [('李宁','一切皆有可能'),('python','编程改变世界')]
a = (['李宁','一切皆有可能'],['python','编程改变世界'])
a = [['李宁','一切皆有可能'],['python','编程改变世界']]
>>> dict4 = dict(a)
>>> dict4
{'李宁': '一切皆有可能', 'python': '编程改变世界'}

1.3，通过对关键字赋值创建一个字典，

注意关键字必须是一个字符串类型且不能加引号，因为程序会默认为其加上一个引号

>>> dict5 = dict(李宁='一切皆有可能', python='让编程改变世界')
>>> dict5
{'李宁': '一切皆有可能', 'python': '编程改变世界'}

1.4，使用内置函数 fromkeys

fromkeys(iterable, value=None, /)创建并返回一个新的字典。

• 第一个参数是一个可迭代对象（序列），
• 第二个参数是value值，当第二个参数不提供时，则默认为none

特别说明：建议使用list()创建空字典

>>> dict1 = dict()
>>> dict2 = dict1.fromkeys((1, 2, 3), 'number')
>>> dict2
{1: 'number', 2: 'number', 3: 'number'}
>>> dict3 = dict1.fromkeys((1, 2, 3))
>>> dict3
{1: None, 2: None, 3: None}

二：字典访问

2.1，直接使用dict[key]

注意：如果key不存在字典中，无法访问，且会报错

>>> dict1 = {1:'one',2:'two',3:'three'}
>>> dict1[2]
'two'

2.2，使用内置函数 get(k[,d])，通过key返回对应的value值，

• 第一个参数为key值，
• 第二个参数d为默认返回的value值，

当key存在则返回对应的值，不存在字典内时返回该valuevalue值，如果不提供则默认为 none

>>> dict5 = {1:'one',2:'two',3:'three'}
>>> dict5.get(3,'木有')
'three'
>>> dict5.get(4,'木有')
'木有'
>>> dict5.get(4)
>>> print(dict5.get(4))
None

三：单独访问 key,value,及item

• keys() 返回字典所有的key,返回可迭代对象，
• values() 返回字典所有的value，返回可迭代对象
• items() 返回字典所有的 item，返回可迭代对象

举例说明：

>>> dict4={1:'one',2:'two',3:'three'}
>>> dict4.keys()        #返回字典的所有key值
dict_keys([1, 2, 3])
>>> dict4.values()
dict_values(['one', 'two', 'three'])
>>> dict4.items()
dict_items([(1, 'one'), (2, 'two'), (3, 'three')])

四：修改或增加字段元素

4.1，使用[key]=value 添加或修改元素

当key值存在于字典内时，则重置key的value值 ，相当于修改

当key值不存在于字典内时，则字典增加一个键值对（key:value）

>>> dict6 = {'李宁': '一切皆有可能', 'python': '让编程改变世界'}
>>> dict6['李宁'] = '非一般'
>>> dict6
{'李宁': '非一般', 'python': '让编程改变世界'}
>>> dict6['fruit']='apple'
>>> dict6
{'fruit': 'apple', '李宁': '非一般', 'python': '让编程改变世界'}

4.2，使用内置函数 update

• 对于不存在的键值对 ,则添加key-value
• 对于存在的键值对，则修改key对应的值

>>> dict7 = {1: 'one', 2: None, 3: 'three'}
>>> dict8 = {4:'four'}
>>> dict7.update(dict8)            #对于不存在的key ,key-value则添加
>>> dict7
{1: 'one', 2: None, 3: 'three', 4: 'four'}
>>> dict9 = {2:'two'}
>>> dict7.update(dict9)          #对于存在的key，则修改key对应的值
>>> dict7
{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

4.3，函数setdefault(k[,d])

k表示键，用于在字典中查找指定键对应的值，既可以访问字典，又可以修改字典

• - k不在字典内时 新增一个键值对item 同时返回d的值，如果d没提供则返回空
• - k存在字典内时，把该键对应的值返回，不会在字典中添加新的键值对

>>> dict7 ={3: 'three'}
>>> dict7.setdefault(1,'one') #1不存在字典中， 返回设定的one，同时新增一个键值对
'one'
>>> dict7
{1: 'one', 3: 'three'}
>>> dict7.setdefault(2) #2不在字典中，但是没有设置参数d，默认返回None，同时新增一个键值对（2，None）
None
>>> dict7
{1: 'one', 2: None, 3: 'three'}
>>> dict7.setdefault(3,'有') #3存在，返回3对应的three
'three'

五：字典删除和清空

5.1，pop(k[,d]) 删除字典的键值对。

• - 当k存在字典的key时，在字典内去除该key对应的（key,value）并返回对应的value，
• - 当k不存在字典的key时，返回d的值，如果不提供d则返回错误，

dict7={1: 'one', 2: 'two', 3: 'three'}
>>> dict7.pop(1,'木有')
'one'
>>> dict7
{2: 'two', 3: 'three'}
>>> dict7.pop(1,'木有')
'木有'
>>> dict7.pop(1)
KeyError: 1

5.2，popitem()

删除字典内的一个（key,value），并返回该键值对，如果字典本身为空时报错

>>> dict7
{2: 'two', 3: 'three'}
>>> dict7.popitem()
(2, 'two')
>>> dict7
{3: 'three'}

5.3，使用del删除指定键的元素

>>> dict1 = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
>>> del dict1['apple']
>>> dict1
{'banana': 3, 'pear': 1, 'orange': 2}

5.4，clear() 字典清空

>>> dict7.clear()
>>> dict7
{}

六：字典复制

copy() 相当于复制出一个新的字典

>>> dict5 = {1: 'one', 2: 'two', 3: 'three'}
>>> dict6 = dict5     #赋值操作，相当于贴了个新标签，内存地址不变
>>> id(dict6)            #查看对象内存地址
58796168
>>> id(dict5)
58796168
>>> dict7 = dict5.copy() #copy()相当于复制出一个新的字典
>>> id(dict7)
58795208
>>> dict6.clear() #当清除dict6时，dict5也一并清除
>>> dict6
{}
>>> dict5
{}
>>> dict7 #copy()复制出的新的字典不会被清空
{1: 'one', 2: 'two', 3: 'three'}

六：获取字典中最大的值对应的键

命名参数key接受一个函数，该函数接受一个参数并返回一个可以比较大小的对象，max返回使该函数的返回值最大的成员。传dict.get时，就会对dict中每个键返回对应的值，这样找到的就是值最大的键。

dict1={'a':10,'b':15,'c':5}
max(dict1,key=dict1.get)
'b'
min(dict1,key=dict1.get)
'c'