Python3 教程-8. 列表

Python 列表 是 Python 中最基础、最灵活且应用最为广泛的数据结构之一。它类似于一个可随时调整大小的”购物篮”，允许你存储不同类型的数据，并在程序运行过程中动态地添加、删除、修改和查询这些数据。与静态数组不同，Python 列表无需预先声明大小，且支持多种数据类型的混合存储，这使得它成为处理数据集合的理想选择。本文将从基础概念出发，全面介绍列表的操作方法，包括==创建、增删改查、遍历==等核心功能，帮助初学者快速掌握这一重要数据结构。

1. 列表的基本概念与特性

---

1.1 列表的定义

列表是 Python 中一种有序、可变的序列类型，用方括号[]包裹，元素之间用逗号分隔。与元组不同，列表是可变的，意味着我们可以在创建后直接修改其内容。

1.2 核心特性

• 有序性：列表中的元素按照插入顺序排列，每个元素都有一个明确的索引位置
• 可变性：列表可以在创建后动态地添加、删除、修改元素
• 多类型支持：列表可以存储不同类型的数据（整数、字符串、浮点数、布尔值等）
• 嵌套支持：列表可以包含其他列表，形成多维数据结构
• 可变长度：列表的大小可以动态调整，无需预先指定容量

1.3 列表与其他数据结构的区别

• 元组：与列表类似，但元组是不可变的，使用圆括号()创建
• 集合：无序且元素唯一的数据结构，使用花括号{}创建
• 字典：键值对的无序集合，使用花括号{}创建

列表 (List)	元组 (Tuple)	集合 (Set)	字典 (Dict)
有序, 可变	有序, 不可变	无序, 唯一	键值对, 无序

2. 列表的创建方法

---

2.1 基本创建方式

创建列表最直接的方式是使用方括号[]，并在其中添加元素：

# 创建整数列表
numbers = [10, 20, 30, 40]
# 创建字符串列表
fruits = ["apple", "banana", "orange"]
# 创建混合类型列表
mixed = [100, "Python", True, 3.14]
# 创建空列表
empty_list = []

推荐方式：创建空列表时，直接使用[]比list()更简洁高效。

2.2 使用 list() 构造函数

list()构造函数可以将其他可迭代对象（如字符串、元组、集合）转换为列表：

# 转换元组为列表
tuple_list = list((1, 2, 3, 4))  # 输出: [1, 2, 3, 4]

# 转换字符串为列表（每个字符成为单独元素）
char_list = list("hello")  # 输出: ['h', 'e', 'l', 'l', 'o']

# 转换集合为列表
set_list = list({1, 2, 3})  # 输出: [1, 2, 3]（顺序可能不同）

2.3 列表推导式

列表推导式是一种简洁、高效地创建列表的方式，特别适合批量生成元素：

# 生成0-9的整数列表
squares = [x**2 for x in range(10)]  # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 生成偶数列表
even_numbers = [x for x in range(20) if x % 2 == 0]  # 输出: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# 嵌套列表推导式
matrix = [[1, 2], [3, 4], [5, 6]]
flattened = [num for row in matrix for num in row]  # 输出: [1, 2, 3, 4, 5, 6]

⚠️ 注意：列表推导式通常比显式循环更高效，且代码更简洁。

列表推导式是一种强大的语法糖，它将一个可迭代对象转换为另一个列表，通常比显式循环更高效、代码更简洁。

3. 列表的增删改查操作

---

3.1 增加元素

列表提供了多种添加元素的方法，各有适用场景：

3.1.1 append() 方法

在列表末尾添加单个元素，返回None，直接修改原列表：

# 添加单个元素
fruits = ["apple", "banana"]
fruits.append("orange")  # 输出: ["apple", "banana", "orange"]

# 添加另一个列表（作为单个元素）
numbers = [1, 2, 3]
numbers.append([4, 5])  # 输出: [1, 2, 3, [4, 5]]

3.1.2 extend() 方法

在列表末尾添加可迭代对象的所有元素，返回None，直接修改原列表：

# 添加列表中的元素
fruits = ["apple", "banana"]
fruits.extend(["orange", "grape"])  # 输出: ["apple", "banana", "orange", "grape"]

