python进阶--月考一

（一）装饰器

创建名为decor.py的文件，编写装饰器record_all，为多个函数加上记录调用功能，要求每次调用函数都将被调用的函数名称写入文件
（15分)
具体要求：
1）该装饰器要求做到通用，可以装饰定长，不定长各种参数的函数。
2）如果被装饰的函数抛出异常，则记录异常信息到文件error_log.txt。
3）装饰器带一个参数，可以指定调用记录被写入哪个文件，指定具体的文件路径。如果文件不存在，则自动创建文件。
4）如果被装饰函数正常执行没有异常，则记录调用成功，并记录被调用函数的函数名，参数个数，到指定路径的文件中。

rom functools import wraps
#装饰器
def record_all(path):
    def outer(fn):
        @wraps(fn)
        def inner(*args, **kwargs):
            try:
                str1=fn(*args, **kwargs)
            except BaseException as e:
                with open("error_log.txt", "a", encoding="utf-8")as f:
                    f.write(f"{e}")
            else:
                # 函数名，参数个数
                with open(path, "a", encoding="utf-8")as f:
                    f.write(f"函数名：{fn.__name__}，参数个数：{len(args)+len(kwargs)}")
				return str1
        return inner
    return outer


@record_all(path="name.txt")
def show():
    print("这是show")

if __name__ == '__main__':
    show()

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

# 1)求30以内所有能被3整除的数   （2分）
list=[i for i in range(30) if i%3==0]
print(list)
# 2)求30以内所有能被3整除的数的平方（2分）
list1=[i**2 for i in range(30) if i%3==0]
print(list1)
# 3)生成一天间隔5分钟的时间列表序列（2分）
list2=[f"{x}:{y}"for x in range(0,24) for y in range(0,60,5)]
print(list2)
# 4)求(x, y)，其中x是0-5之间的偶数，y是0-5之间的奇数组成的元祖列表（2分）
list3=[(x,y) for x in range(0,5) if x%2==0 for y in range(0,5) if y%2==1]
print(list3)
# 5)M = [[1,2,3], [4,5,6], [7,8,9]] 求M中3, 6, 9组成的列表（2分）
M = [[1,2,3], [4,5,6], [7,8,9]]
list4=[i[2] for i in M]
print(list4)
# 6)M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]  求M中斜线1, 5, 9组成的列表（2分）
M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
list5=[M[i][i] for i in range(3)]
print(list5)
# 7)strings = ['import','is','with','if','file','exception'] 用字符串和其长度创建字典（2分）
strings = ['import','is','with','if','file','exception']
dict={i:len(i) for i in strings}
print(dict)
# 8)mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3} 把大小写key合并（2分）
mcase = {'a': 10, 'b': 34, 'A': 7, 'Z': 3}
dict1={k.lower():mcase.get(k.lower(),0)+mcase.get(k.upper(),0) for k,v in mcase.items()}
print(dict1)
# 9)strings = ['a','is','with','if','file','exception'] 用集合推导式，创建字符串长度的集合（2分）
strings = ['a','is','with','if','file','exception']
set={len(i) for i in strings}
print(set)
# 10)names = [['Tom','Billy','Jefferson', 一个由男人列表和女人列表组成的嵌套列表，取出姓名中带有两个以上含字母e的姓名，组成列表（2分）
names = [['Tom','Billy','Jefferson','Andrew','Wesley','Steven','Joe'], ['Alice','Jill','Ana','Wendy','Jennifer','Sherry','Eva']]
list6=[j for i in names for j in i if j.count("e")>2]
print(list6)
# 11)通过列表推导式完成下面数据类型转换。 将 ["{‘a’:11,‘b’:2}", “[11,22,33,44]”] 转换为以下格式： li1 = [{‘a’: 11, ‘b’: 2}, [11, 22, 33, 44]]（2分）
a=["{'a':11,'b':2}", "[11,22,33,44]"]
list7=[eval(i) for i in a]
print(list7)
# 12)生成包含1到100之间的10个随机数的列表（3分）
import random
l12=[random.randint(1,100) for i in range(10)]
print(l12)

（三）创建名为multi_proc.py的文件，计算1-3000之间的素数

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

import multiprocessing, os

def check(start, end, que):
    for i in range(start, end):
        count = 0
        for j in range(1, i + 1):
            if i % j == 0:
                count += 1
        if count == 2:
            print(f"父进程id：{os.getppid()},子进程id：{os.getpid()},值：{i}")
            que.put(i)


if __name__ == '__main__':
    #创建进程队列
    que = multiprocessing.Queue()
    start = [1, 1001, 2001]

    for i in range(3):
        mu1 = multiprocessing.Process(target=check, args=(start[i], start[i] + 1000, que))
        mu1.start()
        mu1.join()

    list1 = []
    #循环读取队列中的数据并添加到列表
    while not que.empty():
        list1.append(que.get())
    print(list1)

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

