Python列表详解

列表是Python中最常用的数据结构之一，用于存储有序的元素集合。Python提供了丰富的列表操作方法和功能。本文将详细介绍Python列表的特性、操作和最佳实践。

一、列表概述

1. 什么是列表？

列表（List）是Python中的一种有序、可变的序列类型，用于存储任意类型的元素。列表中的元素可以是数字、字符串、布尔值、None、甚至是其他列表（嵌套列表）。

2. 列表的特点

• 有序性：列表中的元素有固定的顺序，可以通过索引访问
• 可变性：列表创建后可以修改其内容（添加、删除、修改元素）
• 可迭代性：可以使用循环遍历列表中的每个元素
• 可容纳任意类型：可以存储不同类型的元素
• 可嵌套：列表中可以包含其他列表

3. 列表的表示

列表使用方括号[]表示，元素之间用逗号,分隔：

# 列表示例
numbers = [1, 2, 3, 4, 5]
fruits = ["apple", "banana", "orange"]
mixed = [1, "apple", True, None, [1, 2, 3]]

二、列表的创建

1. 基本创建方法

# 使用方括号创建空列表
empty_list = []

# 创建包含元素的列表
numbers = [1, 2, 3, 4, 5]
strings = ["hello", "world"]
mixed = [1, "hello", True]

# 创建嵌套列表
nested = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

2. 使用list()函数创建

# 创建空列表
empty_list = list()

# 将可迭代对象转换为列表
from_string = list("hello")  # ['h', 'e', 'l', 'l', 'o']
from_tuple = list((1, 2, 3))  # [1, 2, 3]
from_set = list({1, 2, 3})  # [1, 2, 3]（集合是无序的，所以顺序可能不同）
from_range = list(range(10))  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

3. 使用列表推导式创建

列表推导式是一种简洁创建列表的方法（详见第七部分）：

# 列表推导式示例
squares = [x ** 2 for x in range(1, 6)]  # [1, 4, 9, 16, 25]
evens = [x for x in range(10) if x % 2 == 0]  # [0, 2, 4, 6, 8]

三、列表的基本操作

1. 访问列表元素

可以通过索引访问列表中的元素：

# 访问列表元素示例
fruits = ["apple", "banana", "orange", "grape"]

# 正索引（从0开始）
print(fruits[0])  # apple
print(fruits[1])  # banana

# 负索引（从末尾开始，-1表示最后一个元素）
print(fruits[-1])  # grape
print(fruits[-2])  # orange

# 超出范围的索引会报错
try:
    print(fruits[10])
except IndexError as e:
    print(f"错误：{e}")  # 错误：list index out of range

2. 修改列表元素

可以通过索引修改列表中的元素：

# 修改列表元素示例
numbers = [1, 2, 3, 4, 5]
numbers[0] = 10
print(numbers)  # [10, 2, 3, 4, 5]

numbers[-1] = 50
print(numbers)  # [10, 2, 3, 4, 50]

# 修改嵌套列表中的元素
nested = [[1, 2, 3], [4, 5, 6]]
nested[0][1] = 20
print(nested)  # [[1, 20, 3], [4, 5, 6]]

3. 列表切片

切片用于获取列表的子列表，语法为list[start:end:step]：

# 列表切片示例
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 基本切片
print(numbers[0:5])  # [0, 1, 2, 3, 4]（索引0到5，不包含5）
print(numbers[5:])  # [5, 6, 7, 8, 9]（索引5到末尾）
print(numbers[:5])  # [0, 1, 2, 3, 4]（从开头到索引5，不包含5）

# 使用负索引切片
print(numbers[-5:])  # [5, 6, 7, 8, 9]（从倒数第5个元素到末尾）
print(numbers[:-5])  # [0, 1, 2, 3, 4]（从开头到倒数第5个元素，不包含）

