Python 列表 (list) 全面详解（超详细版）

Yorlen_Zhang

1925人浏览 · 2026-02-26 15:35:18

Yorlen_Zhang · 2026-02-26 15:35:18 发布

列表（list）是 Python 中最常用、最核心的可变序列数据类型，属于有序、可修改的集合，支持存储重复元素、不同数据类型的元素，是日常开发中处理批量数据的基础工具。本文将从概念、创建、核心操作、常用方法、高级特性、注意事项六个维度，超详细讲解列表的所有使用细节，结合大量可运行案例，让新手也能快速掌握。

一、列表的核心特性

有序性：列表中的元素按插入顺序排列，通过下标（索引） 精准访问，下标从0开始，也支持负索引。
可修改性：支持新增、删除、修改元素，无需创建新列表（与字符串不可变特性区分）。
元素多样性：可存储整数、浮点数、字符串、列表、字典等任意数据类型，也可混合存储。
允许重复：列表中可以存在多个相同值的元素。
动态扩容：Python 会自动为列表分配内存，无需手动指定长度，添加元素时自动扩容。

二、列表的创建

创建列表有直接赋值法和内置函数法两种方式，支持创建空列表和非空列表，其中直接赋值法是最常用的方式。

2.1 创建空列表

方式 1：使用`[]`直接创建（推荐，更简洁）

# 空列表创建
empty_list1 = []
# 查看类型和内容
print(type(empty_list1))  # 输出：<class 'list'>
print(empty_list1)        # 输出：[]

方式 2：使用`list()`内置函数创建

empty_list2 = list()
print(type(empty_list2))  # 输出：<class 'list'>
print(empty_list2)        # 输出：[]

2.2 创建非空列表

直接在[]中写入初始元素，元素之间用逗号分隔，支持混合数据类型。

# 纯数字列表
num_list = [1, 2, 3.14, 5, 3.14]
# 混合类型列表（整数+浮点数+字符串+布尔值）
mix_list = [1, 2.2, "Python", True, [10, 20]]
# 查看列表
print(num_list)  # 输出：[1, 2, 3.14, 5, 3.14]
print(mix_list)  # 输出：[1, 2.2, 'Python', True, [10, 20]]

2.3 从其他可迭代对象创建列表

通过list()函数将字符串、元组、集合、range 对象等可迭代对象转换为列表：

# 字符串转列表（按字符拆分）
str2list = list("Python")
# range对象转列表（生成连续整数）
range2list = list(range(1, 6))
# 元组转列表
tuple2list = list((10, 20, 30))

print(str2list)   # 输出：['P', 'y', 't', 'h', 'o', 'n']
print(range2list) # 输出：[1, 2, 3, 4, 5]
print(tuple2list) # 输出：[10, 20, 30]

三、列表的核心操作

列表的操作围绕新增、删除、查找、修改、遍历、切片、拼接七大核心场景展开，是使用列表的基础，每个场景都有对应的专属方法 / 语法，以下逐一讲解并附详细案例。

3.1 新增列表元素

向列表中添加元素有append()、insert()、extend()三种核心方法，分别适用于末尾追加、指定位置插入、批量拼接场景，注意区分使用场景。

3.1.1 `append()`：列表末尾追加单个元素（最常用）

功能：在列表最后一位添加任意单个元素（数字、字符串、列表、字典等均可），直接修改原列表，无返回值。语法：列表名.append(待添加元素)

# 基础使用：追加普通元素
a = [1, 3.0, 2.2]
a.append("Python")
print(a)  # 输出：[1, 3.0, 2.2, 'Python']

# 进阶使用：追加嵌套列表
a.append([10, 20])
print(a)  # 输出：[1, 3.0, 2.2, 'Python', [10, 20]]

3.1.2 `insert()`：指定下标插入单个元素

功能：在列表任意指定下标位置插入单个元素，支持正索引和负索引，直接修改原列表，无返回值。语法：列表名.insert(目标下标, 待添加元素)核心知识点：负索引负索引从列表最后一个元素开始往前计数，依次为-1、-2、-3...，例如：列表[1,3.0,2.2]中，-1对应2.2，-2对应3.0，-3对应1。

a = [1, 3.0, 2.2]
# 正索引：在下标1的位置插入"Hello"
a.insert(1, "Hello")
print(a)  # 输出：[1, 'Hello', 3.0, 2.2]

# 负索引：在倒数第一个元素前插入"World"（-1对应最后一个元素2.2）
a.insert(-1, "World")
print(a)  # 输出：[1, 'Hello', 3.0, 'World', 2.2]

