Python基础之列表(List)全面操作指南

发布于:2025-07-06 ⋅ 阅读:(15) ⋅ 点赞:(0)

列表(List)是 Python 中最常用的序列类型之一,它可以存储多个不同类型的元素,并且支持动态修改。本文将详细讲解列表的基本特性、常用操作、高级技巧及注意事项,帮助你熟练掌握列表的使用。

一、列表的基本特性

1. 列表的类型

列表属于 list 类型,用方括号 [] 表示,元素之间用逗号分隔,支持存储整数、字符串、甚至其他列表等任意数据类型。

# 查看列表类型
a = [1, 2, '3', 4, "python"]
print(type(a))  # <class 'list'>

2. 列表的可变性

与字符串的不可变性不同,列表是可变序列,可以直接修改、新增、删除元素,无需创建新对象。

二、列表的基础访问

1. 下标访问

通过下标(索引)获取单个元素,规则与字符串一致:

  • 正向索引:从左到右,从 0 开始
  • 反向索引:从右到左,从 -1 开始
a = [1, 2, '3', 4, "python"]
print(a[3])  # 4(正向索引:第4个元素)
print(a[-2])  # 4(反向索引:从右数第2个元素)

2. 切片操作

截取列表的一部分,遵循 **“包前不包后”** 原则,支持指定步长。

a = [1, 2, '3', 4, "python"]
print(a[3:])        # [4, 'python'](从下标3到结尾)
print(a[:3])        # [1, 2, '3'](从开头到下标2)
print(a[1:4:2])     # [2, 4](步长为2,截取下标1、3)

3. 迭代遍历

列表是可迭代对象,可通过 for 循环逐个访问元素。

a = [1, 2, '3', 4, "python"]
for i in a:
    print(i)  # 依次输出:1、2、'3'、4、"python"

三、列表的核心操作

1. 新增元素

列表提供多种新增元素的方法,适用于不同场景:

方法 说明 示例
append(x) 在列表末尾添加单个元素 a.append("哈哈") → [1, 2, '3', 4, 'python', '哈哈']
extend(iter) 将可迭代对象(列表、字符串等)的元素逐个添加到末尾 a.extend("this") → [..., 't', 'h', 'i', 's']
insert(index, x) 在指定下标位置插入元素 a.insert(1, "is") → [1, 'is', 2, '3', 4, 'python', ...]
+ 运算符 拼接两个列表(生成新列表) a + ['java', 'web'] → [1, 2, '3', 4, 'python', 'java', 'web']

2. 修改元素

通过下标直接赋值修改元素。

a = [1, 2, '3', 4, "python"]
a[2] = "T"  # 将下标2的元素改为"T"
print(a)  # [1, 2, 'T', 4, 'python']

3. 查询元素

判断元素是否存在或获取元素位置:

  • in / not in:判断元素是否在列表中
  • index(x):返回第一个匹配元素的下标(元素不存在则报错)
  • count(x):统计元素出现的次数
a = [1, 2, '3', 4, "python", "python"]
print("3" in a)          # True(元素存在)
print("python" not in a) # False(元素存在)
print(a.index("python")) # 4(第一个"python"的下标)
print(a.count("python")) # 2("python"出现2次)

4. 删除元素

根据需求选择删除方式:

方法 说明 示例
del list[index] 删除指定下标的元素 del a[0] → 删除下标 0 的元素
pop(index) 删除指定下标的元素并返回该元素(默认删除最后一个) a.pop(2) → 删除下标 2 的元素,返回被删值
remove(x) 删除第一个匹配的元素(无返回值) a.remove("python") → 删除第一个 "python"
a = [1, 2, '3', 4, "python", "python"]

# del 删除
del a[0]
print(a)  # [2, '3', 4, 'python', 'python']

# pop 删除
b = [1, 2, '3', 4, "python"]
b.pop()  # 默认删除最后一个元素
print(b)  # [1, 2, '3', 4]

# remove 删除
c = [1, 2, '3', 4, "python"]
c.remove("python")
print(c)  # [1, 2, '3', 4]

5. 排序与反转

  • sort():对列表元素排序(默认升序,直接修改原列表)
  • reverse():反转列表元素的顺序(直接修改原列表)
# 排序
a = [1, 2, 3, 8, -1, 9]
a.sort()
print(a)  # [-1, 1, 2, 3, 8, 9](升序)

# 反转
b = [1, 2, 3, 8, -1, 9]
b.reverse()
print(b)  # [9, -1, 8, 3, 2, 1]

四、列表的高级特性

1. 列表推导式

一种简洁创建列表的方式,格式为:

  • 基础格式:[表达式 for 变量 in 可迭代对象]
  • 带条件格式:[表达式 for 变量 in 可迭代对象 if 条件]

 

# 示例1:生成元素乘以5的列表
li = [1, 2, 3, 4, 5, 6]
result = [i * 5 for i in li]
print(result)  # [5, 10, 15, 20, 25, 30]

