Python编程之Dict（词典）

4.1 Dict类型（字典）

1. Dict介绍及其创建方法

要根据名字找到对应的成绩，用两个 list 表示就不方便。如果把名字和分数关联起来，组成下面类似的查找表，给定一个名字，就可以直接查到分数。

'Adam' ==> 95
'Lisa' ==> 85
'Bart' ==> 59

Python的 dict 就是专门干这件事的。用 dict 表示“名字”-“成绩”的查找表如下：（类似于指针概念）

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}

我们把名字称为key，对应的成绩称为value，dict就是通过 key来查找 value。

花括号 {} 表示这是一个dict，然后按照 key: value, 写出来即可。最后一个 key: value 的逗号可以省略。

由于dict也是集合，len() 函数可以计算任意集合的大小：

>>> len(d)
3

注意: 一个 key-value 算一个，因此，dict大小为3。

Dict创建方法主要有以下三种：

1）创建一个空的dict，然后向其中添加内容，或直接用键值对创建

>>> person = {"name":"qiwsir","site":"qiwsir.github.io","language":"python"}
>>> person
{'name': 'qiwsir', 'language': 'python', 'site': 'qiwsir.github.io'}

2）利用元组构建词典，方法如下：

>>> name = (["first","Google"],["second","Yahoo"])
>>> website = dict(name)
>>> website
{'second': 'Yahoo', 'first': 'Google'}

或者用如下方法：

>>> ad = dict(name="qiwsir", age=42)
>>> ad
{'age': 42, 'name': 'qiwsir'}

3）使用 fromkeys，这种情况下相当于新建一个dict
>>> website = {}.fromkeys(("third","forth"),"facebook")
>>> website
{'forth': 'facebook', 'third': 'facebook'}

需要提醒注意的是，在字典中的“键”，必须是不可变的数据类型；“值”可以是任意数据类型。
 

2. 访问Dict

我们已经能创建一个dict，用于表示名字和成绩的对应关系：

d = {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}

那么，如何根据名字来查找对应的成绩呢？

可以简单地使用 d[key] 的形式来查找对应的 value，这和 list 很像，不同之处是，list 必须使用索引返回对应的元素，而dict使用key。

通过 key 访问 dict 的value，只要 key 存在，dict就返回对应的value。如果key不存在，会直接报错：KeyError。要避免 KeyError 发生，有两个办法：

一是先判断一下 key 是否存在，用 in 操作符：

if 'Paul' in d:
    print d['Paul']

如果 'Paul' 不存在，if语句判断为False，自然不会执行 print d['Paul'] ，从而避免了错误。

二是使用dict本身提供的一个 get 方法，在Key不存在的时候，返回None：

>>> print d.get('Bart')
59
>>> print d.get('Paul')
None

 

3. Python中Dict的特点

dict的第一个特点是查找速度快，无论dict有10个元素还是10万个元素，查找速度都一样。而list的查找速度随着元素增加而逐渐下降。不过dict的查找速度快不是没有代价的，dict的缺点是占用内存大，还会浪费很多内容，list正好相反，占用内存小，但是查找速度慢。由于dict是按 key 查找，所以，在一个dict中，key不能重复。

dict的第二个特点就是存储的key-value序对是没有顺序的！这和list不一样。

dict的第三个特点是作为 key 的元素必须不可变，Python的基本类型如字符串、整数、浮点数都是不可变的，都可以作为 key。但是list是可变的，就不能作为 key。

 

4. dict的更新与遍历

Dict中键值对添加：例如要把新同学'Paul'的成绩 72 加进去，用赋值语句： d['Paul'] = 72。如果 key 已经存在，则赋值会用新的 value 替换掉原来的 value。

由于dict也是一个集合，所以，遍历dict和遍历list类似，都可以通过 for 循环实现。

直接使用for循环可以遍历 dict 的 key，通过 key 可以获取对应的 value，因此，在循环体内，可以获取到value的值。

如遍历输出dict内所有的键值对。

d= {
    'Adam': 95,
    'Lisa': 85,
    'Bart': 59
}
for key in d:
    print key + ':', d[key]   #这里也可以写成  print key, ‘:’, d[key]

 

5. python中Dict的基本操作

• len(d)，返回字典(d)中的键值对的数量
• d[key]，返回字典(d)中的键(key)的值
• d[key]=value，将值(value)赋给字典(d)中的键(key)
• del d[key]，删除字典(d)的键(key)项（将该键值对删除）
• key in d，检查字典(d)中是否含有键为 key 的项

 

6. 其他重要Dict操作（Dict函数）