特殊情况：指定下标超出列表有效范围

正索引超出范围：元素插入到列表末尾（等同于append()）
负索引超出范围：元素插入到列表首部

a = [1, 3.0, 2.2]
# 正索引超出范围（列表最大下标为2，指定100）
a.insert(100, "末尾")
print(a)  # 输出：[1, 3.0, 2.2, '末尾']

# 负索引超出范围（列表最小负索引为-3，指定-100）
a.insert(-100, "首部")
print(a)  # 输出：['首部', 1, 3.0, 2.2, '末尾']

3.1.3 `extend()`：批量追加可迭代对象的元素

功能：将可迭代对象（列表、字符串、元组等） 中的所有元素逐个追加到列表末尾，直接修改原列表，无返回值（与append()的区别：append()追加整个对象，extend()拆分对象为单个元素追加）。语法：列表名.extend(可迭代对象)

a = [1, 2, 3]
b = [4, 5, 6]
c = "Python"

# 追加列表：将b的元素逐个加入a
a.extend(b)
print(a)  # 输出：[1, 2, 3, 4, 5, 6]

# 追加字符串：将c的字符逐个加入a
a.extend(c)
print(a)  # 输出：[1, 2, 3, 4, 5, 6, 'P', 'y', 't', 'h', 'o', 'n']

# 对比append()：直接追加整个对象
a.append(b)
print(a)  # 输出：[1,2,3,4,5,6,'P','y','t','h','o','n', [4,5,6]]

3.2 删除列表元素

删除列表元素有pop()、remove()、clear()、del四种方式，分别适用于按下标删除、按值删除、清空列表、批量删除场景，各有适用场景，需重点区分。

3.2.1 `pop()`：按下标删除元素（默认删除末尾）

功能：删除列表中指定下标的元素，返回被删除的元素；若不指定下标，默认删除最后一个元素。语法：列表名.pop(目标下标)（下标可选，默认-1）

a = [1, 3.0, 2.2, "Python"]
# 不指定下标：删除末尾元素
last_elem = a.pop()
print("被删除的元素：", last_elem)  # 输出：被删除的元素：Python
print(a)                            # 输出：[1, 3.0, 2.2]

# 指定下标：删除下标1的元素
spec_elem = a.pop(1)
print("被删除的元素：", spec_elem)  # 输出：被删除的元素：3.0
print(a)                            # 输出：[1, 2.2]

注意：若指定的下标超出列表有效范围，会抛出IndexError异常，需避免。

3.2.2 `remove()`：按元素值删除（删除首次出现的元素）

功能：删除列表中第一个匹配指定值的元素，无返回值，直接修改原列表。语法：列表名.remove(待删除元素值)

# 基础使用：删除单个匹配元素
a = [1, 3.0, 2.2, 3.0]
a.remove(3.0)
print(a)  # 输出：[1, 2.2, 3.0]（仅删除第一个3.0）

# 注意：元素值不存在时，抛出ValueError异常
# a.remove(10)  # 执行此代码会报错：ValueError: list.remove(x): x not in list

3.2.3 `clear()`：清空列表所有元素

功能：删除列表中的所有元素，保留列表对象本身，变为空列表，无返回值。语法：列表名.clear()

a = [1, 2, 3, 4]
a.clear()
print(a)  # 输出：[]（空列表）
print(type(a))  # 输出：<class 'list'>（列表对象仍存在）

3.2.4 `del`关键字：按下标 / 切片批量删除（灵活度最高）

功能：Python 内置关键字，可按单个下标、切片范围删除列表元素，也可直接删除整个列表对象，灵活性远超专用方法。语法：

删除单个元素：del 列表名[目标下标]
删除切片范围元素：del 列表名[start:stop:step]
删除整个列表：del 列表名

a = [1, 2, 3, 4, 5, 6]
# 1. 删除单个元素（下标2）
del a[2]
print(a)  # 输出：[1, 2, 4, 5, 6]

# 2. 删除切片范围元素（下标1到4，左闭右开）
del a[1:4]
print(a)  # 输出：[1, 6]

# 3. 删除整个列表对象
del a
# print(a)  # 执行此代码会报错：NameError: name 'a' is not defined

3.3 查找列表元素

查找列表元素包含判断元素是否存在、获取元素下标、按下标访问元素三种场景，分别对应in/not in操作符、index()方法、下标访问语法，是读取列表数据的基础。

