Python序列的公共API指的就是，之前所学过的Python序列，如：列表、元组、字典等，基本上都支持的操作。

总结如下：

1、运算符

运算符	描述	支持的容器类型
+	合并	字符串、列表、元组
*	复制	字符串、列表、元组
in	元素是否存在	字符串、列表、元组、字典
not in	元素是否不存在	字符串、列表、元组、字典

@1、+加号

+可以将两个序列拼接为一个序列。

# 1. 字符串 `+`号

str1 = 'aa'

str2 = 'bb'

str3 = str1 + str2

print(str3)  # aabb

# 2. 列表 `+`号

list1 = [1, 2]

list2 = [10, 20]

list3 = list1 + list2

print(list3)  # [1, 2, 10, 20]

# 3. 元组 `+`号

t1 = (100, 200)

t2 = (10, 20)

t3 = t1 + t2

print(t3)  # (100, 200, 10, 20)

# 4.字典 `+`号

# 结果：TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

dict1 = {'name': 'Python'}

dict2 = {'age': 30}

dict3 = dict1 + dict2

print(dict3)  # 异常

@2、*乘号

可以将序列重复指定的次数。

# 1. 字符串

# 结果：----------

print('-' * 10) 

# 2. 列表

# 结果：['hello', 'hello', 'hello', 'hello']

list1 = ['hello']

print(list1 * 4)  

# 3. 元组

# 结果：('world', 'world', 'world', 'world')

t1 = ('world',)

print(t1 * 4) 

# 字典

# 结果：TypeError: unsupported operand type(s) for *: 'dict' and 'int'

dict1 = {'name': 'Python'}

print(dict1 * 4)  # 异常

@3、in或not in

# 1. 字符串

print('a' in 'abcd')  # True

print('a' in 'hijk')  # False

print('a' not in 'abcd')  # False

print('a' not in 'hijk')  # True

# 2. 列表

list1 = ['a', 'b', 'c', 'd']

list2 = ['h', 'i', 'j', 'k']

print('a' in list1)  # True

print('a' in list2)  # False

print('a' not in list1)  # False

print('a' not in list2)  # True

# 3. 元组

t1 = ('a', 'b', 'c', 'd')

t2 = ('i', 'j', 'h', 'k')

print('a' in t1)  # True

print('a' in t2)  # False

print('a' not in t1)  # False

print('a' not in t2)  # True

# 4. 字典

dict1 = {'name': 'Python', 'age': 30}

print('name' in dict1)  # True

print('name' not in dict1)  # False

print('name' in dict1.keys())  # True

print('name' in dict1.values())  # False

2、公共方法

函数	描述
len()	计算容器中元素个数
del或del()	删除
max()	返回容器中元素最大值
min()	返回容器中元素最小值
range(start, end, step)	生成从start到end的数字，步长为 step，供for循环使用
enumerate()	函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

@1、len()方法

# 1. 字符串

str1 = 'abcdefg'

print(len(str1))  # 7

# 2. 列表

list1 = [10, 20, 30, 40]

print(len(list1))  # 4

# 3. 元组

t1 = (10, 20, 30, 40, 50)

print(len(t1))  # 5

# 4. 集合

s1 = {10, 20, 30}

print(len(s1))  # 3

# 5. 字典

dict1 = {'name': 'Rose', 'age': 18}

print(len(dict1))  # 2

@2、del和del()

# del和del()都能删除一个序列对象，

# 也能删除序列中的一个元素

# 1. 字符串

# 不同通过del(str1[0])或del str1[0]，删除字符串中的字符。

# 结果：NameError: name 'str1' is not defined

str1 = 'abcdefg'

# del(str1)

del str1

print(str1)

# 2. 列表（元组同理）

list1 = [10, 20, 30, 40]

# 删除列表中的某一元素

# del(list1[0])

del list1[0]

print(list1)  # [20, 30, 40]

# 删除列表

# del(list1)

del list1

# 3.字典

dict1 = {'name': 'TOM', 'age': 18}