# 添加字符串中的字符
chars = ['a', 'b']
chars.extend("xyz")  # 输出: ['a', 'b', 'x', 'y', 'z']

# 添加元组中的元素
tup = (10, 20)
fruits.extend(tup)  # 输出: ["apple", "banana", 10, 20]

关键区别：append()添加一个元素，extend()添加多个元素（将可迭代对象拆分为单独元素）。

==关键区别简单说：==append() 将一个元素（即使是列表）作为单个项添加到末尾。而 extend() 则是将一个可迭代对象“打散”，将其包含的所有元素逐个添加到列表末尾。

3.1.3 insert() 方法

在指定位置插入元素，原有元素自动后移：

# 在索引1的位置插入元素
students = ["Alice", "Bob", "Charlie"]
students.insert(1, "David")  # 输出: ['Alice', 'David', 'Bob', 'Charlie']

# 当索引超过列表长度时，元素会添加到末尾
students.insert(100, "Eve")  # 输出: ['Alice', 'David', 'Bob', 'Charlie', 'Eve']

3.1.4 其他添加方法

• 切片赋值：可以将新元素插入到列表的任意位置
• + 运算符：连接两个列表，生成新列表
• += 运算符：连接两个列表，修改原列表

# 切片赋值
nums = [1, 2, 3]
nums[1:1] = [4, 5]  # 在索引1前插入4和5
# 输出: [1, 4, 5, 2, 3]

# + 运算符
list1 = [1, 2]
list2 = [3, 4]
combined = list1 + list2  # 输出: [1, 2, 3, 4]

# += 运算符
list1 += [5, 6]  # 相当于 list1.extend([5, 6])
# 输出: [1, 2, 5, 6]

3.2 删除元素

列表提供了多种删除元素的方法，适用于不同场景

3.2.1 del 语句

根据索引删除元素或子列表，直接修改原列表：

# 删除单个元素
nums = [10, 20, 30, 40]
del nums[1]  # 删除索引1的元素
# 输出: [10, 30, 40]

# 删除多个元素（切片）
words = ["hello", "world", "python", "code"]
del words[1:3]  # 删除索引1到2的元素
# 输出: ['hello', 'code']

# 删除所有元素（清空列表）
empty = [1, 2, 3]
del empty[:]  # 清空列表
# 输出: []

3.2.2 pop() 方法

删除并返回指定索引的元素，默认删除并返回最后一个元素：

# 删除最后一个元素并返回
fruits = ["apple", "banana", "orange"]
last_fruit = fruits.pop()  # last_fruit为'orange'，fruits变为['apple', 'banana']

# 删除指定索引的元素
second_fruit = fruits.pop(1)  # second_fruit为'banana'，fruits变为['apple']

# 当索引超出范围时会引发IndexError
# fruits.pop(100)  # 抛出异常

3.2.3 remove() 方法

根据值删除第一个匹配的元素，返回None：

# 删除第一个出现的值
digits = [1, 2, 3, 2, 1]
digits.remove(2)  # 删除第一个2
# 输出: [1, 3, 2, 1]

# 当值不存在时会引发ValueError
# letters.remove('z')  # 如果列表中没有'z'，抛出异常

3.2.4 clear() 方法

删除列表中的所有元素，等同于del list[:]：

# 清空列表
numbers = [10, 20, 30]
numbers.clear()  # 输出: []

3.3 修改元素

列表是可变的，允许直接通过索引修改元素：

# 直接通过索引赋值修改元素
words = ["Python", "is", "awesome"]
words[2] = "fantastic"  # 修改索引2的元素
# 输出: ['Python', 'is', 'fantastic']

# 修改多个元素（切片赋值）
nums = [1, 2, 3, 4, 5]
nums[1:4] = [10, 20]  # 用[10, 20]替换索引1到3的元素
# 输出: [1, 10, 20, 5]

# 批量替换元素
letters = ['a', 'b', 'c', 'd']
letters[1:3] = ['x', 'y', 'z']  # 替换索引1到2的元素
# 输出: ['a', 'x', 'y', 'z', 'd']

3.4 查询元素

列表支持多种元素查询方式，包括索引访问、切片和成员检测：

3.4.1 索引访问

通过正向或负向索引访问特定位置的元素：

# 正向索引（从0开始）
fruits = ["apple", "banana", "orange"]
print(fruits[0])  # 输出: apple
print(fruits[1])  # 输出: banana

