python字典是python中非常重要的一个基础类型,它是一个高效的基础类型,不仅在编写程序的时候经常用到,就连python底层的实现都大量的使用了字典。
主要从几个方面去学习python的字典
1. 字典的基本使用
2. 字典的扩展和针对它的一些类库(针对特殊用途的字典)
3. 自定义自己的字典
4. 字典的底层实现
字典的基本使用
创建字典
创建字典有很多种方式,但是要注意一点的是,字典的键必需是能够哈希的,因此字典的键的哈希值应该在对象的生命周期中是不会变的,这其中包括不可变类型如:str, bytes, int,还有frozen set, 和不包含可变类型项的元组,以及实现了eq()和hash()方法的hash值不变的对象。
下面列举了一些构造字典的方法
(只考虑方法,并未关注效率问题, 关于效率问题在深入研究之后来分析)
直接构造字典的方式
a = {‘one’ : 1, ‘two’ : 2, ‘three’ : 3}
通过工厂方法创建字典
传字典参数的方法构造字典:
b = dict(one=1, two=2, three=3)
使用zip方法构造
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})
列表对元组的方式
f = dict(([‘one’, 1], [‘two’,2],[‘three’,3]))
fromkeys创建默认值字典:
g = dict.fromkeys([‘one’,’tow’,’three’], 1)
字典推导式
h = {value:index+1 for index, value in enumerate(['one','tow','three'])}
可见python中的字典是非常强大的,它的操作非常丰富和方便,下面列举一些常用的操作
常用操作
字典中有哪些方法,怎么使用了
首先来看下字典的类图
dict_test = {1: ‘one’, 2: ‘two’, 3: ‘three’}
- container
可以使用 in 来判断元素是否存在:
>>> 1 in dict_test
True
- mapping
>>> dict_test.keys()
dict_keys([1, 2, 3])
>>> dict_test.values()
dict_values(['one', 'two', 'three'])
>>> dict_test.items()
dict_items([(1, 'one'), (2, 'two'), (3, 'three')])
注: 在python3中这三个方法返回的都是视图,
- 另外可以通过key取得值
>>> dict_test[1]
‘one’
- 也可以直接给key配对值
>>> dict_test[4] = 'four'
>>> dict_test
{1: ‘one’, 2: ‘two’, 3: ‘three’, 4: ‘four’}
- 以及使用get方法取得值,如果没有这个key返回默认值
>>> dict_test.get(1, '1')
‘one’
>>> dict_test.get('1', '1')
‘1’
- sized
获取字典的长度
>>> len(dict_test)
3
- iterable
可以遍历和是迭代对象(以键进行遍历)
>>> for value in dict_test:
... print(value)
...
1
2
3
>>> from collections import Iterable
>>> isinstance(dict_test, Iterable)
True
>>> iter(dict_test)
- iterator
变成迭代器
>>> iter_test = iter(dict_test)
>>> next(iter_test)
1
>>> next(iter_test)
2
>>> next(iter_test)
3
>>> next(iter_test)
Traceback (most recent call last):
File “”, line 1, in
StopIteration
- 其他一些方法
>>> dir(dict_test)
['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__
', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__s
tr__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']
- 常用的方法
pop 移除并返回移除的键对应的值, 需要传一个key参数
>>> dict_test.pop(1)
‘one’
>>> dict_test
{2: ‘two’, 3: ‘three’}
同上, popitem移除并返回移除的键值对
>>> dict_test.popitem()
(2, ‘two’)
>>> dict_test
{3: ‘three’}
setdefault 方法类似于get方法,只不过在没有找到键的情况下会将这个键对应的值设置成默认值,并将这个值返回,如果有这个键,直接返回键对应的值
>>> dict_test.setdefault(4, 'four')
‘four’
>>> dict_test
{1: ‘one’, 2: ‘two’, 3: ‘three’, 4: ‘four’}
直接删除字典中的键值对
>>> del dict_test[1]
>>> dict_test
{2: ‘two’, 3: ‘three’, 4: ‘four’}
copy方法, 直接调用copy()为浅拷贝, 即创建了一个新对象,但内容实际上是用的原对象内容的引用, 请看下面的这个例子
>>> dict_test = {'one':1, 'two':[1,1]}
>>> dict_copy = dict_test.copy()
>>> dict_copy['two'].append(1)
>>> dict_test['two']
[1, 1, 1]
使用深拷贝就不会有这个问题
dict_test = {'one':1, 'two':[1,1]}
import copy
dict_deep_copy = copy.deepcopy(dict_test)
dict_deep_copy['two'].append(1)
dict_test['two']
[1, 1]
部分方法前面已经有演示了,这里不再说明, update用于字典合并,合并有很多种方法,而且经常用到,
合并和更新字典
这里列举一些方法:
dict1 = dict([(1,'one'), (2,'two')])
dict2 = {2:'two_two',3:'three'}
直接用update方法(这种情况会改变字典)
>>> dict1.update(dict2)
>>> dict1
{1: ‘one’, 2: ‘two_two’, 3: ‘three’}
可以使用copy方法或者工厂方法,新创建一个字典从而不改变原有字典
>>> dict1_copy = dict1.copy() # dict(dict1)
>>> dict1_copy.update(dict2)
>>> dict1_copy
{1: ‘one’, 2: ‘two_two’, 3: ‘three’}
>>> dict1
{1: ‘one’, 2: ‘two’}
使用解绑再组合的方式,这种方式存在一些问题,如下:
>>> dict(dict1, **dict2)
Traceback (most recent call last):
File “”, line 1, in
TypeError: keyword arguments must be strings
因此这种方式只适合key为可作为变量名字的情况
同样可以使用字典推导式的方式进行字典合并
>>> {key:value for d in [dict1, dict2] for key, value in d.items()}
{1: ‘one’, 2: ‘two_two’, 3: ‘three’}
全部遍历相加的方法,类似于前面的推导式
>>> dict(list(dict1.items()) + list(dict2.items()))
{1: ‘one’, 2: ‘two_two’, 3: ‘three’}
使用连接操作符 ‘|’
>>> dict(dict1.items() | dict2.items())
{1: ‘one’, 2: ‘two’, 3: ‘three’}
>>> dict(dict2.items()|dict1.items())
{1: ‘one’, 2: ‘two_two’, 3: ‘three’}
这里覆盖的顺序变了, 如果有重复的key将以第一个字典中key的值作为最终合并的值
借助于其他类库
>>> from itertools import chain
>>> dict(chain(dict1.items(), dict2.items()))
{1: ‘one’, 2: ‘two_two’, 3: ‘three’}
>>> from collections import ChainMap
>>> ChainMap({}, dict2 ,dict1 )
ChainMap({}, {1: ‘one’, 2: ‘two’}, {2: ‘two_two’, 3: ‘three’})
>>> dict(ChainMap({}, dict1, dict2))
{1: ‘one’, 2: ‘two’, 3: ‘three’}
这里第一个空字典,是为了不改变dict1中的值, 而且注意字典的排放顺序, dict1需要放到最后,因为我们需要dict2中的值覆盖dict1中的值, 这种方式不进行字典遍历,因为它首先生成了一个view,在查找的时候才会去匹配,ChainMap并不会直接变成 dict, 需要dict工厂方法进行转换, 这种情况适合合并多个字典的情况
dict3 = {3:'three_three', 4:'four'}
>>> dict(ChainMap({}, dict3, dict2, dict1))
{1: ‘one’, 2: ‘two_two’, 3: ‘three_three’, 4: ‘four’}
注意字典在参数中的位置, 需要更新的字典放最后
全部解绑的方式(这种方便快捷的方式只在python3.5以上有效)
>>> {**dict1, **dict2}
{1: ‘one’, 2: ‘two_two’, 3: ‘three’}
除了合并比较两个字典的大小也常用
比较字典
由于在python2.1之后有增加了更加丰富的比较符, 但python2又一直保留着cmp这个内置函数,因此可以直接通过cmp方法进行比较但是在python3中这个内置方法已经移除,需要自己去实现那些比较符对应的方法,比如 < 对应着 _lt_, 其他类似: <= _le_, == _eq_, != _ne_, > _gt_, >= _ge_.
字典的比较顺序,在python2中遵守下面的规则
首先比较字典的长度, 然后比较字典的键,最后比较字典的值
而在python3中需要自己去实现那些比较符方法
dict1 = {1:'one', 3:'three'}
dict2 = {2:'two', 3:'three_three'}
condition = True if dict1 >= dict2 else False
condition
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-26-6e55c3e20291> in <module>()
----> 1 condition = True if dict1 >= dict2 else False
2 condition
TypeError: unorderable types: dict() >= dict()
dict1.__lt__(dict2)
NotImplemented
另外要说的一点就是, 字典中的键是无序的集合,因此可以利用集合的一些操作来处理字典, 比如找到第一个字典中没有的键值对,可以利用集合的差补来做
{key: dict1[key] for key in set(dict1) - set(dict2)}
{1: ‘one’}
还有其他一些字典的操作,比如给字典排序, 扩展和改造自己的字典类型等,下次有时间总结下。
上面这些例子是在python3.4.3下面测试的