# 删除字典中的某一元素

# del(dict1['name'])

del dict1['name']

# 删除字典

# del(dict1)

del dict1

@3、max()方法

# 返回容器中元素最大值

# 1. 字符串

str1 = 'abcdefg'

print(max(str1))  # g

# 2. 列表

list1 = [10, 20, 30, 40]

print(max(list1))  # 40

@4、min()方法

# 返回容器中元素最小值

# 1. 字符串

str1 = 'abcdefg'

print(min(str1))  # a

# 2. 列表

list1 = [10, 20, 30, 40]

print(min(list1))  # 10

@5、range()

range()是一个函数，可以用来生成一个可迭代的自然数的序列。

语法：

range(start, end, step)

生成从start到end的数字，前闭后开。

步长为step，步长可以省略，默认为1，

range()函数和切片使用方式同理，包括步长可以是负数，

步长要和数字升降的方向一致。

示例：

# range(start, end, step)

# 1 2 3 4 5 6 7 8 9

for i in range(1, 10, 1):

    print(i, end=' ')

# 1 3 5 7 9

for i in range(1, 10, 2):

    print(i, end=' ')

# 1. 如果不写开始，默认从0开始

# 2. 如果不写步长，默认为1

# 0 1 2 3 4 5 6 7 8 9

for i in range(10):

    print(i, end=' ')

"""

range(0, 10, -1)，中0到10是递增的，而-1是反向选取，

方向相反所以不能取到值。

(10, 0, -1)，10到0是递减的，-1是反向选取

方向相同，生成的序列中就有值。

同切片中的示例。

"""

# 1.正确

# 结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

r = range(0, 10, 1)  # 正确

print(list(r))

# 2.range(0, 10, -1)没有创建的序列中没有元素

# 结果：[]

r1 = range(0, 10, -1)  # 错误

print(list(r1))

# 3.正确

# 结果：[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

r2 = range(10, 0, -1)  # 正确

print(list(r2))

注意：range()函数一般情况下都和for循环配合使用，可以创建一个执行指定次数的for循环。

例如：

for i in range(10):

print(i)

@6、enumerate()

enumerate()函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在for循环当中。

语法：

enumerate(可遍历对象, start=0)

注意：start参数用来设置遍历数据的下标的起始值，默认为0。

快速体验：

list1 = ['a', 'b', 'c', 'd', 'e']

for i in enumerate(list1):

    print(i)

for index, char in enumerate(list1, start=1):

    print(f'下标是{index}, 对应的字符是{char}')

"""

输出结果：

(0, 'a')

(1, 'b')

(2, 'c')

(3, 'd')

(4, 'e')

下标是1, 对应的字符是a

下标是2, 对应的字符是b

下标是3, 对应的字符是c

下标是4, 对应的字符是d

下标是5, 对应的字符是e

"""

3、容器类型转换

@1、tuple()函数

作用：将某个序列转换成元组

list1 = [10, 20, 30, 40, 50, 20] # 列表

s1 = {100, 200, 300, 400, 500} # 集合

"""

输出结果：

(10, 20, 30, 40, 50, 20)

(100, 200, 300, 400, 500)

"""

print(tuple(list1))

print(tuple(s1))

@2、list()函数

作用：将某个序列转换成列表

t1 = ('a', 'b', 'c', 'd', 'e') # 元组

s1 = {100, 200, 300, 400, 500} # 集合

"""

输出结果：

['a', 'b', 'c', 'd', 'e']

[100, 200, 300, 400, 500]

"""

print(list(t1))

print(list(s1))

@3、set()函数

作用：将某个序列转换成集合

list1 = [10, 20, 30, 40, 50, 20] # 列表

t1 = ('a', 'b', 'c', 'd', 'e') # 元组

"""

输出结果：

{40, 10, 50, 20, 30}

{'c', 'd', 'e', 'a', 'b'}

"""

print(set(list1))

print(set(t1))

注意：

1. 集合可以快速完成列表去重。
2. 集合不支持下标。