# 负向索引（-1代表最后一个元素）
print(fruits[-1])  # 输出: orange
print(fruits[-2])  # 输出: banana

# 索引越界会引发IndexError
# print(fruits[100])  # 抛出异常

3.4.2 切片操作

通过[start:end:step]语法提取子列表：

# 基本切片
nums = [0, 1, 2, 3, 4, 5]
print(nums[1:4])  # 输出: [1, 2, 3]（包含索引1到3，不包含4）

# 从开头到指定索引
print(nums[:3])  # 输出: [0, 1, 2]

# 从指定索引到末尾
print(nums[2:])  # 输出: [2, 3, 4, 5]

# 反向切片
print(nums[::-1])  # 输出: [5, 4, 3, 2, 1, 0]

# 负向切片
print(nums[-3:-1])  # 输出: [3, 4]

# 步长切片
print(nums[::2])  # 输出: [0, 2, 4]

⚠️ 注意：切片操作会创建一个新列表，原列表不受影响。

3.4.3 成员检测

使用in和not in关键字检测元素是否存在：

# 检测元素是否存在
numbers = [1, 2, 3, 4, 5]
print(3 in numbers)  # 输出: True
print(6 not in numbers)  # 输出: True

# 检测嵌套列表中的元素
matrix = [[1, 2], [3, 4], [5, 6]]
print([3, 4] in matrix)  # 输出: True（检测子列表是否存在）

3.4.4 获取元素位置

使用index()方法获取元素首次出现的索引：

# 获取元素的索引
words = ['Python', 'is', 'amazing', 'and', 'powerful']
index = words.index('amazing')  # index为2
# 输出: 2

# 可指定起始和结束索引
print(words.index('and', 3))  # 输出: 3（从索引3开始搜索）

# 元素不存在时会引发ValueError
# print(words.index('java'))  # 抛出异常

4. 列表的遍历方式

---

列表支持多种遍历方式，适用于不同场景：

4.1 for 循环遍历

最常用且简洁的遍历方式，直接遍历元素：

# 基本for循环
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
    print(fruit)
# 输出:
# apple
# banana
# orange

# 遍历时修改元素
squares = [1, 4, 9, 16]
for i in range(len(squares)):
    squares[i] *= 2
# 输出: [2, 8, 18, 32]

4.2 while 循环遍历

通过索引逐个访问元素，适合需要控制循环次数的场景：

# while循环遍历
numbers = [10, 20, 30, 40]
i = 0
while i < len(numbers):
    print(numbers[i])
    i += 1
# 输出:
# 10
# 20
# 30
# 40

4.3 使用 enumerate() 遍历

同时获取元素的索引和值，适用于需要索引的场景：

# enumerate遍历
words = ["Python", "is", "fantastic"]
for index, word in enumerate(words):
    print(f"索引{index}: 元素{word}")
# 输出:
# 索引0: 元素Python
# 索引1: 元素is
# 索引2: 元素fantastic

# 可指定起始索引
for i, num in enumerate([10, 20, 30], start=1):
    print(f"位置{i}: 值{num}")
# 输出:
# 位置1: 值10
# 位置2: 值20
# 位置3: 值30

5. 列表的实用技巧

---

5.1 列表解包

使用*运算符解包列表，适用于多种场景：

# 基础解包
numbers = [1, 2, 3]
a, b, c = numbers
# a=1, b=2, c=3

# 捕获中间元素
data = [10, 20, 30, 40, 50]
start, *mid, end = data
# start=10, mid=[20, 30, 40], end=50

# 函数参数解包
def print_args(a, b, c):
    print(f"a={a}, b={b}, c={c}")

args = [100, 200, 300]
print_args(*args)  # 输出: a=100, b=200, c=300

⚠️ 注意：解包时变量数量必须与列表元素数量匹配，否则会引发 ValueError。

5.2 多维列表操作📚

处理嵌套列表（如二维矩阵）的技巧：

# 遍历二维列表
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 嵌套for循环
for row in matrix:
    for num in row:
        print(num, end=' ')
    print()
# 输出:
# 1 2 3
# 4 5 6
# 7 8 9

