python进阶--月考六

（一）创建pro1.py，通过多进程、进程间通信等实现A股4201个股票文件，共55M数据的拷贝

1.定义一个copy文件的方法copy_file，参数为文件名、源文件夹、目标文件夹、队列
2.在copy_file中编写从源文件夹中读取文件的代码
3.在copy_file中编写向目标文件夹中写入文件的代码
4.定义main方法来操作进程
5.在main方法中定义路径、源文件夹、目标文件夹
6.获取源文件夹目录下所有的文件名
7.创建进程池，包含5个进程
8.创建队列管理用来进程间通信
9.计算出所有文件的总大小并打印输出
10.执行main方法，拷贝文件的同时输出目标文件夹+文件名
11.使用装饰器记录日志，日志中需包含进程号、读取的源文件名，写入文件的结果三项内容.日志需保存在log.txt文件中，否则本题不得分

import multiprocessing
import os
from functools import wraps

def loggin(fn):  #fn = copy_file
    @wraps(fn)
    def inner(*args,**kwargs):  #args = (old,new,file_name,que)
        result = fn(*args,**kwargs)
        with open('log.txt','a') as f:
            f.write(f'进程：{os.getpid()},源文件夹{args[0]},{result}\n')
        return result
    return inner

@loggin
def copy_file(old,new,file_name,que):
    try:
        with open(f'{old}/{file_name}','r') as f:
            with open(f'{new}/{file_name}','w') as f2:
                f2.write(f.read())
        fsize = os.path.getsize(f'{new}/{file_name}')    #文件夹/文件名
        que.put(fsize)
    except BaseException as e:
        return '拷贝失败'
    else:
        return '拷贝成功'

def main():
    path = '/'  # 路径
    old = 'old'  # 老文件夹
    new = 'new'  # 新文件夹（目标文件夹）
    que = multiprocessing.Manager().Queue()  # 进程池的队列
    sum = 0
    pool = multiprocessing.Pool(5)

    files = os.listdir(old)
    for file_name in files:  # i是文件名
        pool.apply_async(copy_file, args=(old, new, file_name, que))
        print(f'目标文件夹{new},文件名：{file_name}')
    pool.close()
    pool.join()

    # 求和
    while not que.empty():
        sum += que.get()
    print(f'文件的总大小是:{sum}')

if __name__ == '__main__':
    main()

（二）创建pro2.py，使用socket以及threading实现邮件收发

1.编写一个服务器程序，创建一个socket对象，指定协议，并设置监听端口和等待连接的最大数量
2.在服务端写一个方法tcpLink，实现服务器发送数据到客户端，循环接收客户端发来的请求数据
3.服务器通过一个永久的循环来接受来自客户端的连接，创建一个新的线程来处理TCP连接，并开启线程
4.编写一个客户端程序，创建一个socket对象，建立连接，并打印输出欢迎信息
5.客户端连接数量超过10，新的客户端连接时，需要先给出提示“已超过最大连接数”，并断开连接，客户端要求有重试机制
6.客户端连接后，可向指定用户发送邮件，邮件包含收件人、发件人、主题、内容。服务端判断收件人信息并转发给收件人，每天限发五封邮件，代码中需要有对邮件发送数量判断
7.客户端发送的邮件信息需保存到mysql中，表结构自定义，但必须体现收件人、发件人、主题、内容四个字段。可用navicat操作，数据表存储的结果需要截图
8.写一个循环发送数据，最后发送结束的标识，并关闭连接

服务器

#服务器端
# 1.编写一个服务器程序，创建一个socket对象，指定协议，并设置监听端口和等待连接的最大数量
# 2.在服务端写一个方法tcpLink，实现服务器发送数据到客户端，循环接收客户端发来的请求数据
# 3.服务器通过一个永久的循环来接受来自客户端的连接，创建一个新的线程来处理TCP连接，并开启线程
import socket
import threading