3.3.1 `in/not in`：判断元素是否存在（返回布尔值）

功能：判断指定元素是否在列表中，返回True（存在）或False（不存在），是最常用的存在性判断方式。语法：

存在判断：待判断元素 in 列表名
不存在判断：待判断元素 not in 列表名

a = [1, 3.0, 2.2, 3.0, "Python"]
# 存在判断
print(3.0 in a)        # 输出：True
print("Java" in a)     # 输出：False

# 不存在判断
print(10 not in a)     # 输出：True
print("Python" not in a)  # 输出：False

3.3.2 `index()`：获取元素的首次出现下标

功能：返回列表中第一个匹配指定值的元素的下标，若元素不存在，抛出ValueError异常。语法：列表名.index(待查找元素, start, stop)

start（可选）：查找起始下标，默认0
stop（可选）：查找结束下标，默认列表长度（左闭右开）

a = [1, 3.0, 2.2, 3.0, "Python"]
# 基础使用：获取首次出现的3.0的下标
print(a.index(3.0))  # 输出：1

# 进阶使用：指定查找范围（下标2到4）
print(a.index(3.0, 2, 4))  # 输出：3

# 注意：元素不存在时报错
# print(a.index("Java"))  # 报错：ValueError: 'Java' is not in list

3.3.3 下标访问：直接获取指定下标元素

功能：通过[]下标操作符，直接访问列表中指定下标的元素，支持正索引和负索引，是最直接的元素读取方式。语法：列表名[目标下标]

a = [1, 3.0, 2.2, 3.0, "Python"]
# 正索引访问
print(a[0])   # 输出：1（第一个元素）
print(a[4])   # 输出：Python（第五个元素）

# 负索引访问
print(a[-1])  # 输出：Python（最后一个元素）
print(a[-3])  # 输出：2.2（倒数第三个元素）

# 注意：下标超出范围会报错
# print(a[10])  # 报错：IndexError: list index out of range

3.4 修改列表元素

列表是可变序列，支持直接通过下标修改元素值，语法简单，是修改列表数据的核心方式。语法：列表名[目标下标] = 新值

a = [1, 3.0, 2.2, "Python"]
# 修改正索引元素（下标3）
a[3] = "Java"
print(a)  # 输出：[1, 3.0, 2.2, 'Java']

# 修改负索引元素（倒数第一个）
a[-1] = "Python"
print(a)  # 输出：[1, 3.0, 2.2, 'Python']

# 批量修改：通过切片赋值
a[0:2] = [10, 20]
print(a)  # 输出：[10, 20, 2.2, 'Python']

3.5 遍历列表元素

遍历列表即逐个访问列表中的元素，常用for 循环（直接遍历 / 按下标遍历）和while 循环（按下标遍历）三种方式，其中for直接遍历是最简洁、最高效的方式。

3.5.1 for 循环：直接遍历元素（推荐）

功能：直接遍历列表中的每个元素，无需关心下标，语法简洁，适合仅读取元素的场景。语法：for 临时变量 in 列表名: 循环体注意：遍历中修改临时变量，不会影响原列表（临时变量仅为元素的副本）。

a = [1, 3.0, 2.2, 3.0]
# 直接遍历元素
for elem in a:
    print(elem, end=" ")  # 输出：1 3.0 2.2 3.0

print("\n" + "-"*20)
# 遍历中修改临时变量，原列表不变
for elem in a:
    elem += 1
    print(elem, end=" ")  # 输出：2 4.0 3.2 4.0
print("\n原列表：", a)    # 输出：原列表：[1, 3.0, 2.2, 3.0]

3.5.2 for 循环：按下标遍历元素（支持修改原列表）

功能：通过range(len(列表名))生成列表的下标范围，按下标遍历元素，支持修改原列表元素，适合需要同时获取下标和元素的场景。语法：for 下标 in range(len(列表名)): 循环体（通过列表名[下标]访问/修改元素）

a = [1, 3.0, 2.2, 3.0]
# 获取列表长度
n = len(a)
# 按下标遍历，修改原列表
for i in range(n):
    a[i] += 1  # 每个元素+1
    print(a[i], end=" ")  # 输出：2 4.0 3.2 4.0
print("\n修改后列表：", a)  # 输出：修改后列表：[2, 4.0, 3.2, 4.0]

3.5.3 while 循环：按下标遍历元素（灵活可控）

功能：通过下标变量自增的方式，按下标遍历元素，支持灵活控制循环条件（如中途终止、步长自定义），也可修改原列表。语法：

