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) ifx != 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 = yieldfor 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 + bprint('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 eprint("执行出错啦，重新执行")else:print('执行通过')return resreturn wrapperprint()
@rerun
def work2():expected = 'abc'res = input('请输入实际结果：')assert expected == resif __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 wrapperraise eFile "C:\pythonProject\test\day5\装饰器装饰类.py", line 6, in wrapperres = func(*args, **kwargs)File "C:\pythonProject\test\day5\装饰器装饰类.py", line 22, in work2assert 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 resreturn wrapperreturn 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_listli1 = MyList([11, 22, 33,22, 44])
li2 = MyList([1, 22])
res = li1 - li2
print(res)# 运行结果
# [11, 33, 44]

考察__sub__的使用