七、公共操作
公共操作指的就是所学过的数据序列基本上都支持的操作。
以下是总结内容：
（一）运算符
| 运算符 | 描述 | 支持的容器类型 |
|---|---|---|
| + | 合并 | 字符串、列表、元组 |
| * | 复制 | 字符串、列表、元组 |
| 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
（二）公共方法
| 函数 | 描述 |
|---|---|
| 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
"""
（三）容器类型转换
@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))
注意：
- 集合可以快速完成列表去重
- 集合不支持下标
