目录
1. 序列的概念
字符串（String）
列表（List）
元组（Tuple）
2. 标准类型操作符
连接操作符（+）
重复操作符（*）
索引操作符（[]）
切片操作符（[:]）
成员操作符（in 和 not in）
3. 序列的切片操作
基本切片
省略索引
切片对象
4. 序列内建函数
len() 函数
max() 函数
min() 函数
sum() 函数
sorted() 函数
reversed() 函数
enumerate() 函数
1. 序列的概念
序列是一种数据结构，它存储了一组有序的元素。这些元素可以是任何类型的对象，甚至是其他序列。在Python中，最常用的序列类型包括：
- 字符串（String）：由字符组成的序列，用于表示文本。
- 列表（List）：由任意类型的对象组成的可变序列。
- 元组（Tuple）：由任意类型的对象组成的不可变序列。
每个序列中的元素都有一个唯一的索引，可以通过索引访问特定的元素。序列的索引从0开始，正向索引从左到右依次增加，反向索引从右到左依次减少。
字符串（String）
字符串是字符的有序集合，用于表示文本信息。字符串使用单引号（'）、双引号（"）或三引号（''' 或 """）包围。字符串是不可变的，即创建后不能更改。
示例：
s = "Hello, World!"
列表（List）
列表是Python中最常用的数据结构之一，可以存储任意类型的元素。列表是可变的，可以在创建后修改其内容。列表使用方括号（[]）包围，元素之间用逗号分隔。
示例：
lst = [1, 2, 3, "Python", [5, 6]]
元组（Tuple）
元组与列表类似，但元组是不可变的，即一旦创建就不能修改其内容。元组使用圆括号（()）包围，元素之间用逗号分隔。
示例：
tup = (1, 2, 3, "Python", (5, 6))
2. 标准类型操作符
Python提供了一些标准操作符，可以用于操作序列。这些操作符包括连接、重复、索引、切片和成员资格测试。
连接操作符（+）
连接操作符用于将两个序列连接成一个新的序列。
示例：
s1 = "Hello, "
s2 = "World!"
s3 = s1 + s2 # "Hello, World!"
lst1 = [1, 2, 3]
lst2 = [4, 5, 6]
lst3 = lst1 + lst2 # [1, 2, 3, 4, 5, 6]
tup1 = (1, 2, 3)
tup2 = (4, 5, 6)
tup3 = tup1 + tup2 # (1, 2, 3, 4, 5, 6)
重复操作符（*）
重复操作符用于将序列重复指定的次数，生成一个新的序列。
示例：
s = "Hello"
s_repeated = s * 3 # "HelloHelloHello"
lst = [1, 2, 3]
lst_repeated = lst * 2 # [1, 2, 3, 1, 2, 3]
tup = (1, 2, 3)
tup_repeated = tup * 2 # (1, 2, 3, 1, 2, 3)
索引操作符（[]）
索引操作符用于访问序列中的单个元素。正向索引从0开始，反向索引从-1开始。
示例：
s = "Python"
print(s[0]) # "P"
print(s[-1]) # "n"
lst = [1, 2, 3, 4, 5]
print(lst[2]) # 3
print(lst[-2]) # 4
tup = (1, 2, 3, 4, 5)
print(tup[1]) # 2
print(tup[-3]) # 3
切片操作符（[:]）
切片操作符用于访问序列中的一部分元素，生成一个新的序列。切片的语法为 序列[开始:结束:步长]。
示例：
s = "Hello, World!"
print(s[0:5]) # "Hello"
print(s[7:12]) # "World"
print(s[::-1]) # "!dlroW ,olleH" (反转字符串)
lst = [1, 2, 3, 4, 5, 6]
print(lst[1:4]) # [2, 3, 4]
print(lst[:3]) # [1, 2, 3]
print(lst[::2]) # [1, 3, 5]
tup = (1, 2, 3, 4, 5, 6)
print(tup[2:5]) # (3, 4, 5)
print(tup[::3]) # (1, 4)
成员操作符（in 和 not in）
成员操作符用于检查元素是否存在于序列中。
示例：
s = "Hello, World!"
print("H" in s) # True
print("h" not in s) # True
lst = [1, 2, 3, 4, 5]
print(3 in lst) # True
print(6 not in lst) # True
tup = (1, 2, 3, 4, 5)
print(2 in tup) # True
print(7 not in tup) # True
3. 序列的切片操作
切片是从序列中提取子序列的操作。切片操作返回一个新的序列，不修改原序列。切片操作的语法为 序列[开始:结束:步长]。其中，开始和结束为索引位置，步长表示元素间的间隔，默认为1。
基本切片
最简单的切片操作只包含开始和结束索引。
示例：
s = "Hello, World!"
print(s[0:5]) # "Hello"
print(s[7:12]) # "World"
在上述示例中，s[::2] 每隔一个字符提取一次，而 s[::-1] 以步长-1反向提取字符，实现字符串的反转。
省略索引
当省略开始或结束索引时，Python会使用默认值。省略开始索引表示从序列的起始位置开始，省略结束索引表示到序列的末尾。
示例：
s = "Hello, World!"
print(s[:5]) # "Hello"
print(s[7:]) # "World!"
print(s[:]) # "Hello, World!" (整个字符串)
在上述示例中，s[:5] 提取从起始位置到索引4的字符，s[7:] 提取从索引7到末尾的字符。
切片对象
切片对象是通过 slice() 函数创建的，用于表示切片操作。切片对象可以用于在任何支持切片的对象中应用相同的切片。
示例：
s = "Hello, World!"
slice_obj = slice(0, 5)
print(s[slice_obj]) # "Hello"
lst = [1, 2, 3, 4, 5]
print(lst[slice_obj]) # [1, 2, 3, 4, 5]
在上述示例中，slice_obj 表示从索引0到索引4的切片。这个切片对象可以应用于字符串和列表，结果分别为 "Hello" 和 [1, 2, 3, 4, 5]。
4. 序列内建函数
Python提供了一些内建函数，用于操作和处理序列。这些函数包括：
len()：返回序列的长度。max()：返回序列中的最大值。min()：返回序列中的最小值。sum()：返回序列中所有元素的和（适用于数字序列）。sorted()：返回序列的排序副本。reversed()：返回序列的反转迭代器。enumerate()：返回序列中的元素和索引。
len() 函数
len() 函数用于返回序列的长度，即序列中元素的个数。
示例：
s = "Hello, World!"
print(len(s)) # 13
lst = [1, 2, 3, 4, 5]
print(len(lst)) # 5
tup = (1, 2, 3, 4, 5)
print(len(tup)) # 5
在上述示例中，len() 函数分别返回字符串、列表和元组的长度。
max() 函数
max() 函数用于返回序列中的最大值。对于字符串，max() 函数返回字典序中最大的字符。
示例：
s = "Hello, World!"
print(max(s)) # "r"
lst = [1, 2, 3, 4, 5]
print(max(lst)) # 5
tup = (1, 2, 3, 4, 5)
print(max(tup)) # 5
在上述示例中，max() 函数分别返回字符串、列表和元组中的最大值。
min() 函数
min() 函数用于返回序列中的最小值。对于字符串，min() 函数返回字典序中最小的字符。
示例：
s = "Hello, World!"
print(min(s)) # " "
lst = [1, 2, 3, 4, 5]
print(min(lst)) # 1
tup = (1, 2, 3, 4, 5)
print(min(tup)) # 1
在上述示例中，min() 函数分别返回字符串、列表和元组中的最小值。
sum() 函数
sum() 函数用于返回数字序列中所有元素的和。对于非数字序列，sum() 函数会抛出错误。
示例：
lst = [1, 2, 3, 4, 5]
print(sum(lst)) # 15
tup = (1, 2, 3, 4, 5)
print(sum(tup)) # 15
在上述示例中，sum() 函数分别返回列表和元组中所有元素的和。
sorted() 函数
sorted() 函数返回序列的排序副本。对于字符串，sorted() 函数返回字符按字典序排序的新列表。
示例：
s = "Hello, World!"
print(sorted(s)) # [' ', '!', ',', 'H', 'W', 'd', 'e', 'l', 'l', 'l', 'o', 'o', 'r']
lst = [5, 3, 1, 4, 2]
print(sorted(lst)) # [1, 2, 3, 4, 5]
tup = (5, 3, 1, 4, 2)
print(sorted(tup)) # [1, 2, 3, 4, 5]
在上述示例中，sorted() 函数分别返回字符串、列表和元组的排序副本。
reversed() 函数
reversed() 函数返回序列的反转迭代器。
示例：
s = "Hello, World!"
print(''.join(reversed(s))) # "!dlroW ,olleH"
lst = [1, 2, 3, 4, 5]
print(list(reversed(lst))) # [5, 4, 3, 2, 1]
tup = (1, 2, 3, 4, 5)
print(list(reversed(tup))) # [5, 4, 3, 2, 1]
在上述示例中，reversed() 函数分别返回字符串、列表和元组的反转迭代器，并通过 list() 或 join() 方法将其转换为列表或字符串。
enumerate() 函数
enumerate() 函数返回序列中的元素和索引。
示例：
s = "Hello"
for index, char in enumerate(s):
print(f"{index}: {char}")
lst = ["a", "b", "c", "d"]
for index, value in enumerate(lst):
print(f"{index}: {value}")
在上述示例中，enumerate() 函数分别返回字符串和列表中的元素和索引。
