Python中的字典（dictionary）是一种无序的数据集合，其中的元素以键值对的形式存储，键必须是唯一的且不可变的，而值则可以是任意类型的数据。以下是字典的基本方法：

1. `dict.clear()`: 清空字典，删除所有的元素。
2. `dict.copy()`: 返回字典的一个浅拷贝。
3. `dict.fromkeys(iterable, value=None)`: 创建一个新字典，其中包含指定可迭代对象中的元素作为键，并将它们的值设置为一个指定的值（默认为None）。
4. `dict.get(key, default=None)`: 返回指定键的值，如果键不存在，则返回默认值。
5. `dict.items()`: 返回字典的键值对视图。
6. `dict.keys()`: 返回字典的键视图。
7. `dict.values()`: 返回字典的值视图。
8. `dict.pop(key, default=None)`: 删除并返回指定键的值，如果键不存在，则返回默认值。
9. `dict.popitem()`: 随机删除并返回字典中的一对键值对（Python 3.7及以上版本中删除的是最后一个键值对）。
10. `dict.setdefault(key, default=None)`: 如果键存在于字典中，则返回其值，否则将键插入字典并设置默认值。
11. `dict.update(iterable)`: 更新字典中的键值对，可以使用另一个字典或包含键值对的迭代器。
12. `dict.fromkeys(keys[, value])`: 创建一个新字典，其中包含指定的键，并将它们的值设置为一个指定的值（默认为None）。

这些方法可以让你对字典进行增加、删除、查找和更新等操作。以下是一些字典方法的示例用法：

# 创建一个字典
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# 使用get()方法获取指定键的值
age = my_dict.get('age')
print("Age:", age)  # 输出: Age: 30

# 使用items()方法获取键值对视图
items = my_dict.items()
print("Items:", items)  # 输出: Items: dict_items([('name', 'Alice'), ('age', 30), ('city', 'New York')])

# 使用keys()方法获取键视图
keys = my_dict.keys()
print("Keys:", keys)  # 输出: Keys: dict_keys(['name', 'age', 'city'])

# 使用values()方法获取值视图
values = my_dict.values()
print("Values:", values)  # 输出: Values: dict_values(['Alice', 30, 'New York'])

# 使用pop()方法删除并返回指定键的值
city = my_dict.pop('city')
print("Removed city:", city)
print("Dictionary after popping 'city':", my_dict)  # 输出: Dictionary after popping 'city': {'name': 'Alice', 'age': 30}

# 使用popitem()方法删除并返回随机键值对
removed_item = my_dict.popitem()
print("Removed item:", removed_item)
print("Dictionary after popping item:", my_dict)  # 输出: Dictionary after popping item: {'name': 'Alice'}

# 使用setdefault()方法获取键的值，如果键不存在则插入新的键值对
country = my_dict.setdefault('country', 'USA')
print("Country:", country)
print("Dictionary after setting default:", my_dict)  # 输出: Dictionary after setting default: {'name': 'Alice', 'country': 'USA'}

# 使用update()方法更新字典中的键值对
my_dict.update({'age': 31, 'city': 'San Francisco'})
print("Updated dictionary:", my_dict)  # 输出: Updated dictionary: {'name': 'Alice', 'country': 'USA', 'age': 31, 'city': 'San Francisco'}

Python中的列表（list）是一种有序的集合，它可以容纳任意数量的元素，并且可以修改。下面是一些常用的列表方法：

1. `append(x)`: 在列表末尾添加一个元素 `x`。
2. `extend(iterable)`: 在列表末尾一次性追加另一个序列（可迭代对象）中的多个值。
3. `insert(i, x)`: 在指定位置 `i` 插入元素 `x`。
4. `remove(x)`: 移除列表中第一个值为 `x` 的元素。如果没有这样的元素，则会引发 ValueError。
5. `pop([i])`: 移除并返回指定位置 `i` 处的元素。如果未指定 `i`，则移除并返回最后一个元素。
6. `clear()`: 移除列表中的所有元素，等效于 `del list[:]`。
7. `index(x[, start[, end]])`: 返回第一个值为 `x` 的元素的索引。可选参数 `start` 和 `end` 用于指定搜索的范围。
8. `count(x)`: 返回值为 `x` 的元素在列表中的个数。
9. `sort(key=None, reverse=False)`: 对列表进行排序。可选参数 `key` 用于指定排序的关键字函数，`reverse` 用于控制升序或降序，默认升序。
10. `reverse()`: 将列表中的元素反转。
11. `copy()`: 返回列表的一个浅拷贝。

