4 编写结构化程序

赋值

赋值似乎是最基本的编程概念，不值得单独讨论。不过，也有一些令人吃惊的微妙之处。思考下面的代码片段：

>>> foo = 'Monty'
>>> bar = foo 
>>> foo = 'Python' 
>>> bar
'Monty'

这个结果与预期的完全一样。当我们在上面的代码中写bar = foo时，foo的值（字符串'Monty'）被赋值给bar。也就是说，bar是foo的一个副本，所以当我们在第行用一个新的字符串'Python'覆盖foo时，bar的值不会受到影响。

然而，赋值语句并不总是以这种方式复制副本。赋值总是一个表达式的值的复制，但值并不总是你可能希望的那样。特别是结构化对象的“值”，例如一个列表，实际上是一个对象的引用。在下面的例子中，将foo的引用分配给新的变量bar。现在，当我们在行修改foo内的东西，我们可以看到bar的内容也已改变。

>>> foo = ['Monty', 'Python']
>>> bar = foo 
>>> foo[1] = 'Bodkin' 
>>> bar
['Monty', 'Bodkin']

图 4.1：列表赋值与计算机内存：两个列表对象foo和bar引用计算机内存中的相同的位置；更新foo将同样修改bar，反之亦然。

bar = foo行并不会复制变量的内容，只有它的“引用对象”。要了解这里发生了什么事，我们需要知道列表是如何存储在计算机内存的。在4.1中，我们看到一个列表foo是对存储在位置3133处的一个对象的引用（它自身是一个指针序列，其中的指针指向其它保存字符串的位置）。当我们赋值bar = foo时，仅仅是3133位置处的引用被复制。这种行为延伸到语言的其他方面，如参数传递（4.4）。

让我们做更多的实验，通过创建一个持有空列表的变量empty，然后在下一行使用它三次。

>>> empty = []
>>> nested = [empty, empty, empty]
>>> nested
[[], [], []]
>>> nested[1].append('Python')
>>> nested
[['Python'], ['Python'], ['Python']]

请看，改变列表中嵌套列表内的一个项目，它们全改变了。这是因为三个元素中的每一个实际上都只是一个内存中的同一列表的引用。

现在请注意，当我们分配一个新值给列表中的一个元素时，它并不会传送给其他元素：

>>> nested = [[]] * 3
>>> nested[1].append('Python')
>>> nested[1] = ['Monty']
>>> nested
[['Python'], ['Monty'], ['Python']]

我们一开始用含有3个引用的列表，每个引用指向一个空列表对象。然后，我们通过给它追加'Python'修改这个对象，结果变成包含3个到一个列表对象['Python']的引用的列表。下一步，我们使用到一个新对象['Monty']的引用来覆盖三个元素中的一个。这最后一步修改嵌套列表内的3个对象引用中的1个。然而，['Python']对象并没有改变，仍然是在我们的嵌套列表的列表中的两个位置被引用。关键是要明白通过一个对象引用修改一个对象与通过覆盖一个对象引用之间的区别。

等式

Python提供两种方法来检查一对项目是否相同。is操作符测试对象的ID。我们可以用它来验证我们早先的对对象的观察。首先，我们创建一个列表，其中包含同一对象的多个副本，证明它们不仅对于==完全相同，而且它们是同一个对象：

>>> size = 5
>>> python = ['Python']
>>> snake_nest = [python] * size
>>> snake_nest[0] == snake_nest[1] == snake_nest[2] == snake_nest[3] == snake_nest[4]
True
>>> snake_nest[0] is snake_nest[1] is snake_nest[2] is snake_nest[3] is snake_nest[4]
True

现在，让我们将一个新的python放入嵌套中。我们可以很容易地表明这些对象不完全相同:

