Python 序列
Python 序列
目录
- 序列的定义
- 序列的分类
- 可变序列
- 不可变序列
- 常见序列类型
- 序列通用操作
- 序列类型详解
- 列表 (List)
- 元组 (Tuple)
- 字符串 (String)
- 字节序列 (Bytes & Bytearray)
- range 对象
- 序列类型的选择
- 高级序列操作
序列的定义
在 Python 中，序列是一种有序的集合数据类型，它可以存储任意类型的对象。序列中的每个元素都分配有一个从0开始的数字索引，可以通过此索引访问特定位置的元素。
序列是 Python 中最基本和最常用的数据结构之一，为程序员提供了多种操作数据的方法。
序列的分类
Python 中的序列主要分为两大类：可变序列和不可变序列。
可变序列
可变序列是指创建后仍可修改的序列类型。
特点：
- 可以修改、添加或删除其中的元素
- 内存地址不变，但内容可变
主要类型：
- 列表 (list)
- 字节数组 (bytearray)
不可变序列
不可变序列是指创建后不能被修改的序列类型。
特点：
- 创建后不能修改其中的元素
- 任何修改操作都会创建一个新的对象
主要类型：
- 元组 (tuple)
- 字符串 (str)
- 字节序列 (bytes)
- 范围 (range)
常见序列类型
| 序列类型 | 可变性 | 描述 |
|---|---|---|
| 列表 (list) | 可变 | 由方括号 [] 包围，元素用逗号分隔 |
| 元组 (tuple) | 不可变 | 由圆括号 () 包围，元素用逗号分隔 |
| 字符串 (str) | 不可变 | 由引号包围的字符序列 |
| 字节序列 (bytes) | 不可变 | 包含单个字节的不可变序列 |
| 字节数组 (bytearray) | 可变 | 可变的字节序列 |
| 范围 (range) | 不可变 | 表示一个不可变的数字序列 |
序列通用操作
所有序列类型（无论可变还是不可变）都支持以下操作：
1. 索引 (Indexing)
使用方括号 [] 访问序列中的元素：
sequence[index] # 索引从0开始
2. 切片 (Slicing)
获取序列的子序列：
sequence[start:end:step] # 从start到end-1，步长为step
3. 连接 (Concatenation)
使用 + 运算符连接相同类型的序列：
sequence1 + sequence2
4. 重复 (Repetition)
使用 * 运算符重复序列：
sequence * n # 重复n次
5. 成员测试 (Membership)
使用 in 和 not in 运算符：
element in sequence
element not in sequence
6. 迭代 (Iteration)
使用 for 循环遍历序列中的元素：
for element in sequence:
# 处理元素
7. 长度、最小值和最大值
len(sequence) # 序列长度
min(sequence) # 序列中的最小元素
max(sequence) # 序列中的最大元素
序列类型详解
列表 (List)
列表是最常用的序列类型，可以存储不同类型的元素，并且是可变的。
创建列表：
# 空列表
my_list = []
empty_list = list()
# 包含元素的列表
numbers = [1, 2, 3, 4, 5]
mixed = [1, "Hello", 3.14, True]
列表操作：
# 添加元素
my_list.append(6) # 在末尾添加元素
my_list.insert(0, 0) # 在指定位置插入元素
my_list.extend([7, 8, 9]) # 扩展列表
# 删除元素
my_list.remove(5) # 删除第一个值为5的元素
removed = my_list.pop() # 移除并返回最后一个元素
removed = my_list.pop(0) # 移除并返回指定索引的元素
del my_list[1] # 删除指定索引的元素
# 其他常用方法
my_list.sort() # 对列表进行排序
my_list.reverse() # 反转列表
my_list.clear() # 清空列表
count = my_list.count(3) # 计算元素3出现的次数
index = my_list.index(4) # 返回元素4首次出现的索引
元组 (Tuple)
元组与列表类似，但它是不可变的，一旦创建就不能修改。
创建元组：
# 空元组
my_tuple = ()
empty_tuple = tuple()
# 包含元素的元组
numbers = (1, 2, 3, 4, 5)
single_item = (1,) # 注意：单元素元组需要逗号
mixed = (1, "Hello", 3.14, True)
元组操作：
# 元组不支持修改操作，但支持以下方法：
count = my_tuple.count(3) # 计算元素3出现的次数
index = my_tuple.index(4) # 返回元素4首次出现的索引
字符串 (String)
字符串是由字符组成的不可变序列。
创建字符串：
str1 = 'Hello'
str2 = "World"
str3 = '''多行
字符串'''
常用字符串操作：
# 字符串方法
s = "hello, world"
s.upper() # 转换为大写
s.lower() # 转换为小写
s.capitalize() # 首字母大写
s.title() # 每个单词首字母大写
s.strip() # 去除两端空白
s.split(",") # 按指定分隔符分割
s.replace("l", "L") # 替换子串
s.find("world") # 查找子串，返回索引或-1
"world" in s # 检查子串是否存在
字节序列 (Bytes & Bytearray)
bytes 是不可变的字节序列，bytearray 是可变的字节序列。
创建字节序列：
# bytes（不可变）
b1 = b'hello'
b2 = bytes([65, 66, 67]) # ASCII码：ABC
b3 = bytes.fromhex('68 65 6c 6c 6f') # "hello"的十六进制表示
# bytearray（可变）
ba1 = bytearray(b'hello')
ba2 = bytearray([65, 66, 67])
操作字节序列：
# bytes 操作（与字符串类似，但不能修改）
b = b'hello'
b.upper() # 不会修改原bytes
b.decode('utf-8') # 将bytes解码为字符串
# bytearray 操作（可以修改）
ba = bytearray(b'hello')
ba[0] = 72 # 修改元素（ASCII码为'H'）
ba.append(33) # 添加元素（ASCII码为'!'）
range 对象
range 是一个不可变序列，表示一个数字范围。
创建range对象：
r1 = range(5) # 0, 1, 2, 3, 4
r2 = range(1, 6) # 1, 2, 3, 4, 5
r3 = range(0, 10, 2) # 0, 2, 4, 6, 8
range操作：
# 主要用于for循环
for i in range(5):
print(i)
# 转换为列表查看元素
list(range(5)) # [0, 1, 2, 3, 4]
序列类型的选择
如何选择合适的序列类型？
-
列表 (list)：
- 当需要一个可以修改的有序集合
- 当需要频繁添加/删除元素
- 数据量可能变化的场景
-
元组 (tuple)：
- 当数据不需要修改
- 作为字典的键
- 函数的返回值包含多个元素
- 提高程序的安全性，防止数据被意外修改
-
字符串 (str)：
- 处理文本数据
-
bytes/bytearray：
- 处理二进制数据
- 网络通信
- 文件I/O操作
-
range：
- 在循环中生成一系列数字
- 当只需要遍历一次并且不需要存储所有值时（内存效率高）
高级序列操作
列表推导式
简洁创建列表的方法：
squares = [x**2 for x in range(10)]
even_squares = [x**2 for x in range(10) if x % 2 == 0]
生成器表达式
类似列表推导式，但更节省内存：
squares_gen = (x**2 for x in range(10))
解包操作
# 序列解包
a, b, c = [1, 2, 3]
first, *rest = (1, 2, 3, 4, 5) # first=1, rest=[2, 3, 4, 5]
sorted(), reversed() 函数
# 不修改原序列的排序和反转
sorted_list = sorted([3, 1, 4, 1, 5])
reversed_tuple = tuple(reversed((1, 2, 3)))
zip() 函数
并行遍历多个序列：
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages):
print(f"{name} is {age} years old")
序列的浅拷贝和深拷贝
import copy
# 浅拷贝
list1 = [1, 2, [3, 4]]
list2 = list1.copy() # 或 list2 = list1[:]
# 深拷贝
list3 = copy.deepcopy(list1)
总结
- 可变序列（列表、字节数组）适合需要频繁修改的场景
- 不可变序列（元组、字符串、bytes、range）提供了安全性和效率
- 所有序列类型都共享一组基本操作，但各有特殊用途和方法