# 示例2:筛选1-10中的奇数
odd_list = [i for i in range(1, 11) if i % 2 == 1]
print(odd_list)  # [1, 3, 5, 7, 9]

# 示例3:批量添加元素
[li.append(i) for i in range(7, 10)]
print(li)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

2. 列表嵌套

列表中的元素可以是另一个列表,形成嵌套结构,可通过多级下标访问。

li = [1, 2, 3, [4, 5, 6]]  # 嵌套列表
print(li[3])       # [4, 5, 6](访问嵌套的子列表)
print(li[3][0])    # 4(访问子列表的第一个元素)
print(li[3][1:])   # [5, 6](子列表切片)

3. 列表比较

需通过 operator 模块的 eq 方法比较两个列表是否完全相等(元素及顺序均相同)。

import operator
a = [1, 2]
b = [2, 3]
c = [2, 3]
print(operator.eq(a, b))  # False(a与b不相等)
print(operator.eq(c, b))  # True(c与b完全相等)

五、列表的复制:赋值、浅拷贝与深拷贝 

在处理列表时,复制操作的行为差异可能导致意外结果,需明确三者的区别:

1. 直接赋值(完全共享资源)

将一个列表赋值给另一个变量时,两者指向同一个内存地址,修改其中一个会影响另一个。

li = [1, 2, 3, 4]
li2 = li  # 直接赋值,共享内存地址

li.append(5)  # 修改原列表
print(f'li: {li}, id(li): {id(li)}')      # li: [1, 2, 3, 4, 5], id(li): 1721799677504
print(f'li2: {li2}, id(li2): {id(li2)}')  # li2: [1, 2, 3, 4, 5], id(li2): 1721799677504
# 两者id相同,修改同步生效

2. 浅拷贝(数据半共享)

通过 copy.copy() 实现,创建新列表对象,但嵌套的子列表仍共享原内存地址

  • 外层元素修改互不影响
  • 嵌套层元素修改会同步影响
import copy
li = [1, 2, 3, [4, 5, 6]]  # 含嵌套列表
li2 = copy.copy(li)  # 浅拷贝

# 修改外层元素(互不影响)
li.append(7)
print(f'li: {li}, id(li): {id(li)}')      # li: [1, 2, 3, [4, 5, 6], 7], id(li): 1721799810944
print(f'li2: {li2}, id(li2): {id(li2)}')  # li2: [1, 2, 3, [4, 5, 6]], id(li2): 1721799806272

# 修改嵌套层元素(同步影响)
li[3].append(7)  # 操作嵌套子列表
print(f'li[3]: {li[3]}, id(li[3]): {id(li[3])}')      # li[3]: [4, 5, 6, 7], id(li[3]): 1721799685760
print(f'li2[3]: {li2[3]}, id(li2[3]): {id(li2[3])}')  # li2[3]: [4, 5, 6, 7], id(li2[3]): 1721799685760
# 嵌套子列表id相同,修改同步生效

3. 深拷贝(数据完全不共享)

通过 copy.deepcopy() 实现,完全复制所有元素(包括嵌套层),创建独立的内存空间,修改互不影响。

import copy
li = [1, 2, 3, [4, 5, 6]]
li2 = copy.deepcopy(li)  # 深拷贝

# 修改外层元素(互不影响)
li.append(7)
print(f'li: {li}, id(li): {id(li)}')      # li: [1, 2, 3, [4, 5, 6], 7], id(li): 1721799813440
print(f'li2: {li2}, id(li2): {id(li2)}')  # li2: [1, 2, 3, [4, 5, 6]], id(li2): 1721799685888

# 修改嵌套层元素(互不影响)
li[3].append(7)
print(f'li[3]: {li[3]}, id(li[3]): {id(li[3])}')      # li[3]: [4, 5, 6, 7], id(li[3]): 1721799817152
print(f'li2[3]: {li2[3]}, id(li2[3]): {id(li2[3])}')  # li2[3]: [4, 5, 6], id(li2[3]): 1721799810944
# 嵌套子列表id不同,修改互不影响

六、补充实用方法

1. 列表拼接与重复

  • +:拼接两个列表(生成新列表)
  • *:重复列表元素指定次数(生成新列表)
a = [1, 2]
b = [3, 4]
print(a + b)    # [1, 2, 3, 4](拼接)
print(a * 3)    # [1, 2, 1, 2, 1, 2](重复3次)

2. 清空列表

clear() 方法用于清空列表中的所有元素。

a = [1, 2, 3]
a.clear()
print(a)  # []

3. 复制列表

copy() 方法用于创建列表的浅拷贝(仅复制表层元素)。

a = [1, 2, [3, 4]]
b = a.copy()
b[0] = 100
b[2][0] = 300
print(a)  # [1, 2, [300, 4]](子列表元素会被修改,因浅拷贝共享嵌套对象)