# 列表推导式扁平化
flattened = [num for row in matrix for num in row]
# flattened = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# itertools.chain扁平化
import itertools
flattened = list(itertools.chain.from_iterable(matrix))
# flattened = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 使用numpy处理多维数组（需安装numpy）
import numpy as np
np_matrix = np.array(matrix)
for num in np_matrix扁平化():
    print(num)

⚠️ 注意：处理多维列表时，深层嵌套可能需要递归遍历。

5.3 性能优化技巧📚

• 预分配列表：对于已知长度的列表，预分配空间可提升性能
• 使用 extend() 替代多次 append()：批量添加元素时，extend()比多次append()更高效
• 避免在循环中频繁修改列表：如删除元素可能导致索引错乱
• 利用列表推导式：通常比显式循环更高效且代码更简洁

# 预分配列表
n = 10000
preallocated = [None] * n
for i in range(n):
    preallocated[i] = i**2

# 使用extend()批量添加
large_list = list(range(1000))
elements_to_add = list(range(1000, 2000))
large_list.extend(elements_to_add)  # 比1000次append()更快

# 列表推导式替代显式循环
# 低效方式
squares = []
for x in range(100):
    squares.append(x**2)

# 高效方式
squares = [x**2 for x in range(100)]

6. 列表常见错误与解决

---

6.1 直接修改遍历时的列表

在遍历列表时直接修改可能导致意外行为或错误：

# 错误示例：遍历时删除元素
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
    if fruit.startswith('a'):
        fruits.remove(fruit)  # 可能跳过某些元素

# 正确解决方案：遍历列表的副本
for fruit in list(fruits):
    if fruit.startswith('a'):
        fruits.remove(fruit)
# 输出: ['banana', 'orange']

6.2 使用非可迭代对象调用 extend()

extend()方法期望接收一个可迭代对象，否则会引发错误：

# 错误示例：extend()传入非可迭代对象
numbers = [1, 2, 3]
numbers.extend(100)  # 引发TypeError: 'int' object is not iterable

# 正确解决方案：将单个元素转换为可迭代对象
numbers.extend([100])  # 输出: [1, 2, 3, 100]

6.3 列表比较的逻辑误区

列表比较是按元素逐个比较的，顺序很重要：

# 比较操作是逐元素进行的
list1 = [1, 2, 3]
list2 = [1, 2, 4]
print(list1 < list2)  # 输出: True（因为第三个元素3 < 4）

# 字符串比较基于Unicode码点
words1 = ["apple", "banana"]
words2 = ["application", "banana"]
print(words1 > words2)  # 输出: False（因为 apple 的 a 比 application 的 a 相同，但长度更短）

6.4 列表浅拷贝与深拷贝问题

直接赋值列表会创建引用，而非独立副本：

# 错误示例：直接赋值导致引用共享
original = [[1, 2], [3, 4]]
copy = original
copy[0][0] = 100
# original和copy都会变为[[100, 2], [3, 4]]

# 正确解决方案：浅拷贝
import copy
shallow_copy = original.copy()
# shallow_copy = original[:]  # 等效方式
shallow_copy[0][0] = 200
# original变为[[200, 2], [3, 4]]，因为子列表是引用

# 正确解决方案：深拷贝
deep_copy = copy.deepcopy(original)
deep_copy[0][0] = 300
# original保持不变，仍为[[100, 2], [3, 4]]

概念模型: 浅拷贝 vs 深拷贝

原列表	浅拷贝	深拷贝
[[1, 2], [3, 4] ]	共享子对象引用	完全独立的副本
	修改子对象会影响原列表	修改不影响原列表

7. 列表的排序与反转📚

---

7.1 排序操作

Python 提供了多种列表排序方法：

7.1.1 sort()方法

原地排序列表，不返回新列表：

# 默认升序排序
numbers = [30, 10, 50, 20]
numbers.sort()
# 输出: [10, 20, 30, 50]

# 降序排序
numbers.sort(reverse=True)
# 输出: [50, 30, 20, 10]

# 按自定义规则排序
words = ["Python", "is", "amazing"]
words.sort(key=len)  # 按长度排序
# 输出: ['is', 'Python', 'amazing']

7.1.2 sorted() 函数

返回排序后的新列表，原列表不变：

