Python数据结构基本操作总结

1. 列表（Lists）

定义与特性

• 有序集合：列表中的元素按照插入顺序排列，每个元素都有一个对应的索引。
• 可变性：列表是可变的，可以在创建后修改其内容，包括添加、删除或更改元素。
• 多样性：列表可以包含不同类型的元素，如整数、字符串、甚至其他列表（嵌套列表）。

创建列表

# 创建一个空列表
empty_list = []# 创建一个包含多个元素的列表
fruits = ['苹果', '香蕉', '橙子']

基本操作

索引和切片

• 索引：通过索引访问特定位置的元素，索引从0开始。支持负索引，从末尾开始计数。
• 切片：通过指定开始和结束索引来获取子列表。

fruits = ['苹果', '香蕉', '橙子', '葡萄', '桃子']
print(fruits[0])    # 输出: 苹果
print(fruits[-1])   # 输出: 桃子
print(fruits[1:3])  # 输出: ['香蕉', '橙子']

添加和删除元素

• 添加元素：

  • append(x)：在列表末尾添加一个元素。
  • insert(i, x)：在指定位置插入一个元素。
  • extend(iterable)：将一个可迭代对象的所有元素添加到列表末尾。

• 删除元素：

  • remove(x)：删除列表中第一个匹配的元素。
  • pop([i])：删除并返回指定位置的元素，默认删除最后一个元素。
  • clear()：删除列表中的所有元素。

fruits = ['苹果', '香蕉', '橙子']
fruits.append('葡萄')          # ['苹果', '香蕉', '橙子', '葡萄']
fruits.insert(1, '桃子')       # ['苹果', '桃子', '香蕉', '橙子', '葡萄']
fruits.remove('香蕉')          # ['苹果', '桃子', '橙子', '葡萄']
last_fruit = fruits.pop()      # 删除并返回 '葡萄'
fruits.clear()                 # []

列表推导式

列表推导式是一种简洁的生成列表的方式，通常包含一个表达式和一个或多个 for 循环以及可选的 if 条件。

# 生成0到9的平方列表
squares = [x**2 for x in range(10)]  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]# 生成偶数的平方列表
even_squares = [x**2 for x in range(10) if x % 2 == 0]  # [0, 4, 16, 36, 64]

其他常用方法

• index(x)：返回元素x在列表中第一次出现的索引。
• count(x)：返回元素x在列表中出现的次数。
• sort()：对列表进行排序。
• reverse()：反转列表中的元素。

numbers = [3, 1, 4, 1, 5, 9, 2]
print(numbers.index(5))    # 输出: 4
print(numbers.count(1))    # 输出: 2
numbers.sort()             # [1, 1, 2, 3, 4, 5, 9]
numbers.reverse()          # [9, 5, 4, 3, 2, 1, 1]

---

2. 元组（Tuples）

定义与特性

• 有序集合：元组中的元素按照插入顺序排列，每个元素都有一个对应的索引。
• 不可变性：元组一旦创建，其内容不能修改，包括添加、删除或更改元素。
• 多样性：元组可以包含不同类型的元素，支持嵌套。

创建元组

# 创建一个空元组
empty_tuple = ()# 创建一个包含多个元素的元组
coordinates = (10, 20)

基本操作

访问元素

• 索引：通过索引访问特定位置的元素，支持负索引。
• 切片：获取子元组。

coordinates = (10, 20, 30, 40)
print(coordinates[0])    # 输出: 10
print(coordinates[-1])   # 输出: 40
print(coordinates[1:3])  # 输出: (20, 30)

不可变性

• 特性：元组一旦创建，不能修改其内容。这使得元组在需要确保数据不被意外修改的场景下非常有用，例如作为字典的键。
• 优点：由于不可变性，元组在某些情况下比列表更高效，尤其是在作为哈希键使用时。

元组的使用场景

• 多重赋值：

  point = (10, 20)
  x, y = point
  

• 函数返回多个值：

  def get_min_max(values):return (min(values), max(values))min_val, max_val = get_min_max([3, 1, 4, 1, 5, 9, 2])
  

