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

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里是完全允许的，也是它灵活性的体现。

除了直接用方括号，你也可以用

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。

以上就是python怎么创建列表_python列表操作完全指南的详细内容，更多请关注知识资源分享宝库其它相关文章！

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

最近发表

标签列表

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

相关阅读

macOS 14环境下解决google-re2安装中的C++标准兼容性问题（兼容性问题.安装.环境.解决.标准...）

Python中大量文件复制的性能优化策略与实践（复制.性能.优化.实践.策略...）

Pandas DataFrame高效提取Top N值及其行列坐标（高效.坐标.行列.提取.Pandas...）

使用Python根据CSV数据筛选JSON日志条目（条目.筛选.数据.日志.Python...）

macOS 14环境下解决google-re2安装失败的指南（失败.安装.环境.解决.指南...）

macOS 14环境下安装google-re2的兼容性解决方案与步骤详解（兼容性.详解.步骤.解决方案.安装...）

最近发表

标签列表