python自动化测试面试题代码_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]

s = set()

result = []

for i in l:

if i in s:

continue

s.add(i)

result.append(i)

print(result)

注意，这里如果使用：

if not i in result:

result.append(i)

虽然看起来代码简单，但是列表in查找的的时间复杂度为O(n)，not in的效率比in要差，每次都要进行n次比对。

上例中，使用了一个集合变量s来优化in查找，同时使用in代替not in。

Python3.6后字典按键值插入顺序，如果使用Python3.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 groupby

l = [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 = 6

result = []

for a in set1:

b = target - a

if 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 1

return 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 1

return 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 1

return 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):

if len(l) < 2:

return l

target = l[0] # 以第一个数为基准数

low_part, eq_part, high_part = [], [target], []

for i in l[1:]:

if i < target:

low_part.append(i)

elif i == target:

eq_part.append(i)

else:

high_part.append(i)

return quick_sort(low_part) + eq_part + quick_sort(high_part)

注：eq_part中应包含基准数target。

二分查找

二分查找需要序列首先有序。思想是先用序列中间数和目标值对比，如果目标值小，则从前半部分（小于中间数）重复此查找，否则从后半部分重复此查找。

出口1：中间数和目标数相同，返回中间数下标

出口2：列表为空，返回未找到

推导：

def bin_search(l, n):

if not l:

return None

mid = len(l) // 2

if l[mid] == n:

return mid

if 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 = data

self.left = left

self.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 0

return max([max_depth(root.left), max_depth(root.right)]) + 1

相等二叉树判断

相等二叉树是只，一个二叉树，节点数据相同，左右子树也完全相同。由于左右子树也是一个二叉树，因此也可以使用递归求解。

出口：最后的节点都为None时，两个相等，返回True

推导：判断两个节点数据是否相等，左子树是否相等（递归），右子树是否相等（递归）

def is_same_tree(p, q):

if p is None and q is None:

return True

elif 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 0

return max([max_depth(root.left), max_depth(root.right)]) + 1

def is_balance_tree(root):

if root is None:

return True

return abs(max_depth(root.left)-max_depth(root.right))<=1 and is_balance_tree(root.left) and is_balance_tree(root.right)

其他

字符串统计

str1 = 'abcdaacddceea'

set1 = set(str1)

result = [(char, str1.count(char)) for char in set1]

print(result)

统计重复最多的n个字符

from collections import Counter

c = Counter('abcdaacddceea')

print(c.items())

print(c.most_common(3))

字符串反转

简单字符串反转

Python中字符串反转方式非常多，而且比较高效，可以使用反向切片或者reverse实现。

'abcefg'[::-1]

或

''.join(reversed('abcdefg'))

包含数字字母的字符串，仅反转字母

可以通过遍历判断，如果是字母则取其对应反转索引位置的字母，如果是数字则取当前数字。

a = 'abc123efg'

l = len(a)

r = []

for i,c in enumerate(a):

r.append(c) if c.isdigit() else r.append(a[l-i-1])

print(''.join(r))

判断括号是否闭合

这是栈使用的一个经典示例，思路为，遇到正括号则入栈，遇到反括号则和栈顶判断，如果匹配则匹配的正括号出栈（完成一对匹配），否则打印不匹配，break退出。

text = "({[({{abc}})][{1}]})2([]){({[]})}[]"

def is_closed(text)

stack = [] # 使用list模拟栈, stack.append()入栈, stack.pop()出栈并获取栈顶元素

brackets = {')':'(',']':'[','}':'{'} # 使用字典存储括号的对应关系, 使用反括号作key方便查询对应的括号

for char in text:

if char in brackets.values(): # 如果是正括号,入栈

stack.append(char)

elif char in brackets.keys(): # 如果是反括号

if brackets[char] != stack.pop(): # 如果不匹配弹出的栈顶元素

return False

return True

print(is_closed(text))

合并两个有序列表，并保持有序

常见的解法有两种：

连接 + 排序，时间复杂度度为O((m+n)log2(m+n))

两个队列根据大小依次弹出，时间复杂度度约为O(m+n)

依次出队列的逻辑为：

队列1为空，队列2不为空，从队列2弹出一个数据

队列2为空，队列1不为空，从队列1弹出一个数据

两个都不为空，判断两个对队列顶端哪个小，从哪个列表弹出一个数据

以下为使用Python列表模拟两个队列依次弹出的示例。

