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里是完全允许的，也是它灵活性的体现。
立即学习“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提供了两种主要方式：
-
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)
-
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。
