Python教程11：列表基础

“工欲善其事，必先利其器。”

列表（List）是Python中最常用的数据结构之一，就像一个可以随意增删改查的购物清单。今天我们深入学习列表的基础操作，为后续学习打好基础。

1. 什么是列表

列表是一个有序的、可变的元素集合，可以存储不同类型的数据。

1# 创建列表
2empty_list = []  # 空列表
3numbers = [1, 2, 3, 4, 5]  # 整数列表
4mixed = [1, "hello", 3.14, True]  # 混合类型
5nested = [[1, 2], [3, 4], [5, 6]]  # 嵌套列表
6
7# 使用list()函数
8from_string = list("Python")  # ['P', 'y', 't', 'h', 'o', 'n']
9from_range = list(range(5))   # [0, 1, 2, 3, 4]

2. 访问列表元素

索引访问

 1fruits = ["苹果", "香蕉", "橙子", "葡萄", "西瓜"]
 2
 3# 正向索引（从0开始）
 4print(fruits[0])   # 苹果
 5print(fruits[1])   # 香蕉
 6
 7# 负向索引（从-1开始）
 8print(fruits[-1])  # 西瓜（最后一个）
 9print(fruits[-2])  # 葡萄（倒数第二个）
10
11# 索引越界会报错
12# print(fruits[10])  # IndexError

切片访问

 1numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
 2
 3# [start:stop:step]
 4print(numbers[2:5])    # [2, 3, 4]
 5print(numbers[:5])     # [0, 1, 2, 3, 4]
 6print(numbers[5:])     # [5, 6, 7, 8, 9]
 7print(numbers[::2])    # [0, 2, 4, 6, 8]（步长为2）
 8print(numbers[::-1])   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]（反转）
 9
10# 负索引切片
11print(numbers[-3:])    # [7, 8, 9]
12print(numbers[:-3])    # [0, 1, 2, 3, 4, 5, 6]

3. 修改列表

列表是可变的，可以直接修改元素：

 1fruits = ["苹果", "香蕉", "橙子"]
 2
 3# 修改单个元素
 4fruits[0] = "梨"
 5print(fruits)  # ['梨', '香蕉', '橙子']
 6
 7# 修改切片
 8fruits[1:3] = ["葡萄", "西瓜", "芒果"]
 9print(fruits)  # ['梨', '葡萄', '西瓜', '芒果']
10
11# 删除元素
12del fruits[0]
13print(fruits)  # ['葡萄', '西瓜', '芒果']
14
15# 删除切片
16del fruits[1:]
17print(fruits)  # ['葡萄']

4. 列表常用方法

添加元素

 1fruits = ["苹果", "香蕉"]
 2
 3# append()：末尾添加
 4fruits.append("橙子")
 5print(fruits)  # ['苹果', '香蕉', '橙子']
 6
 7# insert()：指定位置插入
 8fruits.insert(1, "葡萄")
 9print(fruits)  # ['苹果', '葡萄', '香蕉', '橙子']
10
11# extend()：扩展列表（添加多个元素）
12fruits.extend(["西瓜", "芒果"])
13print(fruits)  # ['苹果', '葡萄', '香蕉', '橙子', '西瓜', '芒果']
14
15# + 运算符
16more_fruits = fruits + ["草莓", "蓝莓"]
17print(more_fruits)

append vs extend vs +：

  • append(x)：添加x作为一个元素
  • extend(iter)：添加可迭代对象中的所有元素
  • +：创建新列表（不修改原列表）
 1# 区别演示
 2list1 = [1, 2, 3]
 3
 4# append添加的是整个列表作为一个元素
 5list1.append([4, 5])
 6print(list1)  # [1, 2, 3, [4, 5]]
 7
 8list2 = [1, 2, 3]
 9# extend添加的是列表中的每个元素
10list2.extend([4, 5])
11print(list2)  # [1, 2, 3, 4, 5]

删除元素

 1fruits = ["苹果", "香蕉", "橙子", "香蕉", "葡萄"]
 2
 3# remove()：删除第一个匹配的元素
 4fruits.remove("香蕉")
 5print(fruits)  # ['苹果', '橙子', '香蕉', '葡萄']
 6
 7# pop()：删除并返回指定位置的元素（默认最后一个）
 8last = fruits.pop()
 9print(last)    # 葡萄
10print(fruits)  # ['苹果', '橙子', '香蕉']
11
12first = fruits.pop(0)
13print(first)   # 苹果
14print(fruits)  # ['橙子', '香蕉']
15
16# clear()：清空列表
17fruits.clear()
18print(fruits)  # []

