Python 列表基础用法

负索引说明： 我们常说的下标都是从列表第一个元素开始往后，从 0 开始计数的。而负索引则是从列表最后一个元素开始往前，依次为 -1, -2, -3...。因此想要访问列表的最后一个元素，直接访问下标为 -1 的元素即可。

注意：如果指定下标超出列表中的最大下标，则插入到列表末尾（如果为负索引，则插入列表首部）：

a = [1, 3.0, 2.2]
a.insert(100, 'Jinger')
print(type(a))  # <class 'list'>
print(a)        # [1, 3.0, 2.2, 'Jinger']

a.insert(-100, 'Hello')
print(type(a))  # <class 'list'>
print(a)        # ['Hello', 1, 3.0, 2.2, 'Jinger']

2. 删除列表元素

2.1 pop 方法

pop 方法可以删除列表的末尾元素，或者删除指定下标的元素：

a = [1, 3.0, 2.2]
a.pop()
print(type(a))  # <class 'list'>
print(a)        # [1, 3.0]

a.pop(1)
print(type(a))  # <class 'list'>
print(a)        # [1]

2.2 remove 方法

remove 方法可以删除列表中指定的元素：

a = [1, 3.0, 2.2, 3.0]
a.remove(3.0)
print(type(a))  # <class 'list'>
print(a)        # [1, 2.2, 3.0]

注意：当列表中存在重复元素时，使用 remove 方法仅能删除第一次出现的元素。

3. 查找列表元素

3.1 in/not in 操作符

in/not in 操作符可以判断某个元素是否在列表中，如果存在则返回 True，不存在则返回 False：

a = [1, 3.0, 2.2, 3.0]
print(3 in a)       # True
print(3 not in a)   # False
print(type(a))      # <class 'list'>
print(a)            # [1, 3.0, 2.2, 3.0]

3.2 index 方法

index 方法可以查询指定元素在列表中的下标：

a = [1, 3.0, 2.2, 3.0]
print(a.index(2.2))  # 2

3.3 下标访问列表元素

通过 [] 下标访问操作符可以获取到列表中对应下标的元素（支持负索引）：

a = [1, 3.0, 2.2, 3.0]
print(a[3])  # 3.0

4. 修改列表元素

通过 [] 下标访问操作符还可以修改列表中对应下标的元素的值：

a = [1, 3.0, 2.2, 3.0]
a[3] = 4
print(a)  # [1, 3.0, 2.2, 4]

5. 遍历列表元素

5.1 for 循环遍历列表

Python 中的 for 循环可以直接遍历列表中的元素：

a = [1, 3.0, 2.2, 3.0]
for iter in a:
    print(iter)

但是对 iter 进行更改时，列表中的元素不会受到影响（可以理解为是将列表中对应元素的值赋值给了变量 iter，所以修改 iter 不会影响到列表中的元素）：

a = [1, 3.0, 2.2, 3.0]
for iter in a:
    iter += 1
    print(iter)  # 2 4.0 3.2 4.0
print(a)         # [1, 3.0, 2.2, 3.0]

如果想要通过 for 循环来修改列表中的元素，可以使用 for 循环遍历列表元素下标的方式：

a = [1, 3.0, 2.2, 3.0]
n = len(a)
for i in range(n):
    a[i] += 1
    print(a[i])  # 2 4.0 3.2 4.0
print(a)         # [2, 4.0, 3.2, 4.0]

5.2 while 循环遍历列表

while 循环也可以通过变量列表元素下标的方式来访问列表元素：

a = [1, 3.0, 2.2, 3.0]
n = len(a)
i = 0
while i < n:  # 或者使用 while i in range(n)
    a[i] += 1
    print(a[i])  # 2 4.0 3.2 4.0
    i += 1
print(a)  # [2, 4.0, 3.2, 4.0]

6. 子列表提取

6.1 [start:stop]

以 [start:stop] 的方式可以从列表中提取出：从 start 起始下标开始，到 stop 结束下标结束的一组元素（左闭右开）：

a = [1, 3.0, 2.2, 3.0]
b = a[1:2]
c = a[0:2]
d = a[0:3]
print(a)  # [1, 3.0, 2.2, 3.0]
print(b)  # [3.0]
print(c)  # [1, 3.0]
print(d)  # [1, 3.0, 2.2]

6.2 切片时忽略边界

