python字典 更新

python字典

字典即映射

类似于java中的map集合，KV类型的数据结构。以下为书中解释

字典 与列表类似，但是更加通用。 在列表中，索引必须是整数；但在字典中，它们可以是（几乎）任何类型。

字典包含了一个索引的集合，被称为 键（keys） ，和一个值(values)的集合。 一个键对应一个值。这种一一对应的关联被称为 键值对（key-value pair) ， 有时也被称为 项（item）。

在数学语言中，字典表示的是从键到值的 映射，所以你也可以说每一个键 “映射到” 一个值。 举个例子，我们接下来创建一个字典，将英语单词映射至西班牙语单词，因此键和值都是字符串。

dict函数生成一个不含任何项的新字典。 由于 dict 是内建函数名，你应该避免使用它来命名变量。

>>> eng2sp = dict()
>>> eng2sp
{}

花括号 {} 表示一个空字典。你可以使用方括号向字典中增加项：

>>> eng2sp['one'] = 'uno'

这行代码创建一个新项，将键 'one' 映射至值 'uno'。 如果我们再次打印该字典，会看到一个以冒号分隔的键值对：

eng2sp
{'one': 'uno'}

输出的格式同样也是输入的格式。 例如，你可以像这样创建一个包含三个项的字典：

>>> eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}

但是，如果你打印 eng2sp ，结果可能会让你感到意外：

>>> eng2sp
{'one': 'uno', 'three': 'tres', 'two': 'dos'}

键-值对的顺序和原来不同。 同样的例子在你的电脑上可能有不同的结果。通常来说，字典中项的顺序是不可预知的。

但这没有关系，因为字典的元素不使用整数索引来索引，而是用键来查找对应的值：

>>> eng2sp['two']
'dos'

键 'two' 总是映射到值 'dos' ，因此项的顺序没有关系。

如果键不存在字典中，会抛出一个异常：

>>> eng2sp['four']
KeyError: 'four'

len函数也适用于字典；它返回键值对的个数：

>>> len(eng2sp)
3

in操作符也适用于字典；它可以用来检验字典中是否存在某个 键 （仅仅有这个值还不够）。

>>> 'one' in eng2sp
True
>>> 'uno' in eng2sp
False

想要知道字典中是否存在某个值，你可以使用 values 方法，它返回值的集合，然后你可以使用 in 操作符来验证：

>>> vals = eng2sp.values()
>>> 'uno' in vals
True

in操作符对列表和字典采用不同的算法。 对于列表，它按顺序依次查找目标，如搜索一节所示。 随着列表的增长，搜索时间成正比增长。

对于字典，Python使用一种叫做 哈希表（hashtable） 的算法， 这种算法具备一种了不起的特性： 无论字典中有多少项，in 运算符搜索所需的时间都是一样的。

字典作为计数器集合

假设给你一个字符串，你想计算每个字母出现的次数。 有多种方法可以使用：

1. 你可以生成26个变量，每个对应一个字母表中的字母。然后你可以遍历字符串，对于 每个字符，递增相应的计数器，你可能会用到链式条件。
2. 你可以生成具有26个元素的列表。然后你可以将每个字符转化为一个数字（使用内建函数 ord ），使用这些数字作为列表的索引，并递增适当的计数器。
3. 你可以生成一个字典，将字符作为键，计数器作为相应的值。字母第一次出现时，你应该向字典中增加一项。 这之后，你应该递增一个已有项的值。

每个方法都是为了做同一件事，但是各自的实现方法不同。

实现 是指执行某种计算的方法；有的实现更好。 例如，使用字典的实现有一个优势，即我们不需要事先知道字符串中有几种字母， 只要在出现新字母时分配空间就好了。

代码可能是这样的：

def histogram(s):
    d = dict()
    for c in s:
        if c not in d:
            d[c] = 1
        else:
            d[c] += 1
    return d

函数名叫 histogram (直方图) ，是计数器（或是频率）集合的统计术语。

函数的第一行生成一个空字典。for 循环遍历该字符串。 每次循环，如果字符 c 不在字典中， 我们用键 c 和初始值 1 生成一个新项 （因为该字母出现了一次）。 如果 c 已经在字典中了，那么我们递增 d[c] 。

下面是运行结果：

>>> h = histogram('brontosaurus')
>>> h
{'a': 1, 'b': 1, 'o': 2, 'n': 1, 's': 2, 'r': 2, 'u': 2, 't': 1}

