[PY3]——内置数据结构——字典及其常用操作

Posted 2020-09-08 Jelly_lyj

字典的定义、字典的增加与修改、字典的删除、字典的访问、字典的遍历、字典的限制、默认字典(defaultdict)、有序字典(OrderedDict)

字典及其常用操作Xmind图

 

 

关于字典

字典是一种key-value结构

字典是无序的

 

字典的定义

# {}大括号可以直接定义一个空字典
In [1]: d={};type(d)
Out[1]: dict

# {key:value}
In [2]: d={\'a\':1,\'b\':2};print(d)
{\'a\': 1, \'b\': 2}

# dict([(key,value)]) 可迭代对象的元素必须是一个二元组，二元组的第0个元素为key，第1个元素的为value
In [6]: d=dict( [ (\'a\',1),(\'b\',2) ] );print(d)
{\'a\': 1, \'b\': 2}

# dict.fromkeys(可迭代对象,value) 传入的可迭代对象作为key，value缺省时默认为None
In [8]: d=dict.fromkeys(range(5));print(d)
{0: None, 1: None, 2: None, 3: None, 4: None}

In [9]: d=dict.fromkeys(range(5),\'aa\');print(d)
{0: \'aa\', 1: \'aa\', 2: \'aa\', 3: \'aa\', 4: \'aa\'}

 

字典的增加与修改操作

In [10]: d
Out[10]: {0: \'aa\', 1: \'aa\', 2: \'aa\', 3: \'aa\', 4: \'aa\'}

# 可以直接使用key作为下标来操作，下标存在时为修改、不存在时为增加
In [11]: d[\'5\']=\'bb\';print(d)
{0: \'aa\', 1: \'aa\', 2: \'aa\', 3: \'aa\', 4: \'aa\', \'5\': \'bb\'}

# update() 当中的可以是一个字典，所以通常用于合并两个字典
In [15]: d.update([(\'6\',\'cc\')]);print(d)
{0: \'aa\', 1: \'aa\', 2: \'aa\', 3: \'aa\', 4: \'aa\', \'5\': \'bb\', \'6\': \'cc\'}

In [17]: d.update({\'7\':\'ee\'});print(d)
{0: \'aa\', 1: \'aa\', 2: \'aa\', 3: \'aa\', 4: \'aa\', \'e\': \'e\', \'5\': \'bb\', \'6\': \'cc\', \'7\': \'ee\'}

 

字典的删除操作

1. pop(key,返回值)

In [21]: d
Out[21]: {0: \'aa\', 1: \'bb\', 2: \'aa\', 3: \'aa\', 4: \'aa\'}

# pop(key)从字典删除一个key，返回该key对应的value
In [22]: d.pop(4)
Out[22]: \'aa\'
In [23]: d
Out[23]: {0: \'aa\', 1: \'bb\', 2: \'aa\', 3: \'aa\'}

# 删除不存在的key，抛出KeyError
In [24]: d.pop(4)
KeyError: 4

# 删除不存在的key并指定默认值时，不会抛出KeyError并返回默认值
In [25]: d.pop(4,\'default\');print(d)
{0: \'aa\', 1: \'bb\', 2: \'aa\', 3: \'aa\'}

2. popitem() 随机删除一对，对空字典popitem()抛出KeyError

In [26]: d
Out[26]: {0: \'aa\', 1: \'bb\', 2: \'aa\', 3: \'aa\'}

In [27]: d.popitem()
Out[27]: (0, \'aa\')

In [28]: d.popitem()
Out[28]: (1, \'bb\')

3. clear() 清空一个字典

4. del语句（通常不会使用del来删除）

In [29]: d
Out[29]: {2: \'aa\', 3: \'aa\'}

In [30]: del d[3];print(d)
{2: \'aa\'}

 

字典的访问

In [1]: d={\'d\':2,\'p\':0,\'r\':2}

# 可通过key来访问其对应的value
In [2]: d[\'d\']
Out[2]: 2

In [3]: d[\'a\']
KeyError: \'a\'

# get(key,返回值) 返回值不指定时默认为None
In [4]: d.get(\'d\')
Out[4]: 2

In [5]: d.get(\'a\')

In [6]: d.get(\'a\',\'default\')
Out[6]: \'default\'

 

字典的遍历

# for循环直接遍历dict，可遍历到字典的key
In [8]: for i in d:
...: print(i)
p
d
r

# dict.keys()返回一个可迭代对象，元素是字典的所有key
In [17]: d.keys()
Out[17]: dict_keys([\'p\', \'d\', \'r\'])

In [18]: for i in d.keys():
...: print(i)
p
d
r

# dict.values()返回一个可迭代对象，元素是字典的所有value
In [12]: d.values()
Out[12]: dict_values([0, 2, 2])

In [13]: for i in d.values():
...: print(i)
0
2
2

# dict.items()返回一个可迭代对象，元素是字典的(key,value)
In [14]: d.items()
Out[14]: dict_items([(\'p\', 0), (\'d\', 2), (\'r\', 2)])

In [15]: for i in d.items():
...: print(i)
(\'p\', 0)
(\'d\', 2)
(\'r\', 2)

# 可以利用遍历items来做解构
In [16]: for k,v in d.items():
...: print(k,v)
p 0
d 2
r 2

# PY3与PY2的不同在于：
PY3中keys、values、items返回的是类似生成器的可迭代对象，并不会复制一份内存；
PY2中keys、values、items返回的是一个列表，会复制一份内存。(当然啦可用iterkeys、itervalues、iteritems替代)

 

字典的限制

字典的key不能重复，且需要可Hash

 

默认字典

# default初始化的时候，需要传入一个函数，这个函数也叫工厂函数。
# 当我们使用下标访问一个key时，如果这个key不存在，defaultdict会自动调用初始化时传入的函数，生成一个对象作为这个key的value

In [20]: from collections import defaultdict

In [21]: d1={}
In [25]: d1[0]
KeyError: 0

In [23]: d2=defaultdict(list)
In [26]: d2[0]
Out[26]: []

In [24]: d3=defaultdict(tuple)
In [27]: d3[0]
Out[27]: ()

 

有序字典

In [30]: from collections import OrderedDict

In [31]: d=OrderedDict()

In [33]: d[0]=3;d[3]=1;d[6]=1

In [34]: d
Out[34]: OrderedDict([(0, 3), (3, 1), (6, 1)])

In [35]: for k,v in d.items():
...: print(k,v)
0 3
3 1
6 1