python学习笔记4-核心类型-字典

一、字典介绍
字典(dictionary)是除列表意外python之中最灵活的内置数据结构类型。列表是有序的对象结合，字典是无序的对象集合。两者之间的
区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
1、字典的主要属性
*通过键而不是偏移量来读取
字典有时称为关联数组或者哈希表。它们通过键将一系列值联系起来，这样就可以使用键从字典中取出一项。如果列表一样可以使用索引
操作从字典中获取内容。
*任意对象的无序集合
与列表不同，保存在字典中的项并没有特定的顺序。实际上，Python将各项从左到右随机排序，以便快速查找。键提供了字典中项的象征
性位置（而非物理性的）。
*可变，异构，任意嵌套
与列表相似，字典可以在原处增长或是缩短（无需生成一份拷贝），可以包含任何类型的对象，支持任意深度的嵌套，可以包含列表和其他
字典等。
*属于可变映射类型
通过给索引赋值，字典可以在原处修改。但不支持用于字符串和列表中的序列操作。因为字典是无序集合，根据固定顺序进行操作是行不
通的（例如合并和分片操作）。字典是唯一内置的映射类型（键映射到值得对象）。
*对象引用表（哈希表）
如果说列表是支持位置读取对象的引用数组，那么字典就是支持键读取无序对象的引用表。从本质上讲，字典是作为哈希表（支持快速检索的
数据结构）来实现的。一开始很小，并根据要求而增长。此外，Python采用最优化的哈希算法来寻找键，因此搜索是很快速的。和列表一样
字典存储的是对象引用。

2、字典的健
1）不允许一个键对应多个值
原则：每个键键值只能对应一个项。一个键对应多个值是不允许的。当有键发生冲突（即字典键重复赋值），取最后（最近）的赋值。
Python并不会因字典中的健存在冲突而产生一个错误，它不会检查键的冲突。
2）键必须是可哈希的。
像列表和字典这样可变类型，由于他们不是可哈希的，所以不能做键。
所有不可变的类型都是可哈希的，因为它们可以作为字典的健。
注意：值相等的数值表示相同的健如1和1.0
元组是不可变的，但是也不能做字典的健，因为元组里面的元素如果是列表或字典时不可哈希，除非元组中只包含数字和字符串这样的不可变参数，才可以做字典中的有效键。

3、常见的字典操作
可以查看库手册或者运行dir(dict)或者help(dict),类型名位dict。当写成常量表达式时，字典以一系列"键:值（key:value)”对形式写出的，
用逗号隔开，用大括号括起来。可以和列表和元组嵌套
操作 解释
D1={} 空字典
D={'one':1} 增加数据
D1[key]='class' 增加数据：已经存在就是修改，没有存在就是增加数据
D2={'name':'diege','age':18} 两项目字典
D3={'name':{'first':'diege','last':'wang'},'age':18} 嵌套
D2['name'] 以键进行索引计算
D3['name']['last'] 字典嵌套字典的键索引
D['three'][0] 字典嵌套列表的键索引
D['six'][1] 字典嵌套元组的键索引
D2.has_key('name') 方法：判断字典是否有name键,最新的方式用in/not in 判断
D2.keys() 方法：键列表
list(D) 获取D这个字典的的KEY的 MS按字典顺序排序成一个列表 好像也不是>>> list(D) ['job', 'wang', 'name']
D2.values() 方法：值列表
'name' in D2 方法：成员测试：注意使用key来测试
D2.copy() 方法：拷贝
D2.get(key,deault) 方法：默认 如果key存在就返回key的value,如果不存在就设置key的value为default。但是没有改变原对象的数据
D2.update(D1) 方法：合并。D1合并到D2,D1没有变化，D2变化。注意和字符串，列表好的合并操作”+“不同
D2.pop('age') 方法：删除 根据key删除,并返回删除的value
len(D2) 方法：求长（存储元素的数目)
D1[key]='class' 方法：增加：已经存在的数据就是修改，没有存在就是增加数据
D4=dict(name='diege',age=18) 其他构造技术
dict(zip(keyslist,valslist)) dict([(1, 'a')])dict接受一个由k-v组成的元组作为元素的列表
D5=dict.fromkeys(['a','b'],defaultvalue) 其他构造技术 dict.fromkeys 可以从一个列表读取字典的key 值默认为空，可指定初始值.两个参数一个是KEY列表，一个初始值

 

