测试开发面试题
- 1. 通过列表推导式完成下面数据类型转换。将 ["{‘a’:11,‘b’:2}", “[11,22,33,44]”] 转换为以下格式： li1 = [{‘a’: 11, ‘b’: 2}, [11, 22, 33, 44]]
- 2. Names=['python','java','php','c','c++','django','unittest','pytest','pymysql'],请通过列表推导式，获取names中字符串长度大于4的元素
- 3.通过字典推导式，颠倒字典的键名和值:将{'py': "python09", 'java': "java09"} 转换为： {'python09': "py", 'java09': "java"}
- 4.将字典{'x': 'A', 'y': 'B', 'z': 'C' } 通过推导式转换为：['x=A','y=B','z=C']
- 5.有四个数字：1、2、3、4能组成多少个互不相同且无重复数字的三位数？各是多少？
- 6.生成包含1到100之间的10个随机数的列表
- 7.现在有一个列表li = [11,21,4,55,6,67,123,54,66,9,90,56,34,22]请将大于5的数据过滤出来，然后除以2取余数，结果放到一个生成器中
- 8.定义一个可以使用send传入域名，自动生成一个在前面加上http://，在后面加上路径/user/login的url地址，生成器最多可以生成5个url,生成5条数据之后再去生成，则报错StopIteration
- 9.有一个正整数列表(数据是无序的,并且允许有相等的整数存在),编写一个能实现下列功能的函数，传入列表array,和正整数X，返回下面要求的2个数据def func(array, x) ''逻辑代码'''return count, li 1、统计并返回在列表中,比正整数x大的数有几个(相同的数只计算一次)，并返回-----返回值中的的count2、获取列表中比正整数X小的所有偶数，并返回 -----------返回值中的li
- 10.现有有如下功能函数：def work(a,b):res = a+b print('a+b的结果为:',res)调用函数当参数类型不能进行相加时，work执行会报错！如：work(10,‘a’) 需求：在不更改函数代码的前提现，实现调用work函数传入不同类型的参数是函数不报错，输出结果：您传入的参数类型不一样，无法正常执行
- 11.实现一个重运行的装饰器，可以用来装饰任何一个功能函数，只要被装饰的函数执行出现AssertionError，则重新执行该函数，同一个函数最多重运行三次。
- 12.请设计一个装饰器，接收一个int类型的参数number，可以用来装饰任何的函数，如果函数运行的时间大于number，则打印出函数名和函数的运行时间s = time.time()调用函数e = time.time()e-s
- 13.自定义一个列表类型，实现对象之间可以使用 - 来进行操作要求：如果一个对象减去另一个对象，则把和被减对象中一样的数据给删除掉如下：li1 = MyList([11, 22, 33,22, 44])li2 = MyList([1, 22])res = li1 - li2res 打印的结果为[11,33,44]
1. 通过列表推导式完成下面数据类型转换。将 ["{‘a’:11,‘b’:2}", “[11,22,33,44]”] 转换为以下格式： li1 = [{‘a’: 11, ‘b’: 2}, [11, 22, 33, 44]]
# 考察列表推导式
li = ["{'a':11,'b':2}", "[11,22,33,44]"]
# 方法一
new_list = []
for i in li:
res=eval(i)
new_list.append(res)
print(new_list)
# 方法二 列表推导式
res = [ eval(i) for i in li ]
print(res)
2. Names=[‘python’,‘java’,‘php’,‘c’,‘c++’,‘django’,‘unittest’,‘pytest’,‘pymysql’],请通过列表推导式，获取names中字符串长度大于4的元素
# 方法一
Names=['python','java','php','c','c++','django','unittest','pytest','pymysql']
new_name = []
for i in Names:
if len(i) > 4:
new_name.append(i)
print(new_name)
# 方法二 列表推导式
names = [i for i in Names if len(i)>4]
print(names)
3.通过字典推导式，颠倒字典的键名和值:将{‘py’: “python09”, ‘java’: “java09”} 转换为： {‘python09’: “py”, ‘java09’: “java”}
dic = {'py': "python09", 'java': "java09"}
dic1 = {v:k for k,v in dic.items() }
print(dic1)
4.将字典{‘x’: ‘A’, ‘y’: ‘B’, ‘z’: ‘C’ } 通过推导式转换为：[‘x=A’,‘y=B’,‘z=C’]
li1 = ['{}={}'.format(k,v) for k,v in dic2.items()]
li2 = [f'{k}={v}' for k,v in dic2.items()]
5.有四个数字：1、2、3、4能组成多少个互不相同且无重复数字的三位数？各是多少？
lis1 = [1,2,3,4]
for i in lis1:
for j in lis1:
for k in lis1:
if i != j and j !=k and k != i:
print(i,j,k)
# 方法二 列表推导式
lis = [x * 100 + y * 10 + z for x in range(1, 5) for y in range(1, 5) for z in range(1, 5) if
x != y and x != z and y != z]
print(lis)
6.生成包含1到100之间的10个随机数的列表
# 方法一 常规方法
import random
liss = []
for i in range(10):
s = random.randint(1,100)
liss.append(s)
print(liss)
# 方法二 列表推导式
lir = [ random.randint(1,100) for i in range(10)]
print(liss)
7.现在有一个列表li = [11,21,4,55,6,67,123,54,66,9,90,56,34,22]请将大于5的数据过滤出来，然后除以2取余数，结果放到一个生成器中
def work1():
li = [11, 21, 4, 55, 6, 67, 123, 54, 66, 9, 90, 56, 34, 22]
res = (i % 2 for i in li if i > 5)
print(res)
if __name__ == '__main__':
a = work1()
8.定义一个可以使用send传入域名，自动生成一个在前面加上http://，在后面加上路径/user/login的url地址，生成器最多可以生成5个url,生成5条数据之后再去生成，则报错StopIteration
使用案例：
例如:
res = g.send(‘www.baidu.com’)
生成数据res为：http://www.baidu.com/user/login
def work2():
host = yield
for i in range(5):
if host:
host = yield "http://{}/user/login".format(host)
else:
host = yield "http://127.0.0.1:8080/user/login"
if __name__ == '__main__':
g = work2()
next(g)
print('生成的数据：', g.send('www.baidu.com'))
print('生成的数据：', g.send('www.taobao.com'))
print('生成的数据：', g.send('www.sina.com'))
print('生成的数据：', next(g))
print('生成的数据：', g.send('www.test.com'))
print('生成的数据：', g.send('www.iiap.com'))
运行结果：
Traceback (most recent call last):
File "C:\pythonProject\test\day3\homework3.py", line 61, in <module>
print('生成的数据：', g.send('www.iiap.com'))
StopIteration
生成的数据： http://www.baidu.com/user/login
生成的数据： http://www.taobao.com/user/login
生成的数据： http://www.sina.com/user/login
生成的数据： http://127.0.0.1:8080/user/login
生成的数据： http://www.test.com/user/login
9.有一个正整数列表(数据是无序的,并且允许有相等的整数存在),编写一个能实现下列功能的函数，传入列表array,和正整数X，返回下面要求的2个数据def func(array, x) ‘‘逻辑代码’’'return count, li 1、统计并返回在列表中,比正整数x大的数有几个(相同的数只计算一次)，并返回-----返回值中的的count2、获取列表中比正整数X小的所有偶数，并返回 -----------返回值中的li
有一个正整数列表(数据是无序的,并且允许有相等的整数存在),
编写一个能实现下列功能的函数，传入列表array,和正整数X，返回下面要求的2个数据
def func(array, x)
‘’‘逻辑代码’’’
return count, li
1、统计并返回在列表中,比正整数x大的数有几个(相同的数只计算一次)，并返回-----返回值中的的count
2、获取列表中比正整数X小的所有偶数，并返回 -----------返回值中的li
def work3(array, x):
"""用推导式"""
# 比x大的数
count = len({i for i in array if i > x})
# 正整数X小的所有偶数
li = [i for i in array if i < x and i % 2 == 0]
return count, li
res = work3([11, 2, 32, 12, 12, 12, 4, 24], 5)
print(res)
运行结果：
(4, [2, 4])
10.现有有如下功能函数：def work(a,b):res = a+b print(‘a+b的结果为:’,res)调用函数当参数类型不能进行相加时，work执行会报错！如：work(10,‘a’) 需求：在不更改函数代码的前提现，实现调用work函数传入不同类型的参数是函数不报错，输出结果：您传入的参数类型不一样，无法正常执行
现有有如下功能函数：
def work(a,b):
res = a+b
print(‘a+b的结果为:’,res)
#调用函数当参数类型不能进行相加时，work执行会报错！如：work(10,‘a’)
#需求：在不更改函数代码的前提现，实现调用work函数传入不同类型的参数是函数不报错，
输出结果：您传入的参数类型不一样，无法正常执行
此题考察的是装饰器的使用
def decorator1(func):
def wrapper(a, b):
try:
func(a, b)
except:
print("您传入的两个参数类型不一致,不能进行相加")
return wrapper
@decorator1
def work(a, b):
res = a + b
print('a+b的结果为:', res)
if __name__ == '__main__':
work(11, 'a')
work(11,22)
work('a','b')
运行结果：
您传入的两个参数类型不一致,不能进行相加
a+b的结果为: 33
a+b的结果为: ab
11.实现一个重运行的装饰器，可以用来装饰任何一个功能函数，只要被装饰的函数执行出现AssertionError，则重新执行该函数，同一个函数最多重运行三次。
考察装饰器的使用
# 装饰器
def rerun(func):
def wrapper(*args, **kwargs):
for i in range(4):
try:
res = func(*args, **kwargs)
except AssertionError as e:
if i == 3:
raise e
print("执行出错啦，重新执行")
else:
print('执行通过')
return res
return wrapper
print()
@rerun
def work2():
expected = 'abc'
res = input('请输入实际结果：')
assert expected == res
if __name__ == '__main__':
work2()
运行结果：运行失败后可以再重运行3次，
请输入实际结果：123
执行出错啦，重新执行
请输入实际结果：123
执行出错啦，重新执行
请输入实际结果：123
执行出错啦，重新执行
请输入实际结果：345
Traceback (most recent call last):
File "C:\pythonProject\test\day5\装饰器装饰类.py", line 26, in <module>
work2()
File "C:\pythonProject\test\day5\装饰器装饰类.py", line 9, in wrapper
raise e
File "C:\pythonProject\test\day5\装饰器装饰类.py", line 6, in wrapper
res = func(*args, **kwargs)
File "C:\pythonProject\test\day5\装饰器装饰类.py", line 22, in work2
assert expected == res
AssertionError
12.请设计一个装饰器，接收一个int类型的参数number，可以用来装饰任何的函数，如果函数运行的时间大于number，则打印出函数名和函数的运行时间s = time.time()调用函数e = time.time()e-s
请设计一个装饰器，接收一个int类型的参数number，可以用来装饰任何的函数，
如果函数运行的时间大于number，则打印出函数名和函数的运行时间
s = time.time()
#调用函数
e = time.time()
e-s
import time
# 计算函数运行时间的装饰器
def count_time(number):
def decor(func):
def wrapper(*args, **kwargs):
# 获取函数执行之前的时间
s_time = time.time()
res = func(*args, **kwargs)
# 函数执行完后再次获取时间
e_time = time.time()
if (e_time - s_time) > number:
print("函数名：{},运行时间：{}".format(func.__name__, e_time - s_time))
return res
return wrapper
return decor
@count_time(2)
def func_1():
for i in range(3):
time.sleep(1)
if __name__ == '__main__':
func_1()
运行结果：
函数名：func_1,运行时间：3.0204389095306396
13.自定义一个列表类型，实现对象之间可以使用 - 来进行操作要求：如果一个对象减去另一个对象，则把和被减对象中一样的数据给删除掉如下：li1 = MyList([11, 22, 33,22, 44])li2 = MyList([1, 22])res = li1 - li2res 打印的结果为[11,33,44]
如下：
li1 = MyList([11, 22, 33,22, 44])
li2 = MyList([1, 22])
res = li1 - li2
res 打印的结果为[11,33,44]
class MyList(list):
def __sub__(self, other):
new_list = [i for i in self if i not in other]
return new_list
li1 = MyList([11, 22, 33,22, 44])
li2 = MyList([1, 22])
res = li1 - li2
print(res)
# 运行结果
# [11, 33, 44]
考察__sub__的使用
439
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
