ByteFisher

钓鱼爱好者的编程世界

Python 列表与元组

发表于 分类于 ， Waline：
本文详细讲解Python 列表与元组，涵盖Python、教程等核心知识点。「Python基础教程」系列第7篇，共20篇。适合相关开发者。附完整代码示例与实战技巧。

7.1 列表（List）基础

列表是 Python 中最常用的数据结构，是有序、可变的元素集合。

创建列表

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 空列表
empty = []

# 包含元素
numbers = [1, 2, 3, 4, 5]
fruits = ["apple", "banana", "orange"]

# 混合类型
mixed = [1, "hello", 3.14, True]

# 嵌套列表
matrix = [[1, 2], [3, 4], [5, 6]]

# list() 函数
text = "Python"
chars = list(text)
print(chars)  # ['P', 'y', 't', 'h', 'o', 'n']

7.2 列表索引与切片

列表支持索引和切片，语法与字符串相同。

1
2
3
4
5
6
7
8
9
10
11
12
fruits = ["apple", "banana", "orange", "grape", "melon"]

# 索引
print(fruits[0])    # apple
print(fruits[-1])   # melon

# 切片
print(fruits[1:3])   # ['banana', 'orange']
print(fruits[:2])    # ['apple', 'banana']
print(fruits[2:])    # ['orange', 'grape', 'melon']
print(fruits[::2])   # ['apple', 'orange', 'melon']
print(fruits[::-1])  # ['melon', 'grape', 'orange', 'banana', 'apple']

7.3 列表基本操作

修改元素

1
2
3
4
5
6
7
8
9
fruits = ["apple", "banana", "orange"]

# 修改元素
fruits[1] = "blueberry"
print(fruits)  # ['apple', 'blueberry', 'orange']

# 修改切片
fruits[1:3] = ["grape", "melon"]
print(fruits)  # ['apple', 'grape', 'melon']

拼接与重复

1
2
3
4
5
6
7
8
9
10
11
12
13
14
list1 = [1, 2, 3]
list2 = [4, 5, 6]

# 拼接
combined = list1 + list2
print(combined)  # [1, 2, 3, 4, 5, 6]

# 重复
repeated = [0] * 5
print(repeated)  # [0, 0, 0, 0, 0]

# 追加元素
list1.append(4)
print(list1)  # [1, 2, 3, 4]

7.4 列表常用方法

添加元素

1
2
3
4
5
6
7
8
9
10
11
12
13
fruits = ["apple", "banana"]

# append() - 末尾添加
fruits.append("orange")
print(fruits)  # ['apple', 'banana', 'orange']

# insert() - 指定位置插入
fruits.insert(1, "grape")
print(fruits)  # ['apple', 'grape', 'banana', 'orange']

# extend() - 追加多个元素
fruits.extend(["melon", "pear"])
print(fruits)  # ['apple', 'grape', 'banana', 'orange', 'melon', 'pear']

删除元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
fruits = ["apple", "banana", "orange", "grape"]

# remove() - 按值删除（第一个匹配）
fruits.remove("banana")
print(fruits)  # ['apple', 'orange', 'grape']

# pop() - 按索引删除（默认最后一个）
last = fruits.pop()
print(last)    # grape
print(fruits)  # ['apple', 'orange']

first = fruits.pop(0)
print(first)   # apple
print(fruits)  # ['orange']

# del - 删除元素或切片
del fruits[0]
print(fruits)  # []

# clear() - 清空列表
fruits.clear()
print(fruits)  # []

查找与统计

1
2
3
4
5
6
7
8
9
10
11
12
numbers = [1, 2, 3, 2, 4, 2, 5]

# index() - 查找索引
print(numbers.index(2))    # 1（第一个匹配的索引）
print(numbers.index(2, 2)) # 3（从索引 2 开始查找）

# count() - 统计出现次数
print(numbers.count(2))    # 3

# in - 成员检查
print(3 in numbers)        # True
print(10 in numbers)       # False

排序与反转

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
numbers = [3, 1, 4, 1, 5, 9, 2, 6]

# sort() - 原地排序
numbers.sort()
print(numbers)  # [1, 1, 2, 3, 4, 5, 6, 9]

numbers.sort(reverse=True)
print(numbers)  # [9, 6, 5, 4, 3, 2, 1, 1]

# sorted() - 返回新列表
original = [3, 1, 4]
sorted_list = sorted(original)
print(original)     # [3, 1, 4]（不变）
print(sorted_list)  # [1, 3, 4]

# reverse() - 原地反转
numbers.reverse()
print(numbers)

# reversed() - 返回迭代器
reversed_list = list(reversed(numbers))

7.5 列表推导式

列表推导式是创建列表的简洁方式。

基本语法

1
[表达式 for 变量 in 可迭代对象]

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 平方数
squares = [x**2 for x in range(1, 6)]
print(squares)  # [1, 4, 9, 16, 25]

# 偶数列表
evens = [x for x in range(10) if x % 2 == 0]
print(evens)  # [0, 2, 4, 6, 8]

# 字符串处理
words = ["hello", "world", "python"]
upper_words = [w.upper() for w in words]
print(upper_words)  # ['HELLO', 'WORLD', 'PYTHON']

