Python dict(字典)

Python教程 2018-12-26 21:50:10 阅读(10231) 评论(0)

字典(dict, dictionary的简写)是Python中另一个非常重要的内置数据类型,是Python中映射类型(Mapping Type),它把“键”(key)映射到“值”(value),通过key可以快速找到value,它是一种“键值对”(key-value)数据结构。

python dict

“键”,可以是任意不可变的类型对象(可以做hash,即具有hash()eq()方法的对象),通常是字符串和数字,同一个字典中键是唯一的。但不能是list,因为list可以通过索引、切片、append()和extend()方法改变其值。
“值”,可以是任何类型的数据。

python的字典

Python字典(dict)的创建

字典可以通过dict()或一对花括号创建一个空字典: d = {}。花括号内可以放用逗号,隔开的多个键值对,键值对用冒号:隔开:

In [1]: d1 = {}

In [2]: d2 = dict()

In [3]: d1 == d2
Out[3]: True

In [4]: d3 = {'a': 1, 'b': 2, 'c': 3}

In [5]: d3
Out[5]: {'a': 1, 'b': 2, 'c': 3}

In [6]: d4 = {'a': 1, 'a':2, 'a':3}

In [7]: d4
Out[7]: {'a': 3}

上面最后一个例子d4的初始化中,键都是'a',所以得到的字典只有一个键,它的值是最后一次赋值3.

dict()创建字典对象

dict()无参数时生成空字典,也可以通过传入参数进行初始化。传入参数有两种形式:
一种是,序列型数据list或tuple,它每个元素必须又含有两个子元素,以满足key-value对;
一种是,name=value形式的参数。
见下面的例子:

In [21]: d1
Out[21]: {'a': 1, 'b': 2, 'c': 3}

In [22]: d2 = dict(a=1, b=2, c=3)

In [23]: d2
Out[23]: {'a': 1, 'b': 2, 'c': 3}

字典推导式(Dict Comprehension)

类似列表推导式,我们可以通过一个for循环表达式来创建一个字典:

In [10]: dd = {x: x*x for x in range(5)}

In [11]: dd
Out[11]: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

list不能做字典的key,但是可以做value:

In [12]: l1 = [1,2,3]

In [13]: d = {'a': l1}

In [14]: d = {l1: 'a'}
----------------------
TypeError     Traceback (most recent call last)
<ipython-input-14-bcd280c2bff6> in <module>
----> 1 d = {l1: 'a'}

TypeError: unhashable type: 'list'

Python字典(dict)的访问

(1)通过键访问其值
列表可以通过其索引访问元素,字典就是通过键访问对应的值,形式类似列表那样用方括号,只不过用“键”替代了“索引”。方法是字典对象名称加方括号括起来的键名,比如:mydict['a']。如果某个键不在字典对象中,通过方括号访问就会报错:

In [26]: myd = dict(a=1, b=2, c=3)

In [27]: myd
Out[27]: {'a': 1, 'b': 2, 'c': 3}

In [28]: myd['a']
Out[28]: 1

In [29]: myd['e']
------------------
KeyError          Traceback (most recent call last)
<ipython-input-29-86b81ed4647a> in <module>
----> 1 myd['e']

KeyError: 'e'

(2)通过get(key)方法访问其值
给get()传入键作为参数,就可以得到value,如果key不存在则返回None。

In [30]: myd.get('a')
Out[30]: 1

In [31]: print(myd.get('e'))
None

Python字典(dict)的更改

详见下面的示例代码:

In [32]: myd = dict(a=1, b=2, c=3)

In [33]: myd['a'] = 9  # 改变某个键的值

In [34]: myd
Out[34]: {'a': 9, 'b': 2, 'c': 3}

In [35]: myd['e'] = 8  # 增加新的键值对

In [36]: myd
Out[36]: {'a': 9, 'b': 2, 'c': 3, 'e': 8}

In [37]: del myd['e']  # 删除某个键及其值

In [38]: myd
Out[38]: {'a': 9, 'b': 2, 'c': 3}

In [39]: myd.pop('c')  # 删除某个键及其值并得到其值
Out[39]: 3

In [40]: myd
Out[40]: {'a': 9, 'b': 2}

Python字典(dict)相关的内置函数

Python内置了一些函数可以用于操作字典,它们是:

  1. len()
    返回字典的长度,是键的个数,也是值的个数,也是键值对的个数。空字典的长度是0
In [41]: len({'a':1, 'b':2})
Out[41]: 2

In [42]: len({})
Out[42]: 0
  1. any()和all()
    类似于对列表、tuple的操作,不过这两个函数检验的是字典的键(key)。
    any(): 只要字典有一个键为True则返回True;
    all(): 只有字典的所有键都为True才返回True;
In [45]: any({'': 1, 0: 'abcd', False: 333})
Out[45]: False

