<< >>

diveintopython.org |

Python for experienced programmers

## 1.8. 列表 101

列表是Python中使用最频繁的数据类型。如果你对列表仅有的经验是在VB中的数组或Java中的`List`s ，那么振作起来，面对Python列表吧。

例 1.13. 定义列表

    >>> li = ["a", "b", "mpilgrim", "z", "example"]
    >>> li
    ['a', 'b', 'mpilgrim', 'z', 'example']
    >>> li[0]
    'a'
    >>> li[4]
    'example'

| 首先我们定义了一个有5个元素的列表。注意它们保持着它们初始的顺序。这不是一个偶然。一个列表是一个用方括号包括的有序元素集。
| 一个列表可以象一个以0开始的数组一样使用。任何一个非空列表的第一个元素总是 `li[0]`。
| 这个5元素列表的最后一个元素是 `li[4]`，因为列表总是从0开始。

例 1.14. 负的列表索引

    >>> li
    ['a', 'b', 'mpilgrim', 'z', 'example']
    >>> li[-1]
    'example'
    >>> li[-3]
    'mpilgrim'

| 负数索引从列表的尾部开始向后计数存取元素。任何一个非空的列表最后一个元素总是`li[-1]`。
| 如果负数索引使你感到糊涂，象这样理解它：`li[n] == li[n - len(li)]`。所以在这个列表里，`li[2] == li[2 - 5] == li[-3]`.

例 1.15. 分割一个列表

    >>> li
    ['a', 'b', 'mpilgrim', 'z', 'example']
    >>> li[1:3]
    ['b', 'mpilgrim']
    >>> li[1:-1]
    ['b', 'mpilgrim', 'z']
    >>> li[0:3]
    ['a', 'b', 'mpilgrim']

| 你可以通过指定2个索引得到列表的子集，叫做一个“分片”。返回值是一个新的列表，它包含了列表中按顺序从第一个分片索引(这里为 `li[1]`)开始，直到但是不包括第二个分片索引(这里为 `li[3]`)的所有元素。
| 如果一个或两个分片索引是负数，分片也可以工作。如果对你有帮助，你可以这样理解：从左向右阅读列表，第一个分片索引指定了你想要的第一个元素，第二个分片索引指定了第一个你不想要的元素。返回的值为在其间的每个元素。
| 列表从0开始，所以 `li[0:3]` 返回列表的前3个元素，开始从 `li[0]`，直到但不包括 `li[3]`。

例 1.16. 分片缩写

    >>> li
    ['a', 'b', 'mpilgrim', 'z', 'example']
    >>> li[:3]
    ['a', 'b', 'mpilgrim']
    >>> li[3:]
    ['z', 'example']
    >>> li[:]
    ['a', 'b', 'mpilgrim', 'z', 'example']

| 如果任一个分片索引为0，你可以将其省略，默认为0。所以 `li[:3]` 同前一个例子的 `li[0:3]` 一样。
| 注意这里的对称写法。在这个5元素列表中，`li[:3]` 返回前三个元素，而 `li[3:]` 返回后两个元素。实际上，`li[:n]` 将总是返回前 `n` 个元素，而 `li[n:]` 将返回其它的元素。
| 如果两个分片索引均省略，将包括列表的所有元素。但是与原始的列表 `li` 不是同一个，它是一个新的列表，恰好拥有与 `li` 全部一样的元素。`li[:]` 是生成一个列表拷贝的缩写。

例 1.17. 向列表中增加元素

    >>> li
    ['a', 'b', 'mpilgrim', 'z', 'example']
    >>> li.append("new")
    >>> li
    ['a', 'b', 'mpilgrim', 'z', 'example', 'new']
    >>> li.insert(2, "new")
    >>> li
    ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']
    >>> li.extend(["two", "elements"])
    >>> li
    ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']

| `append` 增加单个元素到列表的尾部。
| `insert` 在列表中插入单个元素。数值参数是使得列表增加的第一个元素的索引(此句原文为：“The numeric argument is the index of the first element that gets bumped out of position.”，但实在不好翻译，只暂时这样翻译，希望有什么好的建议。)。注意列表元素不需要唯一，现在有两个独立的元素拥有 `new` 这个值，`li[2]` 和 `li[6]`。
| `extend` 连接列表。注意不要用多个参数调用 `extend` ，要使用一个列表参数调用。在这种情况下，列表有两个元素。