# 使用步长
print(numbers[0:10:2])  # [0, 2, 4, 6, 8]（每2个元素取一个）
print(numbers[::2])  # [0, 2, 4, 6, 8]（从开头到末尾，每2个元素取一个）
print(numbers[::-1])  # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]（反转列表）

# 所有元素
print(numbers[:])  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]（整个列表）

# 切片赋值
numbers[0:3] = [10, 20, 30]
print(numbers)  # [10, 20, 30, 3, 4, 5, 6, 7, 8, 9]

# 删除切片
numbers[3:6] = []
print(numbers)  # [10, 20, 30, 6, 7, 8, 9]

# 插入切片
numbers[3:3] = [40, 50]
print(numbers)  # [10, 20, 30, 40, 50, 6, 7, 8, 9]

4. 列表长度

可以使用len()函数获取列表的长度：

# 列表长度示例
numbers = [1, 2, 3, 4, 5]
print(len(numbers))  # 5

empty_list = []
print(len(empty_list))  # 0

nested = [[1, 2, 3], [4, 5, 6]]
print(len(nested))  # 2（嵌套列表的长度是外层列表的元素个数）

5. 列表拼接

可以使用+运算符拼接列表：

# 列表拼接示例
list1 = [1, 2, 3]
list2 = [4, 5, 6]

combined = list1 + list2
print(combined)  # [1, 2, 3, 4, 5, 6]

# 使用+=运算符
list1 += list2
print(list1)  # [1, 2, 3, 4, 5, 6]

6. 列表重复

可以使用*运算符重复列表：

# 列表重复示例
numbers = [1, 2, 3]
print(numbers * 3)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

# 使用*=运算符
numbers *= 2
print(numbers)  # [1, 2, 3, 1, 2, 3]

7. 成员检查

可以使用in和not in运算符检查元素是否在列表中：

# 成员检查示例
fruits = ["apple", "banana", "orange"]

print("apple" in fruits)  # True
print("grape" not in fruits)  # True

# 检查嵌套列表中的元素
nested = [[1, 2], [3, 4]]
print([1, 2] in nested)  # True
print(1 in nested)  # False（检查的是外层列表的元素）

四、列表的常用方法

Python列表提供了丰富的方法用于操作列表：

1. 添加元素

# 添加元素方法示例
numbers = [1, 2, 3]

# append()：在列表末尾添加一个元素
numbers.append(4)
print(numbers)  # [1, 2, 3, 4]

# extend()：在列表末尾添加另一个可迭代对象的所有元素
numbers.extend([5, 6, 7])
print(numbers)  # [1, 2, 3, 4, 5, 6, 7]

# 使用+运算符也可以实现类似效果，但会创建新列表
numbers = numbers + [8, 9]
print(numbers)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# insert()：在指定位置插入一个元素
numbers.insert(0, 0)  # 在索引0处插入0
print(numbers)  # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

numbers.insert(3, 2.5)  # 在索引3处插入2.5
print(numbers)  # [0, 1, 2, 2.5, 3, 4, 5, 6, 7, 8, 9]

2. 删除元素

# 删除元素方法示例
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# remove()：删除第一个匹配的元素
numbers.remove(2)
print(numbers)  # [0, 1, 3, 4, 5, 6, 7, 8, 9]

# 如果元素不存在会报错
try:
    numbers.remove(10)
except ValueError as e:
    print(f"错误：{e}")  # 错误：list.remove(x): x not in list

# pop()：删除并返回指定位置的元素（默认最后一个元素）
last = numbers.pop()
print(last, numbers)  # 9 [0, 1, 3, 4, 5, 6, 7, 8]

first = numbers.pop(0)
print(first, numbers)  # 0 [1, 3, 4, 5, 6, 7, 8]

# del语句：删除指定位置的元素或整个列表
del numbers[1]  # 删除索引1处的元素
print(numbers)  # [1, 4, 5, 6, 7, 8]

del numbers[2:4]  # 删除索引2到4的元素（不包含4）
print(numbers)  # [1, 4, 7, 8]

