Python字典101-Dictionary至少知道这么多

字典术语：Dict-Mapping;Item-Entry

字典英文成为Dict或者Dictionary，也称作mapping。
Python中，字典是有任意个元素组成的集合，每个元素成为一个Item，也成为Entry。key+value组合构成了Item，即Entry。

Python字典的初始化

初始化方法一：dict(**kwargs)，使用dict[name]=value完成字典的初始化
初始化方法二：dict(iterable,**kwarg)，使用可迭代对象加dict[name]=value初始化字典，注意，这里的iterable可迭代对象的元素必须是一个二元机构
初始化方法三：dict(mapping,**kwarg)，使用字典构造另一个字典

>>> d1 = {}

官方推荐了几种写法：

>>> a = dict(one=1, two=2, three=3)
>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
>>> d = dict([('two', 2), ('one', 1), ('three', 3)])
>>> e = dict({'three': 3, 'one': 1, 'two': 2})
>>> a == b == c == d == e

True

#我们可以对照做练习：
>>> dn = dict(a=100,b=200)
>>> d4=dict(dn)
>>> d5 = dict(d4, a=300, b=400)
>>> d6=dict([('a',100),["b",200],(1,"abcde")],b=300,c=400)
>>> print(dn)
>>> print(d4)
>>> print(d5)
>>> print(d6)

{'a': 100, 'b': 200}
{'a': 100, 'b': 200}
{'a': 300, 'b': 400}
{'a': 100, 'b': 300, 1: 'abcde', 'c': 400}

>>> b = {'one': 1, 'two': 2, 'three': 3}
>>> b

{'one': 1, 'two': 2, 'three': 3}

类方法 dict.fromkeys(iterable, value):

>>> d = dict.fromkeys(range(5))
>>> d

{0: None, 1: None, 2: None, 3: None, 4: None}

>>> d = dict.fromkeys(range(3),0)
>>> d

{0: 0, 1: 0, 2: 0}

Python字典元素的访问

len(d)

Return the number of items in the dictionary d.

d[key]

Return the item of d with key key. Raises a KeyError if key is not in the map.
这种方法，当key不存在时候就会返回KeyError

get(key[,default])

这种方法在key不存在时候，就不会返回KeyError了，而是可以返回一个默认的值。例如：

>>> d.get(9,"返回默认值，并没有设置哦")

'返回默认值，并没有设置哦'

# 查看一下现在的d，确认返回值没有被添加到字典里
>>> d

{0: 0, 1: 0, 2: 0}

setdefault(key,“设置的默认值”)

setdefault方法，当key不存在时候就添加键值对，value设置为default，并且返回default；
如果default没有设置，那么缺省值我None。

>>> d.setdefault(10,"设置默认的值")

'设置默认的值'

>>> d # 对比d.get ，default的值设置进了字典d

{0: 0, 1: 0, 2: 0, 10: '设置默认的值'}

Update

>>> d = {"a","b"}
>>> d1=[12,34]
>>> d.update(d1)
>>> d

{12, 34, 'a', 'b'}

Python字典的删除

pop(key[,default])

key存在就移除它，并返回它的value
key不存在，就返回给定的default
如果default没有设置，那么，key不存在时候就会报出KeyError异常错误

popitem()

移除并返回一个任意值的键值对
字典如果为empty，则抛出KeyError异常

>>> d = {"a":1,"b":2}
>>> d.popitem()

('b', 2)

clear

清空字典

遍历

1. 遍历key

>>> d = {}
>>> for i in range(5):
>>>     d[i]=i+10
    
>>> d

{0: 10, 1: 11, 2: 12, 3: 13, 4: 14}

>>> for k in d:
>>>     print(k)

0
1
2
3
4

>>> for k in d.keys():
>>>     print(k)

0
1
2
3
4

2. 遍历value

>>> for v in d.values():
>>>     print(v)

10
11
12
13
14

>>> for k in d.keys():
>>>     print(d[k])
>>>     print(d.get(k))

10
10
11
11
12
12
13
13
14
14

遍历字典的items

利用items方法把字典的键和值提取出来的方法

>>> for item in d.items():
>>>     print(item)

(0, 10)
(1, 11)
(2, 12)
(3, 13)
(4, 14)

>>> for k,v in d.items():
>>>     print(k,v)

0 10
1 11
2 12
3 13
4 14

>>> for k,_ in d.items():
>>>     print(k)

0
1
2
3
4

>>> for _,k in d.items():
>>>     print(k)

10
11
12
13
14

Python3中, keys, values, items方法返回一个类似一个生成器的可迭代对象

• Dictionary view对象,可以使用len(), iter(), in操作
• 字典的entry的动态的视图,字典变化,视图将反映出这些变化
• keys返回一个类set对象,也就是可以看做一个set集合。如果values都可以hash,那么items也可以看做是类set对象
  Python2中,上面的方法会返回一个新的列表,立即占据新的内存空间。所以Python2建议使用
  iterkeys, itervalues, iteritems版本,返回一个迭代器,而不是返回一个copy

遍历与删除

d = dict(a = 10, b = 20, c = 30)
d

{'a': 10, 'b': 20, 'c': 30}

在删除字典元素过程中，需要使用keys方法，这个过程不能改变字典的size，比如错误的做法：
pop按照key弹出：

# for k,v in d.items():
#     print(d.pop(k))  # 错误的做法，会引起size changed 异常

d = {
    1:0,
    2.0:3,
    "digital":None,
    ("hello","sales","I"):"client",
    b"a":"334455"
}
d

