字典：当索引不好用时

http://www.cnblogs.com/moomu/archive/2011/11/21/2256702.html

1 字典定义：

1. 说明：通过名字引用值的数据结构称为映射，字典是Python中唯一内建的 映射类型；

2 字典的使用:

1. 说明：通过检查到特定的词语（键），查找到它的含义（值）；
2. 注意：比较适合电话薄，词典这类实现
3. 例子：

   1:  #用列表来实现电话薄
   
   2:  >>> phoneNumbers = ['213123','542113','543231','974723']
   
   3:  >>> names=['Ada', 'Bill', 'Candy', 'David']
   
   4:  >>> phoneNumbers[names.index('Bill')]
   
   5:  '542113'
   
   6:  >>> 
   
   7:  
   
   

3 创建和使用字典

1. 说明：字典是由多个键以及其对应的值组成的键值对组成的，字典以左大 括号开始，并以右大括号结束，键与值之间用冒号分隔，键值对儿之间用 逗号分隔；
2. 注意：字典中的键是唯一的
3. 例子：

   1:  >>> mydict={'ada':'1111', 'Bill':'2222', 'Candy':'3333'}
   
   2:  >>> mydict['Bill']
   
   3:  '2222'
   
   4:  >>> 
   
   5:  
   
   

3.1 dict函数

1. 说明：用于创建字典的内建函数，参数可以是键与值的序列，可以是关键 字参数，也可以是其他的映射；
2. 注意：如果不给dict提供参数，则会返回一个空字典
3. 例子：

    1:  #将序列转换成字典
   
    2:  >>> mylst=[('name', 'Bill'),('age', 30)]
   
    3:  >>> mydict = dict(mylst)
   
    4:  >>> mydict
   
    5:  {'age': 30, 'name': 'Bill'}
   
    6:  >>> mydict['name']
   
    7:  'Bill'
   
    8:  
   
    9:  #通过向dict函数传递参数来创建字典
   
   10:  >>> mylst = dict(height=183,weight=161,hair='black')
   
   11:  >>> mylst['hair']
   
   12:  'black'
   
   13:  
   
   14:  #通过字典来创建另一个字典
   
   15:  >>> mylst = dict(mydict)
   
   16:  >>> mylst
   
   17:  {'age': 30, 'name': 'Bill'}
   
   18:  >>> 
   
   19:  
   
   

3.2 基本字典操作

1. 说明：
   1. len（d）：获取字典中键值对的数量；
   2. d[k]：键k对应的值；
   3. d[k]=v：将值v赋给键k；
   4. del d[k]：删除字典d中键为k的项；
   5. k in d：判断字典d中是否包含键为k的项；
2. 注意：
   1. 键类型：键类型可以是任意不可变类型，如整数，浮点数，字符串等；
   2. 自动添加：如果字典中不包含指定的键，可以通过赋值增加新项；
   3. 成员资格：k in d 是查找字典中是不是有键k对应的项，而列表是查 找的是值，v in l， 值v是不是在列表中；
   4. 字典中检查键的效率要比列表检查值的高效；
3. 例子：

    1:  #电话薄
   
    2:  people = {
   
    3:          'Bill Gunn':
   
    4:          {
   
    5:              'phone': '123456',
   
    6:              'addr': 'Tianjin'
   
    7:              },
   
    8:          'Media Zhang':
   
    9:          {
   
   10:              'phone': '999999',
   
   11:              'addr': 'Beijing'
   
   12:              }
   
   13:          }
   
   14:  #输出内容
   
   15:  lables = {
   
   16:          'phone' : 'phone number',
   
   17:          'addr'  : 'address'
   
   18:          }
   
   19:  #用户名
   
   20:  name = input('Name:')
   
   21:  key = input('Phone number(p) or address(a):')
   
   22:  if key == 'p' : key = 'phone'
   
   23:  if key == 'a' : key = 'addr'
   
   24:  if name in people:
   
   25:      print("%s %s is %s" % (name, lables[key], people[name][key]))
   
   26:  input('Press enter!')
   
   27:  
   
   28:  >>> 
   
   29:  Name:Bill Gunn
   
   30:  Phone number(p) or address(a):a
   
   31:  Bill Gunn address is Tianjin
   
   32:  Press enter!
   
   33:  
   
   

3.3 用字典格式化字符串

1. 说明：在格式化字符串中的格式化说明符后添加 键 ，并且 键 需要 用圆括号括起来；
2. 例子：

   1:  >>> table = {
   
   2:          'Alice' : '457819',
   
   3:          'Bill'  : '929181',
   
   4:          'Candy' : '826213'}
   
   5:  >>> print("Alice's phone number is %(Alice)s." % table)
   
   6:  Alice's phone number is 457819.
   
   7:  >>> 
   
   8:  
   
   

3.4 字典方法

 

3.4.1 clear