二、创建字典
1、直接创建，全部数据一起添加
>>> D={'name':'diege','age':18}
>>> D
{'age': 18, 'name': 'diege'}
2、先创建一个空字典，在逐个添加
>>> D={}
>>> D['name']='diege'
>>> D['age']=18
>>> D
{'age': 18, 'name': 'diege'}
>>> D['age']=19
>>>
{'age': 19, 'name': 'diege'}
同样键不存在是新添加数据，键存在就是修改数据
列表不能通过这样的方法来增加数据，列表只能通过append方法，列表之能通过L[1]='A'这样的方法来修改已存在序列的数据。
3、使用工厂函数dict()的K=V 参数格式
>>> D1=dict(name='diege',age=18)
>>> D1
{'age': 18, 'name': 'diege'}
将数据按按key=value作为参数传递给dict()

4、使用工厂函数dict()的([(K1,V1),(K2,V2])参数格式
dict(mapping) -> new dictionary initialized from a mapping object's (key, value) pairs
>>> dict([('name','tom'),('age',23)])
{'age': 23, 'name': 'tom'}
这里将每一个数据(属性），做为元组放到一个列表里传递给dict函数
dict(列表，列表里是每一个key组成的元组)
高级用法 zip函数把程序运行动态获得的键和值列表合并在一起（例如分析数据文件字段）
可以用zip()将两个元组或列表组合好K,V的元组参数传递给dict()
>>> keyslist=['shell','sql']
>>> valslist=[['s1','k1','all'],['s1','k1','all']]
>>> D=dict(zip(keyslist,valslist))
>>> D
{'shell': ['s1', 'k1', 'all'], 'sql': ['s1', 'k1', 'all']}
也等同于：dict(map(None,keyslist,keyslist))

5、使用字典的fromkeys方法 创建一个默认字典
dict.fromkeys(seq,DefautValue)
第一个参数为列表或者元组（元素是可哈希做键），第二个参数为产生的各个字典的默认值，不指定为None
>>> D=dict.fromkeys(['name','age'])
>>> D
{'age': None, 'name': None}
创建只有key没有value的字典。
>>> dict.fromkeys(('name','age'),'jin')
{'age': 'jin', 'name': 'jin'}

5种方法的选择技巧
*如果可以事先拼除整个字典，那么第一种是很方便的。
*如果需要一次动态地建立字典的一个字段，第二种比较合适
*第三种关键字形式所需的代码比常量少，【但是键必须是都是字符串才可行】
*如果需要在程序运行时把键和值逐步建成序列。第四中比较有用。
*如果所有键的值都相同，可以使用特殊形式对字典进行初始化。简单传入一个键列表，以及所有键的初始值（默认为空）

三、访问字典
1、通过key直接访问
>>> D['age']
18
2、多层通过多个key
D[Key1][key2]

3、便利一个字典
#for key in Dict1.keys():
for key in Dict1:
print 'key=%s,value=%s' %(key,Dict1[key])\

4、访问字典时键不存在会报错
避免这样的错误，需要判断可用Dict.has_key(key1)
先判断，有才读取。现在基本使用in或not in操作符判断

四、更新字典-原处修改字典
1、修改一个元素
给字典添加一个K:V 如果这个K存在就是修改更新字典。
1）增加数据
>>> D['age']=18
>>> D
{'age': 18, 'name': 'diege'}
>>> D1['age']=19
>>> D1
{'age': 19, 'name': 'diege'}
同样键不存在是新添加数据，键存在就是修改数据

五、删除字典和删除字典中的元素
1、函数字典中的元素
del dict[key]
>>> D
{'shell': ['s1', 'k1', 'all'], 'sql': ['s1', 'k1', 'all']}
>>> del D['shell']
>>> D
{'sql': ['s1', 'k1', 'all']}
2、删除字典对象
>>> del D
>>> D
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'D' is not defined
3、清除所有字典数据
>>> D={'name':'jin','age':18}
>>> D.clear()
>>> D
{}

六、映射类型操作符
1、标准类型操作符
字典也是对象，所以可以使用标准类型操作符
>,>=,<,<=,==,!=,<>
字典比较算法
1）首先比较字典长度，字典长的大
2）字典长度一样，比较字典的健，按keys()方法顺序比较
当两个键不匹配时比较，对不匹配的健进行比较，dict1中第一同的健的值大于dict2时 cmp()返回1
3）字典长度相同键完全匹配时比较相同键对应的值 dict1相同键的值大于dict2时 cmp()返回1
4) 字典长度相同键完全匹配，值完全匹配时返回为0

2、映射类型操作符
1）字典的健查找操作符([])
d[k]=v 通过k键给字典中某元素赋V
d[k] 通过k键查询字典中某元素的值
>>> D['sex']='man'
>>> D['sex']
'man'
2)(键)成员关系操作（in,not in)
>>> D={'name':'jin','age':18}
>>> 'name' in D
True
>>> 'name' not in D
False