1） copy，用法：y = x.copy()

      注意，这里要区分真拷贝和假拷贝。对象有类型，变量无类型。真copy是在计算机中为新变量重新开辟了一个存储空间，而假拷贝只是为同一个存储空间贴了两个不同的标签。如下：

>>> ad = {"name":"qiwsir", "lang":"Python"}
>>> bd = ad
>>> bd
{'lang': 'Python', 'name': 'qiwsir'}
>>> id(ad)
3072239652L
>>> id(bd)
3072239652L        #两个变量存储在同一个空间，只是一个对象贴了两个标签 

>>> bd["name"] = "laoqi"
>>> bd
{'lang': 'Python', 'name': 'laoqi'}
>>> ad
{'lang': 'Python', 'name': 'laoqi'}  #改变了bd，结果发现ad也跟着变了

#使用copy来复制一个变量，结果发现新变量在内存中另辟了一个空间。此时修改cd便不会对原来的ad产生影响
>>> cd = ad.copy()   
>>> cd
{'lang': 'Python', 'name': 'qiwsir'}
>>> id(cd)
3072239788L          

同时，还要区分“浅拷贝”和"深拷贝"。前面所举的例子都是浅拷贝，如y = x.copy()。"浅拷贝"在某些情况下会显示出不足。如：

>>> x = {"name":"qiwsir", "lang":["Python", "java", "c"]}
>>> y = x.copy()
>>> y
{'lang': ['Python', 'java', 'c'], 'name': 'qiwsir'}
>>> id(x)
3072241012L
>>> id(y)
3072241284L
>>> y["lang"].remove("c")   #调用list的函数remove()来移除“C”
>>> y
{'lang': ['Python', 'java'], 'name': 'qiwsir'}
>>> x
{'lang': ['Python', 'java'], 'name': 'qiwsir'} #内存不同，却发现x中的元素值也跟着变化了

#原因在于字典中的list键值对地址
>>> id(x["lang"])
3072243276L
>>> id(y["lang"])   
3072243276L          #虽然两个Dict地址不同，但是他们包含那个list键值对的地址是相同的

出现以上现象的原因，跟 Python 存储的数据类型特点有关，Python 只存储基本类型的数据，比如 int,str，对于不是基础类型的，比如刚才字典的值是列表，Python 不会在被复制的那个对象中重新存储，而是用引用的方式，指向原来的值。

在 Python 中，有一个“深拷贝”(deep copy)，可以解决上述“浅拷贝”带来的问题。不过，要用import 来导入一个模块。

>>> import copy
>>> z = copy.deepcopy(x)     #copy.deepcopy() 深拷贝了一个新的副本
>>> z
{'lang': ['python', 'java'], 'name': 'qiwsir'}

>>> id(x["lang"])
3072243276L
>>> id(z["lang"])   #此时其中的list键值对存储地址也改变了，变成了两个不同的list
3072245068L

2） clear, 用法：dict.clear()

在交互模式中，用 help 是一个很好的习惯

>>> help(dict.clear)
clear(...)
D.clear() -> None. Remove all items from D.

clear是一个清空字典中所有元素的操作，得到的是一个空字典。（区别于上节说的del操作，del是删除键值对或整个词典，这里只是清空）

>>> a = {"name":"qiwsir"}
>>> a.clear()
>>> a
{}

3）get,setdefault

dict.get(k) 就是要得到字典中某个键的值。那么它的用法以及dict.get('key') 和dict['key'] 的区别如下：

>>> d
{'lang': 'python'}
>>> d.get("lang")
'python'

>>> print d.get("name")  #当查找字典中不存在的值时，可发现二者区别
None
>>> d["name"]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'name'

dict.setdefault(k) 的功能也是查找字典中键k所对应的值。不同之处在于，如果键k不在字典中，就在字典中增加这个键值对。具体用法如下：

>>> d
{'lang': 'Python'}
>>> d.setdefault("lang")
'Python'
>>> d.setdefault("name","qiwsir")
'qiwsir'
>>> d          #若查找的键值对不存在，则所查找内容作为新的键值对添加到词典中
{'lang': 'Python', 'name': 'qiwsir'}

4) items/iteritems, keys/iterkeys, values/itervalues

D.items() 能够得到一个关于字典的列表，列表中的元素是由字典中的键和值组成的元组。例如：

>>> dd = {"name":"qiwsir", "lang":"python", "web":"www.itdiffer.com"}
>>> dd_kv = dd.items()
>>> dd_kv
[('lang', 'Python'), ('web', 'www.itdiffer.com'), ('name', 'qiwsir')]

D.iteritems() 得到的是一个迭代器，得到的 dd_iter 的类型，是一个'dictionary-itemiterator'类型，不过这种迭代器类型的数据不能直接输出，必须用list() 转换一下，才能看到里面的真面目。

