08-02字典

字典

字典是一种key-value结构

字典对象操作

新建字典

• 方式1：d = {}
• 方式2：d = dict()
• 方式3：d = {'a':1, 'b': 2}
• 方式4：d = dict([('a',1), ('b', 2)]) # 可迭代对象的元素必须是一个二元组, 二元组的第0个元素为字典的key, 第一个元素为字典的value。
• 方式5：传入的可迭代元素为key, 值为None。

In [26]: dict.fromkeys(range(5))   # 传入的可迭代元素为key, 值为None。
Out[26]: {0: None, 1: None, 2: None, 3: None, 4: None}

In [27]: d = dict.fromkeys(range(5), 'abc')   # 传入的可迭代对象的元素为key, 值为abc。

In [28]: d
Out[28]: {0: 'abc', 1: 'abc', 2: 'abc', 3: 'abc', 4: 'abc'}

• 方法6：接收一个字典，不常用
  • 例如：In [33]: d = dict({'a':1, 'b':3}) # 接收一个字典

删除字典

字典元素的操作

增加与修改

• 可以直接下标操作，如果key不存在则会增加kv对，如果key存在则会修改其value
• d.update([('c', 3), ('p', 0)])：传入一个字典，该方法通常用于合并字典

In [30]: d['acc'] = 5   # 可以直接使用key做为下标, 对某个不存在的下标赋值, 会增加kv对。

In [31]: d.update([('c', 3), ('p', 0)])   # update传入参数和dict一样

In [32]: d
Out[32]: {0: 'abc', 1: 'abc', 2: 'abc', 3: 'abc', 4: 'abc', 'acc': 5, 'c': 3, 'p': 0}

In [34]: d.update({'r': 2, 'd': 3})   # update通常用于合并字典

In [36]: d.update([('r', 2), ('d', 2)])   # 传入一个值

In [37]: d['a'] = 2   # 当key存在, 对下标赋值的时候, 会修改这个key对应的value。

删除

• d.pop(0)：pop方法用于从字典删除一个key, 并返回其value。当key不存在时会抛出KeyError
• d.pop(0, 'defalut'): 当删除不存在的key, 并且指定了默认值时, 不会抛出KeyError, 并且返回默认值
• d.popitem()：popitem随机返回并删除一个kv对的二元组，如果空字典则会抛出KeyError
• d.clear()：clear方法清空一个字典
• del d['c']：不过通常用pop删除key

In [4]: d.pop(0)   # pop方法用于从字典删除一个key, 并返回其value
Out[4]: 'abc'

In [5]: d.pop(0)   # 当删除不存在的key的时候, 会抛出KeyError
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-5-e1702b259b84> in <module>()
----> 1 d.pop(0)

KeyError: 0

In [6]: d.pop(0, 'defalut')   # 当删除不存在的key, 并且指定了默认值时, 不会抛出KeyError, 并且返回默认值
Out[6]: 'defalut'

In [7]: d.pop(1, 'default')   # 有没有default, 是在key不存在的时候才有所区别。
Out[7]: 'abc'

In [8]: d.popitem()   # popitem随机返回并删除一个kv对的二元组
Out[8]: (2, 'abc')

In [9]: d.clear()   # clear方法清空一个字典

In [10]: d.popitem()   # 对空字典popitem, 将抛出KeyError
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-10-5d3e77a54ba7> in <module>()
----> 1 d.popitem()

KeyError: 'popitem(): dictionary is empty'

In [12]: del d['c']   # 不过通常用pop删除key

访问

单个元素的访问

• d['d']：通过key访问value，当key不存在的时候抛出KeyError
• d.get('d')：get方法通过key访问value，get方法访问不存在的key的时候返回None
• d.get('c', 'default')：事实上get方法访问不存在的key的时候, 返回默认值, 默认值默认为None
• d.setdefault('c', 'default')：当一个key存在value的时候, 返回value, 如果不存在, 就添加其kv对。

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

In [3]: d['d']   # 通过key访问value
Out[3]: 2

In [4]: d['c']   # 当key不存在的时候抛出KeyError
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-4-3e4d85f12902> in <module>()
----> 1 d['c']

KeyError: 'c'

In [5]: d.get('d')   # get方法通过key访问value
Out[5]: 2

In [6]: d.get('c')   # get方法访问不存在的key的时候返回None

In [9]: d.get('c', 'default')   # 事实上get方法访问不存在的key的时候, 返回默认值, 默认值默认为None
Out[9]: 'default'

d.setdefault：当一个key存在value的时候, 返回value, 如果不存在, 就添加其kv对。
In [10]: d.setdefault('c', 'default')     # c不存在
Out[10]: 'default'

In [11]: d
Out[11]: {'c': 'default', 'd': 2, 'p': 0, 'r': 2}

In [12]: d.setdefault('d', 'default')
Out[12]: 2

setdefault的实现：
    In [13]: def setdefault(d, k, default=None):
        ...:     value = d.get(k, default)
        ...:     d[k] = value
        ...:     return value
        ...: 

字典的遍历

字典的元素是成对出现的

