目录

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() 函数分别返回字符串和列表中的元素和索引。