del numbers  # 删除整个列表
try:
    print(numbers)
except NameError as e:
    print(f"错误：{e}")  # 错误：name 'numbers' is not defined

3. 排序和反转

# 排序和反转方法示例
numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]

# sort()：对列表进行排序（默认升序）
numbers.sort()
print(numbers)  # [1, 1, 2, 3, 4, 5, 5, 6, 9]

# 降序排序
numbers.sort(reverse=True)
print(numbers)  # [9, 6, 5, 5, 4, 3, 2, 1, 1]

# 自定义排序（如按照绝对值大小）
numbers = [-3, 1, -4, 1, -5, 9]
numbers.sort(key=abs)
print(numbers)  # [1, 1, -3, -4, 9, -5]

# reverse()：反转列表
numbers = [1, 2, 3, 4, 5]
numbers.reverse()
print(numbers)  # [5, 4, 3, 2, 1]

# 使用切片也可以实现反转
numbers = [1, 2, 3, 4, 5]
reversed_numbers = numbers[::-1]
print(reversed_numbers)  # [5, 4, 3, 2, 1]
print(numbers)  # [1, 2, 3, 4, 5]（原列表不变）

4. 查找和计数

# 查找和计数方法示例
numbers = [1, 2, 3, 2, 4, 2, 5]

# index()：返回第一个匹配元素的索引
print(numbers.index(2))  # 1

# 指定查找范围
print(numbers.index(2, 2))  # 3（从索引2开始查找）

# 如果元素不存在会报错
try:
    print(numbers.index(10))
except ValueError as e:
    print(f"错误：{e}")  # 错误：10 is not in list

# count()：统计元素出现的次数
print(numbers.count(2))  # 3
print(numbers.count(10))  # 0（元素不存在，返回0）

5. 其他常用方法

# 其他常用方法示例
fruits = ["apple", "banana", "orange"]

# copy()：复制列表
fruits_copy = fruits.copy()
print(fruits_copy)  # ["apple", "banana", "orange"]

# clear()：清空列表
fruits.clear()
print(fruits)  # []

# 检查列表是否为空
if not fruits:
    print("列表为空")

# max()：返回列表中的最大值（元素必须可比较）
numbers = [1, 2, 3, 4, 5]
print(max(numbers))  # 5

# min()：返回列表中的最小值（元素必须可比较）
print(min(numbers))  # 1

# sum()：返回列表中所有元素的和（元素必须是数字）
print(sum(numbers))  # 15

五、列表推导式

列表推导式（List Comprehension）是一种简洁创建列表的方法，语法为[expression for item in iterable if condition]：

1. 基本列表推导式

# 基本列表推导式示例

# 创建1-10的平方列表
squares = [x ** 2 for x in range(1, 11)]
print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 创建1-10的偶数列表
evens = [x for x in range(1, 11) if x % 2 == 0]
print(evens)  # [2, 4, 6, 8, 10]

# 创建1-10的奇数列表
odds = [x for x in range(1, 11) if x % 2 != 0]
print(odds)  # [1, 3, 5, 7, 9]

2. 嵌套列表推导式

# 嵌套列表推导式示例

# 创建一个3x3的二维列表
matrix = [[i for i in range(3)] for _ in range(3)]
print(matrix)  # [[0, 1, 2], [0, 1, 2], [0, 1, 2]]

# 创建一个3x3的单位矩阵
identity = [[1 if i == j else 0 for j in range(3)] for i in range(3)]
print(identity)  # [[1, 0, 0], [0, 1, 0], [0, 0, 1]]

# 展平二维列表
nested = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened = [num for sublist in nested for num in sublist]
print(flattened)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# 过滤嵌套列表中的元素
even_flattened = [num for sublist in nested for num in sublist if num % 2 == 0]
print(even_flattened)  # [2, 4, 6, 8]

3. 带有条件的列表推导式