提取子列表的过程也称作切片的过程，以 [start:stop] 的方式进行切片时可以忽略起始下标和结束下标：

• 如果以 [start:] 的方式进行切片，则子列表的元素包括起始下标的元素及其后续所有元素；
• 如果以 [:stop] 的方式进行切片，则子列表的元素包括结束下标之前的所有元素，不包括结束下标的元素；
• 如果以 [:] 的方式进行切片，则子列表的元素包括原列表的所有元素。

a = [1, 3.0, 2.2, 3.0]
b = a[1:2]
c = a[1:]
d = a[:2]
e = a[:]
print(a)  # [1, 3.0, 2.2, 3.0]
print(b)  # [3.0]
print(c)  # [3.0, 2.2, 3.0]
print(d)  # [1, 3.0]
print(e)  # [1, 3.0, 2.2, 3.0]

注意：切片时所用下标支持负索引：

a = [1, 3.0, 2.2, 3.0]
b = a[-3:-1]
print(a)  # [1, 3.0, 2.2, 3.0]
print(b)  # [3.0, 2.2]

6.3 切片时指定步长

以 [start:stop:step] 的方式切片可以指定 step 步长（每访问一个元素后下标自增几步），例如：

a = [1, 3.0, 2.2, 3.0]
b = a[0:3:2]
print(a)  # [1, 3.0, 2.2, 3.0]
print(b)  # [1, 2.2]

注意：指定的步长可以为负数，表示从后往前提取元素。当步长为负数时，会从右向左遍历（反向切片），start 默认为最后一个元素，stop 默认为第一个元素（不包括），只有 start 大于 stop 才能切到元素：

a = [1, 3.1, 2.2, 3.0]
b = a[::-1]
c = a[3:0:-1]
d = a[-1::-2]
print(a)  # [1, 3.1, 2.2, 3.0]
print(b)  # [3.0, 2.2, 3.1, 1]
print(c)  # [3.0, 2.2, 3.1]
print(d)  # [3.0, 3.1]

6.4 切片时下标允许越界

如果在切片时，指定的下标超出了有效范围，运行程序不会抛异常，而是会尽可能将符合要求的元素提取出来：

a = [1, 3.0, 2.2, 3.0]
b = a[2:100:1]
c = a[100:0:-1]
print(a)  # [1, 3.0, 2.2, 3.0]
print(b)  # [2.2, 3.0]
print(c)  # [3.0, 2.2, 3.0]

7. 拼接列表

7.1 使用 + 拼接两个列表

使用 + 操作符可以将两个列表拼接起来生成一个新列表，该操作不会影响两个原有列表：

a = [1, 3.1, 2.2, 3.0]
b = [2.2, 'Jinger']
c = a + b
print(a)  # [1, 3.1, 2.2, 3.0]
print(b)  # [2.2, 'Jinger']
print(type(c))  # <class 'list'>
print(c)  # [1, 3.1, 2.2, 3.0, 2.2, 'Jinger']

7.2 使用 += 操作符

使用 += 操作符可以将一个列表拼接到另一个列表后面：

a = [1, 3.1, 2.2, 3.0]
b = [2.2, 'Jinger']
b += a
print(a)  # [1, 3.1, 2.2, 3.0]
print(b)  # [2.2, 'Jinger', 1, 3.1, 2.2, 3.0]

7.3 extend 方法

使用 extend 方法也可以将一个列表拼接到另一个列表后面：

a = [1, 3.1, 2.2, 3.0]
b = [2.2, 'Jinger']
b.extend(a)
print(a)  # [1, 3.1, 2.2, 3.0]
print(b)  # [2.2, 'Jinger', 1, 3.1, 2.2, 3.0]

性能提示：+= 操作符和 extend 方法都可以将一个列表拼接到另一个列表后面，但是 extend 方法更高效。因为 b += a 等价于 b = b + a，拼接过程中会先构造出一个临时列表作为拼接后的列表，再将 b 原本的列表释放，然后将这个临时列表赋值给 b。而 extend 方法则是直接将 a 列表的元素拼接到 b 列表后面，避免了不必要的释放操作。

列表常用接口

Python 是一种面向对象的语言，因此创建出来的列表本质是一个对象，这些操作列表的方法都是列表的成员方法。列表的常用接口如下：

1. 列表操作

2. 列表的成员函数

总结

本文介绍了 Python 数据类型——列表的相关概念及核心操作方法。