1. 说明：用于清除字典中全部的键值对儿，调用完该方法后，原字典变成一 个空字典；
2. 注意：该方法直接操作原字典，调用后不返回值（或者说直接返回 None ）
3. 例子：

    1:  #字典清空函数的一般用法
   
    2:  >>> mydict = {'Bill':'8289213', 'Candy':'192831'}
   
    3:  >>> mydict.clear()
   
    4:  >>> mydict
   
    5:  {}
   
    6:  >>> 
   
    7:  
   
    8:  #字典清空的情况一
   
    9:  >>> x = {'Bill':'213121'}
   
   10:  #y和x指向同一个字典对象
   
   11:  >>> y = x
   
   12:  # x 指向一个空字典
   
   13:  >>> x = {}
   
   14:  # y 仍然指向原字典
   
   15:  >>> y
   
   16:  {'Bill': '213121'}
   
   17:  >>> 
   
   18:  
   
   19:  #字典清空的情况二
   
   20:  >>> x = {'Name' : 'Bill'}
   
   21:  #y也指向字典
   
   22:  >>> y = x
   
   23:  #对字典中的项操作
   
   24:  >>> x['Name'] = 'Candy'
   
   25:  # y 也跟着变化
   
   26:  >>> y
   
   27:  {'Name': 'Candy'}
   
   28:  #清空字典 x
   
   29:  >>> x.clear()
   
   30:  #y也被清空了
   
   31:  >>> y
   
   32:  {}
   
   33:  >>> 
   
   34:  
   
   

3.4.2 copy

1. 说明：用于创建一个新的字典，用两种复制方法：copy和deepcopy
2. 注意：
   1. copy在复制过程中，如果字典中的 值 对象是复杂对象，如列表， 字典等等，则拷贝完后，新的字典中的 值 指向的还是原字典中的 对象，所以修改新对象中的 值 ，同时也是修改原字典中的值，但 是如果字典中的对象是普通类型，如是数字，字符串等，则修改新字 典不会影响原字典。
3. 例子：

    1:  #copy的用法和效果
   
    2:  >>> x = {'Name' : 'Bill', 'Colors': {'red', 'green', 'blue'}}
   
    3:  >>> y = x.copy()
   
    4:  >>> y
   
    5:  {'Colors': ['blue', 'green', 'red'], 'Name': 'Bill'}
   
    6:  #删除颜色列表中的 ‘red’
   
    7:  >>> x['Colors'].remove('red')
   
    8:  >>> x
   
    9:  {'Colors': ['blue', 'green'], 'Name': 'Bill'}
   
   10:  #y字典中的颜色列表也发生的改变
   
   11:  >>> y
   
   12:  {'Colors': ['blue', 'green'], 'Name': 'Bill'}
   
   13:  >>> 
   
   14:  
   
   15:  
   
   16:  #deepcopy的用法和效果
   
   17:  >>> from copy import deepcopy
   
   18:  >>> x = {'colors':['red','green','blue'],'name':'Bill'}
   
   19:  >>> x
   
   20:  {'colors': ['red', 'green', 'blue'], 'name': 'Bill'}
   
   21:  #将x深拷贝给y
   
   22:  >>> y = deepcopy(x)
   
   23:  >>> y
   
   24:  {'colors': ['red', 'green', 'blue'], 'name': 'Bill'}
   
   25:  #修改x
   
   26:  >>> x['colors'].remove('red')
   
   27:  >>> x
   
   28:  {'colors': ['green', 'blue'], 'name': 'Bill'}
   
   29:  #y没有发生改变
   
   30:  >>> y
   
   31:  {'colors': ['red', 'green', 'blue'], 'name': 'Bill'}
   
   32:  >>> 
   
   33:  
   
   

3.4.3 fromekeys

1. 说明：根据键创建新的字典；
2. 例子：

   1:  >>> {}.fromkeys(['name','age'])
   
   2:  {'age': None, 'name': None}
   
   3:  >>> x.fromkeys(['age'])
   
   4:  {'age': None}
   
   5:  >>> 
   
   6:  
   
   

3.4.4 get

1. 说明：是个更宽松的访问字典项的方法，如果键在字典中，则返回值， 如果不在，返回空，也可以给不存在的键指定默认值；（在字典键不存在的情况下，
2. 直接使用索引访问，会出错）
   
3. 例子：

    1:  >>> x = {'name': 'Bill'}
   
    2:  #字典中包含指定的键
   
    3:  >>> x.get('name')
   
    4:  'Bill'
   
    5:  
   
    6:  #字典中不包含指定的键，返回空
   
    7:  >>> x.get('age')
   
    8:  
   
    9:  #为不包含的键指定默认值
   
   10:  >>> x.get('age', 'N/A')
   
   11:  'N/A'
   
   12:  >>> 
   
   13:  
   
   

3.4.5 has_key

1. 说明：可以检查字典中是否含有给出的键，python3中已经 不 包含此 项，可以用 k in dict 的方式代替；

3.4.6 items和iteritems

