一、元组
Python 中的元组（`tuple`）是一种有序、不可变的集合数据类型。与列表（`list`）类似，元组用于存储多个元素，但一旦创建，它的内容不能修改。元组使用圆括号 `()` 来定义。
1. 元组的定义
元组可以通过圆括号 `()` 来定义，也可以省略括号，直接通过逗号分隔元素。
示例：
# 使用圆括号创建元组
tuple1 = (1, 2, 3, 4)
tuple2 = ('apple', 'banana', 'cherry')
# 不使用圆括号创建元组（逗号分隔）
tuple3 = 1, 2, 3, 4
# 创建空元组
empty_tuple = ()
# 创建包含一个元素的元组（必须加逗号）
single_element_tuple = (1,)
2. 元组的特点
- - **有序**：元组中的元素按顺序排列，可以通过索引访问。
- - **不可变**：一旦创建，元组的内容不能被修改、添加或删除。
- - **支持重复元素**：元组允许包含重复元素。
- - **支持多种数据类型**：元组可以包含不同类型的数据，如整数、浮点数、字符串等。
3. 访问元组中的元素
可以通过索引来访问元组中的元素，索引从 `0` 开始。
示例：
tuple1 = (10, 20, 30, 40)
# 访问第一个元素
print(tuple1[0]) # 输出 10
# 访问最后一个元素
print(tuple1[-1]) # 输出 40
4. 切片操作
与列表类似，元组也支持切片操作，可以获取元组中的部分元素。
示例：
tuple1 = (10, 20, 30, 40, 50)
# 获取索引从 1 到 3 的元素（不包含索引 4）
print(tuple1[1:4]) # 输出 (20, 30, 40)
# 获取从索引 2 到末尾的元素
print(tuple1[2:]) # 输出 (30, 40, 50)
# 获取从开头到索引 2 的元素（不包含索引 3）
print(tuple1[:3]) # 输出 (10, 20, 30)
5. 元组的不可变性
元组是不可变的，意味着元组中的元素不能被修改。如果尝试修改元组中的元素，Python 会引发 `TypeError`。
#### 示例：
tuple1 = (10, 20, 30)
# 尝试修改元素
# tuple1[1] = 25 # 会引发 TypeError: 'tuple' object does not support item assignment
6. 元组的嵌套
元组可以包含其他元组，甚至可以包含列表等其他数据结构。嵌套元组允许构建复杂的结构。
#### 示例：
tuple1 = (1, 2, (3, 4), [5, 6])
print(tuple1[2]) # 输出 (3, 4)
print(tuple1[2][1]) # 输出 4
7. 元组操作
虽然元组不可变，但仍然可以执行一些常见的操作，例如合并、重复等。
- **合并元组**：可以使用 `+` 运算符合并元组。
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
result = tuple1 + tuple2
print(result) # 输出 (1, 2, 3, 4, 5, 6)- - **重复元组**：可以使用 `*` 运算符重复元组中的元素。
tuple1 = (1, 2, 3)
result = tuple1 * 3
print(result) # 输出 (1, 2, 3, 1, 2, 3, 1, 2, 3)
``- - **成员检查**：可以使用 `in` 检查某个元素是否存在于元组中。
tuple1 = (10, 20, 30)
print(20 in tuple1) # 输出 True
print(40 in tuple1) # 输出 False
- - **获取长度**：可以使用 `len()` 函数获取元组的元素个数。
tuple1 = (1, 2, 3, 4)
print(len(tuple1)) # 输出 4
如果元组的元素数量和变量数量不匹配，会引发 `ValueError`。
tuple1 = (1, 2, 3)
# a, b = tuple1 # 会引发 ValueError: too many values to unpack
9. 常用元组方法
尽管元组是不可变的，但它也提供了一些常用的方法来处理和查询数据。
- **`count()`**：返回指定元素在元组中出现的次数。
tuple1 = (1, 2, 2, 3, 2)
print(tuple1.count(2)) # 输出 3
- **`index()`**：返回指定元素第一次出现的索引。
tuple1 = (10, 20, 30, 40)
print(tuple1.index(30)) # 输出 2
二、集合
Python 的集合（`set`）是一种无序且不包含重复元素的数据类型。集合数据类型非常适合用于去除重复元素、进行集合运算（如交集、并集、差集等），以及检查成员资格。
1. 集合的定义
集合使用花括号 `{}` 或 `set()` 函数来定义。集合中的元素是无序的，且集合中的元素必须是可哈希的（即是不可变的数据类型，如整数、字符串、元组等）。
示例：
# 使用花括号定义集合
s1 = {1, 2, 3, 4}
# 使用 set() 函数定义集合
s2 = set([1, 2, 3, 4])
# 空集合
empty_set = set()
# 集合元素必须是不可变类型（数字、字符串、元组）
# 错误示范：包含可变元素的集合
# s3 = {[1, 2], (3, 4)} # 会引发 TypeError，因为列表是可变的
2. 集合的特点
- - **无序**：集合中的元素没有顺序，因此无法通过索引、切片或其他序列操作访问元素。
- - **不重复**：集合中不允许出现重复的元素。如果尝试添加重复元素，集合会自动去重。
- - **可变**：集合是可变的，元素可以添加或删除。
- - **元素必须是不可变类型**：集合的元素必须是可哈希的类型，例如整数、字符串、元组等，但不能包含可变对象（如列表、字典等）。
3. 集合的基本操作
3.1 添加元素
- **`add()`**：向集合中添加一个元素。如果元素已存在，集合不会添加。
s = {1, 2, 3}
s.add(4) # 添加 4
print(s) # 输出 {1, 2, 3, 4}
s.add(3) # 尝试添加重复元素 3
print(s) # 输出 {1, 2, 3, 4}，3 不会重复添加
3.2 删除元素
- - **`remove()`**：删除集合中的指定元素，如果元素不存在，会引发 `KeyError`。
- - **`discard()`**：删除集合中的指定元素，如果元素不存在，不会引发错误。
- - **`pop()`**：随机删除集合中的一个元素，并返回该元素。如果集合为空，调用 `pop()` 会引发 `KeyError`。
- - **`clear()`**：清空集合中的所有元素。
s = {1, 2, 3, 4}
s.remove(3) # 删除元素 3
print(s) # 输出 {1, 2, 4}
s.discard(5) # 尝试删除不存在的元素 5，不会报错
print(s) # 输出 {1, 2, 4}
removed_element = s.pop() # 删除并返回一个随机元素
print(removed_element)
print(s) # 输出集合中剩余的元素
s.clear() # 清空集合
print(s) # 输出 set()
3.3 集合的长度和检查成员
- - **`len()`**：返回集合中的元素个数。
- - **`in`**：检查某个元素是否存在于集合中。
s = {1, 2, 3, 4}
print(len(s)) # 输出 4
print(2 in s) # 输出 True
print(5 in s) # 输出 False
4. 集合运算
集合支持多种数学运算，如并集、交集、差集等。Python 提供了直接的运算符来进行这些操作。
4.1 并集（Union）
- 使用 `|` 运算符或 `union()` 方法来求并集，返回一个包含两个集合所有元素的新集合。
s1 = {1, 2, 3}
s2 = {3, 4, 5}
union_set = s1 | s2 # 或者 s1.union(s2)
print(union_set) # 输出 {1, 2, 3, 4, 5}
4.2 交集（Intersection）
- 使用 `&` 运算符或 `intersection()` 方法来求交集，返回一个包含两个集合共同元素的新集合。
s1 = {1, 2, 3}
s2 = {3, 4, 5}
intersection_set = s1 & s2 # 或者 s1.intersection(s2)
print(intersection_set) # 输出 {3}
4.3 差集（Difference）
- 使用 `-` 运算符或 `difference()` 方法来求差集，返回一个包含在第一个集合中但不在第二个集合中的元素的新集合。
s1 = {1, 2, 3}
s2 = {3, 4, 5}
difference_set = s1 - s2 # 或者 s1.difference(s2)
print(difference_set) # 输出 {1, 2}
4.4 异或集（Symmetric Difference）
- 使用 `^` 运算符或 `symmetric_difference()` 方法来求对称差集，返回一个包含两个集合中不重复的元素的新集合。
s1 = {1, 2, 3}
s2 = {3, 4, 5}
symmetric_difference_set = s1 ^ s2 # 或者 s1.symmetric_difference(s2)
print(symmetric_difference_set) # 输出 {1, 2, 4, 5}
5. 集合的嵌套
集合可以嵌套其他集合，但需要注意集合元素必须是不可变的，因此集合本身不能作为集合的元素。
示例：
# 不能将集合作为元素放入另一个集合
# invalid_set = {{1, 2}, {3, 4}} # 会引发 TypeError6. 集合常用方法
- **`copy()`**：返回集合的一个浅拷贝。
s = {1, 2, 3}
copied_set = s.copy()
print(copied_set) # 输出 {1, 2, 3}
- **`isdisjoint()`**：判断两个集合是否没有交集。如果没有交集，返回 `True`，否则返回 `False`。
s1 = {1, 2, 3}
s2 = {4, 5, 6}
print(s1.isdisjoint(s2)) # 输出 True
s3 = {2, 3, 4}
print(s1.isdisjoint(s3)) # 输出 False- **`issubset()`**：判断一个集合是否是另一个集合的子集。即判断集合的所有元素是否都在另一个集合中。
s1 = {1, 2, 3}
s2 = {1, 2, 3, 4, 5}
print(s1.issubset(s2)) # 输出 True
三、字典
Python 中的字典（`dict`）是一种无序、可变的键值对集合。每个字典由若干个键（key）和值（value）组成，其中键是唯一的，值可以是任何类型的数据。字典通常用于快速查找和存储关联数据。
1. 字典的定义
字典使用花括号 `{}` 或 `dict()` 函数来定义，键和值之间用冒号 `:` 分隔，多个键值对用逗号 `,` 分隔。
示例：
# 使用花括号定义字典
person = {'name': '张三', 'age': 18, 'sex': '男'}
# 使用 dict() 函数定义字典
person2 = dict(name='李四', age=20, sex='女')
# 空字典
empty_dict = {}
# 使用键值对创建字典
dict_from_pairs = dict([('a', 1), ('b', 2)])
# 使用字典推导式创建字典
squared_numbers = {x: x ** 2 for x in range(5)}
print(squared_numbers) # 输出 {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
2. 字典的特点
- - **无序**：字典中的元素是无序的，Python 3.7 及之前的版本，字典中的元素的顺序是随机的，但从 Python 3.7 起，字典保持插入顺序。
- - **可变**：字典是可变类型，可以动态添加、修改或删除键值对。
- - **键唯一**：字典中的键必须是唯一的，如果插入相同的键，后插入的值会覆盖先插入的值。
- - **键必须是不可变类型**：字典的键必须是不可变类型（如字符串、整数、元组等），而值可以是任意数据类型。
- - **查找效率高**：字典提供了通过键进行快速查找的能力，查找操作的时间复杂度为 O(1)。
3. 字典的基本操作
3.1 访问字典中的值
可以通过键来访问字典中的值。如果键不存在，访问时会抛出 `KeyError`，但可以使用 `get()` 方法避免抛出错误。
person = {'name': '张三', 'age': 18, 'sex': '男'}
# 通过键访问值
print(person['name']) # 输出 张三
# 使用 get() 方法访问值
print(person.get('age')) # 输出 18
# 如果键不存在，get() 返回 None
print(person.get('address')) # 输出 None
# 使用 get() 方法指定默认值
print(person.get('address', '未知')) # 输出 未知
3.2 添加或修改字典的键值对
可以直接通过键来添加或修改字典中的元素。如果键已经存在，新的值将覆盖旧的值。
person = {'name': '张三', 'age': 18}
# 添加新的键值对
person['sex'] = '男'
# 修改已存在的键值对
person['age'] = 20
print(person) # 输出 {'name': '张三', 'age': 20, 'sex': '男'}
3.3 删除字典中的元素
- - **`del`**：根据键删除字典中的元素。
- - **`pop()`**：删除指定的键值对，并返回被删除的值。如果键不存在，`pop()` 方法会抛出 `KeyError`，但可以使用 `pop()` 的第二个参数来指定默认值。
- - **`popitem()`**：删除字典中的一个键值对，并返回删除的键值对。该方法删除的是字典中的“最后一个”键值对（Python 3.7 之后按照插入顺序删除）。
- - **`clear()`**：清空字典中的所有元素。
person = {'name': '张三', 'age': 18, 'sex': '男'}
# 使用 del 删除元素
del person['age']
print(person) # 输出 {'name': '张三', 'sex': '男'}
# 使用 pop() 删除并返回指定键值对
age = person.pop('age', '未提供') # 如果键不存在，返回默认值
print(age) # 输出 未提供
print(person) # 输出 {'name': '张三', 'sex': '男'}
# 使用 popitem() 删除并返回字典中的最后一个键值对
last_item = person.popitem()
print(last_item) # 输出 ('sex', '男')
print(person) # 输出 {'name': '张三'}
# 使用 clear() 清空字典
person.clear()
print(person) # 输出 {}
3.4 字典的长度与检查键是否存在
- - **`len()`**：返回字典中键值对的数量。
- - **`in`**：检查某个键是否存在于字典中。
person = {'name': '张三', 'age': 18}
# 获取字典中键值对的数量
print(len(person)) # 输出 2
# 检查某个键是否存在于字典中
print('name' in person) # 输出 True
print('address' in person) # 输出 False
4. 字典的遍历
可以使用 `for` 循环遍历字典中的键、值或键值对。
4.1 遍历字典的键
person = {'name': '张三', 'age': 18, 'sex': '男'}
for key in person:
print(key)
4.2 遍历字典的值
for value in person.values():
print(value)
4.3 遍历字典的键值对
for key, value in person.items():
print(key, value)
5. 字典的常用方法
- - **`keys()`**：返回字典中所有的键。
- - **`values()`**：返回字典中所有的值。
- - **`items()`**：返回字典中所有的键值对。
- - **`update()`**：将一个字典的键值对更新到另一个字典中。如果有相同的键，后面的值会覆盖前面的值。
- - **`copy()`**：返回字典的浅拷贝。
- - **`fromkeys()`**：创建一个新的字典，键来自于给定的序列，值为指定的默认值。
person = {'name': '张三', 'age': 18}
# 获取所有的键
print(person.keys()) # 输出 dict_keys(['name', 'age'])
# 获取所有的值
print(person.values()) # 输出 dict_values(['张三', 18])
# 获取所有的键值对
print(person.items()) # 输出 dict_items([('name', '张三'), ('age', 18)])
# 使用 update() 更新字典
person.update({'sex': '男', 'age': 20})
print(person) # 输出 {'name': '张三', 'age': 20, 'sex': '男'}
# 使用 copy() 创建字典的浅拷贝
person_copy = person.copy()
print(person_copy) # 输出 {'name': '张三', 'age': 20, 'sex': '男'}
# 使用 fromkeys() 创建字典
new_dict = dict.fromkeys(['a', 'b', 'c'], 0)
print(new_dict) # 输出 {'a': 0, 'b': 0, 'c': 0}