>>> import random
>>> position = random.choice(range(size))
>>> snake_nest[position] = ['Python']
>>> snake_nest
[['Python'], ['Python'], ['Python'], ['Python'], ['Python']]
>>> snake_nest[0] == snake_nest[1] == snake_nest[2] == snake_nest[3] == snake_nest[4]
True
>>> snake_nest[0] is snake_nest[1] is snake_nest[2] is snake_nest[3] is snake_nest[4]
False

你可以再做几对测试，发现哪个位置包含闯入者，函数id()使检测更加容易：

>>> [id(snake) for snake in snake_nest]
[4557855488, 4557854763, 4557855488, 4557855488, 4557855488]

这表明列表中的第二个项目有一个独特的标识符。如果你尝试自己运行这段代码，请期望看到结果列表中的不同数字，以及闯入者可能在不同的位置。

有两种等式可能看上去有些奇怪。然而，这真的只是类型与标识符式的区别，与自然语言相似，这里在一种编程语言中呈现出来。

条件

在if语句的条件部分，一个非空字符串或列表被求值为真，而一个空字符串或列表的被求值为假。

>>> mixed = ['cat', '', ['dog'], []]
>>> for element in mixed:
...     if element:
...         print(element)
...
cat
['dog']

也就是说，我们不必在条件中写if len(element) > 0:。

使用if...elif而不是在一行中使用两个if语句有什么区别？嗯，考虑以下情况：

>>> animals = ['cat', 'dog']
>>> if 'cat' in animals:
...     print(1)
... elif 'dog' in animals:
...     print(2)
...
1

因为表达式中if子句条件满足，Python就不会求值elif子句，所以我们永远不会得到输出2。相反，如果我们用一个if替换elif，那么我们将会输出1和2。所以elif子句比单独的if子句潜在地给我们更多信息；当它被判定为真时，告诉我们不仅条件满足而且前面的if子句条件不满足。

all()函数和any()函数可以应用到一个列表（或其他序列），来检查是否全部或任一项目满足某个条件：

>>> sent = ['No', 'good', 'fish', 'goes', 'anywhere', 'without', 'a', 'porpoise', '.']
>>> all(len(w) > 4 for w in sent)
False
>>> any(len(w) > 4 for w in sent)
True

序列类型上的操作

我们可以用多种有用的方式遍历一个序列s中的项目，如4.1所示。

表 4.1：

遍历序列的各种方式

>>> raw = 'Red lorry, yellow lorry, red lorry, yellow lorry.'
>>> text = word_tokenize(raw)
>>> fdist = nltk.FreqDist(text)
>>> sorted(fdist)
[',', '.', 'Red', 'lorry', 'red', 'yellow']
>>> for key in fdist:
...     print(key + ':', fdist[key], end='; ')
...
lorry: 4; red: 1; .: 1; ,: 3; Red: 1; yellow: 2

在接下来的例子中，我们使用元组重新安排我们的列表中的内容。（可以省略括号，因为逗号比赋值的优先级更高。）

>>> words = ['I', 'turned', 'off', 'the', 'spectroroute']
>>> words[2], words[3], words[4] = words[3], words[4], words[2]
>>> words
['I', 'turned', 'the', 'spectroroute', 'off']

这是一种地道和可读的移动列表内的项目的方式。它相当于下面的传统方式不使用元组做上述任务（注意这种方法需要一个临时变量tmp）。

>>> tmp = words[2]
>>> words[2] = words[3]
>>> words[3] = words[4]
>>> words[4] = tmp

正如我们已经看到的，Python有序列处理函数，如sorted()和reversed()，它们重新排列序列中的项目。也有修改序列结构的函数，可以很方便的处理语言。因此，zip()接收两个或两个以上的序列中的项目，将它们“压缩”打包成单个的配对列表。给定一个序列s，enumerate(s)返回一个包含索引和索引处项目的配对。

>>> words = ['I', 'turned', 'off', 'the', 'spectroroute']
>>> tags = ['noun', 'verb', 'prep', 'det', 'noun']
>>> zip(words, tags)
<zip object at ...>
>>> list(zip(words, tags))
[('I', 'noun'), ('turned', 'verb'), ('off', 'prep'),
('the', 'det'), ('spectroroute', 'noun')]
>>> list(enumerate(words))
[(0, 'I'), (1, 'turned'), (2, 'off'), (3, 'the'), (4, 'spectroroute')]