{1: 0,
 2.0: 3,
 'digital': None,
 ('hello', 'sales', 'I'): 'client',
 b'a': '334455'}

# 这个方法就不会破坏字典的size，不过仅做说明只用，因为这样做就等效于clear
>>> while len(d):
>>>     print(d.popitem())
>>> d
#这里返回的是一个惰性对象

(b'a', '334455')
(('hello', 'sales', 'I'), 'client')
('digital', None)
(2.0, 3)
(1, 0)





{}

key的理解

字典的key要求与set元素的要求是一致的：

• set元素就可以看做key，可以把set理解为dict的简化版
• hashable可哈希的才可作为key，所以在使用某对象作为字典key之前，可以用hash做测试
• 使用key访问，就如同列表使用index一样，时间复杂度是O(1),这是我们推荐使用的访问元素的方式，例如：

>>> d = {
    1:0,
    2.0:3,
    "digital":None,
    ("hello","sales","I"):"client",
    b"a":"334455"
>>> }
>>> d

{1: 0,
 2.0: 3,
 'digital': None,
 ('hello', 'sales', 'I'): 'client',
 b'a': '334455'}

>>> d1 = {
 
    2.0:3,
    "digital":None,
    ("hello","sales","I"):"client",
    b"a":"334455"
>>> }
>>> d1

{2.0: 3, 'digital': None, ('hello', 'sales', 'I'): 'client', b'a': '334455'}

>>> d2 = {
 
     
    "digital":None,
    ("hello","sales","I"):"client",
    b"a":"334455"
>>> }
>>> d2

{'digital': None, ('hello', 'sales', 'I'): 'client', b'a': '334455'}

>>> d1.keys()-d2.keys() #可以用减号运算

{2.0}

Python字典有序性的理解

Python字典是按照key的hash值无序存储的

但有时候我们需要一个有序的元素顺序，在Python3.6之前，使用OrderedDict就可以实现；
到Python3.6开始dict自身支持元素按照生成的先后顺序排序；
但是，3.6之后是否还会继续支持dict按照生成顺序排序呢？我们不确定，所以，建议还是按照不知道Python3.6的这个属性学习和处理。

我们闲聊了解一下到底Python对无序数据结构记录了什么顺序？

当我们使用Python3.5 的版本时候，Python 3.6之前，在不同的机器上，甚至同一个程序分别运行2次，都不能确定不同的key的先后顺序。

C:\Python\Python353>python Python 3.5.3

>>> d = {"a":100,"b":200, "c": 300, "d": 400}
>>> print(d)

{'a': 100, 'b': 200, 'c': 300, 'd': 400}

这个输出结果不是固定的,有可能是：
{ ‘b’: 200,‘a’: 100, ‘c’: 300, ‘d’: 400}
也有可能是：
{ ‘b’: 200,‘a’: 100, ‘c’: 300, ‘d’: 400}

这时候我们需要使用OrderedDict模块：

>>> from collections import OrderedDict

>>> orderd = OrderedDict()
>>> orderd["b"] =200
>>> orderd["c"] = 300
>>> orderd["a"] = 100
>>> orderd["d"] =400

>>> print(orderd) # 这时候输出结构就是按照输入的顺序

OrderedDict([('b', 200), ('c', 300), ('a', 100), ('d', 400)])

如上注意，它输出的其实是线性数据解构，即告诉你它的输出是有顺序的。
当然，Python3.6记录了Python字典key的录入顺序，遍历的时候，也是按照这个顺序，例如下面的输出结果一定是固定的，不会像Python3.5那样变：

>>> d = {"a":100,"b":200, "c": 300, "d": 400}
>>> print(d)

{'a': 100, 'b': 200, 'c': 300, 'd': 400}

目前，建议不要3.6提供的这种字典特性，还是以为字典返回的是无序的。如果非要这种有序，建议使 用OrderedDict。

defaultdict

Python字典的defaultdict其实就是实现给字典的key附默认的值，以下面的代码为例：当d1中k不存在的时候，先创建k和[]空列表键值对，然后为列表增加元素。最后，得到{‘l’: [0, 1, 2], ‘o’: [0, 1, 2], ‘v’: [0, 1, 2], ‘e’: [0, 1, 2]}

>>> d1 = {}
>>> for k in 'love':
>>>     for v in range(3):
>>>         if k not in d1.keys():
>>>             d1[k] = []
>>>         d1[k].append(v)
>>> print(d1)

{'l': [0, 1, 2], 'o': [0, 1, 2], 'v': [0, 1, 2], 'e': [0, 1, 2]}

Python提供了defaultdict默认的类，即defaultdict(default_factory)构造一个特殊字典，初始化是可以传入一个工厂函数，当访问一个不存在的key是，就会调用这个工厂函数获得返回值，和key凑成键值对,例如：

>>> from collections import defaultdict
>>> 
>>> d2 = defaultdict(list)
>>> print(d2["a"]) #创建键值对
>>> print(d2) # 这样就发现独立一个键值对

[]
defaultdict(<class 'list'>, {'a': []})

>>> from collections import defaultdict

>>> # d2 = defaultdict(list)
>>> for k in "love":
>>>     for v in range(3):
>>>         d2[k].append(v) # 
>>> print(d2)

defaultdict(<class 'list'>, {'a': [], 'l': [0, 1, 2], 'o': [0, 1, 2], 'v': [0, 1, 2], 'e': [0, 1, 2]})

拓展阅读https://blog.csdn.net/Alen_1996/article/details/87916039