下标变量 = 0
while 下标变量 < len(列表名):
    循环体（通过列表名[下标变量]访问/修改元素）
    下标变量 += 1

a = [1, 3.0, 2.2, 3.0]
n = len(a)
i = 0
# while循环按下标遍历，修改原列表
while i < n:
    a[i] *= 2  # 每个元素*2
    print(a[i], end=" ")  # 输出：2 6.0 4.4 6.0
    i += 1
print("\n修改后列表：", a)  # 输出：修改后列表：[2, 6.0, 4.4, 6.0]

3.6 子列表提取（切片）

列表切片是按范围提取子列表的核心语法，支持指定起始下标、结束下标、步长，语法灵活，是处理列表批量数据的重要方式，切片结果为新列表，不修改原列表。核心语法：列表名[start:stop:step]

start：起始下标，默认0（包含该下标元素）
stop：结束下标，默认列表长度（不包含该下标元素，左闭右开）
step：步长，即每次下标自增的数值，默认1，支持负数（反向切片）
切片下标支持正索引、负索引，且允许越界（不会报错，尽可能提取元素）

3.6.1 基础切片：`[start:stop]`（默认步长 1）

按左闭右开规则提取元素，start为起始位置，stop为结束位置（不包含）。

a = [1, 3.0, 2.2, 3.0, "Python"]
# 提取下标1到3的元素（包含1，不包含3）
b = a[1:3]
# 提取下标0到4的元素（包含0，不包含4）
c = a[0:4]
print(b)  # 输出：[3.0, 2.2]
print(c)  # 输出：[1, 3.0, 2.2, 3.0]

3.6.2 简化切片：忽略`start`/`stop`边界

切片时可忽略start或stop，Python 会使用默认值，简化代码：

[start:]：从start开始，提取到列表末尾的所有元素
[:stop]：从列表开头开始，提取到 stop 前的所有元素
[:]：提取整个列表（等同于列表复制）

a = [1, 3.0, 2.2, 3.0, "Python"]
# 从下标1到末尾
b = a[1:]
# 从开头到下标3
c = a[:3]
# 提取整个列表
d = a[:]
print(b)  # 输出：[3.0, 2.2, 3.0, 'Python']
print(c)  # 输出：[1, 3.0, 2.2]
print(d)  # 输出：[1, 3.0, 2.2, 3.0, 'Python']

3.6.3 高级切片：指定步长`step`

通过step指定遍历步长，可实现隔元素提取，step支持正整数和负整数：

正整数：从左到右按步长提取
负整数：从右到左按步长提取（反向切片），此时start需大于stop才能提取到元素

a = [1, 3.0, 2.2, 3.0, "Python", 10, 20]
# 步长2：从下标0到6，隔1个元素提取
b = a[0:6:2]
# 反向切片：步长-1，提取整个列表（倒序）
c = a[::-1]
# 反向切片：步长-2，从下标6到1，隔1个元素提取
d = a[6:1:-2]

print(b)  # 输出：[1, 2.2, 'Python']
print(c)  # 输出：[20, 10, 'Python', 3.0, 2.2, 3.0, 1]
print(d)  # 输出：[20, 'Python', 2.2]

3.6.4 切片越界：自动容错（不报错）

切片时若指定的start/stop超出列表有效下标范围，Python不会抛出异常，而是尽可能提取符合条件的元素，无元素则返回空列表。

a = [1, 3.0, 2.2, 3.0]
# 正索引越界：下标2到100
b = a[2:100]
# 反向索引越界：下标100到0，步长-1
c = a[100:0:-1]
# 完全越界：返回空列表
d = a[100:200]

print(b)  # 输出：[2.2, 3.0]
print(c)  # 输出：[3.0, 2.2, 3.0]
print(d)  # 输出：[]

3.7 拼接列表

将多个列表合并为一个列表，有 **+操作符、+=操作符、extend()方法 ** 三种方式，其中+=和extend()直接修改原列表，+生成新列表，extend()效率最高。

3.7.1 `+`操作符：生成新列表（不修改原列表）

功能：将两个列表拼接为新列表，原列表保持不变，适合需要保留原列表的场景。语法：新列表名 = 列表1 + 列表2

a = [1, 3.0, 2.2]
b = ["Python", 10, 20]
# 拼接生成新列表
c = a + b
# 原列表不变
print(a)  # 输出：[1, 3.0, 2.2]
print(b)  # 输出：['Python', 10, 20]
# 新列表
print(c)  # 输出：[1, 3.0, 2.2, 'Python', 10, 20]

