03-字典

本文先介绍映射概念，然后利用字典格式化字符串，最后介绍一些字典的方法。

字典的使用

字典是python中唯一内建的映射类型，字典中的值没有特殊的顺序，但是都存储在一个特定的键（Key）下，键可以使数字、字符串甚至是元组。字典：可以通过轻松查找某个特定的词语（键），从而找到它的定义（值）。
例如：表示一个游戏棋盘的状态，每个键都是由坐标值组成的元组；

创建字典

字典可以通过下面的方式创建：

phonebook={‘Alice’:’2341’,’Beth’:’9102’,’Cecil’:’3528’}

字典由多个键及与其对应的值构成的键-值对组成（键-值对也成为项）。在这个例子中名字是键，电话号码是项。每个键和值之间用冒号（：）隔开，项之间用逗号（，）而整个字典用一对大括号括起来。空字典（不包括任何项）由两个大括号组成，如：{}。

• 字典中的键是唯一的，而值是不唯一的。

dict函数

可以通过dict函数来创建字典：

1.（键，值）对

1.通过（键，值）对的序列建立字典 (列表->字典)

>>> items =[('names','Gumby'),('age','42')]
>>> d = dict(items)
>>> d
{'age': '42', 'names': 'Gumby'}

2.关键字参数

2.通过关键字参数来创建字典 (指定-字典)

>>> d=dict(name='Gumby',age=42)
>>> d
{'age': '42', 'names': 'Gumby'}

基本字典操作

• len(d)返回d中项（键-值对）的数量。
• d[k]返回关联到键k上的值。
• d[k]=v将值v关联到键k上。
• del d[k]删除键为k的项。
• k in d检查d中是否含有键为k的项。

字典和列表不同之处：
键类型：字典的键不一定为整型数据，键也可以是浮点型（实型）、字符型或者元组。
自动添加：即使键在字典中起初并不存在，也可以为它赋值，这样字典就会建立新的项。
成员资格：表达式 k in d（d为字典）查找的事键，而不是值。

#将‘Foobar’关联到空字典的键42上
x={}
x[42]='Foobar'
print x

Demo

#字典使用人名作为键，每个人用另一个字典来表示，其键‘phone’和'addr'分别表示他们的电话号码和地址。
people={
    'Alice':{
        'phone':'2341',
        'addr':'Foo drive 23'
    },

    'Beth':{
        'phone':'9012',
        'addr':'Bar street 42'
    },

    'Cecil':{
        'phone':'3158',
        'addr':'Baz avenue 90'
    }
}

#针对电话号码和地质使用的描述性标签，会在打印输出的时候用到

labels ={
    'phone':'phone number',
    'addr':'address'            
}
name =raw_input('Name: ')

#查找电话号码还是地址？

request = raw_input('Phone number(p) or address(a)?')

#使用正确的键：
if request == 'p' : key = 'phone'
if request == 'a':key ='addr'

if name in people: 
    print "%s's %s is %s."%(name,labels[key],people[name][key])

字典的格式化字符串

在每个转换说明符中的%字符后面，加上键（用圆括号括起来），后面再跟上其他说明元素（其实就是引用字典当中某个键的内容）。

>>>phonebook={'Alice':'2341','Beth':'9102','Cecil':'3528'}
>>>'Cecil's phone number is %(Cecil).' %phonebook
'Cecil's phone number is 3258'

字典方法

1.clear

clear方法清除字典中所有的项，这是个原地操作（类似于list.sort），所以无返回值（或者说返回None）。

>>> d ={}
>>> d['name'] = 'Gumby'
>>> d['age'] = 42
>>> print d
{'age': 42, 'name': 'Gumby'}
>>> return_value =d.clear()
>>> print d
{}
>>> print return_value
None

2.copy

copy方法返回一个具有相同键-值对的新字典。

浅复制（shallow copy）

dic1={'A':'a1','B':['b1','b2']}
print '----------copy----------'
print 'dic1=',dic1
dic2=dic1.copy()
print'dic2',dic2
print '----------change----------'
dic2['A']='a0'
print 'dic1=',dic1
print 'dic2',dic2
print '----------remove----------'
dic2['B'].remove('b1')
print 'dic1=',dic1
print 'dic2',dic2