这些是最常用的列表方法，它们可以帮助你在处理列表时进行增加、删除、排序等操作。

# 创建一个空列表
my_list = []

# 使用append()方法向列表中添加元素
my_list.append(1)
my_list.append(2)
my_list.append(3)
print("After appending elements:", my_list)  # 输出: [1, 2, 3]

# 使用extend()方法一次性追加另一个列表中的多个值
my_list.extend([4, 5, 6])
print("After extending elements:", my_list)  # 输出: [1, 2, 3, 4, 5, 6]

# 使用insert()方法在指定位置插入元素
my_list.insert(2, 100)
print("After inserting element at index 2:", my_list)  # 输出: [1, 2, 100, 3, 4, 5, 6]

# 使用remove()方法移除指定值的元素
my_list.remove(100)
print("After removing element 100:", my_list)  # 输出: [1, 2, 3, 4, 5, 6]

# 使用pop()方法移除并返回指定位置的元素
popped_element = my_list.pop(0)
print("Popped element:", popped_element)
print("After popping element at index 0:", my_list)  # 输出: [2, 3, 4, 5, 6]

# 使用clear()方法清空列表
my_list.clear()
print("After clearing the list:", my_list)  # 输出: []

# 创建一个新的列表
new_list = [1, 2, 3, 4, 5, 4, 3, 2, 1]

# 使用index()方法查找元素的索引
index = new_list.index(3)
print("Index of element 3:", index)  # 输出: 2

# 使用count()方法统计元素出现的次数
count = new_list.count(4)
print("Count of element 4:", count)  # 输出: 2

# 使用sort()方法对列表进行排序
new_list.sort()
print("Sorted list:", new_list)  # 输出: [1, 1, 2, 2, 3, 3, 4, 4, 5]

# 使用reverse()方法反转列表中的元素
new_list.reverse()
print("Reversed list:", new_list)  # 输出: [5, 4, 4, 3, 3, 2, 2, 1, 1]

# 使用copy()方法创建列表的浅拷贝
copied_list = new_list.copy()
print("Copied list:", copied_list)  # 输出: [5, 4, 4, 3, 3, 2, 2, 1, 1]

 --------

集合（set）是 Python 中的一种数据类型，它是一个无序且不重复的集合。这里简略归纳一些常用的集合方法：

1. 添加元素：
   - `add(element)`: 向集合中添加一个元素。
   - `update(iterable)`: 将一个可迭代对象中的所有元素添加到集合中。

2. 删除元素：
   - `remove(element)`: 从集合中删除指定的元素，如果元素不存在则会引发 KeyError 异常。
   - `discard(element)`: 从集合中删除指定的元素，如果元素不存在也不会引发异常。
   - `pop()`: 移除并返回集合中的任意一个元素，如果集合为空则引发 KeyError 异常。
   - `clear()`: 清空集合，移除其中的所有元素。

3. 集合运算：
   - `union(other_set)`: 返回一个包含两个集合所有元素的新集合（并集）。
   - `intersection(other_set)`: 返回一个包含两个集合共有元素的新集合（交集）。
   - `difference(other_set)`: 返回一个包含存在于第一个集合但不存在于第二个集合的元素的新集合（差集）。
   - `symmetric_difference(other_set)`: 返回一个包含存在于两个集合中的但不属于两者交集的元素的新集合（对称差集）。

4. 集合查询：
   - `len(set)`: 返回集合中元素的数量。
   - `element in set`: 检查集合中是否存在指定的元素，如果存在返回 True，否则返回 False。

这些是集合对象中一些常用的方法，它们使得对集合进行操作和查询变得非常方便。

# 创建两个集合
set1 = {1, 2, 3, 4}
set2 = {3, 4, 5, 6}

# 添加元素
set1.add(5)  # {1, 2, 3, 4, 5}
set1.update([6, 7])  # {1, 2, 3, 4, 5, 6, 7}

# 删除元素
set1.remove(7)  # {1, 2, 3, 4, 5, 6}
set1.discard(6)  # {1, 2, 3, 4, 5}
set1.pop()  # 返回移除的元素，可能是任意的 {2, 3, 4, 5}，剩余元素为 {3, 4, 5}
set1.clear()  # 清空集合，变为空集合 set()

# 集合运算
union_set = set1.union(set2)  # {3, 4, 5, 6}
intersection_set = set1.intersection(set2)  # {}
difference_set = set1.difference(set2)  # {}
symmetric_difference_set = set1.symmetric_difference(set2)  # {1, 2, 5, 6}

# 集合查询
print(len(set1))  # 0
print(3 in set2)  # True