1. 说明：items以列表方式返回字典中的键值对，iteritems以迭代器对象 返回键值对儿(Python3中不再支持）；
2. 例子：

    1:  >>> x
   
    2:  {'name': 'Bill'}
   
    3:  >>> x.items()
   
    4:  dict_items([('name', 'Bill')])
   
    5:  
   
    6:  #python3中不再包含iteritems
   
    7:  >>> x.iteritems()
   
    8:  Traceback (most recent call last):
   
    9:    File "<pyshell#66>", line 1, in <module>
   
   10:      x.iteritems()
   
   11:  AttributeError: 'dict' object has no attribute 'iteritems'
   
   12:  
   
   

3.4.7 keys

1. 说明：返回字典中的 键
2. 例子：

   1:  >>> x = {'Name':'Bill', 'Age':'30'}
   
   2:  >>> x
   
   3:  {'Age': '30', 'Name': 'Bill'}
   
   4:  >>> x.keys()
   
   5:  dict_keys(['Age', 'Name'])
   
   6:  >>> 
   
   7:  
   
   

3.4.8 pop

1. 说明：用于获取给定键的值，并将该键值对从字典中移除
2. 例子：

   1:  >>> x = {'a':1,'b':2}
   
   2:  >>> x
   
   3:  {'a': 1, 'b': 2}
   
   4:  >>> x.pop('a')
   
   5:  1
   
   6:  >>> x
   
   7:  {'b': 2}
   
   8:  >>> 
   
   9:  
   
   

3.4.9 popitem

1. 说明：用于随机弹出字典中的键值对儿；
2. 例子：

   1:  >>> x = {'a': '1', 'c': '3', 'b': '2'}
   
   2:  >>> while len(x) > 0:
   
   3:          x.popitem()
   
   4:  ('a', '1')
   
   5:  ('c', '3')
   
   6:  ('b', 2)
   
   7:  >>> x
   
   8:  {}
   
   9:  
   
   

3.4.10 setdefault

1. 说明：可以获得给定键的值，如果字典中没有给定键，可以在字典中添 加给定键。如果没有指定给定键的默认值，并且给定键也不在字典中， 则在添加给定键后，将其值设置为 None 。
2. 例子：

    1:  >>> x = {'a':'1','b':'2','c':'3'}
   
    2:  >>> x
   
    3:  {'a': '1', 'c': '3', 'b'/span>: '2'}
   
    4: #字典中包含 a，所以返回键a对应的值1
   
    5: >>> x.setdefault('a')
   
    6: '1'
   
    7: #因为字典中有键a，所以setdefault方法不会改变键a对应的值
   
    8: >>> x.setdefault('a', 'A')
   
    9: '1'
   
   10: >>> x
   
   11: {'a': '1', 'c': '3', 'b': '2'}
   
   12: #字典中没有键d，调用setdefault方法时也没有设置默认值，
   
   13: #所以调用后，在字典中添加了键为d的键值对儿，并返回空。
   
   14: >>> x.setdefault('d')
   
   15: >>> x
   
   16: {'a': '1', 'c': '3', 'b': '2', 'd': None}
   
   17: #调用setdefault时带默认值
   
   18: >>> x.setdefault('e', '5')
   
   19: '5'
   
   20: >>> x
   
   21: {'a': '1', 'c': '3', 'b': '2', 'e': '5', 'd': None}
   
   22: >>> x.setdefault('d', '4')
   
   23: >>> 
   
   24: 
   
   

3.4.11 update

1. 说明：将新字典中的键值对儿更新到原字典中，如果新字典中有的键值 对儿，原字典中没有，则会在原字典中增加新键值对儿；
2. 例子：

    1:  >>> x = {'a':'1','b':'2','c':'3'}
   
    2:  >>> x
   
    3:  {'a': '1', 'c': '3', 'b': '2'}
   
    4:  >>> y = {'a':'A', 'z':'zoo'}
   
    5:  >>> x.update(y)
   
    6:  #键‘a’被更新到字典中，‘z’被添加到字典中
   
    7:  >>> x
   
    8:  {'a': 'A', 'c': '3', 'b': '2', 'e': '5', 'd': None, 'z': 'zoo'}
   
    9:  >>> z=[('g','11'),('q','12')]
   
   10:  >>> x.update(z)
   
   11:  >>> x
   
   12:  {'a': 'A', 'q': '12', 'c': '3', 'b': '2', 'e': '5', 'd': None, 'g': '11', 'z': 'zoo'}
   
   13:  >>> 
   
   14:  
   
   

3.4.12 values和itervalues

1. 说明：values返回字典中的值，itervalues已经不被python3支持。
2. 例子：

   1:  >>> x
   
   2:  {'a': 'A', 'q': '12', 'c': '3', 'b': '2', 'e': '5', 'd': None, 'g': '11', 'z': 'zoo'}
   
   3:  >>> x.values()
   
   4:  dict_values(['A', '12', '3', '2', '5', None, '11', 'zoo'])
   
   5:  >>> 
   
   6:  
   
   

Date: 2011-11-21 09:06:22

Author:

Org version 7.7 with Emacs version 23