Python列表

Python 列表（list）是最常用的有序、可变、可重复数据结构，支持增删改查、切片、排序等丰富操作，适用于存储任意类型元素（整数、字符串、对象等）。以下是列表的核心用法详解：

一、列表的定义与初始化

1. 基本定义

用方括号 [] 包裹元素，元素间用逗号分隔，支持混合类型：

python

运行

# 空列表
empty_list = []
# 同类型元素
num_list = [1, 2, 3, 4, 5]
# 混合类型（整数、字符串、列表、布尔值）
mixed_list = [10, "Python", [True, False], None]

2. 用 list() 构造函数

• 转换字符串、元组、range 等可迭代对象为列表：

python

运行

# 字符串转列表（按字符拆分）
str_list = list("hello")  # 结果：['h', 'e', 'l', 'l', 'o']
# 元组转列表
tuple_list = list((1, 2, 3))  # 结果：[1, 2, 3]
# range 转列表（生成连续整数）
range_list = list(range(1, 6))  # 结果：[1, 2, 3, 4, 5]（左闭右开）

二、列表的核心操作

1. 访问元素（索引与切片）

列表是有序的，通过「索引」访问单个元素，「切片」访问子列表。

（1）索引（正索引 + 负索引）

• 正索引：从 0 开始（第一个元素索引为 0）；
• 负索引：从 -1 开始（最后一个元素索引为 -1）。

python

运行

fruits = ["apple", "banana", "orange", "grape"]
print(fruits[0])    # 访问第一个元素：apple
print(fruits[-1])   # 访问最后一个元素：grape
print(fruits[2])    # 访问第三个元素：orange

⚠️ 注意：索引越界会报错（IndexError），如 fruits[4] 或 fruits[-5] 均无效。

（2）切片（截取子列表）

语法：list[start:end:step]（左闭右开，step 为步长，默认 1）

• start：起始索引（默认 0，可省略）；
• end：结束索引（默认列表长度，可省略）；
• step：步长（正：从左到右；负：从右到左，即倒序）。

python

运行

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# 截取索引 2~5（不含 5）
print(nums[2:5])    # 结果：[2, 3, 4]
# 截取前 3 个元素（start=0 省略）
print(nums[:3])     # 结果：[0, 1, 2]
# 截取从索引 6 到末尾（end 省略）
print(nums[6:])     # 结果：[6, 7, 8, 9]
# 步长为 2（隔一个取一个）
print(nums[1::2])   # 结果：[1, 3, 5, 7, 9]
# 倒序（step=-1）
print(nums[::-1])   # 结果：[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
# 截取最后 3 个元素
print(nums[-3:])    # 结果：[7, 8, 9]

2. 修改元素（列表可变特性）

通过索引直接赋值修改单个元素：

python

运行

fruits = ["apple", "banana", "orange"]
fruits[1] = "pear"  # 修改第二个元素
print(fruits)       # 结果：['apple', 'pear', 'orange']

3. 增加元素

方法	功能	示例
append(x)	在列表末尾添加一个元素 x	fruits.append("grape")
extend(iterable)	拼接可迭代对象（列表、元组等）到末尾	fruits.extend(["mango", "kiwi"])
insert(index, x)	在指定索引位置插入元素 x（其余后移）	fruits.insert(0, "cherry")

示例：

python

运行

fruits = ["apple", "banana"]
fruits.append("orange")        # 结果：['apple', 'banana', 'orange']
fruits.extend(("grape", "pear"))# 结果：['apple', 'banana', 'orange', 'grape', 'pear']
fruits.insert(1, "mango")      # 结果：['apple', 'mango', 'banana', 'orange', 'grape', 'pear']

4. 删除元素

方法	功能	示例
remove(x)	删除第一个值为 x 的元素（无则报错）	fruits.remove("banana")
pop(index)	删除指定索引的元素（默认最后一个），返回该元素	fruits.pop(2) 或 fruits.pop()
del list[index]	删除指定索引 / 切片的元素（支持批量）	del fruits[0] 或 del fruits[1:3]
clear()	清空列表（保留列表对象）	fruits.clear()

示例：

python

运行

fruits = ["apple", "mango", "banana", "orange", "grape"]
fruits.remove("banana")  # 结果：['apple', 'mango', 'orange', 'grape']
fruits.pop(1)           # 删除索引 1 的元素，返回 'mango'，结果：['apple', 'orange', 'grape']
del fruits[0]           # 结果：['orange', 'grape']
del fruits[1:]          # 结果：['orange']（删除索引 1 及以后）
fruits.clear()          # 结果：[]