查找元素

 1numbers = [1, 2, 3, 4, 5, 3, 2, 1]
 2
 3# index()：查找元素的索引
 4print(numbers.index(3))     # 2（第一次出现的位置）
 5# print(numbers.index(10))  # ValueError: 找不到
 6
 7# count()：统计元素出现次数
 8print(numbers.count(1))     # 2
 9print(numbers.count(3))     # 2
10print(numbers.count(10))    # 0
11
12# in：检查元素是否存在
13print(3 in numbers)         # True
14print(10 in numbers)        # False

排序和反转

 1numbers = [3, 1, 4, 1, 5, 9, 2, 6]
 2
 3# sort()：原地排序（修改原列表）
 4numbers.sort()
 5print(numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]
 6
 7numbers.sort(reverse=True)
 8print(numbers)  # [9, 6, 5, 4, 3, 2, 1, 1]
 9
10# sorted()：返回新列表（不修改原列表）
11original = [3, 1, 4, 1, 5]
12sorted_list = sorted(original)
13print(original)     # [3, 1, 4, 1, 5]
14print(sorted_list)  # [1, 1, 3, 4, 5]
15
16# reverse()：反转列表
17numbers = [1, 2, 3, 4, 5]
18numbers.reverse()
19print(numbers)  # [5, 4, 3, 2, 1]
20
21# reversed()：返回反转的迭代器
22original = [1, 2, 3]
23reversed_iter = reversed(original)
24print(list(reversed_iter))  # [3, 2, 1]

5. 列表的遍历

 1fruits = ["苹果", "香蕉", "橙子"]
 2
 3# 方法1：直接遍历元素
 4for fruit in fruits:
 5    print(fruit)
 6
 7# 方法2：enumerate()获取索引和元素
 8for index, fruit in enumerate(fruits):
 9    print(f"{index}: {fruit}")
10
11# 方法3：传统索引方式（不推荐）
12for i in range(len(fruits)):
13    print(f"{i}: {fruits[i]}")

6. 列表的长度和其他操作

 1numbers = [1, 2, 3, 4, 5]
 2
 3# len()：长度
 4print(len(numbers))  # 5
 5
 6# min()、max()、sum()
 7print(min(numbers))  # 1
 8print(max(numbers))  # 5
 9print(sum(numbers))  # 15
10
11# 列表乘法
12print([1, 2] * 3)  # [1, 2, 1, 2, 1, 2]
13print([0] * 5)     # [0, 0, 0, 0, 0]
14
15# 成员测试
16print(3 in numbers)      # True
17print(10 not in numbers) # True

7. 列表的复制

 1# 浅拷贝
 2original = [1, 2, 3]
 3
 4# 方法1：切片
 5copy1 = original[:]
 6
 7# 方法2：list()
 8copy2 = list(original)
 9
10# 方法3：copy()方法
11copy3 = original.copy()
12
13# 修改副本不影响原列表
14copy1[0] = 999
15print(original)  # [1, 2, 3]
16print(copy1)     # [999, 2, 3]
17
18# 直接赋值不是复制！
19not_a_copy = original
20not_a_copy[0] = 999
21print(original)      # [999, 2, 3]（被修改了！）
22print(not_a_copy)    # [999, 2, 3]

重要：直接赋值只是创建了引用，两个变量指向同一个列表。

8. 嵌套列表

 1# 二维列表
 2matrix = [
 3    [1, 2, 3],
 4    [4, 5, 6],
 5    [7, 8, 9]
 6]
 7
 8# 访问元素
 9print(matrix[0])      # [1, 2, 3]
10print(matrix[0][0])   # 1
11print(matrix[1][2])   # 6
12
13# 遍历二维列表
14for row in matrix:
15    for element in row:
16        print(element, end=" ")
17    print()

9. 列表的性能特点

  • 索引访问：O(1)，很快
  • 添加/删除末尾：O(1)，很快
  • 插入/删除中间：O(n)，较慢（需要移动元素）
  • 查找元素：O(n)，需要遍历

10. 小结

今天我们学习了列表的基础操作：

  • 创建：[]、list()
  • 访问：索引、切片
  • 修改：直接赋值、del
  • 方法：append、insert、extend、remove、pop、sort、reverse
  • 遍历：for、enumerate
  • 复制：切片、list()、copy()

列表是Python最常用的数据结构，熟练掌握列表操作是Python编程的基本功。

练习题：

  1. 创建一个列表存储1-10的偶数，然后反转这个列表
  2. 写一个函数，去除列表中的重复元素并保持顺序
  3. 实现列表的flatten功能（把嵌套列表展平成一维列表）

思考题：

为什么列表用方括号[]，而元组用圆括号()？这种设计有什么考虑？

本文代码示例：

相关阅读