标签：ham spam Python eggs keys dict 字典

字典

1. 字典

Python字典的主要属性如下：

通过键而不是偏移量来读取：字典通过键将一系列值联系起来，这样就可以使用键从字典中取出存储于该键下的一项
任意对象的无序集合：与列表不同，保存在字典中的项并没有特定的顺序，实际上，Python将各项伪随机地从左到右随机排序，以便快速查找
长度可变、异构、任意嵌套：与列表类似，字典可以在原位置增长或缩短，它们可以包含任何类型的对象，而且它们支持任意深度的嵌套，每个键只有一个与之相关联的值，而一个值可以同时存储在多个键下
属于可变映射类型：通过给键索引赋值，字典可以在原位置修改
对象引用表（散列表）：字典是支持键读取的无序对象引用表，本质上说，字典是作为散列表来实现的，Python采用散列算法来寻找键，和列表一样，字典存储的是对象引用。

字典常用字面量和操作

字典常用字面量和操作1

字典常用字面量和操作2

2. 字典的实际应用

2.1 字典的基本操作

>>> D = {'spam': 2, 'ham': 1, 'eggs': 3}
>>> D
{'spam': 2, 'ham': 1, 'eggs': 3}
>>> D['spam']  # 通过键获取值
2

字典内部键由左至右的顺序几乎总是与原先输入的顺序不同（Python3.7开始，字典在内部保存键的顺序与输入顺序一致）

内置len函数可以用于字典，将会返回存储在字典里的元素数目，或者说是其keys列表的长度；

in成员运算符可以测试键是否存在；

keys方法可以返回字典中的所有键(返回的是dict_keys可迭代对象)；

>>> len(D)
3
>>> 'ham' in D
True
>>> D.keys()
dict_keys(['spam', 'ham', 'eggs'])
>>> list(D.keys())
['spam', 'ham', 'eggs']

2.2 原位置修改字典

字典是可变类型，因此可以在原位置对字典进行修改。

给一个已存在的键赋值就可以改变该键对应的值，对新的字典键进行赋值会在字典中生成一个新的键值对；

del语句可以删除键对应的键值对。

>>> D
{'spam': 2, 'ham': 1, 'eggs': 3}
>>> D['ham'] = ['grill', 'bake', 'fry']  # 修改键对应的值
>>> D
{'spam': 2, 'ham': ['grill', 'bake', 'fry'], 'eggs': 3}
>>> del D['eggs']  # 删除键对应的键值对
>>> D
{'spam': 2, 'ham': ['grill', 'bake', 'fry']}
>>> D['brunch'] = 'Bacon'  # 增加字典键值对
>>> D
{'spam': 2, 'ham': ['grill', 'bake', 'fry'], 'brunch': 'Bacon'}

2.3 其他字典方法

字典的keys、values和items方法分别返回字典中所有的键、所有的值和所有的(key, value)对元组的可迭代对象

>>> D = {'spam': 2, 'ham': 1, 'eggs': 3}
>>> D.keys()
dict_keys(['spam', 'ham', 'eggs'])
>>> list(D.keys())
['spam', 'ham', 'eggs']
>>> D.values()
dict_values([2, 1, 3])
>>> list(D.values())
[2, 1, 3]
>>> D.items()
dict_items([('spam', 2), ('ham', 1), ('eggs', 3)])
>>> list(D.items())
[('spam', 2), ('ham', 1), ('eggs', 3)]

可以使用[]键索引读取对应的值，如果键不存在会抛出KeyError异常；也可以通过get方法获取键对应的值，通过get方法可以在键不存在时返回设定的default值(default值不设置则默认为None)，避免了missing key错误

>>> D = {'spam': 2, 'ham': 1, 'eggs': 3}
>>> D['spam']
2
>>> D['toast']
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
KeyError: 'toast'
>>> D.get('spam')
2
>>> print(D.get('toast'))  # key不存在时若未指定default则get方法返回None
None
>>> D.get('toast', 88)  # key不存在时若指定了default则get方法返回default
88

