在 Python 编程中，序列是一类可存放多个元素的数据容器，列表、元组、字符串是最典型的序列类型。本文将结合课堂笔记，详细拆解序列的切片操作、拼接与重复、字符串专属操作三大核心知识点，帮助大家系统掌握序列的使用技巧。

一、序列的基础认知

       序列的核心共性：支持下标（索引）访问，下标从 0 开始；但不同序列存在特性差异 —— 列表是可变序列，字符串、元组是不可变序列（字符串无法直接修改元素，元组创建后也无法修改）。

1.什么是序列？
就是能够存放元素的数据容器：列表，元组，字符串都是序列
2.什么是切片？
从序列里面按照指定范围，取出一部分元素，形成一个新的序列

二、序列的切片操作

注意事项：
    1.开始索引如果不写值，默认从0开始
    2.结束索引如果不写值，默认截取序列末尾
    3.步长如果不写值，默认为1
    4.如果结束索引大于序列长度，默认截取到序列末尾
    5.如果起始索引大于结束索引，纳么步长必须为负数，否则结果为空列表
#基本语法 序列[开始索引：结束索引：步长],切片的操作是左闭右开

场景	规则	示例（以列表 li = [10,20,30,40,50,50,60,7,82] 为例）
省略开始索引	默认从 0 开始	li[:5:1] → [10,20,30,40,50]
省略结束索引	默认截取到序列末尾	li[2::1] → [30,40,50,50,60,7,82]
省略步长	默认为 1	li[0:5] → [10,20,30,40,50]
结束索引超序列长度	截取到序列末尾	li[5:20] → [50,60,7,82]
起始索引 > 结束索引	步长必须为负数（反向截取），否则返回空序列	li[5:2:-1] → [50,50,40]；li[12:2:2] → []

# 列表切片
li = [10,20,30,40,50,50,60,7,82]
print(li[0:5:2])  # [10,30,50]（步长2，间隔截取）
print(li[::-1])   # [82,7,60,50,50,40,30,20,10]（步长-1，序列反转）

# 元组切片
t1 = (10,20,30,40,50,50,60,7,82)
print(t1[:4:2])   # (10,30)

# 字符串切片
s1 = 'welcome to python'
print(s1[8:3:-1]) # ' ot em'（反向截取）

三、序列的拼接与重复

1. 序列拼接（+）

将多个同类型序列合并为一个新序列：

# 列表拼接
l1 = [10,20,30,40,50]
l2 = [10,20,30,40,50]
print(l1 + l2)  # [10,20,30,40,50,10,20,30,40,50]

# 字符串拼接
s1 = 'hello'
s2 = 'world'
print(s1 + s2)  # helloworld

2. 序列重复（*）

l1 = [10,20,30,40,50]
print(l1 * 2)   # [10,20,30,40,50,10,20,30,40,50]
print('hello' * 3)  # hellohellohello

四、字符串专属操作

1. 下标访问与不可变性

msg = 'hello world'
print(msg[5])  # 输出空格（下标5对应字符）
# msg[0] = 'H'  # 报错！字符串不可直接修改

2. 核心专属方法

方法	功能	示例
index(字符)	查找指定字符第一次出现的下标	msg.index('h') → 0
split(分隔符)	按分隔符分割字符串，返回列表	'python@java@web'.split('@') → ['python','java','web']
replace(旧字符, 新字符)	替换指定字符 / 子串，返回新字符串（原字符串不变）	'a@b'.replace('@','-') → 'a-b'
count(字符)	统计指定字符出现次数	'a@b@c'.count('@') → 2
strip(字符)	从字符串两端删除指定字符，直到遇到非指定字符	'66hello666'.strip('6') → hello

3. 字符串通用操作

msg = 'hello world'
print(max(msg))    # 输出'w'（字符ASCII码最大值）
print(min(msg))    # 输出空格（ASCII码最小值）
print(len(msg))    # 输出11（字符串长度）
print(sorted(msg)) # 输出按ASCII码排序的列表 → [' ','d','e','h','l','l','l','o','o','r','w']

4. 字符串遍历

msg = 'hello world'
# while循环遍历
index = 0
while index < len(msg):
    print(msg[index])
    index += 1

# for循环（推荐）
for char in msg:
    print(char)

五、集合的核心特性

1. 基础特性

1 无序性：集合无下标概念，无法通过索引访问元素；
2 唯一性：自动去重，重复元素仅保留一个（特殊：布尔值True等价于1、False等价于0，共存时也会去重，保留先出现的元素）；
3 元素类型限制：集合中的元素必须是不可变类型（数字、字符串、元组、不可变集合），可变类型（列表、字典、普通集合）不能作为集合元素。

2. 集合的分类