3.7.2 `+=`操作符：拼接到原列表（修改原列表）

功能：将列表 2 的元素拼接到列表 1 的末尾，直接修改列表 1，无返回值，原列表 2 不变。语法：列表1 += 列表2

a = [1, 3.0, 2.2]
b = ["Python", 10, 20]
# 拼接到原列表a
a += b
print(a)  # 输出：[1, 3.0, 2.2, 'Python', 10, 20]
print(b)  # 输出：['Python', 10, 20]

3.7.3 `extend()`方法：高效拼接到原列表（推荐）

功能：与+=效果一致，将可迭代对象的元素拼接到原列表末尾，效率比+=更高（+=会生成临时列表，extend()直接修改原列表，无额外内存开销）。语法：列表1.extend(列表2)

a = [1, 3.0, 2.2]
b = ["Python", 10, 20]
# 高效拼接
a.extend(b)
print(a)  # 输出：[1, 3.0, 2.2, 'Python', 10, 20]
print(b)  # 输出：['Python', 10, 20]

三者对比：

表格

方式	是否修改原列表	是否生成新列表	效率	适用场景
`+`	否	是	一般	需保留原列表，生成新列表
`+=`	是	否	中等	无需保留原列表，简单拼接
`extend()`	是	否	最高	无需保留原列表，大批量拼接

四、列表的常用内置方法 / 函数

除了上述核心操作，Python 为列表提供了大量内置成员方法和全局函数，用于实现排序、反转、计数、复制等功能，以下是最常用的方法 / 函数，按功能分类整理，附语法和案例。

4.1 列表专属成员方法

列表的成员方法通过列表名.方法名()调用，直接操作列表，部分方法有返回值，部分直接修改原列表，整理如下：

表格

方法名	语法	核心功能	是否修改原列表	返回值
`append()`	`lst.append(x)`	末尾追加单个元素 x	是	无
`insert()`	`lst.insert(i, x)`	在下标 i 处插入单个元素 x	是	无
`extend()`	`lst.extend(iter)`	批量追加可迭代对象 iter 的元素	是	无
`pop()`	`lst.pop(i=-1)`	删除下标 i 的元素，默认删除末尾	是	被删除的元素
`remove()`	`lst.remove(x)`	删除第一个匹配 x 的元素	是	无
`clear()`	`lst.clear()`	清空列表所有元素，保留列表对象	是	无
`index()`	`lst.index(x,start,stop)`	获取 x 在 [start,stop) 内首次出现的下标	否	匹配元素的下标
`count()`	`lst.count(x)`	统计元素 x 在列表中出现的次数	否	出现次数（整数）
`reverse()`	`lst.reverse()`	将列表元素原地反转（倒序）	是	无
`sort()`	`lst.sort(key=None, reverse=False)`	列表原地排序	是	无
`copy()`	`lst.copy()`	复制列表，生成浅拷贝新列表	否	新的列表对象

重点方法案例讲解：

（1）`count()`：统计元素出现次数

a = [1, 3.0, 2.2, 3.0, 3.0, "Python"]
# 统计3.0出现的次数
print(a.count(3.0))  # 输出：3
# 统计不存在的元素，返回0
print(a.count(10))   # 输出：0

（2）`reverse()`：原地反转列表

a = [1, 2, 3, 4, 5]
a.reverse()
print(a)  # 输出：[5, 4, 3, 2, 1]

（3）`sort()`：原地排序（数字 / 字符串）

参数说明：

key：排序依据，默认None（按元素本身排序），可指定函数（如key=len按字符串长度排序）
reverse：排序方向，False（默认，升序），True（降序）

# 数字列表排序
num_lst = [5, 2, 9, 1, 3]
# 升序（默认）
num_lst.sort()
print(num_lst)  # 输出：[1, 2, 3, 5, 9]

# 降序
num_lst.sort(reverse=True)
print(num_lst)  # 输出：[9, 5, 3, 2, 1]

# 字符串列表排序（按字母序）
str_lst = ["Python", "Java", "C", "JavaScript"]
str_lst.sort(key=len)  # 按字符串长度排序
print(str_lst)  # 输出：['C', 'Java', 'Python', 'JavaScript']

（4）`copy()`：列表浅拷贝

生成新列表，与原列表内容相同，但内存地址不同，修改新列表不会影响原列表（浅拷贝仅适用于一维列表，多维列表需用深拷贝）。

