Python列表创建与常用操作详解

Python列表是数据结构中的重要组成部分，本文将深入解析Python中创建和操作列表的各种方法，助力你玩转数据处理。文章详细介绍了使用方括号`[]`直接定义列表、利用`list()`构造函数转换可迭代对象以及使用列表推导式`[expr for item in iterable if cond]`高效生成列表等多种创建方式。同时，文章还阐述了如何通过索引和切片访问、修改列表元素，以及`append`、`extend`、`insert`等常用方法实现列表的增删改查。此外，本文还重点提醒了列表复制时浅拷贝与深拷贝的区别，避免因引用共享导致数据修改的潜在问题。掌握这些技巧，能让你在Python编程中更加得心应手。

Python创建列表最常用方式是用方括号[]直接定义，如my_list = [1, 2, 3]；也可用list()构造函数转换可迭代对象，或使用列表推导式[expr for item in iterable if cond]实现简洁高效的列表生成；列表支持通过索引和切片访问及修改元素，结合append、extend、insert等方法实现增删改查；需注意列表复制时的浅拷贝与深拷贝区别，避免因引用共享导致意外修改。

Python中创建列表其实非常直接，它就像你收集各种东西，然后把它们按顺序排好放在一个盒子里。这个“盒子”就是列表，而“各种东西”可以是任何类型的数据，比如数字、文本，甚至是其他列表。最常见的创建方式就是用方括号 [] 把你想放进去的东西（我们叫它们元素）括起来，用逗号隔开。

解决方案

创建Python列表的方式有很多种，最基础也最常用的就是直接字面量声明。你可以创建一个空的列表，稍后再往里面加东西，也可以在创建时就指定一些初始元素。

比如，一个空列表就这么写：my_empty_list = []。是不是很简单？

如果想一开始就有内容，那就把元素放进去：my_numbers = [1, 2, 3, 4, 5] 或者 my_fruits = ["apple", "banana", "cherry"]。这里要注意，列表里的元素类型可以混搭，比如 mixed_list = [1, "hello", True, 3.14]，这在Python里是完全允许的，也是它灵活性的体现。

除了直接用方括号，你也可以用 list() 构造函数。如果你有一个其他可迭代对象（比如字符串或元组），想把它转换成列表，list() 就派上用场了。 my_string = "Python"list_from_string = list(my_string) # 结果是 ['P', 'y', 't', 'h', 'o', 'n']

my_tuple = (10, 20, 30)list_from_tuple = list(my_tuple) # 结果是 [10, 20, 30]

还有一种非常强大且Pythonic的方式叫做“列表推导式”（List Comprehension），它能让你用一行代码简洁地创建或转换列表。我个人非常喜欢用它来处理一些数据转换的场景，代码会显得非常优雅。 比如，想创建一个包含1到10所有偶数的列表： even_numbers = [i for i in range(1, 11) if i % 2 == 0] # 结果是 [2, 4, 6, 8, 10] 这个方法后面会详细讲，因为它真的很实用。

如何从列表中获取或修改特定元素？

列表的元素是有序的，这意味着每个元素都有一个位置，我们称之为“索引”。在Python里，索引是从0开始的。所以，第一个元素的索引是0，第二个是1，依此类推。

要获取列表中的某个元素，你只需在列表名后面加上方括号，里面写上索引号。 fruits = ["apple", "banana", "cherry"]first_fruit = fruits[0] # 结果是 "apple" second_fruit = fruits[1] # 结果是 "banana"

如果想从列表末尾开始数，可以使用负数索引。[-1] 表示最后一个元素，[-2] 表示倒数第二个，这在处理不确定列表长度时特别方便。 last_fruit = fruits[-1] # 结果是 "cherry"

修改列表中的元素也很简单，直接通过索引赋值就行了： fruits[1] = "orange" # 现在 fruits 变成了 ["apple", "orange", "cherry"]

除了单个元素，我们还可以获取或修改列表的“切片”（slice），也就是列表的一部分。切片操作符是 [start:end:step]。start 是起始索引（包含），end 是结束索引（不包含），step 是步长。 numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]subset = numbers[2:5] # 结果是 [2, 3, 4] (从索引2到索引4) every_other = numbers[::2] # 结果是 [0, 2, 4, 6, 8] (每隔一个取一个) reversed_list = numbers[::-1] # 结果是 [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] (一个很酷的翻转列表技巧)

