python的列表

1.列表是什么？

列表 是一个有序、可变的集合，可以存储任意数量、任意类型的元素。

• 有序：元素有固定的位置（索引），按添加的顺序排列。
• 可变：创建后，可以修改列表的内容（增、删、改）。
• 异构：一个列表中可以包含不同类型的数据（整数、字符串、甚至其他列表）。

2.创建列表

有两种主要方式创建列表：

2.1.1. 使用方括号 []（最常用）

# 空列表
empty_list = []
print(empty_list) # []

# 包含元素的列表
numbers = [1, 2, 3, 4, 5]
fruits = ["apple", "banana", "orange"]
mixed = [1, "hello", 3.14, True] # 包含不同类型

print(numbers) # [1, 2, 3, 4, 5]
print(fruits)  # ['apple', 'banana', 'orange']
print(mixed)   # [1, 'hello', 3.14, True]

2.2.2. 使用 list() 构造函数

创建列表除了用方括号 []，也可以用内置的 list() 函数。
list() 可以将其他可迭代对象（如字符串、元组、字典、集合等）转换为列表。

• 如果传入一个字符串，每个字符会成为列表中的一个元素。
• 如果传入一个元组，列表会包含元组中的元素。
• 如果不传参数，会得到一个空列表。

# 从字符串创建（字符串是可迭代对象）
list_from_string = list("abc")
print(list_from_string) # ['a', 'b', 'c']

# 从元组创建
list_from_tuple = list((1, 2, 3))
print(list_from_tuple) # [1, 2, 3]

# 创建空列表
another_empty_list = list()
print(another_empty_list) # []

3.访问列表元素（索引和切片）

3.1.索引访问

列表使用从 0 开始的索引。

fruits = ["apple", "banana", "orange", "grape"]

print(fruits[0])   # "apple" - 第一个元素
print(fruits[1])   # "banana" - 第二个元素
print(fruits[-1])  # "grape" - 最后一个元素
print(fruits[-2])  # "orange" - 倒数第二个元素

注意：如果索引超出范围，会引发 IndexError。

# print(fruits[10]) # 这会报错：IndexError

3.2.切片访问

切片用于获取列表的一个子集，语法：list[start:stop:step]

• start：起始索引（包含）
• stop：结束索引（不包含）
• step：步长（默认为1）

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(numbers[2:5])    # [2, 3, 4]     # 索引2到5（不含5）
print(numbers[:4])     # [0, 1, 2, 3]  # 从开始到索引4
print(numbers[5:])     # [5, 6, 7, 8, 9] # 从索引5到结束
print(numbers[::2])    # [0, 2, 4, 6, 8] # 每隔一个取一个元素
print(numbers[::-1])   # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] # 反转列表

# 切片创建的是新列表，不影响原列表
sub_list = numbers[1:4]
print(sub_list) # [1, 2, 3]

4.修改列表（增、删、改）

由于列表是可变的，我们可以修改它。

4.1.修改元素

fruits = ["apple", "banana", "cherry"]
fruits[1] = "blueberry"  # 修改第二个元素
print(fruits) # ['apple', 'blueberry', 'cherry']

4.2.添加元素

在列表中添加元素，有多种常用方法：

1. append(x)
   在列表末尾添加一个元素 x。
2. insert(index, x)
   在指定位置 index 插入元素 x，原有及后续元素后移。
3. extend(iterable)
   将另一个可迭代对象（如列表、元组等）的元素逐个添加到列表末尾。

注意：

• append() 是把一个元素作为整体添加到末尾。
• extend() 会把所有元素分别添加到原列表。

例如：

a = [1, 2]
a.append([3, 4])
print(a)  # [1, 2, [3, 4]]  # 整个 [3, 4] 作为一个元素

b = [1, 2]
b.extend([3, 4])
print(b)  # [1, 2, 3, 4]    # 3 和 4 分别添加进列表

fruits = ["apple", "banana"]

# 方法1: append() - 在末尾添加单个元素
fruits.append("orange")
print(fruits) # ['apple', 'banana', 'orange']

# 方法2: insert() - 在指定位置插入元素
fruits.insert(1, "grape") # 在索引1处插入
print(fruits) # ['apple', 'grape', 'banana', 'orange']

# 方法3: extend() - 将另一个可迭代对象的元素逐个添加进来
fruits.extend(["mango", "pineapple"])
print(fruits) # ['apple', 'grape', 'banana', 'orange', 'mango', 'pineapple']

# 注意：append() 和 extend() 的区别
a = [1, 2]
a.append([3, 4])   # 将整个列表作为一个元素添加
print(a) # [1, 2, [3, 4]]

b = [1, 2]
b.extend([3, 4])   # 将列表中的元素逐个添加
print(b) # [1, 2, 3, 4]

4.3.删除元素

在操作列表时，常常需要删除其中的元素。Python 提供了多种删除列表元素的方法，主要包括：