# 条件表达式
numbers = [1, 2, 3, 4, 5]
result = ["偶数" if x % 2 == 0 else "奇数" for x in numbers]
print(result)  # ['奇数', '偶数', '奇数', '偶数', '奇数']

7.6 列表遍历

1
2
3
4
5
6
7
8
9
10
11
12
13
fruits = ["apple", "banana", "orange"]

# 直接遍历
for fruit in fruits:
    print(fruit)

# 带索引遍历
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# 带索引遍历（从 1 开始）
for i, fruit in enumerate(fruits, start=1):
    print(f"{i}. {fruit}")

7.7 列表拷贝

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
original = [1, 2, 3]

# 错误：引用赋值（指向同一对象）
ref = original
ref.append(4)
print(original)  # [1, 2, 3, 4]（被修改）

# 正确：浅拷贝
copy1 = original[:]
copy2 = list(original)
copy3 = original.copy()

copy1.append(5)
print(original)  # [1, 2, 3, 4]（不变）
print(copy1)     # [1, 2, 3, 4, 5]

7.8 元组（Tuple）

元组是有序、不可变的元素集合。

创建元组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 空元组
empty = ()

# 单元素元组（注意逗号）
single = (1,)

# 多元素元组
point = (3, 4)
colors = ("red", "green", "blue")

# 省略括号
coords = 1, 2, 3
print(coords)  # (1, 2, 3)

# tuple() 函数
text = "Python"
t = tuple(text)
print(t)  # ('P', 'y', 't', 'h', 'o', 'n')

元组操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
t = (1, 2, 3, 2, 4)

# 索引
print(t[0])    # 1
print(t[-1])   # 4

# 切片
print(t[1:3])  # (2, 3)

# 方法
print(t.count(2))  # 2
print(t.index(3))  # 2

# 成员检查
print(3 in t)  # True

元组解包

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 基本解包
point = (3, 4)
x, y = point
print(x, y)  # 3 4

# 多变量解包
a, b, c = 1, 2, 3
print(a, b, c)  # 1 2 3

# * 解包
numbers = (1, 2, 3, 4, 5)
first, *middle, last = numbers
print(first)    # 1
print(middle)   # [2, 3, 4]
print(last)     # 5

# 交换变量
x = 10
y = 20
x, y = y, x
print(x, y)  # 20 10

7.9 列表 vs 元组

特性 列表（List） 元组（Tuple）
语法 [] ()
可变性 可变 不可变
性能 较慢 较快
用途 存储同类数据 存储异构数据
方法 丰富 仅 count/index

选择建议

  • 使用列表存储需要修改的数据集合
  • 使用元组存储固定数据（如坐标、配置）
  • 元组可作为字典键，列表不行

7.10 本章小结

  • 列表是有序、可变的集合，支持索引、切片、修改
  • 常用方法：append()、insert()、remove()、pop()、sort()
  • 列表推导式：[表达式 for 变量 in 可迭代对象 if 条件]
  • 元组是有序、不可变的集合，适合存储固定数据
  • 元组解包可简化多变量赋值

练习题

  1. 创建一个包含 10 个随机数的列表，找出最大值和最小值
  2. 使用列表推导式生成 1 到 100 所有能被 3 或 5 整除的数
  3. 输入一个列表，将其反转（不使用 reverse()）
  4. 以下代码输出什么？
    1
    2
    3
    t = (1, 2, 3)
    a, b, c = t
    print(a + b + c)
ByteFisher
分享编程技术 · 记录钓鱼乐趣
扫码关注
▸ 扫码关注 ◂
相关文章
Python 综合实战项目2024-12-10本文详细讲解Python 综合实战项目，涵盖Python、教程等核心知识点。「Python基础教程」系列第20篇，共20篇。适合相关开发者。附完整代码示例与实战技巧。Python 正则表达式2024-12-08本文详细讲解Python 正则表达式，涵盖Python、教程等核心知识点。「Python基础教程」系列第19篇，共20篇。适合相关开发者。附完整代码示例与实战技巧。Python 列表推导与生成器2024-12-06本文详细讲解Python 列表推导与生成器，涵盖Python、教程等核心知识点。「Python基础教程」系列第18篇，共20篇。适合相关开发者。附完整代码示例与实战技巧。Python 常用标准库2024-12-04本文详细讲解Python 常用标准库，涵盖Python、教程等核心知识点。「Python基础教程」系列第17篇，共20篇。适合相关开发者。附完整代码示例与实战技巧。Python 面向对象高级2024-12-02本文详细讲解Python 面向对象高级，涵盖Python、教程等核心知识点。「Python基础教程」系列第16篇，共20篇。适合相关开发者。附完整代码示例与实战技巧。Python 面向对象进阶2024-11-30本文详细讲解Python 面向对象进阶，涵盖Python、教程等核心知识点。「Python基础教程」系列第15篇，共20篇。适合相关开发者。附完整代码示例与实战技巧。
Python基础教程 系列
第 7/20 篇
Python 字符串操作Python 字典与集合
分享：
淡水鱼
淡水鱼
钓鱼爱好者 & Unity 游戏开发者，分享编程技术与钓鱼经验。