# {}大括号可以直接定义一个空字典

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'}

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'}

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')

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替代)

# 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