【Python基础学习篇】Python字典

字典（Dictionary）是由“键-值”对组成的集合，字典中的“值”通过“键”来引用。

一、字典的创建

字典由一系列的“键-值”（key-value）对组成，“键-值”对之间用“逗号”隔开，并且被包含在一对花括号中。

创建字典的格式如下：

dictionary_name = {key1:value1,key2:value2,...}

如果需要创建一个空的字典,只需要一对花括号即可,如下:

dictionary_name = {}

例子：演示字典的创建和访问方法，字典通过一对中括号和索引来访问指定的元素。

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
dict = {"a":"apple","b":"banana","g":"grape","o":"orange"}
print dict
print dict["a"]

输出结果:

---------- python2.7 ----------
{'a': 'apple', 'b': 'banana', 'o': 'orange', 'g': 'grape'}
apple

输出完成 (耗时 0 秒) - 正常终止

注意:

字典的”键”是区分大小写的。

创建字典时，也可以使用数字作为索引：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
dict = {1:"apple",2:"banana",3:"grape",4:"orange"}
print dict
print dict[2]

输出结果：

---------- python2.7 ----------
{1: 'apple', 2: 'banana', 3: 'grape', 4: 'orange'}
banana

输出完成 (耗时 0 秒) - 正常终止

补充知识：

在print()中使用字典

print "%s,%{a}s,%{b}s" %{"a":"apple","b":"banana"}

说明：

隐式创建字典{"a":"apple","b":"banana"}，这个字典用来定制print()中的参数列表。%s输出这个字典的内容，%{a}s获取字典中对应的key值a的value值，%{b}s获取字典中对应key值b的value值。

输出结果：

{"a":"apple","b":"banana"},apple,banana

二、字典的访问

字典的访问与元组/列表有所不同,元组和列表是通过数字索引来获取对应的值,而字典是通过key值获取相对应的value的值.

访问字典元素的格式如下:

value = dict[key]

字典的添加/删除和修改十分简单,添加或修改操作只需要编写一条赋值语句.例如:

dict["x"] = "value"

如果索引x不在字典dict的key列表中,字典dict将添加一条新的映射(x:value)；如果索引x已经在字典dict的key列表中，字典dict将直接修改索引x对应的value值。

字典与列表不同，字典没有remove()。字典元素的删除，可以调用del()实现，del()属于内建函数，直接调用即可。列表可以调用pop()弹出列表中一个元素，字典也有一个pop()方法，该方法的声明和作用与列表的pop()有所不同。

字典的pop()的声明如下：

D.pop(k[,d])->v

pop()必须指定参数才能删除对应的值。其中，参数k表示字典的索引，如果字典D中存在索引k，返回值v等于D[k]，如果字典D中没有找到索引k，返回值为d。

如果需要清空字典中所有的内容，可以调用字典的clear()。

例子：演示字典的常用操作

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
#字典的添加、删除、修改操作
dict = {"a":"apple","b":"banana","g":"grape","o":"orange"}
dict["w"] = "watermelon"
del(dict["a"])
dict["g"] = "grapefruit"
print dict.pop("b")
print dict
dict.clear()
print dict

输出结果：

---------- python2.7 ----------
banana
{'w': 'watermelon', 'o': 'orange', 'g': 'grapefruit'}
{}

输出完成 (耗时 0 秒) - 正常终止

由于字典是无序的，因此字典中没有append()、remove()等方法。如果需要向字典插入新的元素，可以调用setdefault()。

字典的遍历有多种方式，最直接的方式是通过for…in…语句完成遍历的任务。

例子：字典的遍历操作

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
#字典的遍历
dict = {"a":"apple","b":"banana","g":"grape","o":"orange"}
for k in dict:
    print "dict[%s] = " %k,dict[k]

输出结果：

---------- python2.7 ----------
dict[a] =  apple
dict[b] =  banana
dict[o] =  orange
dict[g] =  grape

输出完成 (耗时 0 秒) - 正常终止