类型	定义方式	核心特点
可变集合（set）	{元素1, 元素2} 或 set()（空集合）	可增删改元素，无序、去重
不可变集合（frozenset）	frozenset(可迭代对象)（如列表、元组、普通集合）	元素不可修改，其余特性与可变集合一致

注意：定义空集合必须用set()，直接写{}会被识别为字典类型

六、集合的基础操作（增删改查）

1. 新增元素

方法	语法	说明
add()	集合.add(值)	向集合添加单个值，重复添加无效果（不会报错）
update()	集合.update(可迭代对象)	向集合添加多个值，参数需为可迭代对象（列表、元组、字符串、集合等）

s1 = {1,2,3}
s1.add(4)  # s1: {1,2,3,4}
s1.update('hello')  # 拆分字符串添加，s1: {1,2,3,4,'h','e','l','o'}
s1.update([11,22])  # 添加列表元素，s1: {1,2,3,4,'h','e','l','o',11,22}

2. 删除元素

方法	语法	说明
remove()	集合.remove(值)	删除指定值，值不存在会报错
discard()	集合.discard(值)	删除指定值，值不存在不会报错（推荐优先使用）
pop()	集合.pop()	随机删除一个元素，返回被删除的元素
clear()	集合.clear()	清空集合所有元素

s1 = {1,2,3,'h'}
s1.remove('h')  # s1: {1,2,3}
s1.discard(99)  # 无报错，s1仍为{1,2,3}
del_val = s1.pop()  # 随机删除，如删除1，del_val=1，s1: {2,3}
s1.clear()  # s1: set()

3. 修改元素

集合无专门的 “修改” 方法，需结合remove()（删除旧值）+add()（添加新值）实现：

s1 = {1,2,3}
s1.remove(1)  # 删除旧值1
s1.add('hello')  # 添加新值，s1: {2,3,'hello'}

4. 查询（成员判断）

通过成员运算符in/not in判断元素是否在集合中，返回布尔值（True/False）：

s1 = {1,2,3}
print(3 in s1)  # True
print(99 not in s1)  # True

七、集合的进阶操作（关系判断与数学运算）

1. 集合间关系判断

方法	语法	说明
issubset()	集合A.issubset(集合B)	判断 A 是否是 B 的子集（A 的所有元素都在 B 中）
issuperset()	集合A.issuperset(集合B)	判断 A 是否是 B 的超集（B 的所有元素都在 A 中）
isdisjoint()	集合A.isdisjoint(集合B)	判断 A 和 B 是否无交集，无交集返回 True

a3 = {1,2,3,4,5}
a5 = {1,2,3}
a6 = {4,5}
print(a5.issubset(a3))  # True（a5是a3的子集）
print(a3.issuperset(a6))  # True（a3是a6的超集）
print(a3.isdisjoint(a5))  # False（有交集）

2. 集合的数学运算

集合支持并集、交集、差集、对称差集，可通过方法或运算符实现：

运算类型	方法实现	运算符实现	说明
并集	集合A.union(集合B)	`A | B	取两个集合的全部元素	合并两个集合，自动去重
交集	-	A & B	取两个集合的共同元素
差集	集合A.difference(集合B)	A - B	取 A 中有、B 中没有的元素
差集（修改原集合）	集合A.difference_update(集合B)	-	直接在 A 中删除 B 的元素，无返回值
对称差集	-	A ^ B	取两个集合中 “非共同” 的元素（无交集部分）

s1 = {1,2,3,4,5}
s2 = {1,2,3,6,7,8}

# 并集
print(s1.union(s2))  # {1,2,3,4,5,6,7,8}
print(s1 | s2)  # 同上

# 交集
print(s1 & s2)  # {1,2,3}

# 差集
print(s1.difference(s2))  # {4,5}
print(s1 - s2)  # 同上
s1.difference_update(s2)  # s1被修改为{4,5}

# 对称差集
print(s1 ^ s2)  # {4,5,6,7,8}

八、总结

1.序列

1. 序列是 Python 中承载多元素的基础容器，切片是截取序列的核心操作，需牢记 “左闭右开” 和步长的作用；

2. 序列拼接 / 重复仅支持同类型，是快速扩展序列的便捷方式；

3. 字符串作为不可变序列，拥有丰富的专属方法，重点掌握分割、替换、去字符等高频操作；

4. 遍历序列可通过 while（下标控制）或 for（直接遍历元素）实现，for 循环更简洁.

2.集合

        1.特性：无序、唯一，元素需为不可变类型，分可变（set）和不可变（frozenset）两类；
        2.基础操作：增（add/update）、删（remove/discard/pop/clear）、改（remove+add）、查（in/not in）；
        3.进阶操作：子集 / 超集 / 无交集判断（issubset/issuperset/isdisjoint），并集 / 交集 / 差集 / 对称差集运算；