python怎么创建列表_python列表操作完全指南-Python教程-PHP中文网

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

python怎么创建列表_python列表操作完全指南

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

登录后复制

循环之后。

酷表ChatExcel

北大团队开发的通过聊天来操作Excel表格的AI工具

查看详情

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]

登录后复制

在这里，