列表和元组

Python内置了两种重要的有序数据结构：列表(List)和元组(Tuple)。它们都可以存储多个元素，但有着不同的特性。本章将详细介绍这两种数据结构。

什么是列表(List)

列表是一种可变的有序集合，可以随时添加、删除和修改其中的元素。列表用方括号[]表示。

创建列表

>>> classmates = ['Michael', 'Bob', 'Tracy']
>>> classmates
['Michael', 'Bob', 'Tracy']

变量classmates就是一个list。用len()函数可以获得list元素的个数：

>>> len(classmates)
3

索引访问

用索引来访问list中每一个位置的元素，索引是从0开始的：

┌─────────────────────────────────────────────────────────────┐
│              list索引示意图                                  │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   列表:    ['Michael', 'Bob', 'Tracy']                     │
│            ─────────────────────────────────────          │
│   索引:      [0]        [1]       [2]                       │
│   反向索引:  [-3]       [-2]      [-1]                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

>>> classmates[0]
'Michael'
>>> classmates[1]
'Bob'
>>> classmates[2]
'Tracy'
>>> classmates[3]
Traceback (most recent call last):
  File "", line 1, in 
IndexError: list index out of range

注意

当索引超出了范围时，Python会报一个IndexError错误。确保索引不要越界，最后一个元素的索引是len(classmates) - 1。

反向索引

可以用-1做索引，直接获取最后一个元素：

>>> classmates[-1]
'Tracy'
>>> classmates[-2]
'Bob'
>>> classmates[-3]
'Michael'
>>> classmates[-4]
Traceback (most recent call last):
  File "", line 1, in 
IndexError: list index out of range

列表操作

追加元素 - append()

list是一个可变的有序表，可以往list中追加元素到末尾：

>>> classmates.append('Adam')
>>> classmates
['Michael', 'Bob', 'Tracy', 'Adam']

插入元素 - insert()

可以把元素插入到指定的位置：

>>> classmates.insert(1, 'Jack')
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy', 'Adam']

删除元素 - pop()

删除list末尾的元素：

>>> classmates.pop()
'Adam'
>>> classmates
['Michael', 'Jack', 'Bob', 'Tracy']

删除指定位置的元素：

>>> classmates.pop(1)
'Jack'
>>> classmates
['Michael', 'Bob', 'Tracy']

替换元素

直接把赋值给对应的索引位置：

>>> classmates[1] = 'Sarah'
>>> classmates
['Michael', 'Sarah', 'Tracy']

嵌套列表

list里面的元素的数据类型可以不同，也可以是另一个list：

>>> L = ['Apple', 123, True]
>>> s = ['python', 'java', ['asp', 'php'], 'scheme']
>>> len(s)
4

list里面可以包含list，形成二维数组：

┌─────────────────────────────────────────────────────────────┐
│              二维列表结构图                                  │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   s = ['python', 'java', ['asp', 'php'], 'scheme']        │
│                                                             │
│   s[0] → 'python'                                          │
│   s[1] → 'java'                                            │
│   s[2] → ['asp', 'php']  ← 这是一个子列表                 │
│              ├─────────────────┤                           │
│              │ s[2][0] → 'asp' │                          │
│              │ s[2][1] → 'php' │                          │
│   s[3] → 'scheme'                                         │
│                                                             │
│   所以 s[2][1] = 'php'                                      │
│                                                             │
└─────────────────────────────────────────────────────────────┘

>>> p = ['asp', 'php']
>>> s = ['python', 'java', p, 'scheme']
>>> s[2][1]
'php'

元组(Tuple)

另一种有序列表叫元组：tuple。tuple和list非常类似，但是tuple一旦初始化就不能修改：

>>> classmates = ('Michael', 'Bob', 'Tracy')
>>> classmates
('Michael', 'Bob', 'Tracy')

为什么用tuple？

因为tuple不可变，所以代码更安全。如果可能，能用tuple代替list就尽量用tuple。

tuple的基本操作

tuple没有append()、insert()等方法，但可以用len()和索引：

>>> t = ('Michael', 'Bob', 'Tracy')
>>> t[0]
'Michael'
>>> t[-1]
'Tracy'
>>> len(t)
3

空元组和单元素元组

定义一个空的tuple：

>>> t = ()
>>> t
()

重要：只有1个元素的tuple定义时必须加一个逗号,，来消除歧义：

>>> t = (1)          # 这不是tuple，是数字1！
>>> t
1
>>> t = (1,)         # 正确的单元素tuple写法
>>> t
(1,)

"可变"的Tuple

tuple的"不变"是指tuple的每个元素指向永远不变。但如果tuple包含一个list，list本身是可以变的！

┌─────────────────────────────────────────────────────────────┐
│              tuple内部引用示意图 - 初始状态                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   t = ('a', 'b', ['A', 'B'])                              │
│                                                             │
│   变量t ─────────────────┐                                 │
│                         │                                 │
│           ┌──────────────┼──────────────┐                  │
│           │              │              │                  │
│           ▼              ▼              ▼                  │
│        'a' (不可变)  'b' (不可变)  ['A', 'B'] (可变list)  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

>>> t = ('a', 'b', ['A', 'B'])
>>> t[2][0] = 'X'
>>> t[2][1] = 'Y'
>>> t
('a', 'b', ['X', 'Y'])

┌─────────────────────────────────────────────────────────────┐
│              tuple内部引用示意图 - 修改后                      │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│   t = ('a', 'b', ['X', 'Y'])                              │
│                                                             │
│   变量t ─────────────────┐                                 │
│                         │                                 │
│           ┌──────────────┼──────────────┐                  │
│           │              │              │                  │
│           ▼              ▼              ▼                  │
│        'a' (不可变)  'b' (不可变)  ['X', 'Y'] (list变了，但t的指向没变)
│                                                             │
│   ⚠️ tuple"不变"是指：t[0]不能变成't'，t[1]不能变成'c'  │
│                        t[2]不能变成别的list                 │
│                                                             │
└─────────────────────────────────────────────────────────────┘

重要理解

tuple的"不变"是说不同时指向不同的对象，但指向list的tuple本身可以修改list的内容！

list vs tuple 对比

特性	list	tuple
语法	`[]`	`()`
是否可变	可变	不可变
append/insert	支持	不支持
pop/del	支持	不支持
索引访问	支持	支持
安全性	较低	较高（数据不易被意外修改）
性能	略低	略高

练习题

练习1：列表操作

创建一个包含3个元素的列表，然后：

在末尾添加一个元素
在开头插入一个元素
删除第2个元素
打印最终结果

练习2：二维列表访问

给定以下列表：

L = [['Apple', 'Google', 'Microsoft'],
     ['Java', 'Python', 'Ruby', 'PHP'],
     ['Adam', 'Bart', 'Bob']]

请打印出：Apple、Python、Bob

选择题：以下哪个是有效的单元素tuple？

小结

list是可变的有序列表，可以用append()、insert()、pop()等方法操作；
list的索引从0开始，可以用-1表示最后一个元素；
tuple是不可变的有序列表，安全性更高；
tuple的"不可变"是指指向不变，但包含的list仍然可以修改；
单元素tuple必须加逗号：(1,)；
能用tuple时尽量用tuple，以提高代码安全性。

🐍 Python 在线代码编辑器

📝 运行结果