创建和使用字典

  1. >>> phonebook = {'Alice':'2341','Beth':'9102','Cecil': '3258'}

函数dict

从其他映射（如其他字典）或键-值对序列创建字典。

  1. >>> items = [('name', 'Gumby'), ('age', 42)]
  2. >>> d = dict(items)
  3. >>> d
  4. {'age':42,'name': 'Gumby}
  5. >>> d['name']
  6.  'Gumby'

还可使用关键词实参来调用函数

  1. >>> d = dict(name='Gumby', age=42)
  2. >>> d
  3. {'age': 42, 'name': 'Gumby'}

基本的字典操作

  • len(d) 返回字典1d包含的项（键-值对）数。
  • d[k] 返回与键k想关联的值。
  • d[k] = v 将值b关联到键k。
  • del d[k] 删除键为k的项。
  • k in d 检查字典d是否包含键为 k 的项。

format_map

  1. >>> phonebook
  2. {'Beth': '9102', 'Alice': '2341', 'Cecil': '3258'}
  3. >>> "Cecil's phone umber is {Cecil}.".format_map(phonebook)
  4. "Cecil's phone number is 3258."

在模板系统中，这种字符串格式设置方式很有用（下面的示例使用的是HTML）。

  1. template = '''<html>
  2. <head><title>{title}</title></head>
  3. <body>
  4. <h1>{title}</h1>
  5. <p>{text}</p>
  6. </body>'''
  7. data = {'title': 'My Home Page', 'text': 'Welcome to my home page!'}
  8. print(template.format_map(data))
  9. # html
  10. # <head><title>My Home Page</title></head>
  11. # <body>
  12. # <h1>My Home Page</h1>
  13. # <p>Welcome to my home page!</p>
  14. # </body>

字典方法

clear

删除所有的字典项，就地执行的，因此什么都不返回（或者说返回None）。

  1. >>> d = {'age': 42, 'name': 'Gumby'}
  2. >>> returned_value = d.clear()
  3. >>> d
  4. {}
  5. >>> print(returned_value)
  6. None

copy

返回一个新字典。执行的是浅复制，因为值本身是原件，而非副本。

  1. >>> x = {'username': 'admin', 'machines': ['foo', 'bar','baz']}
  2. >>> y = x.copy()
  3. >>> y['username'] = 'mlh'
  4. >>> y['machines'].remove('bar')
  5. >>> y
  6. {'username': 'mlh', 'machines': ['foo', 'baz']}
  7. >>> x
  8. {'username': 'admin', 'machine': ['foo','baz']}

深复制，可以使用模块 copy 中的函数deepcopy。

  1. >>> from copy import deepcopy
  2. >>> d = {'name': ['Alfred','Bertrand']}
  3. >>> dc = deepcopy(d)
  4. >>> d['name'].append('Clive')
  5. >>> dc
  6. {'name': ['alfred', 'Bertrand']}

fromkeys

创建一个新字典，其中包含指定的键，且每个键对应的值都是None。

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

上面这个示例首先创建了一个空字典，再对其调用方法fromkeys来创建另一个字典，这显得有点多余。可以直接对 dict 调用方法fromkeys。

  1. >>> dict.fromkeys(['name','age'])
  2. {'age': None, 'name': None}
  4. # 如果不想使用默认值None,可提供特定的值。
  5. >>> dict.fromkeys(['name', 'age'], '(unknown)')
  6. {'age': '(unknown)', 'name': '(unknown)'}

get

使用get来访问不存在的键，不会引发异常，而是返回None。可指定“默认”值，这样将返回指定的值而不是None。

  1. >>> d = {'age': 42}
  2. >>> d.get('name', 'N/A')
  3. 'N/A'
  4. >>> d.get('age')
  5. 42

items

返回一个包含所有字典项的列表，其中 每个元素都为(key, value)的形式。字典项在列表中的排序顺序不确定。

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

返回值属于一种名为字典视图的特殊类型。字典视图可用于迭代。另外可以确定其长度，对其执行成员资格检查。

  1. >>> it = d.items()
  2. >>> len(it)
  3. 3
  4. >>> ('spam', 0) in it
  5. True

视图的一个优点是不复制，他们始终是底层字典的反映，及时修改了底层字典亦是如此。

  1. >>> d['spam'] = 1
  2. >>> ('spam', 0) in it
  3. False
  4. >>> d['spam'] = 0
  5. >>> ('spam', 0) in it
  6. True

keys

返回一个字典视图，其中包含指定字典中的键。

pop

获取与指定键相关联的值，并将该键-值对从字典中删除。

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

popitem

类似于list.pop，但list.pop弹出列表中的最后一个元素，而popitem随机地弹出一个字典项，因为字典项的顺序是不确定的，没有“最后一个元素”的概念。如果需要高效的逐个删除并处理所有字典项，这样无需获取键列表。

  1. >>> d = {'url':'http://www.python.org','spam': 0,'title': 'Python Web Site'}
  2. >>> d.popitem()
  3. ('url', 'http://www.python.org')
  4. >>> d
  5. {'spam': 0, 'title': 'Python Web Site'}

setdefault

与get很像，获取与指定键相关联的值，但除此之外，还在字典不包含指定的键时，在字典中添加指定的键-值对， 如果没有指定，默认为None。

  1. >>> d = {}
  2. >>> d.setdefault('name', 'N/A')
  3. 'N/A'
  4. >>> d
  5. {'name': 'N/A'}
  6. >>> d['name'] = 'Gumby'
  7. >>> d.setdefault('name', 'N/A')
  8. 'Gumby'
  9. >>> d
  10. {'name': 'Gumby'}

update

使用一个字典中的项来更新另一个字典。

  1. d = {
  2.     'title': 'Python Web Site',
  3.     'url': 'http://www.python.org',
  4.     'changed': 'Mar 14 22:09:15 MET 2016'
  5. }
  6. x = {'title': 'Python Language Website'}
  7. d.update(x)
  8. print(d)
  9. # {'url': 'http://www.python.org', 'changed': 'Mar 14 22:09:15 MET 2016','title': 'Python Language Website'}

对于通过参数提供的字典，将其项添加到当前字典中。如果当前字典包含键相同的项，则替换。

values

返回一个由字典中的值组成的字典视图。返回的视图可能包含重复的值。

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