对于一些NLP任务，有必要将一个序列分割成两个或两个以上的部分。例如，我们可能需要用90％的数据来“训练”一个系统，剩余10％进行测试。要做到这一点，我们指定想要分割数据的位置，然后在这个位置分割序列。

>>> text = nltk.corpus.nps_chat.words()
>>> cut = int(0.9 * len(text)) 
>>> training_data, test_data = text[:cut], text[cut:] 
>>> text == training_data + test_data 
True
>>> len(training_data) / len(test_data) 
9.0

我们可以验证在此过程中的原始数据没有丢失，也没有重复。我们也可以验证两块大小的比例是我们预期的。

合并不同类型的序列

让我们综合关于这三种类型的序列的知识，一起使用列表推导处理一个字符串中的词，按它们的长度排序。

>>> words = 'I turned off the spectroroute'.split() 
>>> wordlens = [(len(word), word) for word in words] 
>>> wordlens.sort() 
>>> ' '.join(w for (_, w) in wordlens) 
'I off the turned spectroroute'

上述代码段中每一行都包含一个显著的特征。一个简单的字符串实际上是一个其上定义了方法如split() 的对象。我们使用列表推导建立一个元组的列表，其中每个元组由一个数字（词长）和这个词组成，例如(3, 'the')。我们使用sort()方法就地排序列表。最后，丢弃长度信息，并将这些词连接回一个字符串。（下划线只是一个普通的Python变量，我们约定可以用下划线表示我们不会使用其值的变量。）

我们开始谈论这些序列类型的共性，但上面的代码说明了这些序列类型的重要的区别。首先，字符串出现在开头和结尾：这是很典型的，我们的程序先读一些文本，最后产生输出给我们看。列表和元组在中间，但使用的目的不同。一个链表是一个典型的具有相同类型的对象的序列，它的长度是任意的。我们经常使用列表保存词序列。相反，一个元组通常是不同类型的对象的集合，长度固定。我们经常使用一个元组来保存一个纪录，与一些实体相关的不同字段的集合。使用列表与使用元组之间的区别需要一些时间来习惯，所以这里是另一个例子：

>>> lexicon = [
...     ('the', 'det', ['Di:', 'D@']),
...     ('off', 'prep', ['Qf', 'O:f'])
... ]

在这里，用一个列表表示词典，因为它是一个单一类型的对象的集合——词汇条目——没有预定的长度。个别条目被表示为一个元组，因为它是一个有不同的解释的对象的集合，例如正确的拼写形式、词性、发音（以SAMPA计算机可读的拼音字母表示，http://www.phon.ucl.ac.uk/home/sampa/）。请注意，这些发音都是用列表存储的。（为什么呢？）

列表和元组之间的使用上的区别已经讲过了。然而，还有一个更加基本的区别：在Python中，列表是可变的，而元组是不可变的。换句话说，列表可以被修改，而元组不能。这里是一些在列表上的操作，就地修改一个列表。

>>> lexicon.sort()
>>> lexicon[1] = ('turned', 'VBD', ['t3:nd', 't3`nd'])
>>> del lexicon[0]

生成器表达式

我们一直在大量使用列表推导，因为用它处理文本结构紧凑和可读性好。下面是一个例子，分词和规范化一个文本：

>>> text = '''"When I use a word," Humpty Dumpty said in rather a scornful tone,
... "it means just what I choose it to mean - neither more nor less."'''
>>> [w.lower() for w in word_tokenize(text)]
['``', 'when', 'i', 'use', 'a', 'word', ',', "''", 'humpty', 'dumpty', 'said', ...]

假设我们现在想要进一步处理这些词。我们可以将上面的表达式插入到一些其他函数的调用中，Python允许我们省略方括号。

