【Python】容器

列表

Python 中的 列表（list） 是一种内置的数据结构，用于存储有序的元素集合。列表是 Python 中最常用的数据类型之一，具有灵活性和强大的功能。

• 列表的特点

  • 有序性：列表中的元素是有序的，每个元素都有一个固定的位置（索引）。

  • 可变性：列表是可变的（mutable），可以动态添加、删除或修改元素。

  • 异构性：列表可以包含不同类型的元素（如整数、字符串、列表等）。

  • 动态大小：列表的大小可以动态调整，无需预先指定长度。

列表的特点

• 有序性：列表中的元素是有序的，每个元素都有一个固定的位置（索引）。

• 可变性：列表是可变的（mutable），可以动态添加、删除或修改元素。

• 异构性：列表可以包含不同类型的元素（如整数、字符串、列表等）。

• 动态大小：列表的大小可以动态调整，无需预先指定长度。

创建列表

列表用方括号[]表示，元素之间用逗号,分隔。

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

# 创建一个包含整数的列表
numbers = [1, 2, 3, 4, 5]

# 创建一个包含不同类型元素的列表
mixed_list = [1, "hello", 3.14, True]

# 创建一个嵌套列表（列表中的元素也是列表）
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

访问列表元素

列表中的元素通过索引访问，索引从 0 开始。

fruits = ["apple", "banana", "cherry"]

# 访问第一个元素
print(fruits[0])  # 输出: apple

# 访问最后一个元素
print(fruits[-1])  # 输出: cherry

修改列表元素

列表是可变的，可以通过索引直接修改元素。

fruits = ["apple", "banana", "cherry"]

# 修改第二个元素
fruits[1] = "blueberry"
print(fruits)  # 输出: ['apple', 'blueberry', 'cherry']

修列表的常用操作

• 添加元素

  • append()：在列表末尾添加一个元素。

  • insert()：在指定位置插入一个元素。

  • extend()：将另一个列表的所有元素添加到当前列表末尾。

fruits = ["apple", "banana"]

# 在末尾添加元素
fruits.append("cherry")
print(fruits)  # 输出: ['apple', 'banana', 'cherry']

# 在指定位置插入元素
fruits.insert(1, "orange")
print(fruits)  # 输出: ['apple', 'orange', 'banana', 'cherry']

# 添加多个元素
fruits.extend(["grape", "mango"])
print(fruits)  # 输出: ['apple', 'orange', 'banana', 'cherry', 'grape', 'mango']

• 删除元素

  • remove()：删除第一个匹配的元素。

  • pop()：删除指定位置的元素（默认删除最后一个元素）。

  • del：删除指定位置的元素或整个列表。

fruits = ["apple", "banana", "cherry", "banana"]

# 删除第一个匹配的元素
fruits.remove("banana")
print(fruits)  # 输出: ['apple', 'cherry', 'banana']

# 删除指定位置的元素
fruits.pop(1)
print(fruits)  # 输出: ['apple', 'banana']

# 删除整个列表
del fruits

切片操作

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# 获取前3个元素
print(numbers[:3])  # 输出: [0, 1, 2]

# 获取第2到第5个元素
print(numbers[2:5])  # 输出: [2, 3, 4]

# 获取偶数索引的元素
print(numbers[::2])  # 输出: [0, 2, 4, 6, 8]

列表排序

sort()：对列表进行原地排序（修改原列表）。

sorted()：返回一个新的排序列表（不修改原列表）。

numbers = [3, 1, 4, 1, 5, 9, 2]

# 原地排序
numbers.sort()
print(numbers)  # 输出: [1, 1, 2, 3, 4, 5, 9]

# 返回新排序列表
sorted_numbers = sorted(numbers, reverse=True)
print(sorted_numbers)  # 输出: [9, 5, 4, 3, 2, 1, 1]

元组

Python 中的 元组（tuple） 是一种内置的数据结构，用于存储有序的元素集合。元组与列表（list）类似，但有一个关键区别：元组是不可变的（immutable），即创建后不能修改其内容。

元组的特点

• 有序性：元组中的元素是有序的，每个元素都有一个固定的位置（索引）。

• 不可变性：元组是不可变的，创建后不能添加、删除或修改元素。

• 异构性：元组可以包含不同类型的元素（如整数、字符串、列表等）。

• 轻量级：由于元组不可变，它的内存占用和性能通常优于列表。

创建元组

元组用圆括号 () 表示，元素之间用逗号 , 分隔。如果元组只有一个元素，需要在元素后加一个逗号。

# 创建一个空元组
empty_tuple = ()

# 创建一个包含整数的元组
numbers = (1, 2, 3, 4, 5)

# 创建一个包含不同类型元素的元组
mixed_tuple = (1, "hello", 3.14, True)

# 创建一个嵌套元组（元组中的元素也是元组）
nested_tuple = ((1, 2, 3), (4, 5, 6), (7, 8, 9))

# 创建只有一个元素的元组
single_element_tuple = (42,)  # 注意逗号

访问元组元素

元组中的元素通过索引访问，索引从 0 开始。

