wtf
10.18 总结

1.subprocess模块：

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

import subprocess

cmd=input('cmd>>: ')

obj=subprocess.Popen(cmd,shell=True,
                     #返回正确的结果
                     stdout=subprocess.PIPE,
                     #返回错误的结果
                     stderr=subprocess.PIPE)
res=obj.stdout.read()+obj.stderr.read()
print(res.decode('gbk'))

2.粘包问题

服务端第一次发送的数据，客户端无法精确一次性接受完毕。下一次发送的数据与上一次数据粘在一起了。

无法预估对方需要接受的数据大小长度。多次连续发送数据量小、并且时间间隔短的数据一次性打包发送。

TCP协议特性：

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

struct 模块

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

是一个可以将长度很长的数据，压缩成固定的长度的一个标记（数据报头）。

import struct
#打包压缩，i模式，会将数据长度压缩成4个bytes
str1='uwuwhsxnxxbxx'
#报头
#模拟客户端
headers=struct.pack('i',len(str1))
print(headers)

print(len(str1))
#client.send(headers)

#模拟服务端
#headers=conn.recv(4)
data_len=struct.unpack('i',headers)
print(data_len[0])

3.解决粘包问题：

既想发送文件，又想发送文件的描述信息。

#客户端发送字典给服务端
send_dic={
      file_name:文件名
      file_size:文件的真实长度 
}
#通过json模块序列化成bytes数据
json_data=json.dumps(send_dic)
bytes_data=json_data.encode('utf-8')
#先获取字典的报头
headers=struct.pack('i',len(bytes_data))
#服务端接收到字典，并接收文件的真实数据

#服务端
import socket
import subprocess
import struct

server=socket.socket()

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

server.listen(5)

while True:
    conn,addr=server.accept()

    while True:
        try:
            #recv的数据是从内存中获取
            cmd=conn.recv(1024).decode('utf8')

            if cmd=='q':
                break

            if len(cmd)==0:
                continue

            print(cmd)

            #执行cmd命令
            obj=subprocess.Popen(
                cmd,
                shell=True,
                stdout=subprocess.PIPE,
                stderr=subprocess.PIPE,
            )
            #接收终端返回的数据
            result=obj.stdout.read()+obj.stderr.read()

            #打包压缩，获取报头
            headers=struct.pack('i',len(result))

            #先发送报头
            conn.send(headers)

            #再发送真实数据
            conn.send(result)

        except Exception as e:
            print(e)
            break
    conn.close()

#客户端
import socket
import struct

client=socket.socket()

client.connect(
    ('127.0.0.1',9527)
)

while True:
    cmd=input('>>>: ')
    client.send(cmd.encode('utf8'))

    if cmd=='q':
        break

    #先获取数据报头
    headers=client.recv(4)

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

    #接收真实数据长度
    data=client.recv(data_len)

    print(data.decode('gbk'))

client.close()

4.上传大文件

客户端往服务端上传大文件

#服务端
import socket
import json
import struct

server=socket.socket()
server.bind(
    ('127.0.0.1',9533)
)
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('utf8'))
        print(back_dic)

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

        init_data=0
        #以文件名打开字典，准备写入
        with open(file_name,'wb') as f:

            #一点一点接收文件，并写入
            while init_data<file_size:
                data=conn.recv(1024)
                #开始写入视频文件
                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',9533)
)

#1.打开一个视频文件，获取视频数据大小
with open(r'K:\Python课程\上课视频\day25\jason真实写真集.mp4','rb') as f:
    movie_bytes=f.read()

    #关闭文件

#2.为视频文件组织一个字典，字典内有视频的名称，视频大小
send_dic={
    'file_name':'jason真实写真集.mp4',
    'file_size':len(movie_bytes)
}

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

#4.接着发送真实视频文件数据
init_data=0
num=1
with open(r'K:\Python课程\上课视频\day25\jason真实写真集.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)

5.UDP简单使用

--UDP是一种传输协议。

​ 1）不需要建立双向通道。

​ 2）不会粘包。

​ 3）客户端给服务端发送数据，不需要等待服务端返回接收成功。

​ 4）数据容易丢失，不安全。

​ --TCP：好比打电话

​ --UDP：好比发短信。

#服务端：
server=socket.socket(type=socket.SOCK_DGRAM)

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

#TCP
# conn,addr=server.accept() #等待客户端连接，一旦连接上，就以conn作为对象
# conn.recv()

#UDP
msg,addr=server.recvfrom(1024)
msg1,addr1=server.recvfrom(1024)
msg2,addr2=server.recvfrom(1024)
msg3,addr3=server.recvfrom(1024)
msg4,addr4=server.recvfrom(1024)
print(msg,msg1,msg2,msg3,msg4)

#客户端：
import socket

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

server_ip_port=('127.0.0.1',9927)

client.sendto(b'hello',server_ip_port)
client.sendto(b'hello',server_ip_port)
client.sendto(b'hello',server_ip_port)
client.sendto(b'hello',server_ip_port)
client.sendto(b'hello',server_ip_port)

服务端运行结果：
b'hello' b'hello' b'hello' b'hello' b'hello'

6.基于UDP实现QQ聊天室

#服务端
import socket

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

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

while True:
    msg,addr=server.recvfrom(1024)
    msg1, addr1 = server.recvfrom(1024)
    msg2, addr2 = server.recvfrom(1024)

    print(addr)
    print(addr1)
    print(addr2)
    print(msg.decode('utf8'))
    print(msg1.decode('utf8'))
    print(msg2.decode('utf8'))

    #服务端往客户端发送消息
    send_msg=input('服务端发送消息：').encode('utf8')
    server.sendto(send_msg,addr)
    server.sendto(send_msg, addr1)
    server.sendto(send_msg, addr2)

#客户端
import socket

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

server_ip_port=('127.0.0.1',8897)

while True:
    send_msg=input('客户端1： ').encode('utf8')

    #发送消息必须要加上对方的地址
    client.sendto(send_msg,server_ip_port)

    #能接收任何人的消息
    msg=client.recvfrom(1024)

    print(msg.decode('utf8'))
    
 执行三个客户端，发三个消息，服务端才能打印出结果，服务端发一个消息，三个客户端会同时收到。

7.SocketServer

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

#服务端
import socketserver

#定义类
#TCP:必须继承BaseRequestHandler类
class MyTcpServer(socketserver.BaseRequestHandler):
    #必须重写父类的handle
    def handle(self):
        #1.接收消息
        data=self.request.recv(1024)
        print(data)

        #2.给客户端发送消息
        send_msg=input('服务端：').encode('utf8')
        self.request.send(send_msg)

if __name__ == '__main__':
    socketserver.TCPServer.allow_reuse_address=True
    server=socketserver.TCPServer(
        ('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('utf8'))
    back_msg=client.recv(1024)
    print(back_msg.decode('utf8'))
posted on 2019-10-18 20:39  wtfss  阅读(149)  评论(0)    收藏  举报

博客园  ©  2004-2025
浙公网安备 33010602011771号 浙ICP备2021040463号-3 Powered By博客园