Python自动化面试常见的编程题及答案
前言
隨著行業的發展，編程能力逐漸成為軟件測試從業人員的一項基本能力。因此在筆試和面試中常常會有一定量的編碼題，主要考察以下幾點。
-
基本編碼能力及思維邏輯
-
基本數據結構（順序表、鏈表、隊列、棧、二叉樹）
-
基本算法（排序、查找、遞歸）及時間復雜度
除基本算法之外，筆試面試中經常會考察以下三種思想：
-
哈希
-
遞歸
-
分治
?
哈希
哈希即Python中的映射類型，字典和集合，鍵值唯一，查找效率高，序列（列表、元祖、字符串）的元素查找時間復雜度是O(n)，而字典和集合的查找只需要O(1)。
因此哈希在列表問題中主要有兩種作用：
去重
優化查找效率
?
列表去重
列表去重在不考慮順序的情況下可以直接使用set()轉換（轉換后會自動排序），需要保持順序可以使用字典構建的fromkeys()方法，利用字典鍵值的唯一性去重。
不考慮順序：
?
l = [2,1,2,3,4,5,6,6,5,4,3,2,1] result = list(set(l)) print(result)運行結果：
?
[1, 2, 3, 4, 5, 6]考慮順序：
?
l = [2,1,2,3,4,5,6,6,5,4,3,2,1] result = list({}.fromkeys(l).keys()) print(result)運行結果：
?
[2, 1, 3, 4, 5, 6]
?
列表分組
一串字母數字組合的字符串，找出相同的字母或數字，并按照個數排序。
?
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) print(result)這里使用哈希的鍵值不重復性。當然也可以使用python自帶的groupby函數，代碼如下：
?
from itertools import groupbyl = [1,2,3,'a','b','c',1,2,'a','b',3,'c','d','a','b',1] l.sort(key=lambda x: str(x)) # 分組前需要先排序 result = [] for item, group in groupby(l, key=lambda x: str(x)):result.append((item, len(list(group)))) result.sort(key=lambda x:x[1], reverse=True)print(result)
?
海量數據top ?K
對于小數據量可以使用排序+切片，而對于海量數據，需要考慮服務器硬件條件。即要考慮時間效率，也要考慮內存占用，同時還要考慮數據特征。如果大量的重復數據，可以先用哈希進行去重來降低數據量。
這里我們使用生成器生成1000萬個隨機整數，求最大的1000個數，生成隨機數的代碼如下：
?
import random import time n = 10000 * 1000 k = 1000 print(n) def gen_num(n):for i in range(n):yield random.randint(0, n) l = gen_num(n)-
不限內存可以直接使用set()去重+排序
?
start = time.time() l = list(set(l)) result = l[-k:] result.reverse() print(time.time()-start)1000w個數據會全部讀入內存，set后列表自動為遞增順序，使用切片取-1000到最后的即為top 1000的數
-
使用堆排可以節省一些內存
?
start = time.time() result = heapq.nlargest(k, l) print(time.time()-start)這里是用來Python自帶的堆排庫heapq。使用nlargest(k,l)可以取到l序列，最大的k個數。
-
較小內存可以分治策略，使用多線程對數據進行分組處理（略）
?
兩數之和
l=[1,2,3,4,5,6,7,8] 數據不重復，target=6，快速找出數組中兩個元素之和等于target 的數組下標。
注意，不要使用雙重循環，暴力加和來和target對比，正確的做法是單層循環，然后查找target與當前值的差，是否存在于列表中。
但是由于列表的in查詢時間復雜度是O(n)，即隱含了一層循環，這樣效率其實和雙重循環是一樣的，都是O(n^2)。
這里就可以使用哈希來優化查詢差值是否在列表中操作，將O(n)降為O(1)，因此總體的效率就會變成O(n^2)->O(n)。
?
l = [1,2,3,4,5,6,7,8] set1 = set(list1) # 使用集合已方便查找 target = 6result = [] for a in list1:b = target - aif a < b < target and b in set1: # 在集合中查找,為避免重復，判斷a為較小的那個值result.append((list1.index(a), list1.index(b))) # 列表index取下標的操作為O(1)print(result)
?
遞歸問題
遞歸是一種循環調用自身的函數。可以用于解決以下高頻問題：
-
階乘
-
斐波那切數列
-
跳臺階、變態跳臺階
-
快速排序
-
二分查找
-
二叉樹深度遍歷（前序、中序、后序）
-
求二叉樹深度
-
平衡二叉樹判斷
-
判斷兩顆樹是否相同
遞歸是一種分層推導解決問題的方法，是一種非常重要的解決問題的思想。遞歸可快速將問題層級化，簡單化，只需要考慮出口和每層的推導即可。
如階乘，要想求n!，只需要知道前一個數的階乘(n-1)!，然后乘以n即可，因此問題可以轉為求上一個數的階乘，依次向前，直到第一個數。
舉個通俗的例子：
A欠你10萬，但是他沒那么多錢，B欠A 8萬，C欠B 7萬 C現在有錢。因此你要逐層找到C，一層一層還錢，最后你才能拿到屬于你的10萬。
編寫遞歸函數有兩個要點：
出口條件，可以不止一個
推導方法（已知上一個結果怎么推導當前結果）
?
階乘
求n的階乘
-
出口：n = 1 時，返回1
-
推導：(n-1)層的結果 * n
代碼如下：
?
def factorial(n):if n == 1: # 出口return 1return factorial(n-1) * n # 自我調用求上一個結果，然后推導本層結果也可以簡寫為?factorial = lambda n: 1 if n==1 else factorial(n-1) * n
斐波那切數列
斐波那切數列是 1 1 2 3 5 8 ...這樣的序列。前兩個數為1，后面的數為前兩個數之和。
-
出口：n <= 2，返回1
-
推導：(n-1)層的結果 + (n-2)層的結果
代碼如下：
?
def fib(n):if n<=2:return 1return fib(n-2) + fib(n-1)遞歸是一種分層簡化問題的解法，但不一定是效率最高的解法，比如斐波那切數列中，在求fib(n-2) 和 fib(n-1)時實際上反復求解了兩次fib(n-2)。
可以通過緩存來優化效率，代碼如下。
?
from functools import lru_cache@lru_cache() def fib(n):if n<=2:return 1return fib(n-2) + fib(n-1)
?
跳臺階、變態跳臺階
-
跳臺階：一只青蛙，一次可以跳上1階，也可以跳上2階，問跳上n階有多少種跳法。
-
變態跳臺階：一只青蛙，一次可以跳上1階，可以一次跳上n階，為跳上n階有多少種跳法。
這個問題關鍵是邏輯分析每層的推導過程。
跳臺階實際上就是一個從第二位開始的斐波那切數列：1 2 3 5 8 13 ...
-
出口：n <= 2，返回n（即1時返回1，2時返回2）
-
推導：(n-1)層的結果 + (n-2)層的結果
代碼如下：
?
jump1 = lambda n: n if n<=2 else jump1(n-2) + jump1(n-1)變態跳臺階只是推導方式不同，每一層的結果是上一層跳法的2倍。
-
出口：n <= 2，返回n
-
推導：(n-1)層的結果 * 2
代碼如下：
?
jump2 = lambda n: n if n<=2 else jump2(n-1) * 2
?
快速排序
快速排序的是想是選一個基準數（如第一個數），將大于該數和小于該數的分成兩塊，然后在每一塊中重復執行此操作，直到該塊中只有一個數，即為有序。
-
出口：列表長度為1（<2）時，返回列表
-
選擇一個數，（將小于該數的序列）排序結果 ?+ ?基準數 + （大于該數的序列）排序結果
?
def quick_sort(l): length = len(l)if len(l) <=1:return lmid = 0low_part = [i for i in l[1:] if i < l[mid]]eq_part = [i for i in l[1:] if i == l[mid]]high_part = [i for i in l[1:] if i > l[mid]]return quick_sort(low_part) + eq_part + quick_sort(high_part)
?
二分查找
二分查找需要序列首先有序。思想是先用序列中間數和目標值對比，如果目標值小，則從前半部分（小于中間數）重復此查找，否則從后半部分重復此查找。
-
出口1：中間數和目標數相同，返回中間數下標
-
出口2：列表為空，返回未找到
-
推導：
?
def bin_search(l, n): if not l:return Nonemid = len(l) // 2if l[mid] == n:return midif l[mid] > n:return bin_search(l[:mid])return bin_search(l[mid+1:])
?
二叉樹遍歷
二叉樹是非常常考的一種數據結構。其基本結構就是一個包含數據和左右節點的一種結構，使用Python類描述如下：
?
class Node(object):def __init__(self, data, left=None, right=None):self.data = dataself.left = leftself.right = right二叉樹的遍歷分為分層遍歷（廣度優先）和深度遍歷（深度優先）兩種，其中深度遍歷又分為前序、中序、后序三種。
分層遍歷由于每次處理多個節點，使用循環解決更加方便一點（也可以是使用遞歸解決）。
分層遍歷代碼如下：
?
def lookup(root):row = [root]while(row):print(row)row = [kid for item in row for kid in (item.left, item.right) if kid]深度遍歷
-
出口：節點為None
-
推導：
-
前序：打印當前節點-》遍歷左子樹 -》遍歷右子樹
-
中序：遍歷左子樹 -》打印當前節點-》遍歷右子樹
-
后序：遍歷左子樹 -》遍歷右子樹-》打印當前節點
-
以前序為例：
?
def deep(root):if root is none:return[print(root.data), deep(root.left), deep(root.right)]
?
二叉樹最大深度
二叉樹最大深度即其左子樹深度和右子樹深度中最大的一個加上1（當前節點）。由于二叉樹的每一個左右節點都是一個二叉樹，這種層層嵌套的結構非常適合使用遞歸求解。
-
出口：節點為空，深度返回0
-
推導：左子樹深度和右子樹深度中最大的一個 + 1
?
def max_depth(root):if not root:return 0return max([max_depth(root.left), max_depth(root.right)]) + 1
?
相等二叉樹判斷
相等二叉樹是只，一個二叉樹，節點數據相同，左右子樹也完全相同。由于左右子樹也是一個二叉樹，因此也可以使用遞歸求解。如果大家對Python感興趣的話，可以加一下我們的學習交流摳摳群哦：649，825，285，免費領取一套學習資料和視頻課程喲~
-
出口：最后的節點都為None時，兩個相等，返回True
-
推導：判斷兩個節點數據是否相等，左子樹是否相等（遞歸），右子樹是否相等（遞歸）
?
def is_same_tree(p, q):if p is None and q is None:return Trueelif p and q:return p.data == q.data and is_same_tree(p.left, q.left) and is_same_tree(p.right, q.right)?
平衡二叉樹判斷
平衡二叉樹是指，一個二叉樹的左右子樹的高度差不超過1。平衡二叉樹的左右子樹也應該是平衡二叉樹，因此這也是一個遞歸問題。
-
出口：兩個節點都為None時，返回True（平衡）
-
判斷左子樹和右子樹深度的差<=1，并且左右子樹都是平衡二叉樹（遞歸）
注：這里需要使用以上求二叉樹深度的方法
?
def max_depth(root):if not root:return 0return max([max_depth(root.left), max_depth(root.right)]) + 1def is_balance_tree(root):if root is None:return Truereturn abs(max_depth(root.left)-max_depth(root.right))<=1 and is_balance_tree(root.left) and is_balance_tree(root.right)?
總結
以上是生活随笔為你收集整理的Python自动化面试常见的编程题及答案的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 2020年什么编程语言最受欢迎，待遇最高
- 下一篇： Python3基本数据类型快速入门