一、列表的基本概念
1.1 什么是列表？
列表（List）是 Python 中最常用的数据结构之一，用于存储有序的元素集合。列表是可变的（mutable），意味着可以修改其内容。
1.2 列表的特点
有序性：元素按插入顺序排列
可变性：可以修改、添加、删除元素
异构性：可以存储不同类型的元素
可嵌套：列表中可以包含其他列表
动态大小：会根据需要自动调整大小
1.3 列表的定义
# 空列表
empty_list= []
empty_list2=list()
# 包含元素的列表
numbers= [1, 2, 3, 4, 5]
fruits= ["apple", "banana", "cherry"]
mixed= [1, "apple", 3.14, True, [1, 2, 3]] # 异构列表
二、列表的访问和索引
2.1 索引访问
列表中的每个元素都有一个索引，从 0 开始：
fruits= ["apple", "banana", "cherry"]
print(fruits[0]) # 输出: apple
print(fruits[1]) # 输出: banana
print(fruits[2]) # 输出: cherry
# 负索引（从末尾开始）
print(fruits[-1]) # 输出: cherry
print(fruits[-2]) # 输出: banana
print(fruits[-3]) # 输出: apple
2.2 切片操作
切片语法：list[start:end:step]
start：起始索引（包含）
end：结束索引（不包含）
step：步长（默认为 1）
numbers= [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[0:5]) # 输出: [0, 1, 2, 3, 4]
print(numbers[5:]) # 输出: [5, 6, 7, 8, 9]
print(numbers[:5]) # 输出: [0, 1, 2, 3, 4]
print(numbers[::2]) # 输出: [0, 2, 4, 6, 8] (步长为 2)
print(numbers[::-1]) # 输出: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] (反转列表)
print(numbers[1:8:2]) # 输出: [1, 3, 5, 7] (从索引1到8，步长为2)
2.3 嵌套列表访问
nested= [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(nested[0]) # 输出: [1, 2, 3]
print(nested[1][1]) # 输出: 5
print(nested[2][0]) # 输出: 7
三、列表的基本操作
3.1 列表长度
fruits= ["apple", "banana", "cherry"]
length=len(fruits) # 输出: 3
3.2 列表拼接
list1= [1, 2, 3]
list2= [4, 5, 6]
combined=list1+list2# 输出: [1, 2, 3, 4, 5, 6]
3.3 列表重复
list1= [1, 2, 3]
repeated=list1*3# 输出: [1, 2, 3, 1, 2, 3, 1, 2, 3]
3.4 成员检查
fruits= ["apple", "banana", "cherry"]
print("apple"infruits) # 输出: True
print("orange"infruits) # 输出: False
print("banana"notinfruits) # 输出: False
3.5 列表比较
list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = [1, 2, 4]
print(list1 == list2) # 输出: True
print(list1 == list3) # 输出: False
print(list1 < list3) # 输出: True (按元素逐个比较)
四、列表的修改操作
4.1 修改元素
fruits = ["apple", "banana", "cherry"]
fruits[1] = "orange" # 修改索引1处的元素
print(fruits) # 输出: ["apple", "orange", "cherry"]
4.2 添加元素
append()：在列表末尾添加元素
insert()：在指定位置插入元素
extend()：扩展列表，添加多个元素
fruits = ["apple", "banana", "cherry"]
# append()
fruits.append("orange")
print(fruits) # 输出: ["apple", "banana", "cherry", "orange"]
# insert()
fruits.insert(1, "grape")
print(fruits) # 输出: ["apple", "grape", "banana", "cherry", "orange"]
# extend()
fruits.extend(["mango", "pineapple"])
print(fruits) # 输出: ["apple", "grape", "banana", "cherry", "orange", "mango", "pineapple"]
4.3 删除元素
remove()：删除指定值的元素
pop()：删除指定索引的元素并返回
del：删除指定索引或切片的元素
clear()：清空列表
fruits = ["apple", "banana", "cherry", "banana", "orange"]
# remove()
fruits.remove("banana") # 删除第一个匹配的元素
print(fruits) # 输出: ["apple", "cherry", "banana", "orange"]
# pop()
popped = fruits.pop(1) # 删除索引1处的元素
print(popped) # 输出: cherry
print(fruits) # 输出: ["apple", "banana", "orange"]
# del
del fruits[0] # 删除索引0处的元素
print(fruits) # 输出: ["banana", "orange"]
del fruits[0:2] # 删除切片
print(fruits) # 输出: []
# clear()
fruits = ["apple", "banana", "cherry"]
fruits.clear()
print(fruits) # 输出: []
五、列表方法
5.1 查找方法
index()：返回指定值第一次出现的索引
count()：返回指定值出现的次数
numbers = [1, 2, 3, 2, 1, 2, 3]
print(numbers.index(2)) # 输出: 1 (第一次出现的位置)
print(numbers.count(2)) # 输出: 3 (出现的次数)
5.2 排序方法
sort()：原地排序
sorted()：返回排序后的新列表
reverse()：原地反转列表
numbers = [3, 1, 4, 1, 5, 9, 2, 6]
# sort()
numbers.sort()
print(numbers) # 输出: [1, 1, 2, 3, 4, 5, 6, 9]
# 降序排序
numbers.sort(reverse=True)
print(numbers) # 输出: [9, 6, 5, 4, 3, 2, 1, 1]
# 自定义排序
fruits = ["banana", "apple", "cherry", "date"]
fruits.sort(key=len) # 按长度排序
print(fruits) # 输出: ["date", "apple", "cherry", "banana"]
# sorted()
numbers = [3, 1, 4, 1, 5]
sorted_numbers = sorted(numbers)
print(sorted_numbers) # 输出: [1, 1, 3, 4, 5]
print(numbers) # 输出: [3, 1, 4, 1, 5] (原列表不变)
# reverse()
numbers = [1, 2, 3, 4, 5]
numbers.reverse()
print(numbers) # 输出: [5, 4, 3, 2, 1]
5.3 其他方法
# copy()
original = [1, 2, 3, [4, 5]]
copy = original.copy()
print(copy) # 输出: [1, 2, 3, [4, 5]]
# 修改原列表的嵌套列表
original[3][0] = 99
print(original) # 输出: [1, 2, 3, [99, 5]]
print(copy) # 输出: [1, 2, 3, [99, 5]] (浅拷贝，嵌套对象共享)
# 切片拷贝
original = [1, 2, 3]
copy = original[:]
print(copy) # 输出: [1, 2, 3]
六、列表的高级特性
6.1 列表推导式
列表推导式是一种简洁创建列表的方法：
# 基本语法: [expression for item in iterable if condition]
# 示例1: 创建平方列表
squares = [x**2 for x in range(10)]
print(squares) # 输出: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# 示例2: 带条件的列表推导式
even_squares = [x**2 for x in range(10) if x % 2 == 0]
print(even_squares) # 输出: [0, 4, 16, 36, 64]
# 示例3: 嵌套列表推导式
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for row in matrix for num in row]
print(flattened) # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]
# 示例4: 复杂表达式
fruits = ["apple", "banana", "cherry"]
uppercase_fruits = [fruit.upper() for fruit in fruits]
print(uppercase_fruits) # 输出: ["APPLE", "BANANA", "CHERRY"]
6.2 列表与函数
map()：对列表中的每个元素应用函数
filter()：过滤列表中的元素
reduce()：对列表中的元素进行累积操作
# map()
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, numbers))
print(squared) # 输出: [1, 4, 9, 16, 25]
# filter()
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even = list(filter(lambda x: x % 2 == 0, numbers))
print(even) # 输出: [2, 4, 6, 8, 10]
# reduce()
from functools import reduce
numbers = [1, 2, 3, 4, 5]
sum = reduce(lambda x, y: x + y, numbers)
print(sum) # 输出: 15
6.3 列表的深浅拷贝
浅拷贝：只复制列表的顶层元素，嵌套对象共享
深拷贝：递归复制所有元素，包括嵌套对象
import copy
# 浅拷贝
original = [1, 2, 3, [4, 5]]
shallow = copy.copy(original)
original[3][0] = 99
print(original) # 输出: [1, 2, 3, [99, 5]]
print(shallow) # 输出: [1, 2, 3, [99, 5]] (嵌套列表被修改)
# 深拷贝
original = [1, 2, 3, [4, 5]]
deep = copy.deepcopy(original)
original[3][0] = 99
print(original) # 输出: [1, 2, 3, [99, 5]]
print(deep) # 输出: [1, 2, 3, [4, 5]] (嵌套列表未被修改)
6.4 列表的迭代
for 循环：遍历列表元素
enumerate()：同时获取索引和值
zip()：同时遍历多个列表
# for 循环
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
# enumerate()
for index, fruit in enumerate(fruits):
print(f"Index {index}: {fruit}")
# zip()
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages):
print(f"{name} is {age} years old")
七、列表的性能优化
7.1 列表操作的时间复杂度
| 操作 | 时间复杂度 | 说明 |
|---|
| 索引访问 | O(1) | 常数时间 |
| 索引修改 | O(1) | 常数时间 |
| 列表长度 | O(1) | 常数时间 |
| append() | O(1) | 平均常数时间 |
| pop() (末尾) | O(1) | 常数时间 |
| pop(i) (中间) | O(n) | 线性时间，需要移动元素 |
| insert() | O(n) | 线性时间，需要移动元素 |
| remove() | O(n) | 线性时间，需要查找和移动元素 |
| sort() | O(n log n) | 对数线性时间 |
| in 操作 | O(n) | 线性时间，需要遍历查找 |
7.2 性能优化技巧
预分配列表大小：如果知道列表最终大小，使用 [None] * size 预分配
使用列表推导式：比传统循环更高效
避免频繁插入/删除中间元素：考虑使用 collections.deque 对于频繁的中间插入/删除
使用生成器：对于大型数据集，使用生成器表达式减少内存使用
选择合适的方法：根据操作的时间复杂度选择合适的方法
# 预分配列表
size = 1000000
# 低效
lst = []
for i in range(size):
lst.append(i)
# 高效
lst = [None] * size
for i in range(size):
lst[i] = i
# 生成器表达式 (内存更高效)
gen = (x**2 for x in range(1000000))
# 转换为列表时才会计算
lst = list(gen)
7.3 内存优化
# 使用 array 模块存储同类型数据
import array
# 存储整数，比列表更节省内存
int_array = array.array('i', [1, 2, 3, 4, 5])
八、列表的实际应用
8.1 数据存储和处理
# 存储学生信息
students = [
{"name": "Alice", "age": 25, "grade": "A"},
{"name": "Bob", "age": 22, "grade": "B"},
{"name": "Charlie", "age": 23, "grade": "A"}
]
# 按年龄排序
students.sort(key=lambda x: x["age"])
print(students)
# 过滤出成绩为 A 的学生
a_students = [student for student in students if student["grade"] == "A"]
print(a_students)
8.2 算法实现
# 实现冒泡排序
def bubble_sort(lst):
n = len(lst)
for i in range(n):
for j in range(0, n-i-1):
if lst[j] > lst[j+1]:
lst[j], lst[j+1] = lst[j+1], lst[j]
return lst
numbers = [64, 34, 25, 12, 22, 11, 90]
sorted_numbers = bubble_sort(numbers)
print(sorted_numbers) # 输出: [11, 12, 22, 25, 34, 64, 90]
8.3 矩阵操作
# 创建和操作矩阵
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
# 访问元素
print(matrix[1][1]) # 输出: 5
# 转置矩阵
transposed = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
print(transposed) # 输出: [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
# 矩阵加法
matrix1 = [[1, 2], [3, 4]]
matrix2 = [[5, 6], [7, 8]]
result = [[matrix1[i][j] + matrix2[i][j] for j in range(len(matrix1[0]))] for i in range(len(matrix1))]
print(result) # 输出: [[6, 8], [10, 12]]
8.4 字符串处理
# 处理字符串列表
words = ["apple", "banana", "cherry", "date", "elderberry"]
# 按长度排序
words.sort(key=len)
print(words) # 输出: ["date", "apple", "banana", "cherry", "elderberry"]
# 过滤出长度大于 5 的单词
long_words = [word for word in words if len(word) > 5]
print(long_words) # 输出: ["banana", "cherry", "elderberry"]
# 生成首字母大写的单词列表
capitalized = [word.capitalize() for word in words]
print(capitalized) # 输出: ["Date", "Apple", "Banana", "Cherry", "Elderberry"]
九、总结
Python 列表是一种功能强大、灵活多变的数据结构，是 Python 编程中最常用的工具之一。本教程涵盖了列表的基本概念、操作、方法、高级特性、性能优化和实际应用等方面。
通过学习本教程，你应该已经掌握了 Python 列表的核心知识点，包括：
