字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
1、字典的主要属性 *通过键而不是偏移量来读取 字典有时称为关联数组或者哈希表。它们通过键将一系列值联系起来，这样就可以使用键从字典中取出一项。如果列表一样可以使用索引操作从字典中获取内容。 *任意对象的无序集合 与列表不同，保存在字典中的项并没有特定的顺序。实际上，Python将各项从左到右随机排序，以便快速查找。键提供了字典中项的象征性位置（而非物理性的）。 *可变，异构，任意嵌套 与列表相似，字典可以在原处增长或是缩短（无需生成一份拷贝），可以包含任何类型的对象，支持任意深度的嵌套，可以包含列表和其他字典等。 *属于可变映射类型 通过给索引赋值，字典可以在原处修改。但不支持用于字符串和列表中的序列操作。因为字典是无序集合，根据固定顺序进行操作是行不通的（例如合并和分片操作）。字典是唯一内置的映射类型（键映射到值得对象）。 *对象引用表（哈希表） 如果说列表是支持位置读取对象的引用数组，那么字典就是支持键读取无序对象的引用表。从本质上讲，字典是作为哈希表（支持快速检索的数据结构）来实现的。一开始很小，并根据要求而增长。此外，Python采用最优化的哈希算法来寻找键，因此搜索是很快速的。和列表一样字典存储的是对象引用。字典方法
字典对象提供了多种方法，如下表格所示。非变异方法返回结果，但不改变它们使用的对象。在下面列表中，D和D1代表任何字典对象，k代表D中任何有效的键，x为任何对象。| 方法 | 描述 |
| Non-mutating methods | |
| D.copy( ) | Returns a (shallow) copy of the dictionary |
| D.has_key(k) | Returns True if k is a key in D, otherwise returns False |
| D.items( ) | Returns a copy of the list of all items (key/value pairs) in D |
| D.keys( ) | Returns a copy of the list of all keys in D |
| D.values( ) | Returns a copy of the list of all values in D |
| D.iteritems( ) | Returns an iterator on all items(key/value pairs) in D |
| D.iterkeys( ) | Returns an iterator on all keys in D |
| D.itervalues( ) | Returns an iterator on all values in D |
| D.get(k[,x]) | Returns an iterator on all values in D |
| Mutating methods | |
| D.clear( ) | Removes all items from D |
| D.update(D1) | For each k in D1, sets D[k] equal to D1[k] |
| D.setdefault(k[,x]) | Returns D[k] if k is a key in D; otherwise sets D[k] equal to x and returns x |
| D.popitem( ) | Removes and returns an arbitrary item (key/value pair) |
2、常见操作 可以查看库手册或者运行dir(dict)或者help(dict),类型名为dict。当写成常量表达式时，字典以一系列"键:值（key:value)”对形式写出的，用逗号隔开，用大括号括起来。可以和列表和元组嵌套
操作 解释
D={} 空字典 D={'one':1} 创建新字典D[key]='class' 增加数据：已经存在就是修改，没有存在就是增加数据
D={'name':'diege','age':18} 两项目字典 D={'name':{'first':'diege','last':'wang'},'age':18} 嵌套 D['name'] 以键进行索引计算 D['name']['last'] 字典嵌套字典的键索引 D['three'][0] 字典嵌套列表的键索引 D['six'][1] 字典嵌套元组的键索引 D.has_key('name') 方法：判断字典是否有name键或者是'name' in D2 方法：成员测试：用key测试。如：if not key in dictionary
而D2.get(key,deault) 方法：默认 如果key存在就返回对应的value，如果不存在就设置key的value为default。但是没有改变原对象的数据
D2.keys() 方法：键列表 D2.values() 方法：值列表list(D) 获取D这个字典的的KEY的 MS按字典顺序排序成一个列表
D2.copy() 方法：拷贝 D2.update(D1) 方法：合并。D1合并到D2,D1没有变化，D2变化。注意和字符串，列表好的合并操作”+“不同 D2.pop('age') 方法：删除 根据key删除,并返回删除的value len(D2) 方法：求长（存储元素的数目) D1[key]='class' 方法：增加：已经存在的数据就是修改，没有存在就是增加数据 D4=dict(name='diege',age=18) 其他构造技术 D5=dict.fromkeys(['a','b']) 其他构造技术 dict.fromkeys 可以从一个列表读取字典的key 值默认为空，可指定初始值.两个参数一个是KEY列表，一个初始值 >>> D4 {'a': None, 'b': None} >>> D5=dict.fromkeys(['a','b','c'],0) >>> D5 {'a': 0, 'c': 0, 'b': 0} D6=dict(zip(keyslist.valslist)) ？？？ >>> D={} >>> D={'one':1} >>> D {'one': 1} 列表不能通过这样的方法来增加数据，列表只能通过append方法，列表之能通过L[1]='A'这样的方法来修改已存在序列的数据。二、实际应用中的字典
1、字典的基本操作 1）、创建字典的方法 和修改 全部数据一起添加 >>> D={'name':'diege','age':18} >>> D {'age': 18, 'name': 'diege'} >>> D={} >>> D['name']='diege' >>> D['age']=18 >>> D {'age': 18, 'name': 'diege'} >>> D1['age']=19 >>> D1 {'age': 19, 'name': 'diege'} 同样键不存在是新添加数据，键存在就是修改数据 >>> D1=dict(name='diege',age=18) >>> D1 {'age': 18, 'name': 'diege'} 将数据按按key=value作为参数传递给dict() dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs >>> D=dict.fromkeys(['name','age']) >>> D {'age': None, 'name': None} 创建只有key没有value的字典。>>> D=dict.fromkeys(['name','age'],0)
>>> D {'age': 0, 'name': 0} 2）、索引 >>> D['age'] 18 3）、取长 >>> len(D) 2 4）、键存在判断-参数使用key >>> D.has_key('name') True 5)、成员判断 使用key >>> 'age' in D True 6）、字典的键查看 返回键的列表 >>> D.keys() ['age', 'name'] 7）、字典的值查看 返回值的列表 >>> D.values() [18, 'diege'] 8)、拷贝 D2.copy() 2、原处修改字典 1）增加数据 >>> D['age']=18 >>> D {'age': 18, 'name': 'diege'} >>> D1['age']=19 >>> D1 {'age': 19, 'name': 'diege'} 同样键不存在是新添加数据，键存在就是修改数据 2）删除数据 根据键删除 pop方法是从字典中删除一个键并返回它的值 >>> D.pop('age') 18 方法是从字典中删除一个键并返回它的值 >>> del D['age'] 18 从字典前面一对K:V的方式删除，并返回K,V合成的元组 >>> D3.popitem() ('age', 18) 清空字典所有数据 D1.clear() 3）合并数据 D2.update(D1) 方法：合并。D1合并到D2,D1没有变化，D2变化。注意和字符串，列表好的合并操作”+“不同 >>> D1 {'name': 'diege'} >>> D2 {'class': 2, 'level': 2012} >>> D2.update(D1) >>> D1 {'name': 'diege'} >>> D2 {'class': 2, 'name': 'diege', 'level': 2012}3、其他字典方法
字典方法提供很多工具，例如 字典keys,valuse和items方法分别返回字典的键列表,值列表和(key,value)对元组 key列表 >>> D2.keys() ['class', 'name', 'level'] value列表 >>> D2.values() [2, 'diege', 2012] K,V元组的列表 >>> D2.items() [('class', 2), ('name', 'diege'), ('level', 2012)] >>> D2.viewkeys() dict_keys(['class', 'name', 'level']) >>> D2.viewvalues() dict_values([2, 'diege', 2012]) >>> D2.viewitems() dict_items([('class', 2), ('name', 'diege'), ('level', 2012)]) 4、语言表 >>> table={'Python':'Guido', ... 'Perl':'Larry', ... 'Tcl':'John'}for lang in table.keys():
... print lang,'\t',table[lang] ... Python Guido Tcl John Perl Larry 因为字典并非序列，无法像字符串和列表那样直接通过一个for语句迭代他们。但如果要遍历字典的键列表很容易。调用字典的keys()方法，返回经过排序之后所有键的列表。再用for循环进行迭代。 实际上，Python也能然给你遍历字典的键的列表，而并不用在多数for循环中调用keys方法.就任何字典D而言，写成for key in D:和写成完整的for key in D.keys()：效果是一样的 >>> for key in table: ... print key ... Python Tcl Perl >>> for key in table.keys(): ... print key ... Python Tcl Perl >>> for key in table.values(): ... print key ... Guido John Larry 三、字典用法注意事项 *序列运算无效。无法有序合并和分片 *对新索引赋值会增加项。 *键不一定总是字符串。任何不可变对象都可以（也就是不是列表） 1、使用字典模拟灵活的列表 当使用列表的时，对在列表末尾外的偏移赋值是非法的。 >>> L=[] >>> L[99]='diege' Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list assignment index out of range 虽然可以使用重复预先分配足够的大的列表（例如 [0]*100）。但也可以使用字典来坐类似的事。这样就不需要这样的空间分配了。 使用整数键时，字典可以效仿列表再偏移赋值时增长 >>> [0]*100>>> L=[0]*100 >>> L[99]='diege >>> D={} >>> D[99]='diege' >>> D[99] 'diege 这样的不用将来可能会用到的会被赋值的所有位置都分配空间。这样字典很像更具灵活性的列表。 2、字典用于稀疏数据结构 例如多维数组中只有少数位置上有存储的值 >>> M={} >>> M[(2,3,4)]=88 >>> M[(7,8,9)]=99 >>> X=2;Y=3;Z=4 >>> M[(X,Y,Z)] 88 >>> M {(2, 3, 4): 88, (7, 8, 9): 99} 这个数组中只有两个位置(2,3,4),(7,8,9)有值，其他位置都未空。键是元组，他们记录非空元素的坐标。我们并不是分配一个庞大而几乎为空的三维矩阵，而是使用一个简单的两个元素的字典。通过这一方式读取空元素的时，会触发键不存在的异常。因为这些元素实质上并没有被存储。 >>> M[(5,6,7)] Traceback (most recent call last): File "<stdin>", line 1, in <module> KeyError: (5, 6, 7) 3、避免missing-key错误 读取不存在的键的错误在稀疏矩阵中很常见。然而可能并不希望程序因为这一次错误而被关闭。这里有三种方式可以让我们填入默认值而不会出现这样 的错误提示， 1、）使用if语句预先对键进行测试。 >>> if M.has_key((5,6,7)): ... print M[(5,6,7)] ... else: ... print 0 ... 0 2)、使用try语句明确地捕获并修复这一异常。 >>> try: ... print M[(5,6,7)] ... except KeyError: ... print 0 ... 0 3）、使用get方法为不存在的键提供一个默认值 >>> M.get((2,3,4),0) 88 >>> M.get((5,6,7),0) 0 从编程的需要方面来说，get方法是三者中最简捷的。 4、使用字典作为“记录” 一般说来，字典可以取代搜索数据结构（因为用键进行索引是一种搜索操作），并且可以表示多种结构化信息的类型。例如，字典是在程序范围中多种描述某一项 属性的方法之一。也就是说，它们能偶扮演其他语言中的“记录”和结构相同的角色。随时间通过向新键赋值来填写字典的列子 >>> rec={} >>> rec['name']='diege' >>> rec['age']=28 >>> rec['job']='sa/db' >>> print rec['name'] diege 特别是在嵌套的时候，Python的内建数据类型可以很轻松地表达结构化信息。使用字典来捕获对象的属性，但是它是一次性写好的，而且嵌套了一个列表和一个字典来表达结构化属性的值。 >>> offer={'name':'diege','jobs':['sa','dba'],'web':'www.skylog.cn/~diege','home':{'state':'SH','zip':8088}} 当去读嵌套对象的元素时，只要简单地吧索引操作串起来就可以了 >>> offer['name'] 'diege' >>> offer['jobs'][1] 'dba' >>> offer['home']['state'] 'SH 5、创建字典的其他方法 1） >>> {'name':'diege','age':45} {'age': 45, 'name': 'diege'} 2） >>> D={} >>> D['name']='lily' >>> D['age']=18 >>> D {'age': 18, 'name': 'lily'} 3） >>> dict(name='kelly',age=19) {'age': 19, 'name': 'kelly'} 注意这里name,age没有 ’‘括起来，因为这里是变量。 4) >>> dict([('name','tom'),('age',23)]) {'age': 23, 'name': 'tom'} 这里将每一个数据(属性），做为元组放到一个列表里传递给dict函数 4种方法的选择技巧 *如果可以事先拼除整个字典，那么第一种是很方便的。 *如果需要一次动态地建立字典的一个字段，第二种比较合适 *第三种关键字形式所需的代码比常量少，【但是键必须是都是字符串才可行】 *如果需要在程序运行时把键和值逐步建成序列。第四中比较有用。 zip函数把程序运行动态获得的键和值列表合并在一起（例如分析数据文件字段） 如果所有键的值都相同，可以使用特殊形式对字典进行初始化。简单传入一个键列表，以及所有键的初始值（默认为空） >>> dict.fromkeys(['a','b','c'],0) {'a': 0, 'c': 0, 'b': 0}