修改切片也行，但要注意，你替换的元素数量不一定非要和原切片长度一致： numbers[2:5] = [20, 30] # numbers 变成了 [0, 1, 20, 30, 5, 6, 7, 8, 9]。原先的 [2, 3, 4] 被 [20, 30] 替换了，列表长度也随之改变。

要往列表里添加元素，最常用的是 append() 方法，它会把新元素加到列表的末尾： fruits.append("grape") # fruits 变成了 ["apple", "orange", "cherry", "grape"]

如果你想把另一个列表的所有元素都加进来，用 extend() 而不是 append()。append() 会把整个新列表作为一个单一元素添加，而 extend() 会逐个添加： more_fruits = ["kiwi", "mango"]fruits.extend(more_fruits) # fruits 变成了 ["apple", "orange", "cherry", "grape", "kiwi", "mango"]

要在指定位置插入元素，可以用 insert(index, element)： fruits.insert(1, "blueberry") # fruits 变成了 ["apple", "blueberry", "orange", "cherry", "grape", "kiwi", "mango"]

删除元素有几种方式：

• del 语句：根据索引删除。del fruits[0]
• pop() 方法：删除指定索引的元素，并返回被删除的元素。如果不指定索引，默认删除并返回最后一个。 removed_fruit = fruits.pop(1) # removed_fruit 是 "blueberry"
• remove() 方法：删除列表中第一个匹配到的指定值的元素。如果值不存在会报错。 fruits.remove("orange")

除了增删改查，Python 列表还有哪些常用技巧？

列表的操作远不止基本的增删改查，还有很多内置函数和方法能让你的工作更高效。

首先是获取列表长度，用 len() 函数： my_list = [1, 2, 3, 4]list_length = len(my_list) # 结果是 4

判断一个元素是否在列表中，可以使用 in 和 not in 运算符： if "apple" in fruits:print("Apple is in the list.")if "pineapple" not in fruits:print("Pineapple is not here.")

列表的排序是个很常见的需求。Python提供了两种主要方式：

1. list.sort() 方法：直接修改原列表，没有返回值。 numbers = [3, 1, 4, 1, 5, 9, 2]numbers.sort() # numbers 变成了 [1, 1, 2, 3, 4, 5, 9] 你可以传递 reverse=True 参数进行降序排序：numbers.sort(reverse=True)
2. sorted() 函数：返回一个新的排序后的列表，不改变原列表。 original_numbers = [3, 1, 4]sorted_numbers = sorted(original_numbers) # sorted_numbers 是 [1, 3, 4]，original_numbers 保持不变。

如果你只是想反转列表元素的顺序，而不是排序，可以使用 list.reverse() 方法（原地反转）或切片 [::-1]（返回新列表）： my_list = [1, 2, 3]my_list.reverse() # my_list 变成了 [3, 2, 1]another_list = [10, 20, 30]reversed_another_list = another_list[::-1] # reversed_another_list 是 [30, 20, 10]

查找某个元素在列表中出现的次数，用 list.count()： my_list = [1, 2, 1, 3, 1, 4]count_of_one = my_list.count(1) # 结果是 3

查找某个元素第一次出现的索引，用 list.index()： my_list = ["a", "b", "c", "b"]index_of_b = my_list.index("b") # 结果是 1 注意，如果元素不存在，index() 会抛出 ValueError，所以在使用前最好用 in 进行检查。

连接两个或多个列表，可以用 + 运算符： list1 = [1, 2]list2 = [3, 4]combined_list = list1 + list2 # 结果是 [1, 2, 3, 4]

重复列表，可以用 * 运算符： repeated_list = [0] * 5 # 结果是 [0, 0, 0, 0, 0] 但要小心，如果列表包含可变对象（如另一个列表），这种重复只是创建了对相同对象的引用，修改其中一个会影响所有重复项。

# 示例：重复列表的陷阱
nested_list = [[1, 2]] * 3
print(nested_list) # 输出: [[1, 2], [1, 2], [1, 2]]