>>> dd
{'lang': 'Python', 'web': 'www.itdiffer.com', 'name': 'qiwsir'}
>>> dd_iter = dd.iteritems()
>>> type(dd_iter)
<type 'dictionary-itemiterator'>
>>> dd_iter                    #这种迭代器类型的数据无法直接输出，需要用list转换一下
<dictionary-itemiterator object at 0xb72b9a2c>
>>> list(dd_iter)
[('lang', 'Python'), ('web', 'www.itdiffer.com'), ('name', 'qiwsir')]

keys/iterkeys, values/itervalues 的定义和用法和上一组相同

>>> dd
{'lang': 'Python', 'web': 'www.itdiffer.com', 'name': 'qiwsir'}
>>> dd.keys()
['lang', 'web', 'name']
>>> dd.values()
['Python', 'www.itdiffer.com', 'qiwsir']

>>> dd_iterkeys=dd.iterkeys()
>>> dd_iterkeys
<dictionary-keyiterator object at 0x0000000002CA5728>
>>> list(dd_iterkeys)
['lang', 'web', 'name']

>>> dd_itervalue=dd.itervalues()
>>> dd_itervalue
<dictionary-valueiterator object at 0x0000000002CA56D8>
>>> list(dd_itervalue)
['Python', 'www.itdiffer.com', 'qiwsir']

5） pop, popitem

在list中，有关于删除列表中元素的函数pop 和remove ，这两个的区别在于list.remove(x) 用来删除指定的元素，而list.pop([i]) 用于删除指定索引的元素，如果不提供索引值，就默认删除最后一个。而在字典中，同样存在这两个函数。

D.pop(k[,d]) 是以字典的键为参数，删除指定键的键值对。比如利用该函数删除指定键"name"，则可返回其对应的值"qiwsir"。这样，在原字典中，“'name':'qiwsir'”这个键值对就被删除了。值得注意的是，pop 函数中的参数是不能省略的，这跟列表中的那个 pop 有所不同。另外如果要删除字典中没有的键值对，也会报错。

>>> dd
{'lang': 'Python', 'web': 'www.itdiffer.com', 'name': 'qiwsir'}
>>> dd.pop("name")
'qiwsir'
>>> dd
{'lang': 'Python', 'web': 'www.itdiffer.com'}

D.popitem() 的作用跟list.pop() 有相似之处，它不用写参数（list.pop 是可以不写参数），不过它不是删除最后一个（因为dict没有顺序），它的作用是随机删除一个键值对，并将所删除的键值对以元组的形式返回。如果字典是空的，就要报错了。

>>> dd
{'lang': 'Python', 'web': 'www.itdiffer.com'}
>>> dd.popitem()
('lang', 'Python')
>>> dd
{'web': 'www.itdiffer.com'}

6）update

首先，这个函数没有返回值，或者说返回值是 None,它的作用就是更新字典。其参数可以是字典或者某种可迭代的数据类型。利用该函数可以将一个词典的内容添加进另一个词典，也可以以键值对的方式更新词典。因此，总结起来，更新词典可以看成向词典中添加键值对或其他词典内容。例如：

>>> d1 = {"lang":"python"}
>>> d2 = {"song":"I dreamed a dream"}
>>> d1.update(d2)
>>> d1
{'lang': 'Python', 'song': 'I dreamed a dream'}
>>> d2
{'song': 'I dreamed a dream'}

还可以用下面的方法更新，列表的元组是键值对：

>>> d2
{'song': 'I dreamed a dream'}
>>> d2.update([("name","qiwsir"), ("web","itdiffer.com")])
>>> d2
{'web': 'itdiffer.com', 'name': 'qiwsir', 'song': 'I dreamed a dream'}

7）has_key

D.has_key(k) 这个函数的功能是判断字典中是否存在某个键k，跟前一节中遇到的k in D 类似。若存在，则返回True, 否则返回False.

>>> d2
{'web': 'itdiffer.com', 'name': 'qiwsir', 'song': 'I dreamed a dream'}
>>> d2.has_key("web")
True
>>> "web" in d2
True

 

以上是详细总结，同时附上应用比较多的——Python中字典合并的四种方法：https://blog.csdn.net/Jerry_1126/article/details/73017270

 

本人科研小白一枚，如理解有误，欢迎大家留言批评指正！不胜感激！

 

References:

[1] 廖雪峰，慕课网《python入门》，链接：http://www.imooc.com/u/292120/courses?sort=publish

[2] 《从零开始学Python》（第二版），极客学院出版

[3] Python中字典合并的四种方法，链接：https://blog.csdn.net/Jerry_1126/article/details/73017270