a = [1, 2, 3]
b = a.copy()
# 内容相同
print(b)  # 输出：[1, 2, 3]
# 内存地址不同
print(a is b)  # 输出：False
# 修改新列表，原列表不变
b[0] = 100
print(a)  # 输出：[1, 2, 3]
print(b)  # 输出：[100, 2, 3]

4.2 操作列表的全局内置函数

Python 全局内置函数可直接作用于列表，实现获取长度、最值、求和等功能，无需通过列表调用，常用如下：

表格

函数名	语法	核心功能	适用场景
`len()`	`len(lst)`	获取列表的元素个数（长度）	所有列表
`max()`	`max(lst)`	获取列表中的最大值（元素需为同一可比较类型，如纯数字、纯字符串）	数字 / 字符串列表
`min()`	`min(lst)`	获取列表中的最小值（元素需为同一可比较类型）	数字 / 字符串列表
`sum()`	`sum(lst)`	计算列表中所有数字元素的和	纯数字列表
`sorted()`	`sorted(lst, key=None, reverse=False)`	对列表排序，生成新列表	所有可迭代对象
`enumerate()`	`enumerate(lst, start=0)`	将列表转换为 "下标 - 元素" 的可迭代对象	遍历需要同时获取下标和元素

重点函数案例讲解：

（1）`len()`/`max()`/`min()`/`sum()`：基础统计

a = [1, 5, 3, 9, 2]
print(len(a))  # 输出：5（长度）
print(max(a))  # 输出：9（最大值）
print(min(a))  # 输出：1（最小值）
print(sum(a))  # 输出：20（求和）

（2）`sorted()`：排序生成新列表（与`sort()`的区别）

sorted()生成新列表，不修改原列表；sort()原地排序，修改原列表。

a = [5, 2, 9, 1]
# sorted()生成新列表，原列表不变
b = sorted(a)
print(a)  # 输出：[5, 2, 9, 1]
print(b)  # 输出：[1, 2, 5, 9]

# sort()原地排序，修改原列表
a.sort()
print(a)  # 输出：[1, 2, 5, 9]

（3）`enumerate()`：遍历下标 + 元素（高效）

替代 “按下标遍历” 的繁琐写法，直接获取下标和元素，start指定下标起始值（默认0）。

a = ["Python", "Java", "C"]
# 基础使用：下标从0开始
for idx, elem in enumerate(a):
    print(f"下标{idx}：{elem}")

# 进阶使用：下标从1开始
print("-"*20)
for idx, elem in enumerate(a, start=1):
    print(f"第{idx}个元素：{elem}")

输出：

下标0：Python
下标1：Java
下标2：C
--------------------
第1个元素：Python
第2个元素：Java
第3个元素：C

五、列表的高级特性

5.1 列表推导式（快速生成列表，推荐）

列表推导式是 Python 特有的快速生成列表的语法，用一行代码替代循环 + 追加的繁琐操作，简洁、高效、可读性强，是开发中高频使用的技巧。核心语法：[表达式 for 临时变量 in 可迭代对象 if 条件判断]

无条件判断：生成基于可迭代对象的新列表
有条件判断：仅生成满足条件的元素列表
多重循环：嵌套循环生成列表

案例讲解：

# 1. 无条件：生成1-10的整数列表（替代list(range(1,11))）
lst1 = [i for i in range(1, 11)]
print(lst1)  # 输出：[1,2,3,4,5,6,7,8,9,10]

# 2. 有条件：生成1-10的偶数列表
lst2 = [i for i in range(1, 11) if i % 2 == 0]
print(lst2)  # 输出：[2,4,6,8,10]

# 3. 表达式处理：生成1-5的平方列表
lst3 = [i**2 for i in range(1, 6)]
print(lst3)  # 输出：[1,4,9,16,25]

# 4. 多重循环：生成两个列表的元素组合
lst4 = [f"{x}_{y}" for x in [1,2] for y in ["a","b"]]
print(lst4)  # 输出：['1_a', '1_b', '2_a', '2_b']

5.2 列表的浅拷贝与深拷贝

（1）浅拷贝（`copy()`/ 切片`[:]`/`list()`）

仅复制列表的表层元素，若列表包含嵌套可变对象（如子列表、字典），修改嵌套对象会同时影响原列表和新列表，适用于一维列表。

a = [1, 2, [3, 4]]
# 浅拷贝
b = a.copy()
# 修改表层元素：原列表不变
b[0] = 100
print(a)  # 输出：[1, 2, [3, 4]]
print(b)  # 输出：[100, 2, [3, 4]]