In [46]: all({'': 1, 0: 'abcd', False: 333})
Out[46]: False

In [47]: all({'a': 1, 0: 'abcd', False: 333})
Out[47]: False

In [48]: any({'a': 1, 0: 'abcd', False: 333})
Out[48]: True

In [49]: any({})
Out[49]: False

In [50]: all({})
Out[50]: True

不过,空字典有意思,它没有键却认为是所有键都为True,all({})返回True。

  1. sorted()
    跟操作列表、tuple的效果一样,它把字典的所有key当做一个列表(或元组)进行排序
In [51]: sorted({'a': 1, 'c': 3, 'b': 4})
Out[51]: ['a', 'b', 'c']

in 运算符

跟列表,元组一样,in用来检验一个key是不是在字典中:

In [56]: 'a' in {'a': 1, 'c': 3, 'b': 4}
Out[56]: True

In [57]: '3' in {'a': 1, 'c': 3, 'b': 4}
Out[57]: False

In [58]: '3' not in {'a': 1, 'c': 3, 'b': 4}
Out[58]: True

遍历字典:

In [59]: for key in {'a': 1, 'c': 3, 'b': 4}: 
    ...:     print(key) 
    ...:
a
c
b

Python字典(dict)的内置方法:

(1)keys()
返回键(key)的view对象(类型是:dict_keys)。这个view对象可以动态查看字典内部的对象,当字典改变后,这个view对象也会反应变化。
Python 2时,返回的是list,现在是dict_keys。

In [76]: myd = dict(a=1, b=2, c=3)

In [77]: kk = myd.keys()

In [78]: type(kk)
Out[78]: dict_keys

In [79]: for k in kk: 
    ...:     print(k) 
    ...:
a
b
c

In [80]: myd['e'] = 9  # 修改了字典

In [81]: for k in kk:  # 并没有重新获取kk,但是kk已经反应了变化,多了e
    ...:     print(k) 
    ...:
a
b
c
e

(2)values()
返回值(value)的view对象,dict_values。

(3)items()
返回键值对(key-value)的view对象:dict_items

In [82]: vv = myd.values()

In [83]: vv
Out[83]: dict_values([1, 2, 3, 9])

In [84]: ii = myd.items()

In [85]: ii
Out[85]: dict_items([('a', 1), ('b', 2), ('c', 3), ('e', 9)])

(4)get(key)
获取key对应的value,上面已经讲到。

(5)clear()
清空一个字典

In [86]: myd.get('a')
Out[86]: 1

In [87]: myd.get('x', 0)
Out[87]: 0

In [88]: myd.clear()

In [89]: myd
Out[89]: {}

(6)copy()
在Python中,把列表,字典对象赋值给变量时,都是“浅拷贝”,即,变量指向了对象,原来的对象改变了,这个变量的值也会跟着变。而cop()函数是“深拷贝”,重新创造一个新对象赋值给变量,原来的对象的改变不影响新对象。

In [94]: d1 = {'a':1}

In [95]: d2 = d1  # 浅拷贝

In [96]: d3 = d1.copy()  # 深拷贝

In [97]: d1['a'] = 2  # 改变原来的字典

In [98]: d2
Out[98]: {'a': 2}  # 浅拷贝的d2也跟着改变

In [99]: d3
Out[99]: {'a': 1}  # 深拷贝的d3还是原来的值

(7)pop(key)
删除key并返回它的值,上面已经讲到。

(8)popitem()
返回一对键值:

In [105]: myd = dict(a=1, b=2, c=3)

In [106]: myd.popitem()
Out[106]: ('c', 3)

In [107]: myd.popitem()
Out[107]: ('b', 2)

(9)fromkeys()
通过一个序列来初始化字典:

In [109]: d = {}

In [110]: d.fromkeys([1,2,3])
Out[110]: {1: None, 2: None, 3: None}

In [111]: d.fromkeys([1,2,3], 0)
Out[111]: {1: 0, 2: 0, 3: 0}

(10)update()
用一个字典来更新另一字典:

In [113]: d = d.fromkeys([1,2,3], 0)

In [114]: d
Out[114]: {1: 0, 2: 0, 3: 0}

In [115]: d.update({1:10, 2:20})

In [116]: d
Out[116]: {1: 10, 2: 20, 3: 0}

总结

字典是Python中很重要的一个数据结构,也是Python内置的数据类型。今后的编程中会经常用到它,所以要熟练掌握它的各种操作。

练习

  1. 熟悉对字典的各种操作。
  2. 想一想字典可以和日常生活中哪些场景联系起来。

猿人学banner宣传图

我的公众号:猿人学 Python 上会分享更多心得体会,敬请关注。

***版权申明:若没有特殊说明,文章皆是猿人学 yuanrenxue.con 原创,没有猿人学授权,请勿以任何形式转载。***

说点什么吧...