Python字典的所有用法整理

本文整理的 Python 字典的用法，基本覆盖了大部分的开发场景。

一. 创建字典

# 创建空字典
info = {}
info = dict()


# 赋值创建
dic = { 'spam':1, 'egg':2, 'bar':3 }


# 通过关键字 dict 和关键字参数创建
dic = dict(spam = 1, egg = 2, bar =3)


# 通过二元组列表创建
list = [('spam', 1), ('egg', 2), ('bar', 3)]
dic = dict(list)


# dict和zip结合创建
dic = dict(zip('abc', [1, 2, 3]))
dic == {'a': 1, 'c': 3, 'b': 2}


# 通过字典推导式创建
dic = {i:2*i for i in range(3)}
dic == {0: 0, 1: 2, 2: 4}


# 通过dict.fromkeys()创建
dic = dict.fromkeys(range(3), 'x')
dic == {0: 'x', 1: 'x', 2: 'x'}

dic = dict().fromkeys(range(3), 'x')
dic == {0: 'x', 1: 'x', 2: 'x'}

dic = {}.fromkeys(['name', 'blog'])
dic == {'blog': None, 'name': None}

二. 获取字典键值

• 直接获取，当键不存在时会报错，出发KeyError错误。

info['name']

• 使用 get 方法获取值，获取不存在的键值的时候不会触发异常，同时get方法可以接收第二个参数，当不存在该键的时候就会返回第二个参数的值。

info.get('name')
info.get('name','not exists')

• 使用 for 循环迭代字典的值，可只迭代key、可只迭代value、可key和value同时迭代。dict.iteritems()、dict.iterkeys()、dict.itervalues() 这三个字典的方法和dict.items()、dict.keys()、dict.values() 的区别在于，前者是返回一个迭代对象，后者是返回一个列表。

for key in info:
	print key

for key in info.keys()
	print key

for value in info.values():
	print value

for key, value in info.items():
	print key, value

• 判断字典的key是否存在，存在返回True，不存在返回False

info.has_key('age') 

# 等同于

'age' in info.keys()

• 判断字典长度
  len(info)

三. 更新字典

• 直接赋值修改某个键的值
  info['name'] = 'cold'
• 增加字典的键，并设置默认值，如果China没有指定，则值为None
info.setdefault('country', 'China')
• 通过update()函数更新，同时也可以将两个字典合并 info.update(dict)，合并后如果有重复的键值对，最终会显示dict的值。

info = dict(name='yuchaoshui', age=23)
info.update(age=33, location='bj')
info == {'age': 33, 'name': 'yuchaoshui', 'location': 'bj'}

dict1 = {'tel':'18298341309', 'identify':'ok'}
info.update(dict1)
info == {'tel': '181309', 'age': 33, 'ident': 'ok', 'name': 'yuchaoshui', 'location': 'bj'}

• 使用del关键字删除键值对、使用字典pop方法来取出一个键并删除
  del info['name'] 键不存在，则会触发keyerror异常
  info.pop('name')  返回建的值，同时删除该键值对，如果该键不存在，则会触发keyerror异常
  info.pop('name', 'not exists')  返回建的值，同时删除该键值对，如果该键不存在，返回给的的值

四. 字典排序

• 按照key排序
  a、字典本身是无序的， 要有序，则必须是列表或元组。首先对keys 排序，然后用列表生成式生成二元组列表。
  sorted_tuple_list = [ (key,dict[key]) for key in sorted(adict.keys()) ]
  b、使用sorted函数（倒序）， 原理同上，返回二元组列表。
  sorted_tuple_list = sorted(adict.items(), key=lambda x:x[0], reverse = True)
• 按照 value 排序
  a、使用sorted函数，返回二元组列表。
  sorted_tuple_list = sorted(adict.items(), key=lambda x:x[1])
  b、取出value来排序，但是不能保留key的值
  [ value for value in sorted(adict.values()) ]

五. 有序字典

有序字典和普通字典的操作方式相同，只是创建方法不同。

from collections import OrderedDict
a = [("a", 1), ("b", 2), ("c", 3)]
b = OrderedDict(a)

# 或者创建空的有序字典
b = OrderedDict()

OrderedDict内部维护着一个根据键插入顺序排序的双向链表。 每次当一个新的元素插入进来的时候， 它会被放到链表的尾部。需要注意的是，一个 OrderedDict 的大小是一个普通字典的两倍，因为它内部维护着另外一个链表。 所以如果你要构建一个需要大量 OrderedDict 实例的数据结构的时候，需要权衡一下是否使用 OrderedDict 带来的好处要大过额外内存消耗的影响。

六. 默认字典

字典的多值映射。当字典的键对应的值不止一个时， 使用默认字典就非常方便了比如像这种情况，一个键对应的值是字典

{
  'company': {'address': 'shangdi', 'shangban': '9:00', 'xiaban': '6:00'},
  'score': {'chinese': 80, 'math': 91}
  'from': {'ip':'0.0.0.0', 'port':'9999'}
 }

可以很方便的使用 collections 模块中的 defaultdict 来构造这样的字典。 defaultdict 的一个特征是它会自动初始化每个key 刚开始对应的值，所以你只需要关注添加元素操作了。

from collections import defaultdict

d = defaultdict(list)
d['a'].append(1)
d['a'].append(2)
d['b'].append(4)

d = defaultdict(set)
d['a'].add(1)
d['a'].add(2)
d['b'].add(4)

需要注意的是， defaultdict 会自动为将要访问的键（就算目前字典中并不存在这样的键）创建映射实体。 如果你并不需要这样的特性，你可以在一个普通的字典上使用 setdefault() 方法来代替。比如：

d = {} 
d.setdefault('a', []).append(1)
d.setdefault('a', []).append(2)
d.setdefault('b', []).append(4)

这样做的一个缺点就是每次调用都需要写 setdefault('a', []) 这样的格式调用，很麻烦。