1. remove(x) 方法

   • 用于删除列表中第一个值为 x 的元素（如果没有这样的元素会抛出 ValueError）。
   • 只会删除找到的第一个匹配项。
   • 语法：list.remove(x)

2. pop([index]) 方法

   • 用于删除并返回给定索引处的元素。如果没有指定索引，默认删除并返回最后一个元素。
   • 如果索引越界会抛出 IndexError。
   • 语法：list.pop() 或 list.pop(index)

3. del 语句

   • del 可以根据索引删除列表的指定元素，也可以一次性删除多个元素（切片）。
   • 语法：del list[index] 或 del list[start:end]

4. clear() 方法

   • 清空整个列表，变成空列表 []。
   • 语法：list.clear()

提示：

• remove() 和 pop()/del 必须有元素才能删除，否则会报错。
• 使用 del 删除变量本身（如 del mylist）会导致变量名不可用。

fruits = ["apple", "banana", "cherry", "banana", "date"]

# 方法1: remove() - 删除第一个匹配的元素
fruits.remove("banana")
print(fruits) # ['apple', 'cherry', 'banana', 'date']

# 方法2: pop() - 删除并返回指定索引的元素（默认最后一个）
popped_item = fruits.pop() # 删除最后一个
print(popped_item) # 'date'
print(fruits)      # ['apple', 'cherry', 'banana']

popped_item2 = fruits.pop(0) # 删除第一个
print(popped_item2) # 'apple'
print(fruits)       # ['cherry', 'banana']

# 方法3: del 语句 - 按索引删除
del fruits[0] # 删除第一个元素
print(fruits) # ['banana']

# 方法4: clear() - 清空整个列表
fruits.clear()
print(fruits) # []

常用用法与场景选择：

• 删除某个具体元素（但不清楚索引）建议用 remove(x)。
• 需要获取并移除某个位置的值，可以用 pop(index)。
• 批量删除（切片）或彻底清空可用 del 和 clear()。
• 若只是想新建空列表而不是清空原列表，可直接重新赋值：mylist = []。

5.列表操作与方法

5.1.常用操作

列表除了可以“增删改查”，还可以做各种操作和应用。常见的列表操作有：

• 拼接：用加号 + 可以合并两个或多个列表，形成一个新列表，不改变原列表。
• 重复：用乘号 * 可以将列表重复多次，得到新列表。
• 成员测试：使用 in 或 not in 快速判断某个元素是否存在于列表中，结果为布尔值。
• 获取长度：len(lst) 得到列表中的元素数量。

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

# 重复列表
repeated = list1 * 3
print(repeated) # [1, 2, 3, 1, 2, 3, 1, 2, 3]

# 检查元素是否存在
fruits = ["apple", "banana"]
print("apple" in fruits)  # True
print("orange" in fruits) # False

# 获取长度
print(len(fruits)) # 2

5.2.重要方法

• append(x)：在列表末尾添加一个元素 x。
• extend(iterable)：把一个可迭代对象中的所有元素添加到当前列表。
• insert(index, x)：在指定位置插入元素 x。
• remove(x)：删除第一个值等于 x 的元素。
• pop([index])：删除并返回指定位置的元素（默认最后一个）。
• clear()：清空列表内所有元素。
• index(x, [start, [end]])：在指定范围内查找第一个值等于 x 的元素，返回其索引。start 和 end 为可选参数，用于指定搜索范围。如果找不到则抛出 ValueError。
• count(x)：统计元素 x 在列表中出现的次数。
• sort(key=None, reverse=False)：对列表元素进行排序（原地排序，改变原列表）。
• reverse()：反转列表（原地操作）。
• copy()：返回列表的浅拷贝。

numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# 排序 (会改变原列表)
numbers.sort()
print(numbers) # [1, 1, 2, 3, 4, 5, 6, 9]

# 反转 (会改变原列表)
numbers.reverse()
print(numbers) # [9, 6, 5, 4, 3, 2, 1, 1]

# 查找索引
print(numbers.index(5)) # 2 (返回第一个匹配的索引)

# 计数
print(numbers.count(1)) # 2 (元素1出现的次数)

# 复制列表 (创建新列表)
numbers_copy = numbers.copy()
# 等价于 numbers_copy = numbers[:]
# 等价于 numbers_copy = list(numbers)

6.列表遍历

6.1.直接遍历元素

直接遍历元素是最常见的列表遍历方式。例如，下面代码会依次将 fruits 列表中的每个元素赋值给变量 fruit 并执行循环体：

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:
    print(f"I like {fruit}")

# 输出：
# I like apple
# I like banana
# I like cherry

这种方式适用于只关心元素本身、不需要索引的场景。

6.2.遍历索引和元素

使用 enumerate 可以在遍历列表时同时获得每个元素的索引和值。这在需要知道元素位于列表中哪个位置时非常有用。例如：

