subprocess

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

import subprocess

cmd = input('请输入指令; ').strip()

# stdout 返回执行成功结果  stderr 返回保错结果

obj = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

res = obj.stdout.read() + obj.stderr.read()

print(res.decode('gbk'))

粘包问题

问题原因

无法预测需要接收数据的长度, 服务端前一次发送的数据, 客户端无法精确一次性接受完毕, 下一次发送的数据与上一次未发送的数据粘在一起
TCP协议: TCP协议是一个流式协议, 会将多次连续发生的数据量小的, 时间间隔短的数据打包一次性发送

解决问题

struct模块: 将数据长度压缩成固定长度的一个标记(数据报头)发生给对方, 告诉对方即将发送的数据的真实长度
先定义报头, 发送报头, 再发送真实数据

# server.py

import socket

import subprocess

import struct

server = socket.socket()

server.bind(

    ('127.0.0.1', 8888)

)

server.listen(5)

while True:

    conn, addr = server.accept()

    print(addr)

    while True:

        try:

            # 接收指令

            cmd = conn.recv(1024).decode('utf-8')

            obj = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

            # 返回终端结果

            res = obj.stdout.read() + obj.stderr.read()

            # 将result长度压缩, 得到报头

            headers = struct.pack('i', len(res))

            # 将报头发送给客户端

            conn.send(headers)

            # 将结果发送给客户端

            conn.send(res)

        except Exception as e:

            print(e)

            break

    conn.close()

# client.py

import socket

import struct

client = socket.socket()

client.connect(

    ('127.0.0.1', 8888)

)

while True:

    cmd = input('请输入指令: ').strip()

    if cmd == 'q':

        break

    # 向服务端发送指令

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

    # 接收报头

    headers = client.recv(4)

    # 解压报头(得到元祖), 获取数据长度

    res_len = struct.unpack('i', headers)[0]

    # 按数据长度接收服务端返回结果

    res = client.recv(res_len)

    print(res.decode('gbk'))

client.close()

上传大文件

先发送一个报头, 包含字典长度
再发送该字典, 包含文件名和文件长度信息
最后发送该文件

# server.py

import socket

import struct

import json

server = socket.socket()

server.bind(

    ('127.0.0.1', 8888)

)

server.listen(5)

while True:

    conn, addr = server.accept()

    try:

        # 接收字典报头

        headers = conn.recv(4)

        # 解压获取字典长度

        dict_len = struct.unpack('i', headers)[0]

        # 接收字典

        bytes_dict = conn.recv(dict_len)

        json_dict = bytes_dict.decode('utf-8')

        file_info_dict = json.loads(json_dict)

        print(file_info_dict)

        # 获取文件名, 文件长度

        file_name = file_info_dict.get('file_name')

        file_len = file_info_dict.get('file_len')

        init_len = 0

        count = 1

        with open(file_name, 'wb') as f:

            while init_len < file_len:

                # 接收视频文件数据

                file_data = conn.recv(1024)

                # 写入视频文件

                f.write(file_data)

                print(f'第{count}次接收')

                init_len += len(file_data)

                count += 1

            print(f'{file_name}接收完毕!')

    except Exception as e:

        print(e)

        break

conn.close()

# client.py

import socket

import struct

import json

client = socket.socket()

client.connect(

    ('127.0.0.1', 8888)

)

# 读取视频文件数据

with open(r'C:\Users\Black\Desktop\client_video.mp4', 'rb') as f:

    video_data = f.read()

    # 视频文件信息字典

    file_info_dict = {

        'file_name': 'client_video.mp4',

        'file_len': len(video_data)

    }

# 将字典序列化以便获取其长度

json_dict = json.dumps(file_info_dict)

bytes_dict = json_dict.encode('utf-8')

# 字典长度报头

headers = struct.pack('i', len(bytes_dict))

# 发送字典报头

client.send(headers)

# 发送字典

client.send(bytes_dict)

with open(r'C:\Users\Black\Desktop\client_video.mp4', 'rb') as f:

    init_len = 0

    count = 1

    while init_len < len(video_data):

        # 一次读取1024字节

        file_data = f.read(1024)

        # 分多次发送文件数据

        client.send(file_data)

        print(f'第{count}次发送')

        init_len += len(file_data)

        count += 1

    print('文件发送完毕!')

client.close()

UDP协议

User Datagram Protocol 用户数据报协议
不需要建立双向通道
不会粘包
客户端给服务端发送数据, 不需要等待服务端返回接收成功
面向数据包的不可靠传输层通信协议

# server.py

import socket

# 默认为type=socket.SOCK_STREAM, 既TCP协议

server = socket.socket(type=socket.SOCK_DGRAM)

server.bind(

    ('127.0.0.1', 8888)

)

# 不需要半连接池和accept建立连接, 直接接收

msg, addr = server.recvfrom(1024)

print(msg, addr)

# client.py

import socket

# 默认为type=socket.SOCK_STREAM, 既TCP协议

client = socket.socket(type=socket.SOCK_DGRAM)

server_ip_port = ('127.0.0.1', 8888)

# 直接向指定IP和PORT发送即可

client.sendto(b'hello', server_ip_port)

QQ聊天室

# server.py

import socket

server = socket.socket(type=socket.SOCK_DGRAM)

server.bind(

    ('127.0.0.1', 8888)

)

while True:

    recv_msg1, addr1 = server.recvfrom(1024)

    # recv_msg2, addr2 = server.recvfrom(1024)

    # recv_msg3, addr3 = server.recvfrom(1024)

    print(recv_msg1.decode('utf-8'))

    # print(recv_msg2.decode('utf-8'))

    # print(recv_msg3.decode('utf-8'))

    send_msg = input('输入消息: ')

    server.sendto(send_msg.encode('utf-8'), addr1)

    # server.sendto(send_msg.encode('utf-8'), addr2)

    # server.sendto(send_msg.encode('utf-8'), addr3

# client1.py

import socket

client = socket.socket(type=socket.SOCK_DGRAM)

server_ip_port = ('127.0.0.1', 8888)

while True:

    send_msg = input('输入消息:')

    client.sendto(send_msg.encode('utf-8'), server_ip_port)

    recv_msg, addr = client.recvfrom(1024)

    print(recv_msg.decode('utf-8'))

SocketServer

Python内置模块, 可以简化socket套接字服务端的代码
简化TCP与UDP服务端代码
必须要创建一个类

# server.py

import socketserver

# 定义类, 继承socketserver.BaseRequestHandler类

class MyTcpServer(socketserver.BaseRequestHandler):

    # 重写父类的handle方法

    def handle(self):

        # 1.接收消息

        data = self.request.recv(1024)  # conn.recv(1024)

        print(data)

        # 2.发送消息

        send_msg = input('from server:')

        self.request.send(send_msg.encode('utf-8'))

if __name__ == '__main__':

    socketserver.TCPServer.allow_reuse_address = True

    server = socketserver.TCPServer(

        ('127.0.0.1', 8888), MyTcpServer

    )

    # 永久执行服务

    server.serve_forever()

巴特西

Python3 网络基础基础2

subprocess

粘包问题

问题原因

解决问题

上传大文件

UDP协议

SocketServer

最新文章

热门文章