七、映射的内建函数和工厂函数
(一)、标准类型函数
type()
str()
cmp()
(二)映射相关函数
1)、dict 创建字典对象
2)、len() 取长
>>> len(D)
3）、hash()

八、映射类型内建方法（字典的方法）
方法名字 操作
判断
dict.has_key(key) 如果键(key)在字典中存在，返回True，否则返回False. 在Python2.2
版本引入in 和not in 后，此方法几乎已废弃不用了，但仍提供一个
可工作的接口。
创建
dict.copy() 返回字典(浅复制)的一个副本
dict.fromkeysc(seq,val=None) 创建并返回一个新字典，以seq 中的元素做该字典的键，val 做该字
典中所有键对应的初始值(如果不提供此值，则默认为None)
修改
dict.update(dict2)a 将字典dict2 的键-值对添加到字典dict
默认值
dict.get(key,default=None) 对字典dict 中的键key,返回它对应的值value，如果字典中不存在此
键，则返回default 的值(注意，参数default 的默认值为None)
dict.setdefault(key,default=None)e 和方法set()相似，如果字典中不存在key 键，由dict[key]=default 为
它赋值。
查看
dict.items() 返回一个包含字典中(键, 值)对元组的列表
dict.keys() 返回一个包含字典中键的列表
dict.values() 返回一个包含字典中所有值的列表
dict.iter*() 方法iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法
一样，不同的是它们返回一个迭代子，而不是一个列表。
删除
dict.pop(key[, default]) c 和方法get()相似，如果字典中key 键存在，删除并返回dict[key]，
如果key 键不存在，且没有给出default 的值，引发KeyError 异常。
dict.clear() 删除字典中所有元素

1、判断方面
1）、键存在判断-参数使用key
dict.has_key(key) 如果键(key)在字典中存在，返回True，否则返回False. 在Python2.2
版本引入in 和not in 后，此方法几乎已废弃不用了，但仍提供一个
>>> D.has_key('name')
True

2、查看方面
字典keys,valuse和items方法分别返回字典的键列表,值列表和(key,value)对元组
dict.items() 返回一个包含字典中(键, 值)对元组的列表
dict.keys() 返回一个包含字典中键的列表
dict.values() 返回一个包含字典中所有值的列表
dict.iter*() 方法iteritems(), iterkeys(), itervalues()与它们对应的非迭代方法一样，不同的是它们返回一个迭代子，而不是一个列表
>>> D={'name':'diege','age':18}
1）、字典的键查看 返回键的列表
key列表
>>> D.keys()
['age', 'name']
2）、字典的值查看 返回值的列表
value列表
>>> D.values()
[18, 'diege']
3）、K,V查看 K,V组成的元组列表
K,V元组的列表
>>> D.items()
[('age', 18), ('name', 'diege')]

【【【下面这几个没有？？？】】】
>>> D.viewkeys()
dict_keys(['class', 'name', 'level'])
>>> D.viewvalues()
dict_values([2, 'diege', 2012])
>>> D.viewitems()
dict_items([('class', 2), ('name', 'diege'), ('level', 2012)])

3、默认值
dict.get(key,default=None) 对字典dict 中的键key,返回它对应的值value，如果字典中不存在此
键，则返回default 的值(注意，参数default 的默认值为None)
dict.setdefault(key,default=None)e 和方法set()相似，如果字典中不存在key 键，由dict[key]=default 为
它赋值。

4、创建方面
1)、拷贝
D2.copy()
2)dict.fromkeysc(seq,val=None) 创建并返回一个新字典，以seq 中的元素做该字典的键，val 做该字
典中所有键对应的初始值(如果不提供此值，则默认为None)

5、删除方面
1）dict.pop('key')根据键删除
pop方法是从字典中删除一个键并返回它的值
>>> D.pop('age')
18
方法是从字典中删除一个键并返回它的值
从字典前面一对K:V的方式删除，并返回K,V合成的元组
2）dict.popitem() D3.popitem()
>>> D3.popitem() 不需要参数，从第一对K:V 开始删除
('age', 18)
3)dict.clear()清空字典所有数据
D1.clear()
4)使用del
使用del 【del属于什么？】
>>> del D['age']
18
>>> del D

5、合并数据 dict1.update(dict2)
dict.update(dict2)a 将字典dict2 的键-值对添加到字典dict
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}

6、语言表
>>> table={'Python':'Guido',
... 'Perl':'Larry',
... 'Tcl':'John'}
for lang in table:
... 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