Python 数据结构核心指南与常见面试题解析

2. 元组 (Tuple)

元组是有序、不可变的序列，适合存储不应被修改的数据。

特点：

• 用圆括号 () 表示
• 元素可以重复
• 支持索引和切片操作
• 不可变（创建后不能修改）
• 比列表更节省内存，访问速度更快

基本操作：

# 创建元组
my_tuple = (1, "apple", 3.14)
# 或简写形式
my_tuple = 1, "apple", 3.14

# 单元素元组需要加逗号
single_tuple = (5,)

# 访问元素
print(my_tuple[0])      # 1
print(my_tuple[-1])     # 3.14

# 切片
print(my_tuple[1:])     # ("apple", 3.14)

# 其他操作
print(len(my_tuple))            # 3
print("apple" in my_tuple)      # True
print(my_tuple.count("apple"))  # 1
print(my_tuple.index(3.14))     # 2

# 转换为列表
list_from_tuple = list(my_tuple)

3. 字典 (Dictionary)

字典是无序（Python 3.7+ 保持插入顺序）、可变的键值对集合。

特点：

• 用花括号 {} 表示
• 键必须唯一且不可变（字符串、数字、元组）
• 值可以是任何类型
• 支持键访问

基本操作：

# 创建字典
my_dict = {"name": "Alice", "age": 25, "city": "New York"}
# 或使用 dict 构造函数
my_dict = dict(name="Alice", age=25, city="New York")

# 访问元素
print(my_dict["name"])              # Alice
print(my_dict.get("age"))           # 25
print(my_dict.get("gender", "Unknown")) # Unknown（默认值）

# 修改/添加元素
my_dict["age"] = 26
my_dict["gender"] = "Female"

# 删除元素
del my_dict["city"]
popped = my_dict.pop("age")         # popped = 26

# 遍历字典
for key in my_dict:
    print(key)
for value in my_dict.values():
    print(value)
for key, value in my_dict.items():
    print(key, value)

# 其他操作
print(len(my_dict))                 # 2
print("name" in my_dict)            # True
print(my_dict.keys())               # dict_keys(["name", "gender"])
print(my_dict.values())             # dict_values(["Alice", "Female"])

4. 集合 (Set)

集合是无序、可变的唯一元素集合，常用于去重和数学运算。

特点：

• 用花括号 {} 表示（注意空集合用 set() 而不是 {}）
• 元素不可重复
• 不支持索引
• 支持集合运算（并集、交集、差集等）

基本操作：

# 创建集合
my_set = {1, 2, 3, 4, 5}
# 或 set 构造函数（自动去重）
my_set = set([1, 2, 3, 2, 1])  # {1, 2, 3}

# 添加元素
my_set.add(6)
my_set.update([7, 8, 9])       # 添加多个元素

# 删除元素
my_set.remove(3)               # 如果元素不存在会报错
my_set.discard(10)             # 如果元素不存在不会报错
popped = my_set.pop()          # 随机删除一个元素

# 集合运算
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
print(a | b)                   # 并集 {1, 2, 3, 4, 5, 6}
print(a & b)                   # 交集 {3, 4}
print(a - b)                   # 差集 {1, 2}
print(a ^ b)                   # 对称差集 {1, 2, 5, 6}

# 其他操作
print(len(my_set))             # 集合大小
print(3 in my_set)             # 元素是否存在
my_set.clear()                 # 清空集合

5. 字符串 (String)

字符串是有序、不可变的字符序列。

特点：

• 用单引号 ' 或双引号 " 表示
• 支持索引和切片
• 不可变

基本操作：

# 创建字符串
my_str = "Hello, World!"

# 访问字符
print(my_str[0])              # H
print(my_str[-1])             # !

# 切片
print(my_str[7:12])           # World

# 常用方法
print(my_str.upper())         # HELLO, WORLD!
print(my_str.lower())         # hello, world!
print(my_str.split(","))      # ["Hello", " World!"]
print(my_str.replace("Hello", "Hi")) # Hi, World!
print(my_str.strip())         # 去除首尾空白
print(my_str.startswith("Hello"))   # True
print(my_str.endswith("!"))           # True

# 格式化字符串
name = "Alice"
age = 25
print(f"My name is {name} and I'm {age} years old.") # f-string
print("My name is {} and I'm {} years old.".format(name, age)) # format 方法
print("My name is %s and I'm %d years old." % (name, age)) # %格式化

6. 其他数据结构

Python 标准库还提供了更多高级数据结构：

队列 (Queue)：先进先出 (FIFO)

from collections import deque
queue = deque([1, 2, 3])
queue.append(4)      # 添加到末尾
queue.popleft()      # 从开头取出

