1018课堂小结

subprocess模块

subprocess模块的作用

可以帮你通过代码执行操作系统的终端命令,并返回终端执行命令后的结果。

subprocess模块的简单使用

import subprocess

cmd = input('cmd>>:')  # 输入cmd命令,如clac

# 调用popen类,传入几个重要参数
obj = subprocess.Popen(
    # cmd命令
    cmd,
    # Shell=True
    shell=True,
    # 返回正确结果参数
    stdout=subprocess.PIPE,
    # 返回错误结果参数 
    stderr=subprocess.PIPE
)
# 返回结果 正确或者错误信息
result = obj.stdout.read() + obj.stderr.read()

# Windows重点编码为gbk,解码后打印
print(result.decode('gbk'))

struct模块

struct模块的作用

是一个可以将很长的数据的长度,压缩成固定的长度的一个标记(数据报头),用于解决粘包问题。

struct模块的简单使用

import struct

# 打包压缩
# i:模式,会将数据长度压缩成4个bytes
str1 = 'wataaaaaaaaaaaaa'

# 报头
# i模式,10000个字节
headers = struct.pack('i', 10000)
# 打印报头  b"\x10'\x00\x00"
print(headers)

print(len(headers))  # 4 打包压缩成4个字节

# 解包,得到字节数
data_len = struct.unpack('i', headers)  # 输出为元组(10000,)
print(data_len[0])  # 真实数据长度10000

粘包问题

注意:粘包问题只会在TCP协议中出现,UDP协议不会有这个问题

TCP协议特性:
TCP是一个流式协议,会将多次连续发送数据量小、并且时间间隔短的数据一次性打包发送。

解决粘包问题

解决粘包问题的核心是:如何让发送端在发送数据前,把自己将要发送的字节流总大小让接收端知晓,然后接收端来一个死循环一次性接收完所有数据

  • 利用struct模块解决粘包问题

    必须先定义报头,发送报头,再发送真实数据。

    既想发送文件,又想发送文件的描述信息,利用字典还有json模块

  • 下面是解决粘包问题,传输大文件的例子

import socket
import json
import struct
server = socket.socket()
server.bind(('127.0.0.1', 9527))
server.listen(5)
while True:
    conn, addr = server.accept()
    try:
        # 先接收字典报头
        headers = conn.recv(4)

        # 解包获取字典真实数据长度
        data_len = struct.unpack('i', headers)[0]

        # 获取字典真实数据
        bytes_data = conn.recv(data_len)

        # 反序列得到字典
        back_dic = json.loads(bytes_data.decode('utf-8'))

        print(back_dic)

        # 拿到字典的文件名,文件大小
        file_name = back_dic.get('file_name')
        file_size = back_dic.get('file_size')

        init_data = 0
        # 1.以文件名打开文件,准备写入
        with open(file_name, 'wb') as f:
            # 一点一点接收文件,并写入
            while init_data < file_size:
                data = conn.recv(1024)
                # 2.开始写入视频文件
                f.write(data)
                init_data += len(data)
            print(f'{file_name}接收完毕!')
    except Exception as e:
        print(e)
        break

conn.close()
import socket
import struct
import json
client = socket.socket()
client.connect(('127.0.0.1', 9527))

# 1.打开一个视频文件,获取视频数据大小
with open(r'D:\aaa.mp4', 'rb') as f:
    movie_bytes = f.read()
    # 关闭文件

# 2.为视频文件组织一个字典,字典内有视频的名称,视频大小
send_dic = {
    'file_name': 'aaa.mp4',
    'file_size': len(movie_bytes)  # 10G
}

# 3.先打包字典,发送headers报头,再发送真实字典数据
json_data = json.dumps(send_dic)
bytes_data = json_data.encode('utf-8')
headers = struct.pack('i', len(bytes_data))
# 发送报头
client.send(headers)
# 发送真实字典数据
client.send(bytes_data)

# 4.接着发送真实视频文件数据
init_data = 0
num = 1
with open(r'D:\aaa.mp4', 'rb') as f:
    while init_data < len(movie_bytes):
        # 最后一次获取,有多少拿多少
        send_data = f.read(1024)
        print(send_data, num)
        num += 1
        # 每次发送1024数据
        client.send(send_data)
        # 为初始发送数据 + 已发送数据的长度
        init_data += len(send_data)

UDP

UDP是一种传输协议。

  1. 不需要建立双向管道。
  2. 不会粘包
  3. 客户端给服务端发送数据,不需要等待服务端返回接收成功
  4. 数据容易丢失,数据不安全。

qq聊天室

基于 UDP 实现qq聊天室,多人聊天就创建多个客户端,但服务端接收到消息,必须回复消息。

# 服务端
import socket
# type=socket.SOCK_DGRAM代表使用UDP协议,不写是默认为SOCK_STREAM,即TCP协议
server = socket.socket(type=socket.SOCK_DGRAM)

server.bind(('127.0.0.1', 9527))

while True:

    # 服务端接收客户端传过来的消息
    msg, addr = server.recvfrom(1024)  # (消息,客户端地址)
    print(addr)

    # 服务端往客户端发送消息
    send_msg = input('服务端发送消息:').encode('utf-8')
    server.sendto(send_msg, addr)
# 客户端
import socket
client = socket.socket(type=socket.SOCK_DGRAM)
server_ip_port = ('127.0.0.1', 9527)
while True:
    send_msg = input('客户端1: ').encode('utf-8')
    # 发送消息必须要加上对方地址
    client.sendto(send_msg, server_ip_port)
    # 能接收任何人的消息
    msg = client.recv(1024)
    print(msg.decode('utf-8'))

SocketServer

python内置模块,可以简化socket套接字服务端的代码。

  1. 简化TCP与UDP服务端代码
  2. 必须要创建一个类
# socketserver 服务端

import socketserver

# 定义类
# TCP: 必须继承BaseRequestHandler类
class MyTcpServer(socketserver.BaseRequestHandler):
    # 必须重写父类的handle, 当客户端连接时会调用该方法
    def handle(self):
        print(self.client_address)

        while True:
            try:
                # 1.接收消息
                # request.recv(1024) == conn.recv(1024)
                data = self.request.recv(1024).decode('utf-8')
                
                self.request.send(send_msg.encode('utf-8'))

            except Exception as e:
                print(e)
                break


if __name__ == '__main__':
    # socketserver.TCPServer只能有一个服务端 服务 一个客户端
    # server = socketserver.TCPServer(
    #     ('127.0.0.1', 8888), MyTcpServer
    # )

    # ThreadingTCPServer: 有多个服务端 服务 客户端
    server = socketserver.ThreadingTCPServer(
        ('127.0.0.1', 8888), MyTcpServer
    )

    # 永久执行服务
    server.serve_forever()
# 客户端
import socket

client = socket.socket()

client.connect(

    ('127.0.0.1', 8888)
)

while True:
    send_msg = input('客户端: ')

    client.send(send_msg.encode('utf-8'))

    back_msg = client.recv(1024)

    print(back_msg.decode('utf-8'))
相关文章
相关标签/搜索