其他常用方法

• count(x)：返回元素x在元组中出现的次数。
• index(x)：返回元素x在元组中第一次出现的索引。

numbers = (1, 2, 3, 2, 4)
print(numbers.count(2))    # 输出: 2
print(numbers.index(4))    # 输出: 4

---

3. 集合（Sets）

定义与特性

• 无序集合：集合中的元素没有特定的顺序。
• 唯一性：集合中的元素是唯一的，重复的元素会被自动去除。
• 可变性：集合是可变的，可以添加或删除元素。
• 类型限制：集合中的元素必须是可哈希的（即不可变的）。

创建集合

# 创建一个空集合（注意：{} 创建的是空字典）
empty_set = set()# 创建一个包含多个元素的集合
fruits = {'苹果', '香蕉', '橙子'}

基本操作

添加和删除元素

• 添加元素：

  • add(x)：添加一个元素到集合中。
  • update(iterable)：添加多个元素到集合中。

• 删除元素：

  • remove(x)：删除集合中的元素x，如果x不存在会引发 KeyError。
  • discard(x)：删除集合中的元素x，如果x不存在不会有任何操作。
  • pop()：随机删除并返回一个元素。

fruits = {'苹果', '香蕉'}
fruits.add('橙子')              # {'苹果', '香蕉', '橙子'}
fruits.update(['葡萄', '桃子'])  # {'苹果', '香蕉', '橙子', '葡萄', '桃子'}
fruits.remove('香蕉')            # {'苹果', '橙子', '葡萄', '桃子'}
fruits.discard('草莓')           # 不存在，不报错
removed_fruit = fruits.pop()     # 随机删除一个元素

集合运算

• 并集（Union）：两个集合的所有元素。

  • 运算符：|
  • 方法：union()

• 交集（Intersection）：两个集合的共同元素。

  • 运算符：&
  • 方法：intersection()

• 差集（Difference）：存在于第一个集合但不存在于第二个集合的元素。

  • 运算符：-
  • 方法：difference()

• 对称差集（Symmetric Difference）：存在于其中一个集合但不同时存在于两个集合中的元素。

  • 运算符：^
  • 方法：symmetric_difference()

a = {'苹果', '香蕉', '橙子'}
b = {'香蕉', '葡萄', '桃子'}print(a | b)  # 并集: {'苹果', '香蕉', '橙子', '葡萄', '桃子'}
print(a & b)  # 交集: {'香蕉'}
print(a - b)  # 差集: {'苹果', '橙子'}
print(a ^ b)  # 对称差集: {'苹果', '橙子', '葡萄', '桃子'}

其他常用方法

• issubset(other)：判断当前集合是否是另一个集合的子集。
• issuperset(other)：判断当前集合是否是另一个集合的超集。
• isdisjoint(other)：判断两个集合是否没有共同元素。

a = {'苹果', '香蕉'}
b = {'苹果', '香蕉', '橙子'}print(a.issubset(b))      # 输出: True
print(b.issuperset(a))    # 输出: True
print(a.isdisjoint({'葡萄'}))  # 输出: True
print(a.isdisjoint({'香蕉'}))  # 输出: False

---

4. 字典（Dictionaries）

定义与特性

• 键值对集合：字典由键（key）和值（value）组成的对组成，每个键与其对应的值相关联。
• 无序集合：字典中的键值对没有特定的顺序（Python 3.7+ 中，字典保持插入顺序）。
• 键的唯一性：每个键在字典中必须是唯一的，值则可以重复。
• 键的不可变性：键必须是不可变的数据类型，如字符串、数字或元组。

创建字典

# 创建一个空字典
empty_dict = {}# 创建一个包含多个键值对的字典
person = {'姓名': '张三','年龄': 30,'城市': '北京'
}

基本操作

访问与修改

• 访问值：

  • 通过键访问对应的值，使用 dict[key] 或 dict.get(key) 方法。
  • get(key, default) 方法可以在键不存在时返回默认值，而不会引发错误。

• 修改值：

  • 通过键直接赋值，添加或更新键值对。