histogram函数表明字母 'a' 和 'b' 出现了一次， 'o' 出现了两次，等等。

字典类有一个 get 方法，接受一个键和一个默认值作为参数。 如果字典中存在该键，则返回对应值；否则返回传入的默认值。例如：

>>> h = histogram('a')
>>> h
{'a': 1}
>>> h.get('a', 0)
1
>>> h.get('b', 0)
0

循环和字典

在 for 循环中使用字典会遍历其所有的键。 例如，下面的 print_hist 会打印所有键与对应的值：

def print_hist(h):
    for c in h:
        print(c, h[c])

输出类似：

>>> h = histogram('parrot')
>>> print_hist(h)
a 1
p 1
r 2
t 1
o 1

重申一遍，字典中的键是无序的。 如果要以确定的顺序遍历字典，你可以使用内建方法 sorted：

>>> for key in sorted(h):
...     print(key, h[key])
a 1
o 1
p 1
r 2
t 1

逆向查找

给定一个字典 d 以及一个键 t ，很容易找到相应的值 v = d[k] 。 该运算被称作 查找（lookup） 。

但是如果你想通过 v 找到 k 呢？ 有两个问题：第一，可能有不止一个的键其映射到值v。 你可能可以找到唯一一个，不然就得用 list 把所有的键包起来。 第二，没有简单的语法可以完成 逆向查找（reverse lookup）；你必须搜索。

下面这个函数接受一个值并返回映射到该值的第一个键：

def reverse_lookup(d, v):
    for k in d:
        if d[k] == v:
            return k
    raise LookupError()

该函数是搜索模式的另一个例子，但是它使用了一个我们之前没有见过的特性，raise。 raise 语句 能触发异常，这里它触发了 ValueError，这是一个表示查找操作失败的内建异常。

如果我们到达循环结尾，这意味着字典中不存在 v 这个值，所以我们触发一个异常。

下面是一个成功逆向查找的例子：

>>> h = histogram('parrot')
>>> key = reverse_lookup(h, 2)
>>> key
'r'

和一个失败的例子：

