Python自动化测试笔试面试题精选

Python自动化测试笔试面试题主要围绕基本编码能力、数据结构、算法及核心编程思想展开，重点考察哈希、递归、分治等思想的应用。 以下是精选题型及解析：

哈希的核心是通过字典或集合的键值唯一性优化查找效率（时间复杂度O(1)），常用于去重、分组统计、快速查询等场景。

1. 列表去重

   不考虑顺序：直接使用set()转换，自动去重并排序。

   l = [2,1,2,3,4,5,6,6,5,4,3,2,1]result = list(set(l)) # 输出：[1, 2, 3, 4, 5, 6]

   保持顺序：利用字典的fromkeys()方法，通过键值唯一性去重。

   l = [2,1,2,3,4,5,6,6,5,4,3,2,1]result = list({}.fromkeys(l).keys()) # 输出：[2, 1, 3, 4, 5, 6]

2. 分组统计并排序

   方法1：使用集合去重后统计每个元素的出现次数，再按次数排序。

   l = [1,2,3,'a','b','c',1,2,'a','b',3,'c','d','a','b',1]set1 = set(l)result = [(item, l.count(item)) for item in set1]result.sort(key=lambda x: x[1], reverse=True) # 按次数降序排序

   方法2：使用itertools.groupby，需先排序再分组统计。

   from itertools import groupbyl.sort(key=lambda x: str(x)) # 分组前排序result = [(item, len(list(group))) for item, group in groupby(l, key=lambda x: str(x))]result.sort(key=lambda x: x[1], reverse=True)

3. 海量数据找Top K

   小数据量：直接去重后排序取前K个。

   l = list(set(l)) # 去重result = sorted(l)[-k:] # 排序后取最后K个

   大数据量：使用堆排序（heapq.nlargest）优化内存占用。

   import heapqresult = heapq.nlargest(k, l) # 直接取最大的K个数

4. 两数之和

   优化思路：单层循环遍历列表，用集合存储已遍历元素，快速查找目标值与当前值的差是否存在于集合中（时间复杂度O(n)）。

   l = [1,2,3,4,5,6,7,8]set1 = set(l)target = 6result = []for a in l: b = target - a if a < b and b in set1: # 避免重复，确保a是较小的数 result.append((l.index(a), l.index(b)))

递归通过函数调用自身实现分层推导，需明确递归出口和每层推导逻辑，常用于树遍历、排序、数学问题等。

1. 阶乘计算

   递归定义：n! = n * (n-1)!，出口为0! = 1。

   def factorial(n): if n == 0: return 1 return n * factorial(n - 1)

2. 斐波那契数列

   递归定义：F(n) = F(n-1) + F(n-2)，出口为F(0)=0, F(1)=1。

   def fibonacci(n): if n == 0: return 0 elif n == 1: return 1 return fibonacci(n - 1) + fibonacci(n - 2)

3. 二叉树深度遍历

   前序遍历：根节点 → 左子树 → 右子树。

   def preorder(root): if not root: return print(root.val) # 访问根节点 preorder(root.left) # 递归左子树 preorder(root.right) # 递归右子树

4. 判断平衡二叉树

   平衡条件：任意节点的左右子树高度差不超过1。

   def is_balanced(root): def check(node): if not node: return 0 left_height = check(node.left) right_height = check(node.right) if left_height == -1 or right_height == -1 or abs(left_height - right_height) > 1: return -1 # 不平衡 return max(left_height, right_height) + 1 return check(root) != -1

分治通过将问题分解为子问题递归求解，常用于排序、海量数据处理等场景。

1. 快速排序

   分治步骤：选基准值 → 分区（小于基准的放左边，大于的放右边） → 递归排序子数组。

   def quick_sort(arr): if len(arr) <= 1: return arr pivot = arr[len(arr) // 2] left = [x for x in arr if x < pivot] middle = [x for x in arr if x == pivot] right = [x for x in arr if x > pivot] return quick_sort(left) + middle + quick_sort(right)

2. 海量数据分治处理

   场景：1000万数据求Top K时，若内存不足，可分块读取数据，用哈希去重后合并结果，再通过堆排序优化。

   # 示例：分块处理后合并def process_chunk(chunk): return list(set(chunk)) # 去重chunks = [gen_num(1000000) for _ in range(10)] # 分10块merged = []for chunk in chunks: merged.extend(process_chunk(chunk))result = heapq.nlargest(k, merged)

• 哈希：优化查找效率（O(1)），适用于去重、分组统计、快速查询。
• 递归：分层推导问题，需明确出口和递归逻辑，常用于树、排序、数学问题。
• 分治：分解问题递归求解，适用于排序、海量数据处理。

掌握这些核心思想及代码实现，可高效应对Python自动化测试的笔试面试题。