（一）装饰器

具体要求：
1）该装饰器要求做到通用，可以装饰定长，不定长各种参数的函数.（4分）
2）如果被装饰的函数抛出异常，则记录函数名,异常信息到文件error_log.txt。（4分）
3）装饰器可以正确计算函数的运行时间。（3分）
4）创建文件power_fun.py 导入 decory.py中写好的装饰器,编写函数并装饰, 如果被装饰函数正常执行没有异常，则记录调用成功，并记录被调用函数的函数名，参数个数，到指定路径的文件中。（4分）

import time
from functools import wraps


def take_rime(fn):
    @wraps(fn)
    def inner(*args, **kwargs):
        try:
            start = time.time()
            fn(*args, **kwargs)
            end = time.time()
            print(f'运行时间：{end-start}')
        except BaseException as e:
            #e就是报错信息
            with open('error_log.txt','new') as f:
                f.write(f'{e}')
        else:
            with open('日志.txt','new') as f:
                f.write(f'调用成功，{fn.__name__},{len(args)+len(kwargs)}')
    return inner

power_fun.py

#从  decor文件中  导入   装饰器
from decor import take_rime

@take_rime
def show(a,b):
    print(1+'hello')

if __name__ == '__main__':
    show(1,2)

（二）创建名为express.py文件，编写以下推导式（25分）

# 1)求60以内所有能被3和2同时整除的数   （2分）
l1=[i for i in range(60) if i%2==0 and i%3==0]
print(l1)
# 2)求60以内所有能被2整除的数的平方（2分）
l2=[i**2 for i in range(60) if i%2==0]
print(l2)
# 3.已知列表n=['黄三','黄大','李凯','王一博' ] 编写一个推导式，取出所有姓黄的人名（2分）
n=['黄三','黄大','李凯','王一博' ]
l3=[i for i in n if i.startswith('黄')]
print(l3)
# 4.info= ['i','is','a','good','boy','exception']统计列表每个元素的长度,保存成字典的格式（2分）
info= ['i','is','a','good','boy','exception']
d4={k:len(k) for k in info}
print(d4)
# 5)求(a,b)其中a是0-10之间的偶数，b是0-10之间的偶数组成的元祖列表（2分）
l5=[(a,b) for a in range(11) if a%2==0 for b in range(11) if b%2==0]
print(l5)
# 6.Num_list = [[10, 12, 13], [14,15, 16], [17, 18, 19]]  把列表中所有偶数取出来组成新列表（2分）
Num_list = [[10, 12, 13], [14,15, 16], [17, 18, 19]]
l6=[i for j in Num_list for i  in j if i%2==0]
print(l6)
# 7.List1=['a', 'b', 'c',] list2=['A', 'B', 'C',]用列表推导式输出新列表['aA', 'bB', 'cC']（2分）
List1=['a', 'b', 'c',]
list2=['A', 'B', 'C',]
l7=[f'{List1[i]}{list2[i]}' for i in range(3)]
print(l7)
# 8.Info_dict = {'a': 10, 'b': 34, 'A': 7, 'Z': 3} 把字典的key,value互换（2分）
Info_dict = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
d8={k:v for v,k in Info_dict.items()}
print(d8)
# 9.strings = ['a','is','with','if','file','exception']用集合推导式，创建字符串长度的集合（2分）
strings = ['a','is','with','if','file','exception']
s9={len(i) for i in strings}
print(s9)
# 10.，用列表推导式取出列表中带有两个以上含字母e的姓名，组成新的列表（2分）
names = [['david','testeae','effcomecte','aAndrew','tWesley','hsteven','Gcoe'], ['Balice','kill','Banaan','Tendy','cennifer','Dsherry','Eva']]
l10=[j for i in names for j in i if j.count('e')>2]
print(l10)
# 11.通过列表推导式完成下面数据类型转换。 将 转换为以下格式： li1 = [{‘a’: 11, ‘b’: 2}, [11, 22, 33, 44]]（2分）
ls11 = ["{'a':11,'b':2}", "[11,22,33,44]"]
l11=[eval(i) for i in ls11]
print(l11)
# 12.已知列表 编写一个推导式，取出所有以凯结尾的人名（3分）
n12=['黄凯','黄大','李凯','王一博']
l12=[i for i in n12 if i.endswith('凯')]
print(l12)

（三）创建名为process_test.py的文件，计算1-3000之间的水仙花数

具体要求：
1)编写多进程程序，开启3个进程
2)三个进程分别计算1-1000，1000-2000，2000-3000之间的水仙花数
3)每个进程打印当前进程的id和父进程的id，并打印当前进程的计算结果。
4)把三个进程的计算结果汇总到一个列表并输出