• 如果直接用for in遍历字典, 遍历的是字典的key
• d.values()：value返回一个可迭代对象, 元素是字典的所有value
• items方法返回一个可迭代对象, 元素是字典的所有(k, v)对
• d.keys()：eys方法返回一个可迭代对象, 元素是字典所有的key

In [14]: for x in d:
    ...:     print(x)
    ...:
d
p
c
r

In [15]: d
Out[15]: {'c': 'default', 'd': 2, 'p': 0, 'r': 2}

直接用for in遍历字典, 遍历的是字典的key

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

In [19]: for v in d.values():   # 返回values
    ...:     print(v)
    ...:
2
0
default
2

In [20]: d.items()   # items方法返回一个可迭代对象, 元素是字典的所有(k, v)对
Out[20]: dict_items([('d', 2), ('p', 0), ('c', 'default'), ('r', 2)])

In [21]: for x in d.items():   # key和value都出现
    ...:     print(x)
    ...:     
('d', 2)
('p', 0)
('c', 'default')
('r', 2)

In [22]: for k, v in d.items():    # key和value分开出现
    ...:     print(k, v)
    ...:     
d 2
p 0
c default
r 2

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

python2与Python3的不同

python2中返回的都是一个列表, python3中返回的是可迭代对象
区别：python3中的keys, values, items返回的都是生成器, 它并不会复制一份内存。
python2中对应的函数返回的是列表, 会复制一份内存。

Python 2.7.5 (default, Nov  6 2016, 00:28:07) 
[GCC 4.8.5 20150623 (Red Hat 4.8.5-11)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> d = {'r': 2, 'd': 2, 'c': 3, 'p
  File "<stdin>", line 1
    d = {'r': 2, 'd': 2, 'c': 3, 'p
                                  ^
SyntaxError: EOL while scanning string literal
>>> d = {'r': 2, 'd': 2, 'c': 3, 'p': 0}
>>> type(d.keys())
<type 'list'>
>>> type(d.items())
<type 'list'>
>>> type(d.values())
<type 'list'>

字典的限制

• 字典是无序的
• 字典的key不能重复
• 字典的key需要可hash

In [24]: d = {}

In [25]: d[[1, 2, 3]] = 3   # 不可hash的key会报错
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-25-1b5d054185d2> in <module>()
----> 1 d[[1, 2, 3]] = 3

TypeError: unhashable type: 'list'

In [26]: d[(1, 2, 3)] = 3

In [27]: d
Out[27]: {(1, 2, 3): 3}

In [28]: d[0] = [1, 2, 3]   # 字典的value是没有限制的

In [29]: d
Out[29]: {0: [1, 2, 3], (1, 2, 3): 3}

In [30]: hash(d)   # 字典不是可hash的, 所以不能做set的元素
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-30-a37dc9dc2032> in <module>()
----> 1 hash(d)

TypeError: unhashable type: 'dict'

标准库中两个字典的变体

默认字典

• 默认字典的定义：d2 = defaultdict()
• 默认字典的初始值：defaultdict(None, {})

In [31]: from collections import defaultdict

In [32]: d1 = {}    # 普通字典

In [33]: d2 = defaultdict()   # 默认字典

In [34]: d1   # 普通字典的初始值
Out[34]: {}

In [35]: d2
Out[35]: defaultdict(None, {})   # 默认字典的初始值

In [40]: d2 = defaultdict(list)

In [41]: d1['a']
---------------------------------------------------------------------------
KeyError                                  Traceback (most recent call last)
<ipython-input-41-a9ea8faf9ae0> in <module>()
----> 1 d1['a']

KeyError: 'a'

In [42]: d2['a']    # 得到一个list
Out[42]: []

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

In [43]: d = {}
    ...: for k in range(10):
    ...:     for v in range(10):
    ...:         if k not in d.keys():
    ...:             d[k] = []
    ...:         d[k].append(v)
    ...:

In [44]: d = defaultdict(list)

In [45]: for k in range(10):
    ...:     for v in range(10):
    ...:         d[k].append(v)
    ...:

有序字典

In [46]: from collections import OrderedDict

In [47]: d = OrderedDict()

In [48]: d[0] = 3

In [49]: d[3] = 4

In [50]: d
Out[50]: OrderedDict([(0, 3), (3, 4)])

In [51]: for k, v in d.items():
    ...:     print(k, v)
    ...:
0 3
3 4

有序字典, 会保持插入顺序

In [53]: def f():
...:     print('f is called')
...:     return 'a'
...: 

In [54]: d = defaultdict(f)

In [55]: d['xxx']
f is called
Out[55]: 'a'

In [56]: d['yyy']
f is called
Out[56]: 'a'

In [57]: d['xxx']
Out[57]: 'a'

字典总结

字典：
    增加/修改：
        下标操作
        update
    删除
        pop()
            有默认值
            无默认值的区别
        popitem
            无序的
        clear
        del 语句
    访问：
        单个元素：
            下标
            get
            setdefault
        遍历：
            keys
            values
            items
    限制：
        key必须是可hash