入门视频

这些视频可能会为解决本次作业中的编程题提供一些思路。

观看视频前，请先登录你的 berkeley.edu 邮箱账户。

YouTube 链接

可变性

Python 中的列表和字典等对象是 可变的，也就是说可以改变其内容或状态。数字、元组和字符串等其他对象则是 不可变的，创建后就不能再改变。

列表最常见的两种修改操作是元素赋值和 append 方法。

>>> s = [1, 3, 4]
>>> t = s  # A second name for the same list
>>> t[0] = 2  # this changes the first element of the list to 2, affecting both s and t
>>> s
[2, 3, 4]
>>> s.append(5)  # this adds 5 to the end of the list, affecting both s and t
>>> t
[2, 3, 4, 5]

列表还有许多其他修改方法：

• append(elem)：把 elem 添加到列表末尾，返回 None.
• extend(s)：添加可迭代对象中的所有元素 s 添加到列表末尾，返回 None.
• insert(i, elem)：把 elem 插入索引 i。如果 i 大于或等于列表长度，则把 elem 插入末尾。这个操作不会替换现有元素，只会添加新元素 elem，返回 None.
• remove(elem)：删除列表中第一次出现的 elem ，返回 None。如果 elem 不在列表中则报错。
• pop(i)：删除并返回指定索引处的元素 i.
• pop()：删除并返回最后一个元素。

字典同样支持元素赋值（经常使用）以及 pop （很少使用）。

>>> d = {2: 3, 4: 16}
>>> d[2] = 4
>>> d[3] = 9
>>> d
{2: 4, 4: 16, 3: 9}
>>> d.pop(4)
16
>>> d
{2: 4, 3: 9}

迭代器

可迭代对象 是能够逐个元素遍历的值。我们已经用过 for 语句遍历可迭代对象：

for elem in iterable:
    # do something

通常，在可迭代对象上调用内置 可迭代对象 iter 函数会返回一个 迭代器。在迭代器上调用 迭代器 next 函数会返回下一个值。

例如，列表就是一种可迭代值。

>>> s = [1, 2, 3, 4]
>>> next(s)       # s is iterable, but not an iterator
TypeError: 'list' object is not an iterator
>>> t = iter(s)   # Creates an iterator
>>> t
<list_iterator object ...>
>>> next(t)       # Calling next on an iterator
1
>>> next(t)       # Calling next on the same iterator
2
>>> next(iter(t)) # Calling iter on an iterator returns itself
3
>>> t2 = iter(s)
>>> next(t2)      # Second iterator starts at the beginning of s
1
>>> next(t)       # First iterator is unaffected by second iterator
4
>>> next(t)       # No elements left!
StopIteration
>>> s             # Original iterable is unaffected
[1, 2, 3, 4]

也可以在 for 语句中使用迭代器，因为所有迭代器都是可迭代对象。但迭代器会保存自身状态，因此通常只能完整遍历一次：

>>> t = iter([4, 3, 2, 1])
>>> for e in t:
...     print(e)
4
3
2
1
>>> for e in t:
...     print(e)

有些内置函数会返回迭代器。这些 Python 序列操作以惰性方式计算结果。

>>> m = map(lambda x: x * x, [3, 4, 5])
>>> next(m)
9
>>> next(m)
16
>>> f = filter(lambda x: x > 3, [3, 4, 5])
>>> next(f)
4
>>> next(f)
5
>>> z = zip([30, 40, 50], [3, 4, 5])
>>> next(z)
(30, 3)
>>> next(z)
(40, 4)

生成器

可以通过编写 生成器函数来创建自定义迭代器。它返回一种特殊的迭代器，称为 生成器。生成器函数的函数体使用 yield 语句，而不是 return 语句。调用生成器函数会返回生成器对象， 不会 立即执行函数体。

例如，观察下面的生成器函数：

def countdown(n):
    print("Beginning countdown!")
    while n >= 0:
        yield n
        n -= 1
    print("Blastoff!")

调用 countdown(k) 会返回一个从 k 倒数到 0 的生成器对象。生成器也是迭代器，因此可以对结果调用 iter ，它只会返回同一个对象。此时函数体尚未执行，不会打印任何内容，也不会输出数字。

>>> c = countdown(5)
>>> c
<generator object countdown ...>
>>> c is iter(c)
True

那么倒数是怎样进行的？生成器是迭代器，所以我们调用 next 获取下一个元素。第一次调用 next 时，从函数体第一行开始执行，直到遇到 yield 语句。对其中表达式求值所得的结果会被返回。下面的交互会话接续上面的例子。 yield

>>> next(c)
Beginning countdown!
5

与此前见过的函数不同，生成器函数可以记住自身状态。后续每次调用 next时，都会从上一次执行的 yield 语句之后继续。与第一次调用 next一样，程序会一直执行到下一个 yield 语句。正因如此， Beginning countdown! 不会再次打印。

>>> next(c)
4
>>> next(c)
3

接下来三次调用 next 会继续依次产生递减整数，直到 0。再调用一次时会引发 StopIteration 错误，因为已经没有值可以产生（也就是在再次遇到 yield 语句前就到达了函数体末尾）。

>>> next(c)
2
>>> next(c)
1
>>> next(c)
0
>>> next(c)
Blastoff!
StopIteration

分别调用 countdown 会创建各自拥有独立状态的生成器对象。通常生成器不会自行重新开始；若要重置序列，请再次调用生成器函数创建新对象。

>>> c1, c2 = countdown(5), countdown(5)
>>> c1 is c2
False
>>> next(c1)
5
>>> next(c2)
5

总结如下：

• 一个 生成器函数 包含 yield 语句，并返回 生成器对象.
• 对生成器对象调用 iter 函数会返回同一个对象，不会修改其当前状态。
• 只有对生成器对象调用 next 时才会执行生成器函数体。调用 next 会计算并返回序列中的下一个对象。如果序列已经耗尽，则引发 StopIteration 。

• 生成器会为下一次 next 调用“记住”当前状态。因此，

  • 第一次 next 调用的过程如下：

    1. 进入函数并运行到包含 yield.
    2. 返回 yield 语句中的值，同时保存函数状态供后续 next 调用使用。

  • 后续 next 调用的过程如下：

    1. 重新进入函数，从 上次执行的 yield 语句下一行开始，运行到下一个 yield 语句。
    2. 返回 yield 语句中的值，同时保存函数状态供后续 next 调用使用。
• 调用生成器函数会返回全新的生成器对象（类似于对可迭代对象调用 iter ）。
• 除非定义如此，否则生成器不会重新开始。要从第一个元素重新开始，只需再次调用生成器函数创建新生成器。

生成器还有一个实用工具： yield from 语句。 yield from 会依次产生某个迭代器或可迭代对象中的所有值。

>>> def gen_list(lst):
...     yield from lst
...
>>> g = gen_list([1, 2, 3, 4])
>>> next(g)
1
>>> next(g)
2
>>> next(g)
3
>>> next(g)
4
>>> next(g)
StopIteration