>>> key = reverse_lookup(h, 3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 5, in reverse_lookup
LookupError

你触发的异常和 Python 触发的产生效果一样：都打印一条回溯和错误信息。

raise语句接受一个详细的错误信息作为可选的实参。 例如：

>>> raise LookupError('value does not appear in the dictionary')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
LookupError: value does not appear in the dictionary

逆向查找比正向查找慢得多； 如果你频繁执行这个操作或是字典很大，程序性能会变差。

字典和列表

在字典中，列表可以作为值出现。 例如，如果你有一个从字母映射到频率的字典， 而你想倒转它； 也就是生成一个从频率映射到字母的字典。 因为可能有些字母具有相同的频率，所以在倒转字典中的每个值应该是一个字母组成的列表。

下面是一个倒转字典的函数：

def invert_dict(d):
    inverse = dict()
    for key in d:
        val = d[key]
        if val not in inverse:
            inverse[val] = [key]
        else:
            inverse[val].append(key)
    return inverse

每次循环，key 从 d 获得一个键和相应的值 val 。 如果 val 不在 inverse 中，意味着我们之前没有见过它， 因此我们生成一个新项并用一个 单元素集合（singleton） （只包含一个元素的列表）初始化它。 否则就意味着之前已经见过该值，因此将其对应的键添加至列表。

举个例子：

>>> hist = histogram('parrot')
>>> hist
{'a': 1, 'p': 1, 'r': 2, 't': 1, 'o': 1}
>>> inverse = invert_dict(hist)
>>> inverse
{1: ['a', 'p', 't', 'o'], 2: ['r']}

图11-1：状态图

图11-1：状态图是关于 hist 与 inverse 的状态图。字典用标有类型dict的方框表示，方框中是键值对。如果值是整数、浮点数或字符串， 我就把它们画在方框内部，但我通常把列表画在方框外面，目的只是为了不让图表变复杂。

如本例所示，列表可以作为字典中的值，但是不能是键。 下面演示了这样做的结果：

>>> t = [1, 2, 3]
>>> d = dict()
>>> d[t] = 'oops'
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: list objects are unhashable

我之前提过，字典使用哈希表实现，这意味着键必须是 可哈希的（hashable） 。

哈希（hash） 函数接受一个值（任何类型）并返回一个整数。 字典使用被称作哈希值的这些整数，来存储和查找键值对。

如果键是不可变的，那么这种实现可以很好地工作。 但是如果键是可变的，如列表，那么就会发生糟糕的事情。 例如，当你生成一个键值对时，Python哈希该键并将其存储在相应的位置。 如果你改变键然后再次哈希它，它将被存储到另一个位置。 在那种情况下，对于相同的键，你可能有两个值， 或者你可能无法找到一个键。 无论如何，字典都不会正确的工作。

这就是为什么键必须是可哈希的，以及为什么如列表这种可变类型不能作为键。 绕过这种限制最简单的方法是使用元组， 我们将在下一章中介绍。

因为字典是可变的，因此它们不能作为键，但是 可以 用作值。

全局变量

在前面的例子中，known 是在函数的外部创建的， 因此它属于被称作 __main__ 的特殊帧。 因为 __main__ 中的变量可以被任何函数访问，它们也被称作 全局变量（global） 。 与函数结束时就会消失的局部变量不同，不同函数调用时全局变量一直都存在。

全局变量普遍用作 标记（flag）； 也就是说明（标记）一个条件是否为真的布尔变量。 例如，一些程序使用一个被称作 verbose 的标记来控制输出的丰富程度：

verbose = True

def example1():
    if verbose:
        print('Running example1')

如果你试图对一个全局变量重新赋值，结果可能出乎意料。 下面的例子本应该记录函数是否已经被调用过了：

been_called = False

def example2():
    been_called = True         # 错误

但是如果你运行它，你会发现 been_called 的值并未发生改变。 问题在于 example2 生成了一个新的被称作 been_called 的局部变量。 当函数结束的时候，该局部变量也消失了，并且对全局变量没有影响。

要在函数内对全局变量重新赋值，你必须在使用之前 声明(declare) 该全局变量：

been_called = False

def example2():
    global been_called
    been_called = True

global 语句 告诉编译器，“在这个函数里，当我说 been_called 时，我指的是那个全局变量，别生成局部变量”。

下面是一个试图更新全局变量的例子：

count = 0

def example3():
    count = count + 1          # 错误

一旦运行，你会发现：

UnboundLocalError: local variable 'count' referenced before assignment

Python默认 count 是局部变量，在这个假设下，你这是在未写入任何东西前就试图读取。 解决方法还是声明 count 是全局变量。

def example3():
    global count
    count += 1

如果全局变量是可变的，你可以不加声明地修改它：

known = {0:0, 1:1}

def example4():
    known[2] = 1

因此你可以增加、删除和替代全局列表或者字典的元素， 但是如果你想对变量重新赋值，你必须声明它：

def example5():
    global known
    known = dict()

全局变量有时是很有用的，但如果你的程序中有很多全局变量，而且修改频繁， 这样会增加程序调试的难度。

调试

当你操作较大的数据集时，通过打印并手工检查数据来调试很不方便。 下面是针对调试大数据集的一些建议：

缩小输入：

如果可能，减小数据集合的大小。 例如，如果程序读入一个文本文件，从前10行开始分析，或是找到更小的样例。 你可以选择编辑读入的文件，或是（最好）修改程序使它只读入前 n 行。

如果出错了，你可以将 n 缩小为会导致该错误的最小值，然后在查找和解决错误的同时，逐步增加 n 的值。

检查摘要和类型：

考虑打印数据的摘要，而不是打印并检查全部数据集合： 例如，字典中项的数目或者数字列表的总和。

运行时错误的一个常见原因，是值的类型不正确。 为了调试此类错误，打印值的类型通常就足够了。

编写自检代码：

有时你可以写代码来自动检查错误。 例如，如果你正在计算数字列表的平均数，你可以检查其结果是不是大于列表中最大的元素，或者小于最小的元素。 这被称 作“合理性检查”，因为它能检测出“不合理的”结果。

另一类检查是比较两个不同计算的结果，来看一下它们是否一致。这被称作“一致性检查”。

格式化输出：

格式化调试输出能够更容易定位一个错误。 我们在调试一节中看过一个示例。pprint 模块提供了一个 pprint 函数，它可以更可读的格式显示内建类型（ pprint 代表 “pretty print”）。

重申一次，你花在搭建脚手架上的时间能减少你花在调试上的时间。