字典还提供了一个setdefault方法，用于在字典中获取指定键的值，如果该键不存在，则将其添加到字典中，并将其值设为提供的默认值，然后返回默认值；如果键存在，则返回该键对应的值。

>>> D = {'spam': 2, 'ham': 1, 'eggs': 3}
>>> D.setdefault('spam', 0)
2
>>> D.setdefault('toast', 0)
0
>>> D
{'spam': 2, 'ham': 1, 'eggs': 3, 'toast': 0}

字典的D1.update(D2)方法会将字典D2合并到字典D1中，合并是指，如果键在字典D2中存在而在字典D1中不存在时，直接将该键值对添加到字典D1中；如果键在字典D2和D1中都存在时（即键冲突），会将字典D2中的该键值覆盖到字典D1中

>>> D = {'spam': 2, 'ham': 1, 'eggs': 3}
>>> D1 = {'spam': 2, 'ham': 1, 'eggs': 3}
>>> D2 = {'toast': 4, 'ham': 2}
>>> D1.update(D2)
>>> D1
{'spam': 2, 'ham': 2, 'eggs': 3, 'toast': 4}

字典的pop方法能够从字典中删除一个指定的键并返回它的值，字典的popitem则会删除字典按输入顺序的最后一个键值对，字典的clear方法则会删除字典中的所有的键值对

>>> D = {'spam': 2, 'ham': 2, 'eggs': 3, 'toast': 4}
>>> D.pop('toast')
4
>>> D
{'spam': 2, 'ham': 2, 'eggs': 3}
>>> D
{'spam': 2, 'ham': 2, 'eggs': 3}
>>> D.popitem()
('eggs', 3)
>>> D
{'spam': 2, 'ham': 2}
>>> D.clear()
>>> D
{}

2.4 字典迭代遍历

>>> table = {'Holy Grail': '1975',
...          'Life of Brain': '1979',
...          'The Meaning of Life': '1983'}
>>> for movie in table:
...     print(movie + '\t' + table[movie])
...
Holy Grail      1975
Life of Brain   1979
The Meaning of Life     1983

对字典D而言，可以使用for key in D或for key in D.keys()来遍历字典的键。

用元组作键

用元组作为字典键可以实现存储稀疏矩阵

>>> matrix = {}
>>> matrix[(2, 3, 4)] = 88
>>> matrix[(5, 6, 7)] = 99
>>> matrix
{(2, 3, 4): 88, (5, 6, 7): 99}
# 只存储有值的，其余位置都是空

避免键不存在错误

使用if语句判断键是否存在

>>> if (2, 3, 5) in matrix:
...     print(matrix[(2, 3, 5)])
...

使用try语句捕获键不存在异常

>>> try:
...     print(matrix[(2, 3, 5)])
... except KeyError:
...     print(0)
...
0

使用get方法为不存在的键设置默认值

>>> matrix.get((2, 3, 5), 0)
0

字典的嵌套

>>> rec = {'name': 'Bob',
...        'jobs': ['developer', 'manager'],
...        'web': 'www.bobs.org',
...        'home': {'state': 'Overworked', 'zip': 123456} }
KeyError: 'job'
>>> rec['jobs'][0]
'developer'
>>> rec['home']['state']
'Overworked'

2.5 创建字典的其他方式

直接写出整个字典的字面量

>>> D = {'name': 'Bob', 'age': 40}
>>> D
{'name': 'Bob', 'age': 40}

创建空字典，然后动态添加键和值

>>> D = dict()
>>> D
{}
>>> D['name'] = 'Bob'
>>> D['age'] = 40
>>> D
{'name': 'Bob', 'age': 40}

使用dict函数的关键字形式

>>> D = dict(name='Bob', age=40)
>>> D
{'name': 'Bob', 'age': 40}

使用dict函数的(key, value)的元组形式

>>> D = dict([('name', 'Bob'), ('age', 40)])
>>> D
{'name': 'Bob', 'age': 40}

这种形式通常会和zip函数一起使用，zip函数会将多个可迭代对象中的元素打包成一个个元组，然后返回这些元组组成的迭代器。