import multiprocessing,os
def show1(start,end,que):
    for i in range(start,end):
        if i>=100 and i<=999:
            b = i//100%10
            s = i//10%10
            g = i%10
            if b**3 + s**3 +g**3==i:
                print(f'父进程:{os.getppid()}，子进程：{os.getpid()}，水仙花数为：{i}')
                que.put(i)
        if i>=1000 and i<=9999:
            q = i//1000%10
            b = i//100%10
            s = i//10%10
            g = i%10
            if q**4+b**4+s**4+g**4==i:
                print(f'父进程:{os.getppid()}，子进程：{os.getpid()}，水仙花数为：{i}')
                que.put(i)
if __name__ == '__main__':
    que = multiprocessing.Queue()

    l1 = [2,1001,2001]
    for i in range(3):
        p1 = multiprocessing.Process(target=show1,args=(l1[i],l1[i]+1000,que))
        p1.start()
        p1.join()
    l2 = []
    while not que.empty():
        l2.append(que.get())
    print(l2)

在这里插入图片描述

（四）创建文件my_th.py，编写多线程程序

具体要求：
1)主线程产生2000个6位验证码，验证码有大小写字母和数字组成。
2)主线程把生成的随机验证码放入一个队列。
3)启动5个子线程。
4)每个子线程分析验证码，用正则匹配验证码,把符合的验证码放到列表中。
5)如果队列中的验证码匹配完成，则退出当前子线程
6)最终打印出符合规则的验证码的个数和验证码的列表。

import threading,random,string,re
from queue import Queue
l1 = []
def show(que):
    for i in range(400):
        str1 = que.get(i)
        if re.match('^[0-9]+[a-zA-Z]+$',str1):
            l1.append(str1)
if __name__ == '__main__':
    que = Queue()
    for i in range(2000):
        num = ''.join(random.choices(string.digits+string.ascii_letters,k=6))
        que.put(num)

    for i in range(5):
        t1 = threading.Thread(target=show,args=(que,))
        t1.start()

    print(f'验证码个数：{len(l1)},验证码分别为:{l1}')

（五）根据需求进行socket编程

具体要求：
服务端
1)新建一个py文件做完服务端用来接收客户端发送的消息server.py,。
2)服务器无限循环接收客户端发过来的信息。 accept()客户端 revc(1024)
3)客户端连接服务端,则输出“连接已建立‘
4)读取包含敏感字符的sensitive.txt文件,把所有敏感字符以列表的方式存储
5)根据列表进行过滤，如果消息包含铭感字,则输出消息包含敏感字，然后发回给客户端您发送的消息包含敏感字,请重新输入。反之发送随机6位字符给客户端 send()
6)把用户发送的原始消息+ip id保存到mysql数据库中数据库表结构自行定义。
客户端
1)新建一个py文件client.py 作为客户端。
2)客户端无限循环发送信息给服务端。
3)客户端接受服务端发送过来的信息。
4)客户端收到服务器发过来的响应，输出到终端,并把服务端返回的信息记录到my_clent.txt中。
5)客户端输入exit的时候，向服务器发送我要退出了,然后退出程序。

import random
import socket
import string
import threading

#函数：收发消息（多收多发）
def msg(client):
    #可以和每个人说多句话
    while True:
        #1.循环收消息
        #2.判断有没有敏感词 （有-告诉他有重新输   没有-6位随机）
        str1 = client.recv(1024).decode()
        if str1 == '我要退出了':
            break

        #这里存聊天记录

        #for敏感词 ifstr1  replace(旧，新)
        count = 0  #1
        for i in list_str:
            if i in str1:
                str1 = str1.replace(i,'**')  #替换
                count +=1
        if count == 0:  #没有敏感词
            #有敏感词
            # client.send('您发送的消息包含敏感字,请重新输入'.encode())
            client.send(str1.encode())
        else:
            print('消息包含敏感字')
            client.send('您发送的消息包含敏感字,请重新输入'.encode())
            # client.send(str1[::-1].encode())
            # client.send(''.join(random.choices(string.ascii_letters,k=6)).encode())

if __name__ == '__main__':
    server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    server.bind(('127.0.0.1',9009))
    server.listen(128)

    #读取敏感词
    with open('sensitive.txt','r') as f:
        list_str = f.read().split('\n')

    while True:
        #多人
        client,ip = server.accept()
        print(f'连接已建立{ip}')
        thread1 = threading.Thread(target=msg,args=(client,))
        thread1.start()  # 聊天不加join

客户端

import socket
import threading

#收发消息（多收多发）
def msg():
    while True:
        # 发消息
        str1 = input('输入消息：')
        if str1 == 'exit':
            client.send('我要退出了'.encode())
            break
        else:
            client.send(str1.encode())

        # 收消息
        str2 = client.recv(1024).decode()
        print(str2)

        with open('my_clent.txt','new') as f:
            f.write(f'{str2}\n')


if __name__ == '__main__':
    client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    client.connect(('127.0.0.1',9009))

    thread1 = threading.Thread(target=msg)
    thread1.start()  #聊天不加join