栈 (Stack)：后进先出 (LIFO)

from collections import deque
stack = deque([1, 2, 3])
stack.append(4)      # 添加到末尾
stack.pop()          # 从末尾取出（LIFO）

堆 (Heap)：优先队列

import heapq
heap = [3, 1, 4, 1, 5, 9]
heapq.heapify(heap)        # 转换为堆
heapq.heappush(heap, 2)    # 添加元素
heapq.heappop(heap)        # 取出最小元素

有序字典 (OrderedDict)：保持插入顺序的字典（Python 3.7+ 中普通字典已保持插入顺序）

from collections import OrderedDict
od = OrderedDict([("a", 1), ("b", 2)])

默认字典 (defaultdict)：带有默认值的字典

from collections import defaultdict
dd = defaultdict(int)      # 默认值为 0
dd["a"] += 1

7. 面试题目

题目 1：填空题

在 Python 中，__________ 是一种可以存储多个不同类型数据的容器类型。 在 Python 中，__________ 是不可变的数据结构，它与列表类似，但其元素一旦定义就不能修改。

答案： 列表（list）；元组（tuple） 解析： 列表支持混合类型存储且可变；元组与列表结构相似但不可修改。

题目 2：简答题

简要说明列表和元组的区别。Python 中如何使用字典来存储键值对？请给出示例代码。

参考答案：

• 列表： 可变、有序、允许重复，使用 [] 定义，支持 append()/remove() 等操作。
• 元组： 不可变、有序、允许重复，使用 () 定义，适用于保护数据不被修改的场景（如字典键）。
• 字典键值对示例：

student_scores = {"张三": 85, "李四": 90, "王五": 88}
# 查询张三成绩
print(student_scores["张三"])  # 输出：85

题目 3：选择题

以下哪个数据结构是无序的、可变的、并且不允许重复元素？ A. 列表（list） B. 元组（tuple） C. 字典（dict） D. 集合（set）

答案： D. 集合（set） 解析： 集合天然去重且无序，支持并集/交集等操作。

题目 4：编程题

编写一个 Python 程序，使用字典存储学生的姓名和成绩，要求程序可以根据学生姓名查询成绩。

参考代码：

students = {
    "张三": 85,
    "李四": 90,
    "王五": 88
}
name = input("请输入学生姓名：")
if name in students:
    print(f"{name}的成绩是：{students[name]}")
else:
    print("该学生不存在")

题目 5：选择题

在 Python 中，使用下列哪个数据结构可以实现键值对存储？ A. list B. tuple C. dict D. set

答案： C. dict 解析： 字典通过 {键：值} 存储，是唯一支持键值对的内置结构。

题目 6：填空题

Python 中的__________ 是一种有序的容器类型，允许元素重复，可以通过索引来访问其元素。 Python 中的__________ 是一种键值对数据结构，每个元素都包含一个键和一个值。

答案： 列表（list）；字典（dict） 解析： 列表通过索引访问（如 list[0]）；字典通过键访问（如 dict["key"]）。

题目 7：编程题

编写一个 Python 程序，计算并输出列表 [2, 4, 6, 8, 10] 中所有元素的和。提示：使用 for 循环或者 sum() 函数。

参考代码：

numbers = [2, 4, 6, 8, 10]
total = sum(numbers)  # 或使用 for 循环累加
print(f"列表元素和为：{total}")  # 输出：30

题目 8：简答题

简要说明列表和集合的区别，并举例说明它们各自的应用场景。

参考答案：

• 列表 vs 集合：
  • 列表： 有序、可变、允许重复，适用于需要保持顺序的场景（如任务队列）。
  • 集合： 无序、可变、自动去重，适用于需要快速判断元素存在的场景（如去重、集合运算）。

题目 9：选择题

以下哪种数据结构是 Python 中的不可变类型？ A. 列表（list） B. 字典（dict） C. 元组（tuple） D. 集合（set）

答案： C. 元组（tuple） 解析： 元组不可变，常用于定义常量；列表/字典/集合均为可变类型。

题目 10：编程题

编写一个 Python 程序，给定一个列表，删除其中重复的元素并返回一个新的列表。 示例：输入 [1, 2, 2, 3, 4, 4, 5]，输出 [1, 2, 3, 4, 5]

参考代码：

def remove_duplicates(lst):
    seen = set()
    new_list = []
    for item in lst:
        if item not in seen:
            seen.add(item)
            new_list.append(item)
    return new_list

original = [1, 2, 2, 3, 4, 4, 5]
result = remove_duplicates(original)
print(result)  # 输出：[1, 2, 3, 4, 5]（保持原始顺序）