>>> keyslist = ['name', 'age']
>>> valueslist = ['Bob', 40]
>>> D = dict(zip(keyslist, valueslist))
>>> D
{'name': 'Bob', 'age': 40}

使用dict.fromkeys()方法

dict.fromkeys(iterable, value=None)

fromkeys方法用于创建一个新的字典，这个新字典的键来自于一个可迭代对象，而所有键的值都被设置为相同的值（默认是 None）

>>> dict.fromkeys(['a', 'b'], 0)
{'a': 0, 'b': 0}

使用字典推导来创建

>>> D = dict(zip(['a', 'b', 'c'], [1, 2, 3]))
>>> D
{'a': 1, 'b': 2, 'c': 3}
>>> D = {k:v for (k, v) in zip(['a', 'b', 'c'], [1, 2, 3])}
>>> D
{'a': 1, 'b': 2, 'c': 3}
>>> D = {x: x ** 2 for x in [1, 2, 3, 4]}
>>> D
{1: 1, 2: 4, 3: 9, 4: 16}
>>> D = {c: c * 4 for c in 'SPAM'}
>>> D
{'S': 'SSSS', 'P': 'PPPP', 'A': 'AAAA', 'M': 'MMMM'}
>>> D = {c.lower(): c + '!' for c in ['SPAM', 'EGGS', 'HAM']}
>>> D
{'spam': 'SPAM!', 'eggs': 'EGGS!', 'ham': 'HAM!'}

2.6 字典视图

字典的keys、values和items方法都会返回视图对象，字典视图是可迭代对象，保存了字典的输入顺序，但不支持索引操作。

>>> D = {'spam': 2, 'ham': 1, 'eggs': 3}
>>> D.keys()
dict_keys(['spam', 'ham', 'eggs'])
>>> list(D.keys())
['spam', 'ham', 'eggs']
>>> D.values()
dict_values([2, 1, 3])
>>> list(D.values())
[2, 1, 3]
>>> D.items()
dict_items([('spam', 2), ('ham', 1), ('eggs', 3)])
>>> list(D.items())
[('spam', 2), ('ham', 1), ('eggs', 3)]

字典视图与集合

字典的keys视图类似集合（因为字典中的键是唯一的），并且支持集合的相关操作；而字典的values视图则不像集合（因为字典中的值并不是唯一的）；字典的items视图也可以类似集合(如果(key, value)对是唯一的，并且是可散列的(具有不变性))。

>>> D = {'a': 1, 'b': 2, 'c': 3}
>>> K = D.keys()
>>> V = D.values()
>>> I = D.items()
>>> K, V, I
(dict_keys(['a', 'b', 'c']), dict_values([1, 2, 3]), dict_items([('a', 1), ('b', 2), ('c', 3)]))
>>> K | {'x': 4}
{'x', 'c', 'a', 'b'}
>>> V & {'x': 4}
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for &: 'dict_values' and 'dict'
>>> K & {'b'}
{'b'}
>>> I | D
{('a', 1), ('c', 3), 'b', 'c', 'a', ('b', 2)}
>>> I | {('d', 4)}
{('d', 4), ('a', 1), ('c', 3), ('b', 2)}

字典键的排序

字典键视图(dict_keys对象)没有sort方法，如果要对字典键进行排序，可以使用sorted内置函数或者将dict_keys转换为列表再调用列表的sort方法

# 转换成列表后再调用列表的sort方法
>>> D = {'c': 3, 'a': 1, 'b': 2}
>>> keyslist = list(D.keys())
>>> keyslist
['c', 'a', 'b']
>>> keyslist.sort()
>>> keyslist
['a', 'b', 'c']
>>> for k in keyslist: print(k, D[k])
...
a 1
b 2
c 3

# 使用sorted函数
>>> for k in sorted(D.keys()): print(k, D[k])
...
a 1
b 2
c 3

标签：ham,spam,Python,eggs,keys,dict,字典
From： https://www.cnblogs.com/N1rv2na/p/18285188

Python-字典

字典