Python 数据结构：列表、元组、字典与集合

一、列表（List）

（一）列表定义与创建

  • 列表是一种可变的、有序的数据结构，可容纳不同类型的元素。
  • 创建方式：
# 空列表
empty_list = []
# 包含元素的列表
mixed_list = [1, "apple", True, 3.14]

（二）列表操作

  1. 访问元素：通过索引访问，索引从 0 开始。
my_list = [10, 20, 30, 40]
print(my_list[0])  # 输出 10
  1. 切片操作：获取列表的子列表。
print(my_list[1:3])  # 输出 [20, 30]
  1. 修改元素：可直接通过索引修改列表中的元素。
my_list[2] = 35
print(my_list)  # 输出 [10, 20, 35, 40]
  1. 添加元素
  • append()：在列表末尾添加一个元素。
my_list.append(50)
print(my_list)  # 输出 [10, 20, 35, 40, 50]
  • extend()：将一个可迭代对象的元素添加到列表末尾。
new_list = [60, 70]
my_list.extend(new_list)
print(my_list)  # 输出 [10, 20, 35, 40, 50, 60, 70]
  • insert()：在指定位置插入元素。
my_list.insert(2, 25)
print(my_list)  # 输出 [10, 20, 25, 35, 40, 50, 60, 70]
  1. 删除元素
  • remove()：删除指定值的第一个匹配项。
my_list.remove(25)
print(my_list)  # 输出 [10, 20, 35, 40, 50, 60, 70]
  • pop()：删除指定索引的元素，若不指定索引则删除最后一个元素。
removed = my_list.pop(2)
print(removed)  # 输出 35
print(my_list)  # 输出 [10, 20, 40, 50, 60, 70]
  • del：删除指定索引的元素。
del my_list[0]
print(my_list)  # 输出 [20, 40, 50, 60, 70]
  1. 列表排序
  • sort()：对列表进行原地排序。
my_list.sort()
print(my_list)  # 输出 [20, 40, 50, 60, 70]
  • sorted()：返回一个新的排序后的列表，原列表不变。
new_sorted_list = sorted(my_list, reverse=True)
print(new_sorted_list)  # 输出 [70, 60, 50, 40, 20]
  1. 列表反转
my_list.reverse()
print(my_list)  # 输出 [70, 60, 50, 40, 20]

二、元组（Tuple）

（一）元组定义与创建

  • 元组是一种不可变的、有序的数据结构，可容纳不同类型的元素。
  • 创建方式：
# 空元组
empty_tuple = ()
# 包含元素的元组
single_element_tuple = (1,)  # 单个元素的元组需要加逗号
mixed_tuple = (1, "banana", False)

（二）元组操作

  1. 访问元素：通过索引访问，索引从 0 开始。
my_tuple = (100, 200, 300)
print(my_tuple[1])  # 输出 200
  1. 切片操作：获取元组的子元组。
print(my_tuple[0:2])  # 输出 (100, 200)
  1. 元组不可修改：试图修改元组元素会引发错误。
# 以下代码会报错
# my_tuple[1] = 250

三、字典（Dictionary）

（一）字典定义与创建

  • 字典是一种可变的、无序的数据结构，由键值对组成，键必须是唯一的且不可变。
  • 创建方式：
# 空字典
empty_dict = {}
# 包含元素的字典
person = {
    "name": "Alice",
    "age": 25,
    "city": "New York"
}

（二）字典操作

  1. 访问元素：通过键访问对应的值。
print(person["name"])  # 输出 Alice
  1. 修改元素：通过键修改对应的值。
person["age"] = 26
print(person)  # 输出 {'name': 'Alice', 'age': 26, 'city': 'New York'}
  1. 添加元素：直接使用新的键值对赋值。
person["job"] = "Engineer"
print(person)  # 输出 {'name': 'Alice', 'age': 26, 'city': 'New York', 'job': 'Engineer'}
  1. 删除元素：使用 del 关键字删除指定键的键值对。
del person["city"]
print(person)  # 输出 {'name': 'Alice', 'age': 26, 'job': 'Engineer'}
  1. 获取所有键和值
  • keys()：返回字典中所有键的视图。
print(person.keys())  # 输出 dict_keys(['name', 'age', 'job'])
  • values()：返回字典中所有值的视图。
print(person.values())  # 输出 dict_values(['Alice', 26, 'Engineer'])
  • items()：返回字典中所有键值对的视图。
print(person.items())  # 输出 dict_items([('name', 'Alice'), ('age', 26), ('job', 'Engineer')])
  1. 检查键是否存在：使用 in 关键字。
print("name" in person)  # 输出 True

四、集合（Set）

（一）集合定义与创建

  • 集合是一种可变的、无序且元素唯一的数据结构。
  • 创建方式：
# 空集合
empty_set = set()
# 包含元素的集合
my_set = {1, 2, 3, 3}  # 重复元素会被自动去除
print(my_set)  # 输出 {1, 2, 3}

（二）集合操作

  1. 添加元素：使用 add() 方法。
my_set.add(4)
print(my_set)  # 输出 {1, 2, 3, 4}
  1. 删除元素
  • remove()：删除指定元素，若元素不存在会引发错误。
my_set.remove(3)
print(my_set)  # 输出 {1, 2, 4}
  • discard()：删除指定元素，若元素不存在不会引发错误。
my_set.discard(5)
  1. 集合运算
  • 并集：使用 union() 方法或 | 运算符。
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
print(union_set)  # 输出 {1, 2, 3, 4, 5}
  • 交集：使用 intersection() 方法或 & 运算符。
intersection_set = set1.intersection(set2)
print(intersection_set)  # 输出 {3}
  • 差集：使用 difference() 方法或 - 运算符。
difference_set = set1.difference(set2)
print(difference_set)  # 输出 {1, 2}
  • 对称差集：使用 symmetric_difference() 方法或 ^ 运算符。
symmetric_difference_set = set1.symmetric_difference(set2)
print(symmetric_difference_set)  # 输出 {1, 2, 4, 5}