# 修改嵌套子列表：原列表和新列表同时改变
b[2][0] = 300
print(a)  # 输出：[1, 2, [300, 4]]
print(b)  # 输出：[100, 2, [300, 4]]

（2）深拷贝（`copy.deepcopy()`）

复制列表的所有层级元素，包括嵌套对象，生成完全独立的新列表，修改新列表不会影响原列表，适用于多维 / 嵌套列表，需导入copy模块。

import copy
a = [1, 2, [3, 4]]
# 深拷贝
b = copy.deepcopy(a)
# 修改嵌套子列表：原列表不变
b[2][0] = 300
print(a)  # 输出：[1, 2, [3, 4]]
print(b)  # 输出：[1, 2, [300, 4]]

5.3 列表作为函数参数（可变对象传参）

列表是可变对象，作为函数参数时，传递的是内存地址，函数内部修改列表会直接影响原列表（与不可变对象如数字、字符串区分）。

# 函数内部修改列表
def modify_list(lst):
    lst.append(100)
    lst[0] = 0

a = [1, 2, 3]
modify_list(a)
print(a)  # 输出：[0, 2, 3, 100]（原列表被修改）

# 避免修改原列表：传入列表的拷贝
a = [1, 2, 3]
modify_list(a.copy())
print(a)  # 输出：[1, 2, 3]（原列表不变）

六、列表使用的注意事项与避坑指南

下标越界问题：访问 / 删除 / 修改元素时，下标超出列表有效范围会抛出IndexError，切片时下标越界则自动容错，需注意区分。
remove()的匹配规则：仅删除第一个匹配的元素，若需删除所有匹配元素，需结合循环实现。
sort()与sorted()的区别：sort()原地排序（修改原列表），无返回值；sorted()生成新列表，不修改原列表，可对任意可迭代对象排序。

遍历列表时删除元素：直接遍历列表时删除元素会导致下标错乱，漏删元素，建议遍历列表的拷贝或倒序遍历。

# 错误示例：漏删元素（删除2后，3的下标变为1，循环跳过3）
a = [1,2,3,2]
for elem in a:
    if elem == 2:
        a.remove(elem)
print(a)  # 输出：[1,3,2]（仍有一个2未删除）

# 正确示例：遍历列表拷贝
a = [1,2,3,2]
for elem in a.copy():
    if elem == 2:
        a.remove(elem)
print(a)  # 输出：[1,3]

列表推导式的效率：列表推导式的执行效率远高于for循环 +append()，建议优先使用。
浅拷贝与深拷贝的选择：一维列表用浅拷贝（copy()/ 切片），多维 / 嵌套列表用深拷贝（copy.deepcopy()）。
元素的可比较性：使用max()/min()/sort()时，列表元素需为同一可比较类型（如纯数字、纯字符串），否则会抛出TypeError。

七、总结

列表是 Python 中最基础、最常用的数据类型，核心要点可总结为：

特性：有序、可变、支持重复元素、混合数据类型、动态扩容。
创建：[]直接创建（推荐）、list()函数创建，也可从其他可迭代对象转换。
核心操作：新增（append()/insert()/extend()）、删除（pop()/remove()/del/clear()）、查找（in/not in/index()/ 下标）、修改（下标赋值）、遍历（for/while）、切片（[start:stop:step]）、拼接（+/+=/extend()）。
常用方法：count()（统计）、reverse()（反转）、sort()（原地排序）、copy()（浅拷贝）是开发中高频使用的方法。
高级技巧：列表推导式快速生成列表，enumerate()高效遍历下标 + 元素，浅拷贝 / 深拷贝处理嵌套列表。
避坑重点：避免下标越界、遍历删除元素时遍历拷贝、区分sort()与sorted()、根据列表维度选择拷贝方式。

CSDN-OPC开发者社区

这里是“一人公司”的成长家园。我们提供从产品曝光、技术变现到法律财税的全栈内容，并连接云服务、办公空间等稀缺资源，助你专注创造，无忧运营。

更多推荐

从零构建 Java 智能体 RAG 系统：Milvus 向量数据库实战指南

CSDN-OPC开发者社区

提升办公效率：OpenClaw 本地自动化 AI 工具搭建实战教程

CSDN-OPC开发者社区

从Copilot到Agent：我的开发工作流正在被颠覆

总结Agent技术对开发者个体与行业带来的深远影响，展望未来“超级个体”与“AI团队”共生的开发模式。

CSDN-OPC开发者社区