>>> max([w.lower() for w in word_tokenize(text)]) 
'word'
>>> max(w.lower() for w in word_tokenize(text)) 
'word'

第二行使用了生成器表达式。这不仅仅是标记方便：在许多语言处理的案例中，生成器表达式会更高效。在中，列表对象的存储空间必须在max()的值被计算之前分配。如果文本非常大的，这将会很慢。在中，数据流向调用它的函数。由于调用的函数只是简单的要找最大值——按字典顺序排在最后的词——它可以处理数据流，而无需存储迄今为止的最大值以外的任何值。

Python代码风格

编写程序时，你会做许多微妙的选择：名称、间距、注释等等。当你在看别人编写的代码时，风格上的不必要的差异使其难以理解。因此，Python 语言的设计者发表了Python代码风格指南，httphttp://www.python.org/dev/peps/pep-0008/。风格指南中提出的基本价值是一致性，目的是最大限度地提高代码的可读性。我们在这里简要回顾一下它的一些主要建议，并请读者阅读完整的指南，里面有对实例的详细的讨论。

代码布局中每个缩进级别应使用4个空格。你应该确保当你在一个文件中写Python代码时，避免使用tab缩进，因为它可能由于不同的文本编辑器的不同解释而产生混乱。每行应少于80个字符长；如果必要的话，你可以在圆括号、方括号或花括号内换行，因为Python能够探测到该行与下一行是连续的。如果你需要在圆括号、方括号或大括号中换行，通常可以添加额外的括号，也可以在行尾需要换行的地方添加一个反斜杠：

>>> if (len(syllables) > 4 and len(syllables[2]) == 3 and
...    syllables[2][2] in [aeiou] and syllables[2][3] == syllables[1][3]):
...     process(syllables)
>>> if len(syllables) > 4 and len(syllables[2]) == 3 and \
...    syllables[2][2] in [aeiou] and syllables[2][3] == syllables[1][3]:
...     process(syllables)

过程风格与声明风格

我们刚才已经看到可以不同的方式执行相同的任务，其中蕴含着对执行效率的影响。另一个影响程序开发的因素是编程风格。思考下面的计算布朗语料库中词的平均长度的程序：

>>> tokens = nltk.corpus.brown.words(categories='news')
>>> count = 0
>>> total = 0
>>> for token in tokens:
...     count += 1
...     total += len(token)
>>> total / count
4.401545438271973

在这段程序中，我们使用变量count跟踪遇到的词符的数量，total储存所有词的长度的总和。这是一个低级别的风格，与机器代码，即计算机的CPU 所执行的基本操作，相差不远。两个变量就像CPU的两个寄存器，积累许多中间环节产生的值，和直到最才有意义的值。我们说，这段程序是以过程风格编写，一步一步口授机器操作。现在，考虑下面的程序，计算同样的事情：

>>> total = sum(len(t) for t in tokens)
>>> print(total / len(tokens))
4.401...

第一行使用生成器表达式累加标示符的长度，第二行像前面一样计算平均值。每行代码执行一个完整的、有意义的工作，可以高级别的属性，如：“total是标识符长度的总和”，的方式来理解。实施细节留给Python解释器。第二段程序使用内置函数，在一个更抽象的层面构成程序；生成的代码是可读性更好。让我们看一个极端的例子：

>>> word_list = []
>>> i = 0
>>> while i < len(tokens):
...     j = 0
...     while j < len(word_list) and word_list[j] <= tokens[i]:
...         j += 1
...     if j == 0 or tokens[i] != word_list[j-1]:
...         word_list.insert(j, tokens[i])
...     i += 1
...

等效的声明版本使用熟悉的内置函数，可以立即知道代码的目的：

>>> word_list = sorted(set(tokens))

另一种情况，对于每行输出一个计数值，一个循环计数器似乎是必要的。然而，我们可以使用enumerate()处理序列s，为s中每个项目产生一个(i, s[i])形式的元组，以(0, s[0])开始。下面我们枚举频率分布的值，生成嵌套的(rank, (word, count))元组。按照产生排序项列表时的需要，输出rank+1使计数从1开始。

