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