nested_list[0][0] = 99
print(nested_list) # 输出: [[99, 2], [99, 2], [99, 2]] -- 噢，所有子列表都被修改了！

这其实是Python浅拷贝的一个经典案例，在使用时需要特别留意。

列表推导式是什么？它能让我的代码更简洁吗？

列表推导式（List Comprehension）是Python提供的一种非常优雅和高效的创建列表的方式。它能将循环和条件判断结合在一行代码中，生成新的列表。我个人觉得，一旦你掌握了它，你的Python代码会变得更加简洁、可读性更强，而且通常运行效率也更高。

它的基本语法是：[expression for item in iterable if condition]

• expression：对 item 进行操作，生成新列表的元素。
• item：从 iterable 中取出的每一个元素。
• iterable：一个可迭代对象，比如范围、元组、字符串或另一个列表。
• condition (可选)：一个布尔表达式，只有当它为 True 时，item 才会参与 expression 的计算。

我们来看几个例子：

1. 简单的元素转换： 假设你有一个数字列表，想把每个数字都平方。 传统方法：

numbers = [1, 2, 3, 4, 5]
squared_numbers = []
for num in numbers:
    squared_numbers.append(num ** 2)
print(squared_numbers) # 输出: [1, 4, 9, 16, 25]

使用列表推导式：

numbers = [1, 2, 3, 4, 5]
squared_numbers = [num ** 2 for num in numbers]
print(squared_numbers) # 输出: [1, 4, 9, 16, 25]

是不是简洁了很多？

2. 结合条件过滤： 现在，我们只想平方偶数。 传统方法：

numbers = [1, 2, 3, 4, 5]
even_squared_numbers = []
for num in numbers:
    if num % 2 == 0:
        even_squared_numbers.append(num ** 2)
print(even_squared_numbers) # 输出: [4, 16]

使用列表推导式：

numbers = [1, 2, 3, 4, 5]
even_squared_numbers = [num ** 2 for num in numbers if num % 2 == 0]
print(even_squared_numbers) # 输出: [4, 16]

条件判断 if num % 2 == 0 被放在了 for 循环之后。

3. 带有 if-else 的条件表达式： 如果条件判断需要根据结果生成不同的值，而不是过滤元素，你可以把 if-else 放在 expression 部分： 假设你想把偶数变成它们的平方，奇数保持不变。 传统方法：

numbers = [1, 2, 3, 4, 5]
transformed_numbers = []
for num in numbers:
    if num % 2 == 0:
        transformed_numbers.append(num ** 2)
    else:
        transformed_numbers.append(num)
print(transformed_numbers) # 输出: [1, 4, 3, 16, 5]

使用列表推导式：

numbers = [1, 2, 3, 4, 5]
transformed_numbers = [num ** 2 if num % 2 == 0 else num for num in numbers]
print(transformed_numbers) # 输出: [1, 4, 3, 16, 5]

这里的 if-else 结构是在 for 循环之前。记住这个区别，它很重要。

4. 嵌套列表推导式： 列表推导式甚至可以嵌套，用来处理多维数据或生成笛卡尔积。

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flattened_list = [num for row in matrix for num in row]
print(flattened_list) # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]

这个例子将一个二维列表“展平”成了一维列表。

什么时候使用列表推导式？

• 当你需要基于一个现有列表或其他可迭代对象创建新列表时。
• 当你想用更少的代码实现循环和条件逻辑时。
• 当你关心代码的执行效率时（列表推导式通常比显式的 for 循环更快，因为它在C语言层面进行了优化）。

不过，如果逻辑过于复杂，或者嵌套层级太多，列表推导式可能会变得难以阅读。在这种情况下，传统的 for 循环可能更清晰。平衡简洁性和可读性是关键。

为什么我的列表复制后，原列表也跟着变了？（浅拷贝的坑）

在Python中处理列表时，一个非常常见的误区就是关于列表的复制。如果你不小心，可能会遇到“为什么我修改了副本，原列表也跟着变了？”的困惑。这通常涉及到“浅拷贝”（shallow copy）和“深拷贝”（deep copy）的概念。