5. 列表常用查询与统计

方法 / 函数	功能	示例
index(x)	返回第一个值为 x 的元素索引（无则报错）	nums.index(3)
count(x)	统计元素 x 在列表中出现的次数	nums.count(2)
len(list)	统计列表长度（元素个数）	len(nums)
in / not in	判断元素是否在列表中（返回布尔值）	3 in nums 或 5 not in nums

示例：

python

运行

nums = [1, 2, 3, 2, 4, 2, 5]
print(nums.index(2))   # 结果：1（第一个 2 的索引）
print(nums.count(2))   # 结果：3（2 出现 3 次）
print(len(nums))       # 结果：7（列表长度为 7）
print(4 in nums)       # 结果：True
print(6 not in nums)   # 结果：True

三、列表的进阶操作

1. 排序与反转

方法	功能	示例
sort(reverse=False)	原地排序（修改原列表），默认升序	nums.sort() 或 nums.sort(reverse=True)
sorted(list)	生成新排序列表（不修改原列表）	new_nums = sorted(nums, reverse=True)
reverse()	原地反转列表（修改原列表）	nums.reverse()

示例：

python

运行

nums = [3, 1, 4, 2, 5]
nums.sort()          # 升序，结果：[1, 2, 3, 4, 5]
nums.sort(reverse=True)  # 降序，结果：[5, 4, 3, 2, 1]

nums = [3, 1, 4, 2, 5]
new_nums = sorted(nums)  # 新列表升序：[1,2,3,4,5]，原列表不变
nums.reverse()       # 反转，结果：[5, 2, 4, 1, 3]

2. 列表推导式（高效创建列表）

用简洁语法生成列表，格式：[表达式 for 变量 in 可迭代对象 if 条件]，比 for 循环更高效。

示例：

python

运行

# 生成 1~10 的平方列表
squares = [x*x for x in range(1, 11)]  # 结果：[1,4,9,...,100]
# 生成 1~20 的偶数列表
evens = [x for x in range(1, 21) if x % 2 == 0]  # 结果：[2,4,...,20]
# 过滤列表中的负数
nums = [-2, -1, 0, 1, 2]
positive_nums = [x for x in nums if x > 0]  # 结果：[1,2]
# 嵌套推导式（二维列表转一维）
matrix = [[1,2], [3,4], [5,6]]
flatten = [x for row in matrix for x in row]  # 结果：[1,2,3,4,5,6]

3. 列表的复制（深拷贝 vs 浅拷贝）

列表是可变对象，直接赋值（a = b）是引用传递（修改 a 会影响 b），需用以下方式实现「真正复制」：

复制方式	类型	适用场景（元素为不可变类型时）	示例
list.copy()	浅拷贝	单层列表	new_list = old_list.copy()
old_list[:]	浅拷贝（切片）	单层列表	new_list = old_list[:]
copy.deepcopy()	深拷贝	嵌套列表（元素为可变对象）	from copy import deepcopy; new_list = deepcopy(old_list)

示例（浅拷贝 vs 深拷贝）：

python

运行

# 1. 浅拷贝（单层列表无问题，嵌套列表会受影响）
old_list = [1, 2, [3, 4]]
new_list = old_list.copy()
new_list[0] = 100  # 修改外层元素，原列表不变
new_list[2][0] = 300  # 修改嵌套列表元素，原列表也变！
print(old_list)  # 结果：[1, 2, [300, 4]]

# 2. 深拷贝（嵌套列表也完全独立）
from copy import deepcopy
old_list = [1, 2, [3, 4]]
new_list = deepcopy(old_list)
new_list[2][0] = 300  # 修改嵌套列表，原列表不变
print(old_list)  # 结果：[1, 2, [3, 4]]

四、列表的注意事项

1. 有序性：列表的元素顺序与插入顺序一致，可通过索引精确访问；

2. 可变性：支持增删改操作（与字符串、元组的不可变性区分）；

3. 可重复性：允许存储重复元素（如 [1, 2, 2, 3]）；

4. 性能：

   • 末尾增删（append/pop()）效率高（O (1)）；
   • 中间插入 / 删除（insert/pop(index)）效率低（需移动元素，O (n)）；

5. 类型灵活：可存储任意类型元素，但建议同一列表存储同类型（可读性更高）。

总结

列表是 Python 中最灵活的数据结构之一，核心用法可概括为：

• 初始化：[] 或 list()；
• 访问：索引（[i]）、切片（[s:e:step]）；
• 增删改：append/extend/insert/remove/pop/del；
• 进阶：排序（sort/sorted）、列表推导式、深浅拷贝。