fruits = ("apple", "banana", "cherry")

# 访问第一个元素
print(fruits[0])  # 输出: apple

# 访问最后一个元素
print(fruits[-1])  # 输出: cherry

元组的不可变性

元组是不可变的，因此不能直接修改元组的元素。如果尝试修改元组，会抛出 TypeError。

fruits = ("apple", "banana", "cherry")

# 尝试修改元组元素（会报错）
fruits[1] = "blueberry"  # TypeError: 'tuple' object does not support item assignment

元组的常用操作

切片操作

切片用于获取元组的子集，语法为 tuple[start:stop:step]。

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

# 获取前3个元素
print(numbers[:3])  # 输出: (0, 1, 2)

# 获取第2到第5个元素
print(numbers[2:5])  # 输出: (2, 3, 4)

# 获取偶数索引的元素
print(numbers[::2])  # 输出: (0, 2, 4, 6, 8)

元组拼接

可以使用 + 操作符拼接两个元组。

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)

# 拼接两个元组
combined_tuple = tuple1 + tuple2
print(combined_tuple)  # 输出: (1, 2, 3, 4, 5, 6)

元组重复

可以使用 * 操作符重复元组。

tuple1 = (1, 2, 3)

# 重复元组
repeated_tuple = tuple1 * 3
print(repeated_tuple)  # 输出: (1, 2, 3, 1, 2, 3, 1, 2, 3)

字典

Python 中的 字典（dictionary） 是一种内置的数据结构，用于存储键值对（key-value pairs）。字典是无序的（在 Python 3.7 及更高版本中，字典保持插入顺序），并且键必须是唯一的。字典非常适合用于存储和快速查找数据。

字典的特点

• 键值对：字典中的每个元素都是一个键值对，格式为 key: value。

• 无序性：在 Python 3.6 及更早版本中，字典是无序的；在 Python 3.7 及更高版本中，字典保持插入顺序。

• 可变性：字典是可变的（mutable），可以动态添加、删除或修改键值对。

• 键的唯一性：字典中的键必须是唯一的，如果重复，后面的键值对会覆盖前面的。

• 键的类型：键必须是不可变类型（如整数、字符串、元组），而值可以是任意类型。

创建字典

字典用花括号 {} 表示，键值对之间用逗号 , 分隔。

# 创建一个空字典
empty_dict = {}

# 创建一个包含键值对的字典
person = {
    "name": "Alice",
    "age": 25,
    "is_student": True
}

# 使用 dict() 函数创建字典
another_person = dict(name="Bob", age=30, is_student=False)

访问字典元素

字典中的值通过键访问。

person = {
    "name": "Alice",
    "age": 25,
    "is_student": True
}

# 访问键 "name" 对应的值
print(person["name"])  # 输出: Alice

# 访问不存在的键会报错
# print(person["address"])  # KeyError: 'address'

使用 get() 方法
get() 方法可以安全地访问字典元素，如果键不存在，返回 None 或指定的默认值。

# 使用 get() 方法访问键
print(person.get("name"))  # 输出: Alice

# 访问不存在的键，返回 None
print(person.get("address"))  # 输出: None

# 访问不存在的键，返回默认值
print(person.get("address", "Unknown"))  # 输出: Unknown

修改字典元素

字典是可变的，可以通过键直接修改或添加元素。

person = {
    "name": "Alice",
    "age": 25,
    "is_student": True
}

# 修改键 "age" 对应的值
person["age"] = 26
print(person)  # 输出: {'name': 'Alice', 'age': 26, 'is_student': True}

# 添加新的键值对
person["address"] = "123 Main St"
print(person)  # 输出: {'name': 'Alice', 'age': 26, 'is_student': True, 'address': '123 Main St'}

删除字典元素

可以使用 del 语句、pop() 方法或 popitem() 方法删除字典中的元素。

person = {
    "name": "Alice",
    "age": 25,
    "is_student": True
}

# 使用 del 删除键值对
del person["age"]
print(person)  # 输出: {'name': 'Alice', 'is_student': True}

# 使用 pop() 删除键值对并返回值
is_student = person.pop("is_student")
print(is_student)  # 输出: True
print(person)  # 输出: {'name': 'Alice'}

# 使用 popitem() 删除并返回最后一个键值对（Python 3.7+）
key, value = person.popitem()
print(key, value)  # 输出: name Alice
print(person)  # 输出: {}

字典的常用操作

遍历字典

可以使用 for 循环遍历字典的键、值或键值对。

person = {
    "name": "Alice",
    "age": 25,
    "is_student": True
}

# 遍历键
for key in person:
    print(key)  # 输出: name, age, is_student

# 遍历值
for value in person.values():
    print(value)  # 输出: Alice, 25, True

# 遍历键值对
for key, value in person.items():
    print(key, value)  # 输出: name Alice, age 25, is_student True

检查键是否存在

可以使用 in 关键字检查字典中是否包含某个键。

if "name" in person:
    print("Name exists")  # 输出: Name exists

获取字典的长度

使用 len() 函数获取字典中键值对的数量。

print(len(person))  # 输出: 3