例 1.18. 搜索列表

    >>> li
    ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
    >>> li.index("example")
    5
    >>> li.index("new")
    2
    >>> li.index("c")
    Traceback (innermost last):
      File "<interactive input>", line 1, in ?
    ValueError: list.index(x): x not in list
    >>> "c" in li
    0

| `index` 在列表中查找值第一次的出现并返回索引值。
| `index` 在列表中查找值 第一次 的出现。在本例中， `new` 在列表中出现了两次，在 `li[2]` 和`li[6]`，但是 `index` 将只返回第一个索引，`2`。
| 如果在列表中没有找到值，Python会引发一个异常。这一点与大部分的语言相当不同，大部分语言将会返回某个无效索引。尽管这种处理可能看上去令人讨厌，它仍然是好东西，因为它说明你的程序会由于源代码的问题而崩溃，好于在后面当你使用无效索引而引起崩溃。
| 要测试一个值是否在列表内，使用 `in`，如果值找到了，它返回 `1` ，或者没找到则为 `0` 。

在Python中不存在布尔类型。在一个布尔上下文中(象 `if` 语句)，`0` 是假，所有其它的数值为真。这一点也可以扩展到其它类型。一个空串(`""`)，一个空列表(`[]`)，和一个空字典(`{}`)都是假，所有其它的字符串，列表，和字典是真。

例 1.19. 从列表中除去元素

    >>> li
    ['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
    >>> li.remove("z")
    >>> li
    ['a', 'b', 'new', 'mpilgrim', 'example', 'new', 'two', 'elements']
    >>> li.remove("new")
    >>> li
    ['a', 'b', 'mpilgrim', 'example', 'new', 'two', 'elements']
    >>> li.remove("c")
    Traceback (innermost last):
      File "<interactive input>", line 1, in ?
    ValueError: list.remove(x): x not in list
    >>> li.pop()
    'elements'
    >>> li
    ['a', 'b', 'mpilgrim', 'example', 'new', 'two']

| `remove` 从列表中除掉第一次出现的值。
| `remove` 仅 除掉第一次出现的值。在本例中，`new` 在列表中出现了两次，但是 `li.remove("new")` 仅除掉了第一次出现的值。
| 如果在列表中没有找到值，Python引发一个异常。它反映了 `index` 方法的行为。
| `pop` 是一个有趣的东西。它执行两件事：除掉列表的最后一个元素，然后返回除掉的值。注意这一点同 `li[-1]`不同，后者返回一个值但不改变列表，也不同于 `li.remove(value)`，后者改变列表但不返回值。

例 1.20. 列表操作符

    >>> li = ['a', 'b', 'mpilgrim']
    >>> li = li + ['example', 'new']
    >>> li
    ['a', 'b', 'mpilgrim', 'example', 'new']
    >>> li += ['two']
    >>> li
    ['a', 'b', 'mpilgrim', 'example', 'new', 'two']
    >>> li = [1, 2] * 3
    >>> li
    [1, 2, 1, 2, 1, 2]

| 列表也可以用 `+` 操作符连接起来。`list = list + otherlist` 相当于 `list.extend(otherlist)`。但是 `+` 操作符将连接后的列表作为一个值返回，而 `extend` 仅修改存在的列表。
| Python支持 `+=` 操作符。`li += ['two']` 相当于 `li = li + ['two']`。`+=` 操作符可用于列表，字符串，和整数，并且它也可以在用户定义类中被重载。(第三章会有更多的类)
| `*` 操作符作为一个重复符可用在列表上。`li = [1, 2] * 3` 相当于 `li = [1, 2] + [1, 2] + [1, 2]`， 将三个列表连成一个。

进一步阅读 |

- How to Think Like a Computer Scientist 讲解了列表并且提出一个重点关于 作为函数参数传递列表。
- Python Tutorial 展示了 使用列表作为堆栈和队列。
- Python Knowledge Base 回答了 关于列表的常见问题 并且有很多 使用列表的例子代码。
- Python Library Reference 总结了 全部的列表方法。

« 字典 101 | 序列 101 »