变量k获取的是字典dict的key值，并没有直接获得value值。

还可以使用字典的items()方法实现字典的遍历操作，items()返回一个由若干个元组组成的列表。

例子：items()的使用方法

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
#字典items()的使用方法
dict = {"a":"apple","b":"banana","g":"grape","o":"orange"}
print dict.items()

输出结果：

---------- python2.7 ----------
[('a', 'apple'), ('b', 'banana'), ('o', 'orange'), ('g', 'grape')]

输出完成 (耗时 0 秒) - 正常终止

items()把字典中每对key和value组成了一个元组，并把这些元组存放在列表中返回。

例子：用字典的items()方法实现字典的遍历

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
#字典items()方法实现字典的遍历
dict = {"a":"apple","b":"banana","g":"grape","o":"orange"}
for (k,v) in dict.items():
    print "dict[%s] = "%k,v

输出结果：

---------- python2.7 ----------
dict[a] =  apple
dict[b] =  banana
dict[o] =  orange
dict[g] =  grape

输出完成 (耗时 0 秒) - 正常终止

说明：变量k和v分别与字典dict中的key和value值对应。

字典的遍历操作还可以使用iteritems()、iterkeys()、itervalues()实现，这些方法将返回一个遍历器对象，通过这个对象实现遍历输出。

iteritems()的声明如下：

D.iteritems()->an iterator over the (key,value) items of D

iterkeys()的声明如下：

D.iterkeys()->an iterator over the keys of D

itervalues()的声明如下：

D.itervalues->an iterator over the values of D

例子：使用itertems()、iterkeys()、itervalues()实现字典的遍历

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
#字典iteritems()方法实现字典的遍历
dict = {"a":"apple","b":"banana","g":"grape","o":"orange"}
print dict.iteritems()
for k,v in dict.iteritems():
    print "dict[%s] = "%k,v
for (k,v) in zip(dict.iterkeys(),dict.itervalues()):
    print "dict[%s] = "%k,v

输出结果：

---------- python2.7 ----------
<dictionary-itemiterator object at 0x00000000024F9D18>
dict[a] =  apple
dict[b] =  banana
dict[o] =  orange
dict[g] =  grape
dict[a] =  apple
dict[b] =  banana
dict[o] =  orange
dict[g] =  grape

输出完成 (耗时 0 秒) - 正常终止

使用元组、列表或字典作为value值创建的字典，称之为混合型字典。

混合型字典的创建格式如下：