# 带有条件的列表推导式示例

# 三元表达式
numbers = [1, 2, 3, 4, 5]
result = ["even" if x % 2 == 0 else "odd" for x in numbers]
print(result)  # ['odd', 'even', 'odd', 'even', 'odd']

# 多个条件
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = [x for x in numbers if x % 2 == 0 and x > 5]
print(result)  # [6, 8, 10]

# 嵌套条件
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = ["small even" if x < 5 and x % 2 == 0 else "small odd" if x < 5 and x % 2 != 0 else "large even" if x % 2 == 0 else "large odd" for x in numbers]
print(result)  # ['small odd', 'small even', 'small odd', 'small even', 'large odd', 'large even', 'large odd', 'large even', 'large odd', 'large even']

六、嵌套列表

嵌套列表是指列表中包含其他列表，用于表示二维或多维数据结构：

1. 创建嵌套列表

# 创建嵌套列表示例

# 二维列表（矩阵）
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 三维列表
cube = [
    [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
    ],
    [
        [10, 11, 12],
        [13, 14, 15],
        [16, 17, 18]
    ]
]

2. 访问嵌套列表元素

# 访问嵌套列表元素示例
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 访问第0行第0列的元素
print(matrix[0][0])  # 1

# 访问第1行第2列的元素
print(matrix[1][2])  # 6

# 访问第2行所有元素
print(matrix[2])  # [7, 8, 9]

# 访问所有行的第1列元素
column1 = [row[1] for row in matrix]
print(column1)  # [2, 5, 8]

3. 修改嵌套列表元素

# 修改嵌套列表元素示例
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 修改第0行第0列的元素
matrix[0][0] = 10
print(matrix)  # [[10, 2, 3], [4, 5, 6], [7, 8, 9]]

# 修改第1行所有元素
matrix[1] = [11, 12, 13]
print(matrix)  # [[10, 2, 3], [11, 12, 13], [7, 8, 9]]

# 修改所有行的第2列元素
for row in matrix:
    row[2] = row[2] * 2
print(matrix)  # [[10, 2, 6], [11, 12, 26], [7, 8, 18]]

4. 遍历嵌套列表

# 遍历嵌套列表示例
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# 遍历所有元素
for row in matrix:
    for num in row:
        print(num, end=" ")
    print()
# 输出：
# 1 2 3
# 4 5 6
# 7 8 9

# 使用列表推导式遍历
all_elements = [num for row in matrix for num in row]
print(all_elements)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

七、列表的高级操作

1. 列表的复制

列表的复制有几种方法，需要注意浅拷贝和深拷贝的区别：

# 列表复制示例
original = [1, 2, [3, 4]]

# 方法1：使用copy()方法（浅拷贝）
copy1 = original.copy()

# 方法2：使用切片（浅拷贝）
copy2 = original[:]

# 方法3：使用list()函数（浅拷贝）
copy3 = list(original)

# 修改原列表中的不可变元素
original[0] = 10
print(original)  # [10, 2, [3, 4]]
print(copy1)  # [1, 2, [3, 4]]（副本不受影响）

# 修改原列表中的可变元素（浅拷贝的问题）
original[2][0] = 30
print(original)  # [10, 2, [30, 4]]
print(copy1)  # [1, 2, [30, 4]]（副本也被修改了）

# 深拷贝（需要使用copy模块）
import copy

deep_copy = copy.deepcopy(original)
original[2][1] = 40
print(original)  # [10, 2, [30, 40]]
print(deep_copy)  # [10, 2, [30, 4]]（深拷贝不受影响）

2. 列表的排序算法

Python的sort()方法使用Timsort算法，这是一种高效的混合排序算法，结合了归并排序和插入排序的优点：

# 列表排序算法示例

# 使用key参数自定义排序
words = ["apple", "banana", "cherry", "date"]

# 按照长度排序
words.sort(key=len)
print(words)  # ['date', 'apple', 'banana', 'cherry']