具体要求：
1)主线程产生1000个随机的邮件地址，@前面由随机的10位英文字符组成，@后面是163.com、qq.com、126.com、sina.com、gmail.com之一。
2)主线程把生成的随机地址放入一个队列。
3)启动5个子线程，从队列中消费生成的邮件地址。
4)每个子线程分析当前邮箱地址后缀，相同后缀的邮箱写入相同的文件。最终会产生5个文件，每个文件中的邮件地址后缀都相同。
5)如果队列中的邮件地址被消费空，则退出当前子线程
6)最终打印出5个文件中邮件地址的个数。

import random
import string
import threading
from queue import Queue

def check_email():
    for i in range(200):
        email = que.get()  #[email protected]     163.com   163
        type1 = email.split('@')[1].split('.')[0]  #163   qq
        with open(f'{type1}.txt','a') as f:  #163.txt  qq.txt  gmail.txt
            f.write(f'{email}\n')

if __name__ == '__main__':
    #163.com、qq.com、126.com、sina.com、gmail.com
    list1 = ['163.com','qq.com','126.com','sina.com','gmail.com']
    que = Queue()  #线程的队列
    for i in range(1000):
        email_name = ''.join(random.choices(string.ascii_letters,k=10))
        email_name2 = email_name+'@'+list1[random.randint(0,4)]
        que.put(email_name2)
    #
    for i in range(5):
        thread1 = threading.Thread(target=check_email)
        thread1.start()
        thread1.join()

    #读文件
    with open('126.txt','r') as f:
        print(f'126文件中有：{len(f.readlines())}行')
    #自己补后面--每个文件都要读取    

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

具体要求：
服务端
1)创建server.py文件，编写服务端。
2)服务器可以无限多次接收客户端消息。
3)服务器启动后一直等待客户端连接，如果有客户端连接，则打印“新连接建立，客户IP xxx.xxx.xxx.xxx”
4)服务端会把客户端发来的消息，根据一个自定义的敏感词列表进行过滤，替换敏感词为星号，然后发回给客户端。并且服务器会把检测到的敏感词，客户端IP，信息内容保存到数据库，数据库表自定义。
5)客户端发送的所有原始消息，服务器都会记录到文本文件history.txt中，要记录客户端IP和消息内容。
6)服务器启动时从sensitive.txt中加载所有敏感词，敏感词可以自己手动在文件中定义。
7)当服务端30秒没收到任何客户端消息时，自动退出。
客户端
1)创建client.py文件，编写客户端。
2)客户端等待用户输入内容并发送给服务器。
3)客户端客户无限多次接收用户的输入，不能输入一次就退出程序。
4)客户端收到服务器发过来的响应，要打印到终端，同时记录到res.log文件。
5)客户端输入quit的时候，不发送给服务器，直接退出。

import socket


#1.加载词库 ['aa','bb','boy','杨瑞']  {'a':'9','b':2}   一次
#2.过滤 for列表  if消息  替换消息

if __name__ == '__main__':

    try:
        server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        #端口号复用
        server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
        server.bind(('127.0.0.1',9006))
        server.listen(128)
        server.settimeout(5) #设置超时的时间

        #加载词库  只有一个（循环外）
        # words = ['aa','bb','boy','杨瑞']
        with open('sensitive.txt','r') as f:
            words = f.read().split('-')

        while True:
            #ip=('ip地址',端口号)
            client,ip = server.accept()
            print(f'新连接建立，客户IP {ip[0]}')
            while True:
                str_client = client.recv(1024).decode()
                #表示不是真
                if not str_client:
                    break  #消息为空停止
                print(str_client)  #接收消息并打印
                #原始消息
                with open('history.txt','a') as f:
                    f.write(f'{ip[0]}---{str_client}\n')
                msg_word = []  #消息里的敏感词
                #过滤  第4问  存数据
                for i in words:
                    if i in str_client:
                       # print(i)  #敏感词
                        msg_word.append(i)  #装多个敏感词的
                        str_client = str_client.replace(i,'*')
                client.send(str_client.encode())

                print(msg_word)
                #存数据库 str_client ip[0]  msg_word

    except socket.timeout as e:
        print('超时了')

客户端

# 客户端
import socket

if __name__ == '__main__':

    client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    client.connect(('127.0.0.1',9006))

    while True:
        str1 = input('输入内容：')
        if str1 == 'quit':
            break  # 没发
        client.send(str1.encode())

        str_recv = client.recv(1024).decode()
        print(str_recv)
        with open('res.log','a') as f:
            f.write(f'{str_recv}\n')