def tcpLink(client):
    while True:
        #收数据
        str1 = client.recv(1024).decode()
        if str1:
            print(str1)
            if str1=='bye':
                #踢人
                users.pop(send_per)
            else:
                recv_per = int(str1.split('-')[0])  #收件人57281
                send_per = int(str1.split('-')[1])  #发件人57283
                title = str1.split('-')[2]  #主题
                content = str1.split('-')[3]  #内容
                print(recv_per,send_per,title,content)

                #转发
                #{57281：client,57283:client}
                if recv_per in users.keys():
                    users[recv_per].send(str1.encode())

if __name__ == '__main__':

    server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    server.bind(('127.0.0.1',8007))
    server.listen(128)
    users = {}  #存#{57281：client,57283:client}
    while True:
        client,ip = server.accept()  #收客户端
        users[ip[1]] = client  #把端口号和客户端
        print(f'欢迎{ip}')
        if len(users) >10:
            print('已超过最大连接数')
            client.close()  #断开连接
        else:
            thread1 = threading.Thread(target=tcpLink,args=(client,))
            thread1.start()

客户端

import socket
import threading
import time
# 6.客户端连接后，可向指定用户发送邮件，邮件包含收件人、发件人、主题、内容。服务端判断收件人信息并转发给收件人，每天限发五封邮件，代码中需要有对邮件发送数量判断
# 7.客户端发送的邮件信息需保存到mysql中，表结构自定义，但必须体现收件人、发件人、主题、内容四个字段。可用navicat操作，数据表存储的结果需要截图
# 8.写一个循环发送数据，最后发送结束的标识，并关闭连接c

def msg_send():
    count = 0  #邮件的数量
    while True:
        #发消息
        recv_per = input('输入收件人：')
        send_per = input('输入发件人：')
        title = input('输入主题：')
        content = input('输入内容：')
        str1 = f'{recv_per}-{send_per}-{title}-{content}'
        client.send(str1.encode())
        count +=1
        if count >= 5:
            client.send('bye'.encode())
            # client.close() #这里不生效
            break


def msg_recv():
    while True:
        #收消息
        str2 = client.recv(1024).decode()
        if str2:  #str2有内容
            print(str2)

if __name__ == '__main__':

    try:
        client = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        client.connect(('127.0.0.1',8007))
        print('欢迎客户端')
    except BaseException as e:
        #没连上,3秒后重新连接  ---- 重连机制
        time.sleep(3)
        client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        client.connect(('127.0.0.1', 8008))
    else:
        #连上了
        threaad1 = threading.Thread(target=msg_send)
        threaad1.start()

        threaad2 = threading.Thread(target=msg_recv)
        threaad2.start()

（三）创建pro3.py，完成以下推导式

# 1.使用列表推导式，定义一个1-10的立方的列表，只包含偶数
list1 = [i**3 for i in range(1,11) if i%2==0]
# 2.使用列表推导式，在’123‘和’abc‘两个字符串中，推导出如下结果['1a', '1b', '1c', '2a', '2b', '2c', '3a', '3b', '3c']
list2 = [f'{x}{y}' for x in '123' for y in 'abc']
print(list2)
# 3.使用字典推导式，定义一个字典，键分别为2、4、6，值为这几个数字的立方
dict= {k:k**3 for k in [2,4,6] }
print(dict)
# 4.使用集合推导式，在字符串’abracadabra‘中找到非a、b、c的字符，并生成集合
set1 = {x for x in 'abracadabra' if x not in 'abc'}
print(set1)
# 5.使用字典推导式，在字符串’rocky like python‘中，键为每一个字母，值为字木出现的次数，
# 效果如下{'r': 1, 'o': 2, 'c': 1, 'k': 2, 'y': 2, ' ': 2, 'l': 1, 'i': 1, 'e': 1, 'p': 1, 't': 1, 'h': 1, 'n': 1}
str1 = 'rocky like python'
dict2 = {k:str1.count(k) for k in str1}
print(dict2)