套接字实现客户和服务端连接进行发送消息

客户端

from socket import *
import sys

from util import send_data, start_data


def _output(sock):
    def _input():
        msg = input('>>')
        if msg == "emd":
            print("客户端结束连接")
            sock.send(msg.encode('utf8'))
            sys.exit(1)
        elif msg == "请接收我的精美图片":
            sock.send(msg.encode('utf8'))
        elif msg == "请为我分析成绩单，我需要了解最高成绩。最低成绩，平均成绩，高于平均成绩的同学有哪些":
            sock.send(msg.encode('utf8'))
        else:
            sock.send(msg.encode('utf8'))

    while True:
        connex = sock.recv(1024).decode('utf-8')
        print("魔品: ", connex)
        if connex == "好的":
            msg = input('请输入您的图片路径:')
            sock.send('图片发送成功'.encode('utf-8'))
            send_data(sock, _path=msg)
        elif connex == "感谢你提供的精美图片，我也有惊喜送给你，请接受我的视须问候":
            msg = input('>>>')
            sock.send(msg.encode('utf-8'))
        elif connex == 'B.mp4发送成功':
            start_data(sock, _form="server_")
        elif connex == "请发送成绩单":
            msg = input('请输入您的文件路径:')
            sock.send('文件发送成功'.encode('utf-8'))
            send_data(sock, _path=msg)
        elif connex[: 10] == "你好，成绩分析己完成":
            sock.send('谢谢魔品，你真是我的好帮手'.encode('utf-8'))
        else:
            _input()


def main():
    client_socket = socket(AF_INET, SOCK_STREAM)
    client_socket.connect(('localhost', 8899))
    client_socket.send('你好，我叫zss'.encode('utf-8'))
    _output(client_socket)


if __name__ == '__main__':
    main()

服务端

from socket import *
from threading import Thread

from main import analysis_data
from util import start_data, send_data

_msg = {
    "请接收我的精美图片": "好的",
    "请为我分析成绩单，我需要了解最高成绩。最低成绩，平均成绩，高于平均成绩的同学有哪些": "请发送成绩单",
    "谢谢魔品，你真是我的好帮手": "不客气哦"
}


def _input(sock, connex):
    if connex == '图片发送成功':
        start_data(sock, _form="client_")
    elif connex == "好的":
        sock.send('B.mp4发送成功'.encode('utf-8'))
        send_data(sock, _path="file_server/B.mp4")
    elif connex == "文件发送成功":
        data = start_data(sock, _form="")
        performance = analysis_data(data)
        sock.send(performance.encode('utf-8'))
    else:
        if connex in _msg.keys():
            sock.send(_msg.get(connex).encode('utf-8'))
        else:
            data = "你好，我是你的程能聊天伙伴，我叫魔品"
            sock.send(data.encode('utf-8'))


def _output(client_conn, client_file):
    print(f'用户连接{client_conn},端口{client_file}')
    while True:
        connex = client_conn.recv(1024).decode('utf-8')
        print('客户端: ', connex)
        if connex == "emd":
            connex.close()
            break
        else:
            _input(client_conn, connex)


def main():
    with socket(AF_INET, SOCK_STREAM) as sock:
        sock.bind(('localhost', 8899))
        sock.listen(5)
        print("服务端 等待连接，端口:", 8899)
        while True:
            client_conn, client_file = sock.accept()
            thread = Thread(target=_output, args=(client_conn, client_file, ))
            thread.start()
            thread.join()


if __name__ == '__main__':
    main()

压缩文件解压文件

import os
import struct


def send_data(sock, _path):
    head = struct.pack(b'128sq',
                       bytes(os.path.basename(_path),
                             encoding='utf-8'),
                       os.stat(_path).st_size)
    sock.send(head)
    with open(_path, 'rb') as f:
        while True:
            data = f.read(1024)
            if data:
                sock.send(data)
            else:
                break


def start_data(sock, _form):
    new_file_name = None
    while True:
        new_file_size = struct.calcsize('128sq')
        new = sock.recv(new_file_size)
        if new:
            file_name, file_size = struct.unpack('128sq', new)
            file_name = file_name.decode().strip('\x00')
            if file_name == "B.mp4":
                new_file_name = os.path.join('C.mp4')
            else:
                new_file_name = os.path.join('from_' + _form + file_name)

            size = 0
            with open(new_file_name, 'wb') as f:
                while not file_size == size:
                    if file_size - size > 1024:
                        data = sock.recv(1024)
                        size += len(data)
                    else:
                        data = sock.recv(1024)
                        size = file_size
                    f.write(data)
        break

    if _form == 'server_':
        print("###解压成功###  server ------> client")
        data = "谢谢你的礼物，我会收藏起来的"
        sock.send(data.encode('utf-8'))
    elif _form == 'client_':
        print("###解压成功###  client ------> server")
        data = "感谢你提供的精美图片，我也有惊喜送给你，请接受我的视须问候"
        sock.send(data.encode('utf-8'))
    return new_file_name

数据分析

import re


class Analysis(object):
    def __init__(self, _post):
        with open(_post, 'r', encoding="utf-8") as f:
            self.list_data = re.sub('分', '', f.read()).strip().split(',')
            self.score = [int(i.split(':')[1].strip()) for i in self.list_data]
            self.name = [i.split(':')[0].strip() for i in self.list_data]
            self.avg = sum(self.score) / len(self.score)
            self.max = max(self.score)
            self.min = min(self.score)
            self.list_zip = list(zip(self.name, self.score))
            self.list_sorted = list(sorted(self.list_zip, key=lambda x: x[1], reverse=True))
            self.list_filter = list(filter(lambda x: x[1] > self.avg, self.list_zip))

    def result(self):
        print('分数排序', self.list_sorted)
        return "你好，成绩分析己完成如下请您参考:最高成绩:%s分。最低成绩:%s分，平均成绩:%s分，高于平均成绩的同学有:%s"\
            % (self.max, self.min, self.avg, self.list_filter)


def analysis_data(_post):
    analysis = Analysis(_post=_post)
    return analysis.result()

装饰器

def decorator_with_parameters(parameter):
    def decorator(func):
        def wrapper(*args, **kwargs):
            # 执行装饰器前的逻辑
            print(f"装饰器参数: {parameter}")
            result = func(*args, **kwargs)
            # 执行装饰器后的逻辑
            return result
        return wrapper
    return decorator


@decorator_with_parameters("参数值")
def decorated_function():
    print("被装饰的函数")

# 调用被装饰的函数
decorated_function()

迭代器

 class Iterator:
#     def __init__(self, data):
#         self.data = data
#         self.index = 0
# 
#     def __iter__(self):
#         return self
# 
#     def __next__(self):
#         while self.index < len(self.data):
#             num = self.data[self.index]
#             self.index += 1
#             return num
#         raise StopIteration
# 
# 
# if __name__ == '__main__':
#     my_iterator = Iterator('123456')
#     for i in my_iterator:
#         print(i)

生成器

def number_generator(n):
    for i in range(n):
        yield i

# 创建生成器对象
my_generator = number_generator(5)

# 使用生成器产生值
print(next(my_generator))  # 输出: 0
print(next(my_generator))  # 输出: 1
print(next(my_generator))  # 输出: 2
print(next(my_generator))  # 输出: 3
print(next(my_generator))  # 输出: 4

面向对象编程，封装继承多态

# 封装
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass

# 继承
class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

# 多态
def animal_speak(animal):
    print(animal.speak())

dog = Dog("Buddy")
cat = Cat("Whiskers")

animal_speak(dog)  # 输出: Woof!
animal_speak(cat)  # 输出: Meow!