• 删除键值对：

  • 使用 del dict[key] 删除特定键。
  • 使用 pop(key) 删除特定键并返回其值。
  • 使用 clear() 删除所有键值对。

person = {'姓名': '张三', '年龄': 30}# 访问
print(person['姓名'])          # 输出: 张三
print(person.get('城市', '未知'))  # 输出: 未知# 修改
person['年龄'] = 31           # 更新年龄
person['城市'] = '上海'        # 添加城市# 删除
del person['城市']            # 删除城市
age = person.pop('年龄')      # 删除年龄并返回
person.clear()                # 清空字典

字典方法

• keys()：返回字典中所有键的视图。
• values()：返回字典中所有值的视图。
• items()：返回字典中所有键值对的视图。
• update(other)：将另一个字典或键值对序列合并到当前字典中。
• copy()：返回字典的浅拷贝。

person = {'姓名': '张三', '年龄': 30, '城市': '北京'}print(person.keys())    # 输出: dict_keys(['姓名', '年龄', '城市'])
print(person.values())  # 输出: dict_values(['张三', 30, '北京'])
print(person.items())   # 输出: dict_items([('姓名', '张三'), ('年龄', 30), ('城市', '北京')])# 更新字典
person.update({'年龄': 31, '职业': '工程师'})

字典推导式

类似于列表推导式，字典推导式用于通过某种逻辑生成字典。

# 生成一个数字及其平方的字典
squares = {x: x**2 for x in range(5)}  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}# 过滤字典中的偶数键
filtered = {k: v for k, v in squares.items() if k % 2 == 0}  # {0: 0, 2: 4, 4: 16}

---

5. 序列操作（Sequence Operations）

通用操作

Python 提供了一组通用函数，可以应用于所有序列类型（如列表、元组、字符串等）。

• len(s)：返回序列的长度。
• max(s)：返回序列中的最大值。
• min(s)：返回序列中的最小值。
• sorted(s)：返回一个排序后的新列表。
• reversed(s)：返回一个反向迭代器。

fruits = ['苹果', '香蕉', '橙子']
print(len(fruits))    # 输出: 3
print(max(fruits))    # 输出: 橙子（根据字母顺序）
print(min(fruits))    # 输出: 苹果sorted_fruits = sorted(fruits)      # ['苹果', '橙子', '香蕉']
reversed_fruits = list(reversed(fruits))  # ['橙子', '香蕉', '苹果']

成员测试

使用 in 和 not in 运算符检查元素是否存在于序列中。

fruits = ['苹果', '香蕉', '橙子']
print('香蕉' in fruits)     # 输出: True
print('葡萄' not in fruits) # 输出: True

连接与重复

• 连接：使用 + 运算符连接两个序列。
• 重复：使用 * 运算符重复序列。

a = [1, 2, 3]
b = [4, 5]
c = a + b        # [1, 2, 3, 4, 5]
d = a * 2        # [1, 2, 3, 1, 2, 3]s1 = 'Hello'
s2 = 'World'
s3 = s1 + ' ' + s2  # 'Hello World'
s4 = s1 * 3          # 'HelloHelloHello'

---

6. 列表推导式（List Comprehensions）

定义与用法

列表推导式是一种简洁且高效的方法，用于根据已有的可迭代对象生成新列表。它由一个表达式和一个或多个 for 循环组成，并可包含条件筛选。

# 基本语法
[表达式 for 变量 in 可迭代对象]# 带条件的列表推导式
[表达式 for 变量 in 可迭代对象 if 条件]

示例

• 生成平方数列表：

  squares = [x**2 for x in range(10)]  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
  

• 筛选偶数：

  even_squares = [x**2 for x in range(10) if x % 2 == 0]  # [0, 4, 16, 36, 64]
  

• 嵌套循环：

  pairs = [(x, y) for x in range(3) for y in range(3)]  
  # [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
  

嵌套推导式

列表推导式可以嵌套使用，用于生成多维列表或更复杂的数据结构。