# 按照字母顺序的相反顺序排序
words.sort(key=str.lower, reverse=True)
print(words)  # ['cherry', 'banana', 'date', 'apple']

# 使用lambda函数作为key
students = [
    {"name": "张三", "age": 20},
    {"name": "李四", "age": 18},
    {"name": "王五", "age": 22}
]

# 按照年龄排序
students.sort(key=lambda student: student["age"])
print(students)  # [{'name': '李四', 'age': 18}, {'name': '张三', 'age': 20}, {'name': '王五', 'age': 22}]

3. 列表的迭代器和生成器

# 列表的迭代器和生成器示例

# 使用iter()函数创建迭代器
numbers = [1, 2, 3, 4, 5]
iterator = iter(numbers)

print(next(iterator))  # 1
print(next(iterator))  # 2
print(next(iterator))  # 3

# 使用for循环自动使用迭代器
for num in numbers:
    print(num)

# 生成器表达式（比列表推导式更节省内存）
squares_generator = (x ** 2 for x in range(1, 11))

for square in squares_generator:
    print(square)

# 将生成器转换为列表
print(list(squares_generator))  # []（生成器只能遍历一次）

八、列表的性能分析

1. 常见操作的时间复杂度

2. 性能优化建议

• 尽量使用append()而不是+运算符进行列表扩展（append()是O(1)，+是O(k)）
• 尽量使用列表推导式而不是循环和append()（列表推导式更快）
• 避免频繁在列表开头插入或删除元素（O(n)操作）
• 如果需要频繁在两端操作，考虑使用collections.deque（双端队列，两端操作都是O(1)）

九、列表的最佳实践

1. 列表创建

• 对于简单列表，使用方括号直接创建
• 对于复杂列表，使用列表推导式
• 避免创建不必要的列表副本

# 好的写法
numbers = [1, 2, 3, 4, 5]
squares = [x ** 2 for x in numbers]

# 不好的写法
numbers = []
for i in range(1, 6):
    numbers.append(i)

 squares = []
for x in numbers:
    squares.append(x ** 2)

2. 列表操作

• 优先使用列表方法而不是手动实现
• 避免频繁修改列表开头
• 使用切片进行批量操作

# 好的写法
numbers = [1, 2, 3, 4, 5]
numbers.extend([6, 7, 8])

# 不好的写法
for i in [6, 7, 8]:
    numbers.append(i)

3. 列表遍历

• 使用for循环直接遍历列表元素
• 避免使用索引遍历列表

# 好的写法
fruits = ["apple", "banana", "orange"]
for fruit in fruits:
    print(fruit)

# 不好的写法
for i in range(len(fruits)):
    print(fruits[i])

4. 列表排序

• 使用sort()方法对列表进行原地排序
• 使用sorted()函数获取排序后的新列表
• 利用key参数进行自定义排序

# 好的写法
numbers = [3, 1, 4, 1, 5, 9]
numbers.sort()  # 原地排序

# 获取排序后的新列表
sorted_numbers = sorted(numbers)

# 不好的写法
for i in range(len(numbers)):
    for j in range(i+1, len(numbers)):
        if numbers[i] > numbers[j]:
            numbers[i], numbers[j] = numbers[j], numbers[i]

十、总结

Python列表是一种强大、灵活的数据结构，具有以下特点：

1. 有序性和可变性：列表中的元素有固定顺序，可以修改
2. 丰富的操作：支持访问、修改、添加、删除、切片等操作
3. 强大的方法：提供了大量用于操作列表的方法
4. 列表推导式：简洁高效地创建列表
5. 嵌套列表：支持二维和多维数据结构
6. 可迭代性：可以使用循环遍历

通过掌握Python列表的特性和操作方法，可以高效地处理各种数据集合，编写简洁、优雅的代码。

发布网站：荣殿教程（zhangrongdian.com）

作者：张荣殿