一. 序列
1. 什么是序列
序列（Sequence）是一种基本且核心的数据结构，它允许我们以有序的方式存储和操作数据。序列可以包含不同类型的元素，并且支持通过索引来访问和修改这些元素。
常见的序列类型包括：列表（List）、元组（Tuple）、字符串（String）。
2. 序列的操作
- 索引：sequence[0]
- 切片：sequence[1:3]
- 相加：sequence1 + sequence2
- 乘法：sequence * 3
- 检查成员：x in sequence
- 计算长度：len(sequence)
- 计算最大值、最小值：max(sequence)、min(sequence)
二. 列表List
- 列表是一个可变的、有序的元素集合。
- 列表使用 [] 定义，数据之间使用 , 分隔。
- 列表中每个元素都有对应的位置值，称为索引或下标，索引从起始从0开始向后逐个递增，并且从末尾从-1开始逐个向前递减。
- 列表中元素可以是不同的类型。
1. 创建列表
list1 = [100, 200, 300, 400, 500]
2. 访问列
1）通过索引获取列表中元素
list1 = [100, 200, 300, 400, 500]
print(list1[1]) # 200
print(list1[-2]) # 400
2）列表切片
list1 = [100, 200, 300, 400, 500]
print(list1) # 取全部元素
print(list1[:]) # 复制整个列表
print(list1[2:4]) # 取索引从2开始到4(不包含)的元素
print(list1[2:]) # 取索引从2开始到末尾的元素
print(list1[:2]) # 取索引从0开始到2(不包含)的元素
print(list1[2:-1]) # 取索引从2开始到-1(不包含)的元素
print(list1[::-1]) # 倒序取元素
3. 向列表中添加元素
list1 = [100, 200, 300, 400, 500]
list1.append(600) # 在列表末尾追加元素
list1.insert(2,700) # 在列表指定的位置追加元素
print(list1)
4. 列表相加
list1 = [100, 200, 300]
list2 = ["a", "b", "c"]
print(list1 + list2) # [100, 200, 300, 'a', 'b', 'c']
5. 列表乘法
list1 = [100, 200, 300]
print(list1 * 2) # [100, 200, 300, 100, 200, 300]
6. 修改列表中元素
1）通过下标修改。
list1 = [100, 200, 300, 400, 500]
list1[0] = -1
print(list1)
2）通过切片修改。
list1 = [100, 200, 300, 400, 500]
list1[2:4] = ["a", "b", "c"]
print(list1)
7. 检查成员是否为列表中元素
list1 = [100, 200, 300]
print(100 in list1) # True
8. 获取列表长度
list1 = [100, 200, 300]
print(len(list1)) # 3
9. 求列表中元素的最大值、最小值、加和
list1 = [100, 200, 300, 400, 500]
print(max(list1)) # 500
print(min(list1)) # 100
print(sum(list1)) # 1500
10. 遍历列表
1）直接遍历列表元素
list1 = [100, 200, 300, 400, 500]
for i in list1:
print(i)
2）通过下标遍历列表
list1 = [100, 200, 300, 400, 500]
for i in range(len(list1)):
print(i, list1[i])
3）使用enumerate()同时获取列表的下标和元素
list1 = [100, 200, 300, 400, 500]
for i, val in enumerate(list1):
print(i, val)
11. 删除列表指定位置元素或者切片
list1 = [100, 200, 300, 400, 500]
del list1[2]
print(list1)
12. 嵌套列表
# 列表中的元素可以为列表。
list1 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for inner_list in list1:
print(inner_list)
13. 列表推导式
列表推导式是 Python 中一种简洁创建列表的方式，它将一个可迭代对象（如列表、元组、集合、字符串等）的元素通过某种运算或条件筛选后生成一个新的列表。
1）基础的列表推导式
squares = [x**2 for x in range(5)]
print(squares) # [0, 1, 4, 9, 16]
2）带条件的列表推导式
squares = [x**2 for x in range(10) if x % 2 == 0]
print(squares) # [0, 4, 16, 36, 64]
3）使用现有列表的列表推导式
list1 = [1, 2, 3, 4, 5]
squares = [x**2 for x in list1]
print(squares) # [1, 4, 9, 16, 25]
4）包含多个循环的列表推导式
list1 = [1, 2, 3, 4, 5]
list2 = ["a", "b", "c", "d", "e"]
tuple_list = [(i, j) for i in list1 for j in list2]
print(tuple_list)
14. zip()函数
# zip()函数可将多个可迭代对象中对应元素打包为一个个元组。
list1 = [1, 2, 3, 4, 5]
list2 = ["a", "b", "c", "d", "e"]
zipped = zip(list1, list2)
print(list(zipped))
15. 常用函数
| 函数 | 说明 |
|---|---|
| list.insert(index,x) | 在指定位置插入x |
| list.append(x) | 在列表末尾追加x |
| list1.extend(list2) | 在列表1的末尾追加列表2的数据 |
| del list[index] | 删除指定位置的数据或切片 |
| list.remove(x) | 删除第一次出现的x |
| list.pop([index]) | 删除指定位置的数据，默认为末尾数据 |
| list.clear() | 清空列表中元素 |
| list[index] = x | 修改指定位置的数据 |
| list1[start:end] = list2 | 修改列表切片的数据 |
| sorted(list[,reverse=True]) | 返回排序后的新列表，可选降序 |
| list.sort([reverse=True]) | 对列表就地排序，可选降序 |
| list.reverse() | 反转列表中的元素 |
| list.index(x[,start,[,end]]) | 返回x在列表中首次出现的位置，可指定起始和结束范围 |
| list.count(x) | 返回x的数量，x出现了几次 |
| len(list) | 返回列表元素个数 |
| max(list) | 返回列表中最大值 |
| min(list) | 返回列表中最小值 |
| sum(list) | 返回列表中所有元素和 |
| list.copy() | 拷贝列表 |
| list(x) | 将序列转换为列表 |
三. 字符串String
- 字符串是不可变的、有序的。
- 字符串中元素不可修改。
- 字符串使用单引号、双引号或三重引号定义。
- 字符串中每个值都有对应的位置值，称为索引或下标，索引从起始从0开始向后逐个递增，并且从末尾从-1开始逐个向前递减。
1、创建字符串
str1 = "hello world"
2、访问字符串
str1 = "hello world"
print(str1[0])
print(str1[-1])
print(str1[4:-3])
3、字符串相加
str1 = "hello world"
str2 = "dlrow olleh"
print(str1 + str2) # hello worlddlrow olleh
4、字符串乘法
str1 = "hello world"
print(str1 * 2) # hello worldhello world
5、检查成员是否为字符串中元素
str1 = "hello world"
print("lo" in str1) # True
6、原始字符串
所有的字符串按照字面意思处理，没有转义字符。需在字符串前加上r / R。
print("hello\nworld")
print(r"hello\nworld")
7、常用函数
| 函数 | 说明 |
|---|---|
| str.replace(old,new[,max]) | 把将字符串中的old替换成new,如果指定max，则替换不超过max次 |
| str.split([x][,n]) | 按x分隔字符串，默认按任何空白字符串分隔并在结果中丢弃空字符串。可指定最大分隔次数 |
| str.rsplit([x][,n]) | 与split()类似，从右边开始分隔 |
| x.join(seq) | 以x作为分隔符，将序列中所有的字符串合并为一个新的字符串 |
| str.strip([x]) | 截掉字符串两边的空格或指定字符 |
| str.lstrip([x]) | 截掉字符串左边的空格或指定字符 |
| str.rstrip([x]) | 截掉字符串右边的空格或指定字符 |
| str.removeprefix() | 截掉字符串指定前缀 |
| str.removesuffix() | 截掉字符串指定后缀 |
| str.upper() | 将所有字符转为大写 |
| str.lower() | 将所有字符转为小写 |
| str.swapcase() | 反转字符串中字母大小写 |
| str.capitalize() | 将字符串第一个字母变为大写，其他字母变为小写 |
| str.title() | 将字符串每个单词首字母大写 |
| str.casefold() | 返回适合无大小写比较的字符串版本 |
| len(str) | 返回字符串长度 |
| max(str) | 返回字符串中最大值 |
| min(str) | 返回字符串中最小值 |
| str.find(x[,start][,end]) | 返回字符串中第一个x的索引值，不存在则返回-1，可指定字符串开始结束范围 |
| str.rfind(x[,start][,end]) | 与find()类似，从右边开始查找 |
| str.index(x[,start][,end]) | 返回字符串中第一个x的索引值，不存在则报错，可指定字符串开始结束范围 |
| str.rindex(x[,start][,end]) | 与index()类似，从右边开始查找 |
| str.count(x[,start][,end]) | 返回字符串中x的个数，可指定字符串开始结束范围 |
| str.startswith(x[,start][,end]) | 检查字符串是否以x开头，可指定字符串开始结束范围 |
| str.endswith(x[,start][,end]) | 检查字符串是否以x结尾，可指定字符串开始结束范围 |
| str.isspace() | 检查字符串是否非空且只包含空白 |
8、其他函数
| 函数 | 说明 |
|---|---|
| str.center(width[,x]) | 返回长度为width且居中的字符串，空白使用x填充，默认为空格 |
| str.ljust(width[,x]) | 返回长度为width且左对齐的字符串，空白使用x填充，默认为空格 |
| str.rjust(width[,x]) | 返回长度为width且右对齐的字符串，空白使用x填充，默认为空格 |
| str.zfill(width) | 返回长度为width且右对齐的字符串，空白使用0填充 |
| str.splitlines([keepends]) | 按行分隔字符串，返回每行字符串组成的列表，可选是否保留换行符 |
| str.partition(x) | 使用x将字符串分隔为3部分，如果分隔后不足3部分或字符串中没有x则以空白填充 |
| str.rpartition(x) | 与partition()类似，从右边开始分隔 |
| str.encode(encoding='UTF-8',errors='strict') | 对字符串使用指定格式编码，并指定错误处理方案 |
| str.expandtabs([tabsize]) | 将字符串中\t转化为空格，可指定每个\t空格数 |
| str.format_map(dict) | 使用字典等映射关系数据来格式化字符串 |
| str.isalnum() | 检查字符串是否非空且只包含字母(英文字母+汉字)和数字 |
| str.isalpha() | 检查字符串是否非空且只包含字母(英文字母+汉字) |
| str.isascii() | 检查字符串是否只包含ASCII字符，空字符串也是ASCII |
| str.isdecimal() | 检查字符串是否非空且只包含十进制字符 |
| str.isdigit() | 检查字符串是否非空且只包含数字 |
| str.isidentifier() | 检查字符串是否是有效的标识符 |
| str.isupper() | 检查字符串中是否包含至少一个区分大小写的字符，且所有这些(区分大小写的)字符都是大写 |
| str.islower() | 检查字符串中是否包含至少一个区分大小写的字符，且所有这些(区分大小写的)字符都是小写 |
| str.isnumeric() | 检查字符串是否非空且只包含数值字符 |
| str.isprintable() | 检查字符串是否可打印 |
| str.istitle() | 检查字符串是否非空且符合title格式 |
| str.maketrans(str1,str2[,str3]) | 生成翻译表供translate()使用。如果只传一个参数，它必须是将Unicode序号（整数）或字符映射到Unicode序号、字符串或None的字典。然后，字符键将转换为序数。如果传两个参数，需要str1和str2为等长的字符串，并且在生成的字典中，str1中的每个字符都将映射到str2中相同位置的字符。如果有第三个参数，它必须是一个字符串，其字符将在结果中映射到None |
| str.translate() | 使用给定的翻译表替换字符串中的每个字符 |
四. 元组Tuple
- 元组是一个不可变的、有序的元素集合。
- 不能对元组中的元素进行修改操作。
- 元组使用 () 定义，数据之间使用 , 分隔。
- 元组中每个元素都有对应的位置值，称为索引或下标，索引从起始从0开始向后逐个递增，并且从末尾从-1开始逐个向前递减。
- 元组中元素可以是不同的类型。
- 元组的使用方式与列表类似。
1. 创建元组
tuple1 = (100, 200, 300, 400, 500)
# 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用。
tuple1 = (100,)
# 也可以通过元组推导式创建元组。
tuple_generator = (x for x in range(10)) # 获取生成器对象
print(tuple_generator)
tuple1 = tuple(tuple_generator) # 转换为元组
print(tuple1)
2. 访问元组
tuple1 = (100, 200, 300, 400, 500)
print(tuple1[2])
print(tuple1[-1])
print(tuple1[2:4])
3. 元组相加
tuple1 = (100, 200, 300)
tuple2 = ("a", "b", "c")
print(tuple1 + tuple2) # (100, 200, 300, 'a', 'b', 'c')
4. 元组乘法
tuple1 = (100, 200, 300)
print(tuple1 * 2) # (100, 200, 300, 100, 200, 300)
5. 检查成员是否为元组中元素
tuple1 = (100, 200, 300, 400, 500)
print(300 in tuple1) # True
6. 获取元组长度
tuple1 = (100, 200, 300, 400, 500)
print(len(tuple1)) # 5
7. 求元组中元素的最大值、最小值、加和
tuple1 = (100, 200, 300, 400, 500)
print(max(tuple1)) # 500
print(min(tuple1)) # 100
print(sum(tuple1)) # 1500
8. 遍历元组
tuple1 = (100, 200, 300, 400, 500)
for i in tuple1:
print(i)
for i in range(len(tuple1)):
print(i, tuple1[i])
for i, val in enumerate(tuple1):
print(i, val)
9. 元组的不可变
# 元组的不可变指的是元组所指向的内存中的内容不可变，但可以重新赋值。
tuple1 = (100, 200, 300)
print(id(tuple1), tuple1)
tuple1 = tuple1 + (1, 2, 3)
print(id(tuple1), tuple1)
# 如果元组中元素是可变数据类型，其嵌套项可以被修改。
tuple1 = (100, 200, 300, [1, 2, 3])
tuple1[3].append(4)
print(tuple1) # (100, 200, 300, [1, 2, 3, 4])
五. 集合Set
- 集合是无序的，且不包含重复元素。
- 集合使用 {} 定义，数据之间使用 , 分隔，也可以使用set()定义。
- 集合没有索引，所以不能通过切片方式访问集合元素。
- 集合中元素可以是不同的类型。
- 集合可以进行数学上的集合操作，如并集、交集和差集。
- 集合适用于需要快速成员检查、消除重复项和集合运算的场景。
1. 创建集合
# 可以通过{}或set()创建集合，但创建空集合需要使用set()而非{}，因为{}会创建空字典。
set1 = {1, 2, 3}
set2 = set([1, 2, 3]) # 使用set()函数从列表创建集合
set3 = set()
print(set1, set2, set3)
# 也可以通过集合推导式创建集合。
set1 = {x for x in range(10) if x % 2 == 0}
print(set1) # {0, 2, 4, 6, 8}
2. 向集合中添加元素
set1 = {1, 2, 3}
set1.add(4)
set1.add(5)
print(set1)
3. 从集合中删除元素
set1 = {1, 2, 3}
set1.remove(2)
print(set1)
4. 检查成员是否为集合中元素
set1 = {1, 2, 3, 4, 5}
print(2 in set1) # True
5. 获取集合长度
set1 = {1, 2, 3, 4, 5}
print(len(set1)) # 5
6. 求集合中元素的最大值、最小值、加和
set1 = {1, 2, 3, 4, 5}
print(max(set1)) # 5
print(min(set1)) # 1
print(sum(set1)) # 15
7. 遍历集合
my_set = {1, 2, 3, 4, 5}
for item in my_set:
print(item)
8. 常用函数
| 函数 | 说明 |
|---|---|
| set.add(x) | 添加元素 |
| set.update(x) | 添加元素，x可以为列表、元组、字符串、字典等可迭代对象 |
| set.union(x) | 添加元素后返回一个新的集合，x可以为列表、元组、字符串、字典等可迭代对象 |
| set.remove(x) | 从集合中移除x，x不存在则报错 |
| set.discard(x) | 从集合中移除x，x不存在也不报错 |
| set.pop() | 随机取出集合中的一个元素，如果集合为空则报错 |
| set.clear() | 清空集合 |
| set.difference(x1,...) | 求set1和x1的差集，返回一个新的集合 |
| set.difference_update(x1,...) | 求set1和x1的差集 |
| set.intersection(x1,...) | 求set1和x1的交集，返回一个新的集合 |
| set.intersection_update(x1,...) | 求set1和x1的交集 |
| set1 & set2 | 两集合求交集 |
| set1 | set2 | 两集合求并集 |
| set1 - set2 | 两集合求差集 |
| set1.isdisjoint(set2) | 判断两集合是否没有交集 |
| set1.issubset(set2) | 判断set1是否为set2的子集 |
| set1.issuperset(set2) | 判断set2是否为set1的子集 |
| set1.symmetric_difference(set2) | 求两集合中不重复的元素，返回一个新的集合 |
| set1.symmetric_difference_update(set2) | 求两集合中不重复的元素 |
| set.copy() | 拷贝集合 |
| len(set) | 返回集合元素个数 |
| max(set) | 求集合中元素的最大值 |
| min(set) | 求集合中元素的最小值 |
| sum(set) | 求集合中元素的加和 |
六. 字典Dictionary
- 一个无序的键值对集合，键是唯一的，而值可以重复。
- 字典使用 {} 定义，键（key）和值（value）使用 : 连接，每个键值对之间使用 , 分隔。如{key1 : value1 , key2 : value2}
- 字典没有索引。
- 字典可以通过键来获取对应的值。
- 值可以取任何数据类型，但键必须是不可变的，如字符串、数字、元组。
1. 创建字典
# 可以通过{}或dict()创建字典。
dict1 = {}
dict2 = dict()
dict3 = {"name": "Alice", "age": 18, "gender": "male"}
dict4 = dict(name="Bob", age=20, gender="female")
dict5 = dict([("name", "Tom"), ("age", 22), ("gender", "male")])
print(dict1)
print(dict2)
print(dict3)
print(dict4)
print(dict5)
# 也可以通过字典推导式创建字典。
squares = {x: x**2 for x in range(4)}
print(squares) # {0: 0, 1: 1, 2: 4, 3: 9}
2. 访问字典
# 可通过 [] 访问字典中的元素。key不存在时会报错。
dict1 = {"name": "Alice", "age": 18, "gender": "male"}
print(dict1["name"]) # Alice
print(dict1["age"]) # 18
print(dict1["gender"]) # male
print(dict1["address"]) # 报错
# 也可以通过get()获取字典中的元素。key不存在时会返回None，也可以指定默认值。
dict1 = {"name": "Alice", "age": 18, "gender": "male"}
print(dict1.get("name")) # Alice
print(dict1.get("age")) # 18
print(dict1.get("gender")) # male
print(dict1.get("address")) # None
print(dict1.get("address", "earth")) # earth
3. 向字典中添加元素
# 为字典指定的key赋值value，若key原本不存在则会被添加。
dict1 = {"name": "Alice", "age": 18, "gender": "male"}
dict1["address"] = "earth"
print(dict1)
4. 修改字典中元素
# 通过key修改对应的value。
dict1 = {"name": "Alice", "age": 18, "gender": "male"}
dict1["name"] = "Bob"
print(dict1)
5. 检查成员是否为字典中的key
dict1 = {"name": "Alice", "age": 81, "gender": "male"}
print("name" in dict1) # 检查key是否存在
print("Alice" in dict1) # 无法直接检查value是否存在
6. 获取字典长度
dict1 = {"name": "Alice", "age": 81, "gender": "male"}
print(len(dict1)) # 3
7. 遍历字典
my_dict = {'Name': 'Tom', 'Age': 17}
# 遍历出所有k
keys = my_dict.keys()
for k in keys:
print (k)
print("-" *20)
# 遍历出所有v
vals = my_dict.values()
print(vals)
for v in vals:
print (v)
print("-" *20)
# k-v遍历
keys = my_dict.keys()
for k in keys:
print (k + "---" + str(my_dict[k]))
print("-" *20)
kv = my_dict.items()
for i in kv:
print(i)
8. 删除字典元素
my_dict = {'Name': 'Tom', 'Age': 17}
del my_dict['Name'] # 删除键 'Name'
# my_dict.clear() # 清空字典
# del my_dict # 删除字典
print (my_dict)
9. 常用函数
| 函数 | 说明 |
|---|---|
| del dict[key] | 根据key删除键值对 |
| dict.pop(key[,default]) | 获取key所对应的value，同时删除该键值对，可设置默认值 |
| dict.popitem() | 取出字典中的最后插入的键值对，字典为空则报错 |
| dict.clear() | 清空字典 |
| dict1.update(dict2) | 将dict2中的键值对更新到dict1中 |
| dict.get(key[,default]) | 获取字典中key对应value，可设置默认值 |
| dict.setdefault(key[,default]) | 获取字典中key对应value，可设置默认值。若key不存在于字典中，将会添加key并将value设为默认值 |
| dict.keys() | 获取字典所有的key，返回一个视图对象。字典改变，视图也会跟着变化 |
| dict.values() | 获取字典所有的value，返回一个视图对象 |
| dict.items() | 获取字典所有的(key,value)，返回一个视图对象 |
| dict.copy() | 拷贝字典 |
| dict.fromkeys(seq[,default]) | 以序列seq中元素做字典的key创建一个新字典，可设置value的默认值 |
七. 列表、元组、字典和集合的区别
| 数据结构 | 是否可变 | 是否重复 | 是否有序 | 定义符号 |
|---|---|---|---|---|
| 列表（List） | 可变 | 允许 | 有序 | []或list() |
| 元组（Tuple） | 不可变 | 允许 | 有序 | ()或tuple() |
| 字典（Dictionary） | 可变 | 键不允许，值允许 | 键无序（Python 3.7+版本中保持插入顺序） | {}或dict() |
| 集合（Set） | 可变 | 不允许 | 无序 | {}或set() |
