python----selenuim自动化面试题
一、selenium中如何判断元素是否存在？
定位是可以定位到的，但是不能操作，可以判断元素is_displayed()
想点击的话，可以用js去掉dispalay=none的属性
1.集成到jenkins一键执行，可以手动执行，也可以定时执行
七、什么是持续集成？
通过研究selenium-webdriver的源码，笔者发现其实webdriver的实现原理并不高深莫测无法揣度。在这里以webdriver ruby binding的firefox-webdriver实现为例，简单介绍一下webdriver的工作原理。
-
当测试脚本启动firefox的时候，selenium-webdriver 会首先在新线程中启动firefox浏览器。如果测试脚本指定了firefox的profile，那么就以该profile启动，否则的话就新启1个profile，并启动firefox；
-
firefox一般是以-no-remote的方法启动，启动后selenium-webdriver会将firefox绑定到特定的端口，绑定完成后该firefox实例便作为webdriver的remote server存在；
-
客户端(也就是测试脚本)创建1个session，在该session中通过http请求向remote server发送restful的请求，remote server解析请求，完成相应操作并返回response；
-
客户端接受response，并分析其返回值以决定是转到第3步还是结束脚本；
这就是webdriver的工作流程，看起来很复杂实际上当了解了webdriver的实现原理后，理解上述问题应该比较简单。
webdriver是按照server – client的经典设计模式设计的。
server端就是remote server，可以是任意的浏览器。当我们的脚本启动浏览器后，该浏览器就是remote server，它的职责就是等待client发送请求并做出相应；
client端简单说来就是我们的测试代码，我们测试代码中的一些行为，比如打开浏览器，转跳到特定的url等操作是以http请求的方式发送给被 测试浏览器，也就是remote server；remote server接受请求，并执行相应操作，并在response中返回执行状态、返回值等信息；
1.通俗来讲，就是页面元素放到一个脚本，封装页面元素操作方法，每个页面但是一个page对象方便页面元素的维护
7、列表和字典有什么区别？
答： 一般都是问列表和元组有什么不同。
（1）获取元素的方式不同。列表通过索引值获取，字典通过键获取。
（2）数据结构和算法不同。字典是hash算法，搜索的速度特别快。
（3）占用的内存不同。
8、如何结束一个进程？
答：
（1）调用terminate方法。
（2）使用subProcess模块的Popen方法。使用简单，具体用法，这里不展开。
13、ui自动化，如何做集群？
答： Selenium Grid。
1、以你做过的项目，举例来说一下你的自动化测试是怎么做的？
参考答案：就拿简历上的ecshop项目来说吧，在编写脚本前，我们会对系统进行评估，确认这个系统可不可以实现UI自动化，如果可以的话，就筛选出能实现自动化测试的用例，一般优先把冒烟测试用例的转为成脚本。我们是用selenium工具来实现自动化，采用python脚本语言，基于unittest框架进行用例的编写。比如，下单这个功能的脚本，我们是这样做的：首先，我们会构建一个测试工程，测试工程包含public部分(这里封装脚本公共的内容，比如，打开浏览器，登陆等操作)，testCases（存放测试用例），reports（存放测试报告），runAllCases（用于运行项目自动化用例），脚本调试完后，我们会用jenkins持续集成工具（定时），设置脚本每天晚上8点跑一遍脚本，跑完后生成html格式的自动化测试报告。
自动化脚本失败的原因：
1）、可能是测试环境的网络不稳定；
2）、开发修改了代码没通知到测试人员修改脚本；
3）、开发引入了新的问题。
2、测试脚本用到了哪些技术？
参考答案：元素定位，表单切换，模块调用，JS定位等等，脚本是基于python自带的unittest单元测试框架，采用了模块化方式编写，把复用性高的操作封装到公共模块中，如果脚本需要用到对应的操作，直接调用就可以了，如果元素发生变化，只需要调整元素封装的代码就可以了，提高测试用例的可维护性。
脚本怎么组织的？(编写自动化脚本，你的思路是什么？)
参考答案：构建测试套，测试套包含public部分(包括测试用例中公共的部分)，testCases（存放测试用例），reports（存放测试报告），runAllCases（用于运行项目自动化用例），测试脚本使用的是python的unittest单元测试框架组织管理，将所有测试脚本通过单元测试框架组织起来运行，这样做的好处是，维护起来方便，可以生成测试html格式的测试报告，报告包括：测试用例，通过数，失败数。
4、自动化率多少？
参考答案：一般是30%到40%，这个没有固定的，我们是优先将优先级高的测试用例，比如，冒烟测试的测试用例转换成自动化脚本的，后面有时间的时候再不断补充，能写多少写多少。
5、你们自动化脚本的通过率是多少？（注意这个题目的意思）
参考答案：这个说不准，如果没有什么异常情况，自动化脚本都是100%运行通过；如果异常情况比较多，比如出现测试环境不稳定，或者开发修改了代码没通知到测试人员及时修改脚本，又或者开发引入了新的问题等等，自动化脚本通过率可能80%都不到。
6、用那个方法判断元素是否显示？
is_displayed()
7.你曾经都写过多少自动化测试用例？
参考答案：这个具体没有算过。但是只要有时间，模块稳定的功能都会写。就拿上个项目来说，自动化测试用例大概写了将近有70-80条这样子吧。
8、python3 的数据类型有哪些? (set集合 不重复的列表)
不可变数据（四个）：int (整型)、float (浮点型)、str（字符串）、Tuple（元组）、Sets（集合）；
可变数据（两个）：List（列表）、Dictionary（字典）。
9、unittest框架了解吗？
参考答案：unittest框架，由setUp()--环境预置，testCase()--- 测试用例 tearDown()----环境恢复，三大部分组成，unittest框架可组织执行测试用例，并且提供丰富的断言方法，判断测试用例是否通过，最终生成测试结果。
12、元素定位失败的原因？
1）、页面的元素未加载完成
2）、元素的属性值不唯一
3）、元素的属性值是动态值
4）、元素在另外一个表单
5）、元素在另外一个页面
13、自动化脚本，如何切换不同的浏览器？
参考答案：使用对应的浏览器驱动，然后在脚本中更换不同的浏览器。
15、python怎么定义一个函数，怎么定义一个类？
def 函数名:函数体
class 类名:属性,方法
16、有些元素，在谷歌浏览器上能定位，在火狐浏览器上定位失败，是什么原因呢？
参考答案：因为不同浏览器的内核不一样，他们的CSS样式不一样。
17、如何提高selenium脚本的执行速度？
参考答案：
1）、提高网速；
2）、少用sleep，多用隐式等待或显式等待（强制）。
******************************************************************************************************
1、元素定位的方式有哪些？
id定位： find_element_by_id()
name定位： find_element_by_name()
class_name定位：find_element_by_class_name()
tag_name定位：find_element_by_tag_name()
link_text定位：find_element_by_link_text()
partial_link定位：find_element_by_partial_link_text()
xpath定位：find_element_by_xpath()
css_selector定位：find_element_by_css_selector()
2、如何切换iframe？
switch_to.frame()
switch_to.default_content()
3、如何切换窗口？
switch_to.window()
4、鼠标悬停的方法是什么？
shezhi=dr.find_element_by_link_text("设置")
ActionChains(dr).move_to_element(shezhi).perform()
5、如何定位下拉框？
sq=dr.find_element_by_name("sel_question")
Select(sq).select_by_value("motto")
6、如何获取弹出警告框的text？
#获取警告框的文本信息
t1=dr.switch_to.alert.text
print(t1)
#点击确定
dr.switch_to.alert.accept()
#取消警告框
#dr.switch_to.alert.dismiss()
7、做自动化做了多久？
参考答案：一直都在做，通常只要有时间，模块稳定的功能都会写。断断续续的做了一年多了。
8、selenium的工作原理是什么？
参考答案：selenium的工作原理是什么:selenium工作原理涉及三个部份，分别是浏览器、驱动器、代码; 代码发送请求给驱动器，驱动器解析请求，并在浏览器上执行相应的操作把执行结果返回给代码
9、什么样的项目适合做自动化？
参考答案：项目周期长，版本多，界面元素稳定的项目。
10、selenium如何做兼容性测试？
参考答案：使用对应的浏览器驱动，然后在脚本中更换不同的浏览器。
11、为什么会生成HTML报告？
参考答案：使用了HTMLTestRunner第三方工具包来实现的
12、脚本运行出错，应该怎样定位，说出分析过程
生成报告，从报告中分析：网络，开发修改，引入新的问题（从断言中分析）
参考答案：运行结束之后我们会得到一个测试报告，我们根据测试报告先定位一下是脚本的原因还是程序的原因，一般来说脚本的原因在报告中都会显示出哪一行代码出错了，如果是程序的原因通常来说都是断言的问题。
13、如果系统有验证码，怎么做自动化？
参考答案：
1）、去掉验证码。
2）、设置万能验证码。
3）、用python调用OCR模块，自己写代码来识别。这种方法可以识别出简单的验证码。
4）、调用第三方平台提供的接口进行识别。比如：斐斐打码，尖叫数据这些平台接口。
14、setUp()，tearDown()和setUpClass()，tearDownClass()的区别？
参考答案：当测试用例有多个，setUp()和tearDown()就会被执行多次；不管测试用例有多少个，setUpClass()和tearDownClass()只会被执行一次（在全局的开关的情况，）。
16、python的第三方模块/标准库有哪些？
time
random
unittest
selenium
sys
HTMLTestRunner
datetime
需要导入的，自带的不需
17、python的pass语句的作用是？
参考答案：占位符，当方法没有内容时，防止出现语法错误。跳过，执行去下一个
18、自动化写过哪些模块的脚本？
参考答案：主要是把冒烟测试的用例转化为脚本，比如，我这个xx商城系统，做自动化的模块有后台的上架商品，订单查询，添加团购活动，促销活动，前台的搜索商品，添加商品到购物车，下单等等。
19、常见的排序算法？
参考答案：冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序等.
20、元素是动态变换的，如何定位？
参考答案：使用css或者xpath先定位到其上级不变的元素，然后再定位到该元素即可
21、隐藏元素是否可以操作？
参考答案：隐藏元素只能够定位到，无法对其进行操作 如果想要对隐藏元素进行操作，我们需要使用js语句对其操作
随着行业的发展，编程能力逐渐成为软件测试从业人员的一项基本能力。因此在笔试和面试中常常会有一定量的编码题，主要考察以下几点。
-
基本编码能力及思维逻辑
-
基本数据结构（顺序表、链表、队列、栈、二叉树）
-
基本算法（排序、查找、递归）及时间复杂度
除基本算法之外，笔试面试中经常会考察以下三种思想：
-
哈希
-
递归
-
分治
哈希
哈希即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 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 list1:
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):
length = len(l)
if len(l) <=1:
return l
mid = 0
low_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 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)
浙公网安备 33010602011771号