python基础：python语言的数据结构+面试习题

Python语言中内置了多种常用的数据结构，用于组织和存储数据：

1. 列表 (List)

有序、可变的序列，允许存储不同类型的元素。

特点 ：

• 用方括号 [] 表示

• 元素可以重复

• 支持索引和切片操作

• 可变（可修改、添加、删除元素）

基本操作：

# 创建列表
my_list = [1, "apple", 3.14, True]

# 访问元素
print(my_list[0])  # 1
print(my_list[-1])  # True

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

# 添加元素
my_list.append("new")  # [1, "apple", 3.14, True, "new"]
my_list.insert(1, "orange")  # [1, "orange", "apple", 3.14, True, "new"]

# 删除元素
my_list.remove("apple")  # [1, "orange", 3.14, True, "new"]
del my_list[0]  # ["orange", 3.14, True, "new"]
popped = my_list.pop()  # ["orange", 3.14, True], popped = "new"

# 其他操作
print(len(my_list))  # 3
print("apple" in my_list)  # False
print(my_list.reverse())  # [True, 3.14, "orange"]
print(my_list.sort())  # 对同类型元素排序

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)

无序、可变的键值对集合。

特点 ：

• 用花括号 {} 表示

• 键必须唯一且不可变（字符串、数字、元组）

• 值可以是任何类型

• 支持键访问

基本操作 ：

# 创建字典
my_dict = {"name": "Alice", "age": 25, "city": "New York"}
# 或
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}
# 或
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)  # 元素是否存在
print(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
queue = deque([1, 2, 3])
queue.append(4)  # 添加到末尾
queue.popleft()  # 从开头取出

堆 (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

}

要求用户输入一个学生姓名，程序输出该学生的成绩。
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_listoriginal = [1, 2, 2, 3, 4, 4, 5]
result = remove_duplicates(original)print(result)  
# 输出：[1, 2, 3, 4, 5]（保持原始顺序）