fruits = ["apple", "banana", "cherry"]

for index, fruit in enumerate(fruits):
    print(f"Index {index}: {fruit}")

# 输出：
# Index 0: apple
# Index 1: banana
# Index 2: cherry

其中，index 是当前元素的索引，fruit 是对应的值。

6.3.列表推导式

列表推导式（List Comprehensions）是 Python 提供的一种简洁优雅的构造新列表的方法。它既可以替代传统的 for 循环，也可以在创建列表时加入条件判断，让表达更加简明。

6.3.1.基本语法

new_list = [表达式 for 变量 in 可迭代对象]

相当于：

new_list = []
for 变量 in 可迭代对象:
    new_list.append(表达式)

6.3.2.带条件的列表推导式

还可以在推导式中添加条件：

new_list = [表达式 for 变量 in 可迭代对象 if 条件]

这样只有满足条件的元素才会加入新列表。

6.3.3.示例

• 生成数字平方的列表：

nums = [1, 2, 3, 4]
squares = [x**2 for x in nums]  # [1, 4, 9, 16]

• 过滤出偶数的平方：

squares_even = [x**2 for x in nums if x % 2 == 0]  # [4, 16]

• 处理字符串：

fruits = ["Apple", "Banana", "cherry"]
lower_fruits = [f.lower() for f in fruits]  # ['apple', 'banana', 'cherry']

列表推导式常用来构建、转换、筛选列表，使代码更为简洁、易读。

# 传统方式：创建一个平方数列表
squares = []
for x in range(5):
    squares.append(x ** 2)
print(squares) # [0, 1, 4, 9, 16]

# 使用列表推导式（更简洁）
squares = [x ** 2 for x in range(5)]
print(squares) # [0, 1, 4, 9, 16]

# 带条件的列表推导式
even_squares = [x ** 2 for x in range(10) if x % 2 == 0]
print(even_squares) # [0, 4, 16, 36, 64]

7.多维列表（列表的列表）

列表可以包含其他列表，形成多维结构。

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

# 访问元素
print(matrix[0])     # [1, 2, 3] - 第一行
print(matrix[1][2])  # 6 - 第二行第三列

# 遍历二维列表
for row in matrix:
    for element in row:
        print(element, end=" ")
    print() # 换行

# 输出：
# 1 2 3
# 4 5 6
# 7 8 9

8.重要注意事项

8.1.1. 浅拷贝 vs 深拷贝

浅拷贝（shallow copy）和深拷贝（deep copy）是列表复制时的两个概念，尤其是在涉及多维列表（嵌套列表）时需要特别注意。

• 浅拷贝：只复制最外层的列表对象，内部的子对象依然引用原来的地址。常用 list.copy()、切片[:] 或 list() 实现。
• 深拷贝：不仅复制最外层列表，也递归复制所有子对象，互不影响。需要用 copy.deepcopy()（需 import copy）。

例如：

# 浅拷贝
a = [[1, 2], [3, 4]]
b = a.copy()  # 只复制最外层
b[0][0] = 99
print(a)  # [[99, 2], [3, 4]]，原列表被影响

# 深拷贝
import copy
a = [[1, 2], [3, 4]]
b = copy.deepcopy(a)
b[0][0] = 88
print(a)  # [[1, 2], [3, 4]]，原列表不变
print(b)  # [[88, 2], [3, 4]]

所以：

• 如果只是简单列表，浅拷贝足矣。
• 如果是嵌套复杂结构，且需要完全独立的副本，务必使用深拷贝。

# 浅拷贝问题
original = [[1, 2], [3, 4]]
shallow_copy = original.copy()

# 修改浅拷贝中的子列表会影响原列表
shallow_copy[0][0] = 99
print(original)    # [[99, 2], [3, 4]] - 原列表也被改了！
print(shallow_copy) # [[99, 2], [3, 4]]

# 深拷贝解决方案
import copy
original = [[1, 2], [3, 4]]
deep_copy = copy.deepcopy(original)

deep_copy[0][0] = 99
print(original)  # [[1, 2], [3, 4]] - 原列表不受影响
print(deep_copy) # [[99, 2], [3, 4]]

8.2.列表 vs 元组

• 列表：可变，用 []
• 元组：不可变，用 ()

my_list = [1, 2, 3]  # 可以修改
my_tuple = (1, 2, 3) # 创建后不能修改

9.总结

操作类别	方法/语法	描述
创建	[], list()	创建列表
访问	list[index], list[start:stop:step]	索引和切片
修改	list[index] = value	直接赋值修改
添加	append(), insert(), extend()	添加元素
删除	remove(), pop(), del, clear()	删除元素
查询	index(), count(), in	查找元素
排序	sort(), reverse()	排序和反转
遍历	for item in list, enumerate()	循环遍历
高级	列表推导式	优雅创建新列表