# 生成一个3x3的矩阵
matrix = [[x for x in range(3)] for y in range(3)]
# [[0, 1, 2], [0, 1, 2], [0, 1, 2]]

优势

• 简洁：相比传统的 for 循环，列表推导式代码更简洁。
• 高效：列表推导式在执行速度上通常比等效的循环更快。

注意事项

• 可读性：过于复杂的列表推导式可能影响代码的可读性，建议在逻辑简单时使用，复杂时采用传统循环。
• 嵌套深度：避免过多嵌套，以免代码难以理解。

---

7. 嵌套数据结构（Nested Data Structures）

多层嵌套

Python 的数据结构（如列表、元组、字典、集合）可以相互嵌套，形成复杂的数据层次，适用于存储和处理复杂的数据关系。

# 列表嵌套
matrix = [[1, 2, 3],[4, 5, 6],[7, 8, 9]
]# 字典嵌套
students = {'张三': {'年龄': 20, '成绩': {'数学': 90, '英语': 85}},'李四': {'年龄': 22, '成绩': {'数学': 95, '英语': 80}}
}# 混合嵌套
data = [{'姓名': '张三', '兴趣': ['足球', '音乐']},{'姓名': '李四', '兴趣': ['篮球', '绘画']}
]

访问嵌套元素

通过多级索引或键访问内部元素。

# 访问嵌套列表
print(matrix[1][2])  # 输出: 6# 访问嵌套字典
print(students['张三']['成绩']['数学'])  # 输出: 90# 访问混合嵌套
print(data[0]['兴趣'][1])  # 输出: 音乐

应用场景

• 数据库记录：模拟数据库中的表和记录。
• 配置文件：存储多层次的配置选项。
• 数据分析：处理和组织复杂的数据集。

---

8. 其他数据结构

集合推导式（Set Comprehensions）

类似于列表推导式，集合推导式用于生成集合，保证元素的唯一性。

# 生成一个包含0到9平方的集合
squares_set = {x**2 for x in range(10)}  # {0, 1, 4, 9, 16, 25, 36, 49, 64, 81}# 过滤偶数
even_squares_set = {x**2 for x in range(10) if x % 2 == 0}  # {0, 4, 16, 36, 64}

字典推导式（Dictionary Comprehensions）

用于通过某种逻辑生成字典，包含键和值的表达式。

# 生成一个数字及其平方的字典
squares_dict = {x: x**2 for x in range(5)}  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}# 反转键值对
inverse_dict = {v: k for k, v in squares_dict.items()}  # {0: 0, 1: 1, 4: 2, 9: 3, 16: 4}

---

9. 数据结构的选择

适用场景

选择合适的数据结构对编写高效、可维护的代码至关重要。以下是常见数据结构的适用场景：

• 列表（Lists）：

  • 特点：有序、可变、允许重复元素。
  • 适用场景：需要按顺序存储元素并频繁进行添加、删除操作的场景，如任务列表、动态数据集合。

• 元组（Tuples）：

  • 特点：有序、不可变、允许重复元素。
  • 适用场景：需要固定数据集合，确保数据不被修改的场景，如函数返回多个值、字典的键。

• 集合（Sets）：

  • 特点：无序、唯一、不重复。
  • 适用场景：需要去重、进行集合运算（如并集、交集）的场景，如用户标签、权限管理。

• 字典（Dictionaries）：

  • 特点：键值对存储、无序（保持插入顺序）、键唯一。
  • 适用场景：需要快速查找、关联数据的场景，如配置选项、数据库记录。

性能考虑

• 访问速度：

  • 列表：按索引访问速度快，但查找元素需要线性时间。
  • 字典和集合：基于哈希表，查找、插入和删除操作平均时间复杂度为O(1)。

• 内存使用：

  • 列表和元组：内存占用较低，尤其是元组因不可变性更为紧凑。
  • 字典和集合：由于需要存储哈希值，内存占用相对较高。

可变性与不可变性

• 可变数据结构（如列表、字典、集合）适用于需要频繁修改数据的场景。
• 不可变数据结构（如元组）适用于需要确保数据不被修改或作为哈希键的场景。