dict = {"key1":(tuple),"keys2":"[list]","keys3":"[dictionary]}

例子：混合型字典的创建和访问方法

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
#使用列表、字典作为字典的值
dict = {"a":("apple",),"bo":{"b":"banana","o":"orange"},"g":["grape","grapefruit"]}
print dict["a"]
print dict["a"][0]
print dict["bo"]
print dict["bo"]["o"]
print dict["g"]
print dict["g"][1]

输出结果：

---------- python2.7 ----------
('apple',)
apple
{'b': 'banana', 'o': 'orange'}
orange
['grape', 'grapefruit']
grapefruit

输出完成 (耗时 0 秒) - 正常终止

三、字典的方法

1、keys()和values()方法

keys()和values()方法将返回字典的key列表和value列表。

例子：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
dict = {"a":"apple","b":"banana","g":"grape","o":"orange"}
print dict.keys()
print dict.values()

输出结果：

---------- python2.7 ----------
['a', 'b', 'o', 'g']
['apple', 'banana', 'orange', 'grape']

输出完成 (耗时 0 秒) - 正常终止

2、get()方法

要获取字典中的某个value值，可以使用dict[key]的结构访问。另一种取value值的方法是使用字典的get()方法。

get()的声明如下：

D.get(k[,d])->D[k]

说明：

参数k表示字典的键值，参数d可以作为get()的返回值，参数d可以默认，默认值为None。

get()相当于if…else…语句，参数k如果在字典D中，get()将返回D[k]；参数k如果不在字典D中，则返回参数d。

get()的等价代码如下：

D = {"key1":"value1","key2":"value2"}
if "key1" in D:
    print D["key1"]
else:
    print "None"

例子：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
dict = {"a":"apple","b":"banana","c":"grape","d":"orange"}
print dict
print dict.get("c","apple")
print dict.get("e","apple")

输出结果：

---------- python2.7 ----------
{'a': 'apple', 'c': 'grape', 'b': 'banana', 'd': 'orange'}
grape
apple

输出完成 (耗时 0 秒) - 正常终止

说明：

由于字典dict存在索引c，返回返回key值c对应的value值；由于字典dict不存在索引e，所以返回参数apple。

采用get()访问字典中的value值减少了代码的长度，避免了if语句带来的维护代价。

3、update()方法

如果要添加新的元素到已经存在的字典中，可以调用字典的update()方法。update()把一个字典中的key和value值全部拷贝到另一个字典中，update()相当于一个合并函数。

update()的声明如下：

D.update(E)->None

如果把字典E的内容合并到字典D中，update()的等价代码如下：

D = {"key1":"value1","key2":"value2"}
E = {"key3":"value3","key4":"value4"}
for k in E:
    D[k] = E[k]
print D

通过for…in…循环语句访问字典E，并把字典E中的内容逐个添加到字典D中。字典D更新后的结果：

---------- python2.7 ----------
{'key3': 'value3', 'key2': 'value2', 'key1': 'value1', 'key4': 'value4'}

输出完成 (耗时 0 秒) - 正常终止

如果字典E中含有字典D中相同的键值，字典E的值将覆盖字典D中的值。

例子：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
D = {"key1":"value1","key2":"value2"}
E = {"key2":"value3","key4":"value4"}
for k in E:
    D[k] = E[k]
print D

输出结果：

---------- python2.7 ----------
{'key2': 'value3', 'key1': 'value1', 'key4': 'value4'}

输出完成 (耗时 0 秒) - 正常终止

字典的update()也存在同样的问题，如果某些key在目标字典中已经存在，则更新后新字典中的值将覆盖原有的值。

例子：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
dict = {"a":"apple","b":"banana"}
print dict
dict2 = {"c":"grape","d":"orange"}
dict.update(dict2)
print dict

输出结果：

---------- python2.7 ----------
{'a': 'apple', 'b': 'banana'}
{'a': 'apple', 'c': 'grape', 'b': 'banana', 'd': 'orange'}

输出完成 (耗时 0 秒) - 正常终止

说明：

字典不属于序列，所以字典没有顺序性。update()调用后，字典中各元素的排列顺序是无序的。

4、setdefault()方法

字典的setdefault()方法可以创建新的元素并设置默认值，setdefault()方法的声明如下：

D.setdefault->D.get(k,d)

setdefault()方法与get()的使用类似，参数k表示字典的键值，参数d表示D[k]的默认值。参数d可以省略，默认值为None。参数k的值如果在字典D中，setdefault()将返回get(k,d)获得的结果；参数k的值如果不在字典D中，字典D将添加新的元素D[k]，并调用get(k,d)返回参数d的值。

例子：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
dict = {}
dict.setdefault("a")
print dict
dict["a"] = "apple"
dict.setdefault("a","default")
print dict

输出结果：

---------- python2.7 ----------
{'a': None}
{'a': 'apple'}

输出完成 (耗时 0 秒) - 正常终止

下面再列出一些字典中的常用方法

四、字典的排序与复制

1、字典的排序

列表的排序可以使用sorted()实现，字典的排序同样可以使用该函数。

例子：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
dict = {"a":"apple","b":"grape","c":"orange","d":"banana"}
print dict
#按照key排序
print sorted(dict.items(),key=lambda d:d[0])
#按照value排序
print sorted(dict.items(),key=lambda d:d[1])

输出结果：

---------- python2.7 ----------
{'a': 'apple', 'c': 'orange', 'b': 'grape', 'd': 'banana'}
[('a', 'apple'), ('b', 'grape'), ('c', 'orange'), ('d', 'banana')]
[('a', 'apple'), ('d', 'banana'), ('b', 'grape'), ('c', 'orange')]

输出完成 (耗时 0 秒) - 正常终止

说明：

dict.items()作为需要排序的集合，其中items()用于字典的遍历，并返回(key,value)元组组成的列表。参数key表示排序的依据，d[0]表示items()中的key()中的key，即按照key值进行排序。lanbda可以创建匿名的函数，用于返回一些计算结果。

2、字典的复制

update()把字典A的内容复制到字典B中，且字典B中原有的内容保持不变，从而实现了字典B的扩展。如果需要把字典A的内容复制到字典B总，并清除B中的内容，可以使用copy()。

copy()的声明如下：

D.copy()->a shallow copy of D

例子：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
dict = {"a":"apple","b":"grape"}
dict2 = {"c":"orange","d":"banana"}
dict2 = dict.copy()
print dict2

输出结果：

---------- python2.7 ----------
{'a': 'apple', 'b': 'grape'}

输出完成 (耗时 0 秒) - 正常终止

补充知识点：深拷贝和浅拷贝

深拷贝能够拷贝对象内部所有的数据和引用，类似C语言的指针，但是Python中没有指针，在变量的内存结构中是通过引用来维护变量的。

浅拷贝只是复制数据，数据的引用没有复制，因此新的数据和旧的数据是使用同一块内存空间。

例如，字典B浅拷贝了字典A的数据，如果字典B的数据发生了添加、删除或者修改操作，字典A的数据也将发生变化；相反，如果字典B深拷贝字典A的数据，字典B的数据即使发生了变化也不会影响字典A。

深拷贝和浅拷贝可以应用与Python的任何对象，不单单字典。在Python中可以使用copy()模块来实现对象的深拷贝和浅拷贝，其中的deepcopy()用于深拷贝操作，copy()用于浅拷贝的操作。

例子：

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
import copy
dict = {"a":"apple","b":{"g":"grape","o":"orange"}}
dict2 = copy.deepcopy(dict)
dict3 = copy.copy(dict)#等价于dict.copy()
dict2["b"]["g"] = "orange"#字典dict的数据保持不变
print dict
dict3["b"]["g"] = "orange"
print dict

输出结果：

---------- python2.7 ----------
{'a': 'apple', 'b': {'o': 'orange', 'g': 'grape'}}
{'a': 'apple', 'b': {'o': 'orange', 'g': 'orange'}}

输出完成 (耗时 0 秒) - 正常终止

五、全局字典-sys.modules模块

sys.modules是一个全局字典，该字典是python启动后就加载在内存中的。每当导入新的模块，sys.modules都将记录这些模块。字典sys.modules对于加载模块起到了缓存的作用。当某个模块第一次导入，字典sys.modules将自动记录该模块。当第2次再导入该模块时，python会直接到字典中查找，从而加快了程序运行的速度。

字典sys.modules具有字典所拥有的一切方法，可以通过这些方法了解当前的环境加载了哪些模块。

例子：

调用字典的keys()和values()方法，keys()返回当前环境下加载的模块，values()返回这些模块的引用路径。

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
import sys
print sys.modules.keys()
print sys.modules.values()
print sys.modules["os"]

输出结果：

---------- python2.7 ----------
['copy_reg', 'sre_compile', 'locale', '_sre', 'functools', 'encodings', 'site', '__builtin__', 'sysconfig', 'operator', '__main__', 'types', 'encodings.encodings', 'encodings.gbk', 'abc', '_weakrefset', 'encodings._codecs_cn', 'errno', 'encodings.codecs', 'sre_constants', 're', '_abcoll', 'ntpath', '_codecs', 'encodings._multibytecodec', 'nt', '_warnings', 'genericpath', 'stat', 'zipimport', 'encodings.__builtin__', 'warnings', 'UserDict', '_multibytecodec', 'sys', 'codecs', 'os.path', '_functools', '_codecs_cn', '_locale', 'signal', 'traceback', 'linecache', 'encodings.aliases', 'exceptions', 'sre_parse', 'os', '_weakref']
[<module 'copy_reg' from 'D:\Python27\lib\copy_reg.pyc'>, <module 'sre_compile' from 'D:\Python27\lib\sre_compile.pyc'>, <module 'locale' from 'D:\Python27\lib\locale.pyc'>, <module '_sre' (built-in)>, <module 'functools' from 'D:\Python27\lib\functools.pyc'>, <module 'encodings' from 'D:\Python27\lib\encodings\__init__.pyc'>, <module 'site' from 'D:\Python27\lib\site.pyc'>, <module '__builtin__' (built-in)>, <module 'sysconfig' from 'D:\Python27\lib\sysconfig.pyc'>, <module 'operator' (built-in)>, <module '__main__' from 'Noname1.py'>, <module 'types' from 'D:\Python27\lib\types.pyc'>, None, <module 'encodings.gbk' from 'D:\Python27\lib\encodings\gbk.pyc'>, <module 'abc' from 'D:\Python27\lib\abc.pyc'>, <module '_weakrefset' from 'D:\Python27\lib\_weakrefset.pyc'>, None, <module 'errno' (built-in)>, None, <module 'sre_constants' from 'D:\Python27\lib\sre_constants.pyc'>, <module 're' from 'D:\Python27\lib\re.pyc'>, <module '_abcoll' from 'D:\Python27\lib\_abcoll.pyc'>, <module 'ntpath' from 'D:\Python27\lib\ntpath.pyc'>, <module '_codecs' (built-in)>, None, <module 'nt' (built-in)>, <module '_warnings' (built-in)>, <module 'genericpath' from 'D:\Python27\lib\genericpath.pyc'>, <module 'stat' from 'D:\Python27\lib\stat.pyc'>, <module 'zipimport' (built-in)>, None, <module 'warnings' from 'D:\Python27\lib\warnings.pyc'>, <module 'UserDict' from 'D:\Python27\lib\UserDict.pyc'>, <module '_multibytecodec' (built-in)>, <module 'sys' (built-in)>, <module 'codecs' from 'D:\Python27\lib\codecs.pyc'>, <module 'ntpath' from 'D:\Python27\lib\ntpath.pyc'>, <module '_functools' (built-in)>, <module '_codecs_cn' (built-in)>, <module '_locale' (built-in)>, <module 'signal' (built-in)>, <module 'traceback' from 'D:\Python27\lib\traceback.pyc'>, <module 'linecache' from 'D:\Python27\lib\linecache.pyc'>, <module 'encodings.aliases' from 'D:\Python27\lib\encodings\aliases.pyc'>, <module 'exceptions' (built-in)>, <module 'sre_parse' from 'D:\Python27\lib\sre_parse.pyc'>, <module 'os' from 'D:\Python27\lib\os.pyc'>, <module '_weakref' (built-in)>]
<module 'os' from 'D:\Python27\lib\os.pyc'>

输出完成 (耗时 0 秒) - 正常终止

 

例子2：实现导入模块的过滤

#!/usr/bin/env python
# -*- coding=utf-8 -*-
#Using GPL v2.7
#Author: [email protected]
import sys
d = sys.modules.copy()
import copy,string
print zip(set(sys.modules) - set(d))

输出结果：

---------- python2.7 ----------
[('weakref',), ('copy',), ('strop',), ('string',)]

输出完成 (耗时 0 秒) - 正常终止

说明：

调用set()把字典sys.modules、字典d存入set集合中，set集合实现了减法运算符，set(sys.modules) – set(d)将返回在字典d中不存在，而在字典sys.modules中存在的模块。然后调用zip()对set集合“解包”，返回一个列表。该列表就是使用import copy，string语句导入的模块。