由于Python列表尾部弹出list.pop()的的操作效率O(1)，比首部弹出list.pop(0)的操作效率O(n)更高，因此我们先按从大到小排序，最后在执行一次反转。

list1 = [1,5,7,9]

list2 = [2,3,4,5, 6,8,10,12,14]

result = []

for i in range(len(list1) + len(list2)):

if list1 and not list2:

result.append(list1.pop())

elif list2 and not list1:

result.append(list2.pop())

else:

result.append(list1.pop()) if list1[-1] > list2[-1] else result.append(list2.pop()) # 弹出顶端大的数

result.reverse() # 执行反转

print(result)

两个队列实现一个栈

队列是先入先出，栈是先入后出。

使用两个队列实现栈的方式有很多种，主要分为优化入栈和优化出栈两种，以下为优化入栈的一种实现方法。

入栈时直接存入队列q1

出栈时，将q1中元素依次放入q2, 直到最后一个元素，弹出元素，然后将q2中元素重新依次放回q1

实现代码如下：

import queue

class Stack(object):

def __init__(self):

self.q1 = queue.Queue()

self.q2 = queue.Queue()

def push(self, value):

self.q1.put(value)

def pop(self):

while self.q1.qsize() > 1:

self.q2.put(self.q1.get())

value = self.q1.get()

while not self.q2.empty():

self.q1.put(self.q2.get())

return value

测试代码：

s = Stack()

[s.push(i) for i in [1,2,3,4,5,6,7]]

print(s.pop())

打印结果为：

python自动化测试面试题代码_Python自动化测试面试题-编程篇相关推荐

python自动化测试面试题代码_Python自动化测试常见面试题（四）
一._ init _ _ 和 _ _ new _ _是什么? 1.1.概述在python的面向对象中,利用new方法创建对象,然后把这个创建的对象传递到init函数中,以第一个参数进 1.2.详细描 ...
python自动化测试框架哪个好_Python 自动化测试框架unittest与pytest的区别
引言前面一篇文章Python单元测试框架介绍已经介绍了python单元测试框架,大家平时经常使用的是unittest,因为它比较基础,并且可以进行二次开发,如果你的开发水平很高,集成开发自动化测试平 ...
python人像录制加声音_Python自动化测试入门必读
入门自动化测试必读自动化测试概念自动化测试是把以人为驱动的测试行为转化为机器执行的一种过程.通常,在设计了测试用例并通过评审之后,由测试人员根据测试用例中描述的规程一步步执行测试,得到实际结果与期 ...
python爬取豆瓣代码_python爬取豆瓣
在上课时,有时需要显示一个倒计时时钟,让学生做题. PPT 没有简单有效的方法实现倒计时时钟,参考了多个方案,最终决定采用 GIF 动画来实现. 这样使用起来很简单,只要把事先做好的各个时长的倒计时动 ...
python求平方根的代码_Python求解平方根的方法
本文实例讲述了Python求解平方根的方法.分享给大家供大家参考.具体如下: 主要通过SICP的内容改写而来.基于newton method求解平方根.代码如下: #!/usr/bin/python ...
python中怎么复制代码_Python对象怎么引用_Python对象怎么复制代码_一聚教程网
本次文章要给大家讲解的是Python对象引用及复制代码,相信这也是大家问题比较大的一个点,下面为大家具体整理了操作过程,一起来了解下. 可以说Python没有赋值,只有引用.你这样相当于创建了一个引用 ...
python判别性别的代码_python如何实现性别识别 python实现性别识别代码示例
python如何实现性别识别?本篇文章小编给大家分享一下python实现性别识别代码示例,文章代码介绍的很详细,小编觉得挺不错的,现在分享给大家供大家参考,有需要的小伙伴们可以来看看. 使用keras ...
python读文件完整代码_Python读写文件的代码示例
本篇文章给大家带来的内容是关于Python读写文件的代码示例,有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助一.读取文件读取文件步骤: 1.找到文件 2.打开文件 3.读取文件内容 ...
python画正方形的代码_python画正方形的代码是什么？
python画正方形的代码是什么? python画正方形的代码是:import turtle #导入 turtle.title("画正方形") turtle.pensize(5) ...

python自动化测试面试题代码_Python自动化测试面试题-编程篇

python自动化测试面试题代码_Python自动化测试面试题-编程篇相关推荐

最新文章

热门文章