# 默认升序排序
numbers = [30, 10, 50, 20]
sorted_numbers = sorted(numbers)
# sorted_numbers = [10, 20, 30, 50]
# numbers保持不变

# 降序排序
sorted_numbers_desc = sorted(numbers, reverse=True)
# sorted_numbers_desc = [50, 30, 20, 10]

7.2 反转操作

反转列表元素的顺序：

# reverse()方法：原地反转，不返回新列表
numbers = [10, 20, 30, 40]
numbers.reverse()
# 输出: [40, 30, 20, 10]

# 切片反转：创建新列表
reversed_numbers = numbers[::-1]
# reversed_numbers = [10, 20, 30, 40]
# numbers保持不变

8. 综合应用示例

---

8.1 学生成绩统计

# 创建成绩列表
scores = [85, 92, 78, 95, 88]

# 计算平均分
average = sum(scores) / len(scores)
print(f"平均分: {average:.1f}")  # 输出: 平均分: 87.8

# 找到最高分
highest = max(scores)
print(f"最高分: {highest}")  # 输出: 最高分: 95

# 找到最低分
lowest = min(scores)
print(f"最低分: {lowest}")  # 输出: 最低分: 78

# 筛选及格分数
passing_scores = [score for score in scores if score >= 60]
print(f"及格分数: {passing_scores}")  # 输出: 及格分数: [85, 92, 78, 95, 88]

# 统计分数分布
from collections import Counter
score_counts = Counter(scores)
print("分数分布:", score_counts)
# 输出: 分数分布: Counter({85: 1, 92: 1, 78: 1, 95: 1, 88: 1})

Data Insight: 学生成绩统计

8.2 待办事项管理

# 创建待办事项列表
todo_list = ["买牛奶", "写报告", "回复邮件"]

# 添加新事项
todo_list.append("整理书桌")
# 输出: ['买牛奶', '写报告', '回复邮件', '整理书桌']

# 按优先级插入事项
todo_list.insert(1, "紧急会议")
# 输出: ['买牛奶', '紧急会议', '写报告', '回复邮件', '整理书桌']

# 批量添加事项
new_todo = ["买面包", "健身"]
todo_list.extend(new_todo)
# 输出: ['买牛奶', '紧急会议', '写报告', '回复邮件', '整理书桌', '买面包', '健身']

# 删除已完成的事项
if "回复邮件" in todo_list:
    todo_list.remove("回复邮件")
# 输出: ['买牛奶', '紧急会议', '写报告', '整理书桌', '买面包', '健身']

# 显示待办事项
print("当前待办事项:")
for index, task in enumerate(todo_list, start=1):
    print(f"{index}. {task}")
# 输出:
# 当前待办事项:
# 1. 买牛奶
# 2. 紧急会议
# 3. 写报告
# 4. 整理书桌
# 5. 买面包
# 6. 健身

# 按字母顺序排序
todo_list.sort()
# 输出: ['买面包', '买牛奶', '紧急会议', '健身', '整理书桌', '写报告']

# 保存为已完成列表
completed = ["回复邮件", "回复电话"]
all_tasks = todo_list + completed  # 或使用extend()

# 清空待办事项
todo_list.clear()
# 输出: []

待办事项管理流程：

1. 创建 & 添加：使用 append(), insert(), extend() 动态添加新任务。
2. 管理 & 查询：使用 remove(), in, enumerate() 删除、查找和遍历任务。
3. 组织 & 完成：使用 sort() 排序，并最终使用 clear() 清空列表。

==最后你要明白：==

• 列表是有序、可变的序列，支持多种数据类型
• append()添加单个元素，extend()添加可迭代对象，insert()指定位置插入
• pop()删除并返回元素，remove()按值删除第一个匹配项，del按索引删除
• 使用索引和切片可以高效访问和修改列表元素
• 遍历列表时，for循环简洁直观，enumerate()可同时获取索引和值
• 列表解包和推导式能显著提高代码的可读性和效率
• 注意列表操作中的常见错误，如遍历时修改列表、浅拷贝问题等
  通过本文的详细介绍和示例，希望你能全面掌握 Python 列表的基础操作，为后续更复杂的编程任务打下坚实基础。随着实践的深入，你还可以探索列表的高级应用，如与itertools、numpy等库结合使用，处理更复杂的多维数据结构。

练习：

---