广西建设网站广州企业网站seo

Python 序列

目录

1. 序列的定义
2. 序列的分类
   • 可变序列
   • 不可变序列
3. 常见序列类型
4. 序列通用操作
5. 序列类型详解
   • 列表 (List)
   • 元组 (Tuple)
   • 字符串 (String)
   • 字节序列 (Bytes & Bytearray)
   • range 对象
6. 序列类型的选择
7. 高级序列操作

序列的定义

在 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]

序列类型的选择

如何选择合适的序列类型？

1. 列表 (list)：

   • 当需要一个可以修改的有序集合
   • 当需要频繁添加/删除元素
   • 数据量可能变化的场景

2. 元组 (tuple)：

   • 当数据不需要修改
   • 作为字典的键
   • 函数的返回值包含多个元素
   • 提高程序的安全性，防止数据被意外修改

3. 字符串 (str)：

   • 处理文本数据

4. bytes/bytearray：

   • 处理二进制数据
   • 网络通信
   • 文件I/O操作

5. 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）提供了安全性和效率
• 所有序列类型都共享一组基本操作，但各有特殊用途和方法