#输出结果
----------copy----------
dic1= {'A': 'a1', 'B': ['b1', 'b2']}
dic2 {'A': 'a1', 'B': ['b1', 'b2']}
----------change----------
dic1= {'A': 'a1', 'B': ['b1', 'b2']}
dic2 {'A': 'a0', 'B': ['b1', 'b2']}
----------remove----------
dic1= {'A': 'a1', 'B': ['b2']}
dic2 {'A': 'a0', 'B': ['b2']}

深复制（deep copy）

from copy import deepcopy
d={}
d['names']=['A','B']
print 'd=',d
c =d.copy()
print 'c=',c
dc=deepcopy(d)
print 'dc=',dc
d['names'].append('C')
print 'd=',d
print '---------------------------------------'
print 'c=',c
print 'dc=',dc

#输出结果
d= {'names': ['A', 'B']}
c= {'names': ['A', 'B']}
dc= {'names': ['A', 'B']}
d= {'names': ['A', 'B', 'C']}
---------------------------------------
c= {'names': ['A', 'B', 'C']}
dc= {'names': ['A', 'B']}

3.fromkeys

fromkeys方法使用给定的键建立新的字典，每个键都对应一个默认的值None。

>>>{}.fromkeys(['name','age'])
{'age': None, 'name': None}

#可以赋初始值
{}.fromkeys(['name','age'],'(unknown)')
{'age': '(unknown)', 'name': '(unknown)'}

4.get

get方法是个更宽松的访问字典项的方法，当访问一个不存在的键时，没有异常，而得到了None值，还可以定义默认值。

>>>d={}
print d.get('name')

#定义默认值
>>> d={}
>print d.get('name','N/A')
'N/A'

5.has_key

has_key方法可以检查字典中是否含有特定的键，表达式d.has_key（k）相当于表达式k in d。

>>> d = {}
>>> d.has_key('name')
False
>>> d['name']='Eric'
>>> d.has_key('name')
True

6.items和iteritems

items方法将字典所有的项以列表方式返回，列表中的每一项都表示为（键，值）对的形式。(字典->列表)

>>> d={'title':'Python web Site','url':'http://www.python.org','spam':0}
>>> d.items()
[('url', 'http://www.python.org'), ('spam', 0), ('title', 'Python web Site')]

7.key和iterkeys

keys方法将字典中的键以列表形式返回，而iterkeys则返回针对键的迭代器。

>>> d={'title':'Python web Site','url':'http://www.python.org','spam':0}
>>> d.keys()
['url', 'spam', 'title']
>>> d.iterkeys()
<dictionary-keyiterator object at 0x000000000B102C78>

8.pop

pop方法用于获得对应于给定键的值，然后将这个键-值对从字典中移除。

>>> d={'x':'1','y':'2'}
>>> d.pop('x')
1
>>>d
{'y': '2'}

9.popitem

popitem方法类似于list.pop，后者会弹出列表的最后一个元素。但不同的是，popitem弹出随机的项，因为字典并没有给出‘最后的项’或者其他有关顺序的概念(随机弹出一个（键-值）对)

>>> d={'title':'Python web Site','url':'http://www.python.org','spam':0}
>>> d.popitem() 
('url', 'http://www.python.org') 
>>> d 
{'spam': 0, 'title': 'Python web Site'}

10.setdefault

setdault方法在某种程度上类似于get方法，能够获得与给定键相关联的值，除此之外，setdault还能在字典中不含有给定键的情况下设定相应的键值。

>>> d={}
>>> d.setdefault('name','N/A')
N/A
>>> d
{'name': 'N/A'}
>>> d['name'] = 'Gaumy'
>>> d.setdefault('name','N/A')
>>> d
{'name': 'Gaumy'}

1>当键不存在的时候，setdefault返回默认值并且相应更新字典。
2>如果键存在，那么就返回与其对应的值，但不改变字典。

11.update

update方法可以利用一个字典项更新另一个字典项

>>> d={'title':'Python web Site','url':'http://www.python.org','spam':0}
>>> x={'title':'Python Language Website'}
d.update(x)
>>> d
{'url': 'http://www.python.org', 'spam': 0, 'title': 'Python Language Website'}

12.values

values方法以列表的形式返回字典中的值（itervalues返回值的迭代器），与返回键的列表不同的是，返回值的列表中可以包含重复的元素。

>>> d={}
>>> d[1]=1
>>> d[2]=2
>>> d[3]=3
>>> d[4]=1
>>> d
{1: 1, 2: 2, 3: 3, 4: 1}
>>> d.values()
[1, 2, 3, 1]