所有评论(0)

查看更多评论

Yorlen_Zhang

@weixin_41147796

已为社区贡献2条内容

Python 列表 (list) 全面详解（超详细版）

Yorlen_Zhang

一、列表的核心特性

二、列表的创建

2.1 创建空列表

方式 1：使用[]直接创建（推荐，更简洁）

方式 2：使用list()内置函数创建

2.2 创建非空列表

2.3 从其他可迭代对象创建列表

三、列表的核心操作

3.1 新增列表元素

3.1.1 append()：列表末尾追加单个元素（最常用）

3.1.2 insert()：指定下标插入单个元素

3.1.3 extend()：批量追加可迭代对象的元素

3.2 删除列表元素

3.2.1 pop()：按下标删除元素（默认删除末尾）

3.2.2 remove()：按元素值删除（删除首次出现的元素）

3.2.3 clear()：清空列表所有元素

3.2.4 del关键字：按下标 / 切片批量删除（灵活度最高）

3.3 查找列表元素

3.3.1 in/not in：判断元素是否存在（返回布尔值）

3.3.2 index()：获取元素的首次出现下标

3.3.3 下标访问：直接获取指定下标元素

3.4 修改列表元素

3.5 遍历列表元素

3.5.1 for 循环：直接遍历元素（推荐）

3.5.2 for 循环：按下标遍历元素（支持修改原列表）

3.5.3 while 循环：按下标遍历元素（灵活可控）

3.6 子列表提取（切片）

3.6.1 基础切片：[start:stop]（默认步长 1）

3.6.2 简化切片：忽略start/stop边界

3.6.3 高级切片：指定步长step

3.6.4 切片越界：自动容错（不报错）

3.7 拼接列表

3.7.1 +操作符：生成新列表（不修改原列表）

3.7.2 +=操作符：拼接到原列表（修改原列表）

3.7.3 extend()方法：高效拼接到原列表（推荐）

四、列表的常用内置方法 / 函数

4.1 列表专属成员方法

（1）count()：统计元素出现次数

（2）reverse()：原地反转列表

（3）sort()：原地排序（数字 / 字符串）

（4）copy()：列表浅拷贝

4.2 操作列表的全局内置函数

（1）len()/max()/min()/sum()：基础统计

（2）sorted()：排序生成新列表（与sort()的区别）

（3）enumerate()：遍历下标 + 元素（高效）

五、列表的高级特性

5.1 列表推导式（快速生成列表，推荐）

5.2 列表的浅拷贝与深拷贝

（1）浅拷贝（copy()/ 切片[:]/list()）

（2）深拷贝（copy.deepcopy()）

5.3 列表作为函数参数（可变对象传参）

六、列表使用的注意事项与避坑指南

七、总结

所有评论(0)

温馨提示：您尚未绑定手机号

Yorlen_Zhang

方式 1：使用`[]`直接创建（推荐，更简洁）

方式 2：使用`list()`内置函数创建

3.1.1 `append()`：列表末尾追加单个元素（最常用）

3.1.2 `insert()`：指定下标插入单个元素

3.1.3 `extend()`：批量追加可迭代对象的元素

3.2.1 `pop()`：按下标删除元素（默认删除末尾）

3.2.2 `remove()`：按元素值删除（删除首次出现的元素）

3.2.3 `clear()`：清空列表所有元素

3.2.4 `del`关键字：按下标 / 切片批量删除（灵活度最高）

3.3.1 `in/not in`：判断元素是否存在（返回布尔值）

3.3.2 `index()`：获取元素的首次出现下标

3.6.1 基础切片：`[start:stop]`（默认步长 1）

3.6.2 简化切片：忽略`start`/`stop`边界

3.6.3 高级切片：指定步长`step`

3.7.1 `+`操作符：生成新列表（不修改原列表）

3.7.2 `+=`操作符：拼接到原列表（修改原列表）

3.7.3 `extend()`方法：高效拼接到原列表（推荐）

（1）`count()`：统计元素出现次数

（2）`reverse()`：原地反转列表

（3）`sort()`：原地排序（数字 / 字符串）

（4）`copy()`：列表浅拷贝

（1）`len()`/`max()`/`min()`/`sum()`：基础统计

（2）`sorted()`：排序生成新列表（与`sort()`的区别）

（3）`enumerate()`：遍历下标 + 元素（高效）

（1）浅拷贝（`copy()`/ 切片`[:]`/`list()`）

（2）深拷贝（`copy.deepcopy()`）