>>> fd = nltk.FreqDist(nltk.corpus.brown.words())
>>> cumulative = 0.0
>>> most_common_words = [word for (word, count) in fd.most_common()]
>>> for rank, word in enumerate(most_common_words):
...     cumulative += fd.freq(word)
...     print("%3d %6.2f%% %s" % (rank + 1, cumulative * 100, word))
...     if cumulative > 0.25:
...         break
...
  1   5.40% the
  2  10.42% ,
  3  14.67% .
  4  17.78% of
  5  20.19% and
  6  22.40% to
  7  24.29% a
  8  25.97% in

到目前为止，使用循环变量存储最大值或最小值，有时很诱人。让我们用这种方法找出文本中最长的词。

>>> text = nltk.corpus.gutenberg.words('milton-paradise.txt')
>>> longest = ''
>>> for word in text:
...     if len(word) > len(longest):
...         longest = word
>>> longest
'unextinguishable'

然而，一个更加清楚的解决方案是使用两个列表推导，它们的形式现在应该很熟悉：

>>> maxlen = max(len(word) for word in text)
>>> [word for word in text if len(word) == maxlen]
['unextinguishable', 'transubstantiate', 'inextinguishable', 'incomprehensible']

请注意，我们的第一个解决方案找到第一个长度最长的词，而第二种方案找到所有最长的词（通常是我们想要的）。虽然有两个解决方案之间的理论效率的差异，主要的开销是到内存中读取数据；一旦数据准备好，第二阶段处理数据可以瞬间高效完成。我们还需要平衡我们对程序的效率与程序员的效率的关注。一种快速但神秘的解决方案将是更难理解和维护的。

计数器的一些合理用途

在有些情况下，我们仍然要在列表推导中使用循环变量。例如：我们需要使用一个循环变量中提取列表中连续重叠的n-grams：

>>> sent = ['The', 'dog', 'gave', 'John', 'the', 'newspaper']
>>> n = 3
>>> [sent[i:i+n] for i in range(len(sent)-n+1)]
[['The', 'dog', 'gave'],
 ['dog', 'gave', 'John'],
 ['gave', 'John', 'the'],
 ['John', 'the', 'newspaper']]

确保循环变量范围的正确相当棘手的。因为这是NLP中的常见操作，NLTK提供了支持函数bigrams(text)、trigrams(text)和一个更通用的ngrams(text, n)。

下面是我们如何使用循环变量构建多维结构的一个例子。例如，建立一个m行n列的数组，其中每个元素是一个集合，我们可以使用一个嵌套的列表推导：

>>> m, n = 3, 7
>>> array = [[set() for i in range(n)] for j in range(m)]
>>> array[2][5].add('Alice')
>>> pprint.pprint(array)
[[set(), set(), set(), set(), set(), set(), set()],
 [set(), set(), set(), set(), set(), set(), set()],
 [set(), set(), set(), set(), set(), {'Alice'}, set()]]

请看循环变量i和j在产生对象过程中没有用到，它们只是需要一个语法正确的for 语句。这种用法的另一个例子，请看表达式['very' for i in range(3)]产生一个包含三个'very'实例的列表，没有整数。

请注意，由于我们前面所讨论的有关对象复制的原因，使用乘法做这项工作是不正确的。

>>> array = [[set()] * n] * m
>>> array[2][5].add(7)
>>> pprint.pprint(array)
[[{7}, {7}, {7}, {7}, {7}, {7}, {7}],
 [{7}, {7}, {7}, {7}, {7}, {7}, {7}],
 [{7}, {7}, {7}, {7}, {7}, {7}, {7}]]

迭代是一个重要的编程概念。采取其他语言中的习惯用法是很诱人的。然而， Python提供一些优雅和高度可读的替代品，正如我们已经看到。