Python变量存储的不是值本身，而是对内存中对象的引用。当我们对列表进行“复制”操作时，究竟是复制了引用，还是复制了实际内容，这决定了后续操作的行为。

1. 直接赋值（=）：这不是复制，而是引用！ 这是最容易犯错的地方。当你写 list_b = list_a 时，你并没有创建一个新的列表 list_b。实际上，list_a 和 list_b 现在都指向内存中的同一个列表对象。它们只是同一个对象的两个不同名字而已。

original_list = [1, 2, 3]
new_list = original_list # 仅仅是引用
new_list.append(4)

print(original_list) # 输出: [1, 2, 3, 4] -- 咦，原列表也变了！
print(new_list)      # 输出: [1, 2, 3, 4]

修改 new_list 实际上就是修改了 original_list 指向的那个对象。

2. 浅拷贝（Shallow Copy）：复制列表本身，但不复制其内部的可变对象。 浅拷贝会创建一个新的列表对象，但这个新列表中的元素，如果是可变对象（比如另一个列表），则仍然是原列表中对应元素的引用。这意味着，如果你修改了新列表中可变子对象的内容，原列表中的子对象也会被修改。

有几种方法可以进行浅拷贝：

• 切片操作 [:]： 这是最常用和推荐的浅拷贝方法之一。

  original_list = [1, 2, [3, 4]]
  copied_list = original_list[:] # 浅拷贝
  copied_list.append(5)
  copied_list[2].append(6) # 修改了内部的子列表
  
  print(original_list) # 输出: [1, 2, [3, 4, 6]] -- 子列表变了！
  print(copied_list)   # 输出: [1, 2, [3, 4, 6], 5]

  可以看到，append(5) 只影响了 copied_list，因为它是在顶层添加了一个新元素。但 copied_list[2].append(6) 修改了内部的子列表 [3, 4]，由于 original_list 和 copied_list 的子列表 [3, 4] 仍然是同一个对象，所以 original_list 也受到了影响。

• list() 构造函数： 效果与切片 [:] 相同。

  original_list = [1, 2, [3, 4]]
  copied_list = list(original_list) # 浅拷贝
  # 后续操作同上，结果一样

• copy 模块的 copy() 函数： 明确表示进行浅拷贝。

  import copy
  original_list = [1, 2, [3, 4]]
  copied_list = copy.copy(original_list) # 浅拷贝
  # 后续操作同上，结果一样

3. 深拷贝（Deep Copy）：彻底复制所有内容，包括嵌套的可变对象。 深拷贝会创建一个全新的列表对象，并且递归地复制原列表中所有嵌套的可变对象。这意味着，深拷贝后的列表与原列表在内存中完全独立，修改其中任何一个都不会影响另一个。

要进行深拷贝，你需要使用 copy 模块中的 deepcopy() 函数：

import copy
original_list = [1, 2, [3, 4]]
deep_copied_list = copy.deepcopy(original_list) # 深拷贝
deep_copied_list.append(5)
deep_copied_list[2].append(6) # 修改了内部的子列表

print(original_list)     # 输出: [1, 2, [3, 4]] -- 原列表保持不变！
print(deep_copied_list)  # 输出: [1, 2, [3, 4, 6], 5]

在这里，original_list 即使在 deep_copied_list 的子列表被修改后，也依然保持原样，因为 deepcopy() 连同内部的子列表也一并复制了。

总结一下：

• 直接赋值 (=): 只是创建了对同一对象的另一个引用。
• 浅拷贝 ([:], list(), copy.copy()): 创建了新的顶层列表，但内部的可变对象仍是引用。
• 深拷贝 (copy.deepcopy()): 创建了完全独立的副本，包括所有嵌套的可变对象。

选择哪种拷贝方式取决于你的具体需求。如果你的列表只包含不可变对象（如数字、字符串、元组），那么浅拷贝就足够了，因为它和深拷贝的效果一样。但如果你的列表包含其他列表、字典等可变对象，并且你希望修改副本时原列表不受影响，那么深拷贝是你的不二之选。理解这个差异，能帮你避免很多不必要的bug。

以上就是《Python列表创建与常用操作详解》的详细内容，更多关于列表操作,浅拷贝,深拷贝,列表推导式,Python列表的资料请关注golang学习网公众号！