day27

目录

• subprocess模块
• 粘包问题
• struct模块
• 上传大文件
• UDP
• QQ聊天室
• Socketserver

subprocess模块

​ subprocess模块允许你去创建一个新的进程让其执行另外的程序，并与它进行通信，获取标准的输入、标准的输出、标准错误以及返回码等。

​ 1.可以帮你通过代码执行操作系统的终端命令

​ 2.并返回终端执行命令的结果

import subprocess

cmd = input('cmd>>>:')
obj = subprocess.Popen(
	#cmd命令
	cmd,
	#Shell = True
	shell = true,
	#返回正确结果参数
	stdout = subprocess.PIPE,
	#返回错误结果参数 error
	stderr = subprocess.PIPE
)
result = obj.stdout.read()+obj.stderr.read()
print(result.decode('gbk'))

粘包问题

​ 服务端第一次发送的数据，客户端无法精确一次性接收完毕

​ 下一次发送的数据与上一次数据黏在一起了

​

​ 1.无法预测对方需要接收的数据大小长度

​ 2.多次连续发送数据量小、并且时间间隔短的数据一次性打包发送

​ TCP协议特性：

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

解决粘包问题：

​ struct模块

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

​ 即想发送文件，又想发送文件的描述信息

客户端发送字典给服务端
 send_dic = {
 	file_name:文件名
 	file_size:文件的真实长度 100000
 }
 	#通过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 struct

client = socket.socket()

client.connect(
		('127.0.0.1',9507)
)
while True:
		cmd = input('>>>:')
		client.send(cmd.encode('utf-8'))
	
		if cmd =='q':
	 	 	break
		#先获取数据报头
		headers = client.rev(4)
		#解包，或者真实数据长度
		data_len = struct.unpack('i',headers)[0]
		#接收真实数据长度
		data= client.recv(data_len)
		print(data.decode('gbk'))
client.close()

服务端
import socket
import subprocess
import struct

server = socket.socket()
server.bind(
	('127.0.0.1',9507)
)
server.listen(5)
while True:
	conn,addr = server.accept()
	while True:
		try:
		#recv的数据是从内存中获取
		cmd = conn.recv(1024).decode('utf-8')
		if cmd == 'q':
		   break
		if len(cmd)==0:
			break
		print(cmd)
		#执行cmd命令
		obj = subprocess.Popen(
		      cmd,
		      shell = True，
		      stdout = subprocess.PIPE,
		      srderr = 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()

struct模块

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

import struct

#打包压缩
#i：模式，会将数据长度压缩成4个bytes
str1 = ‘fsahoifhsoaifhdso’

#报头
#模式客户端
headers = struct.pack('i',10000)
print(headers)

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

#模拟服务器
#headers = conn.recv(4)
data_len = struct.unpack('i',headers)#(10000,)
print(data_len[0])#真实数据长度10000

上传大文件

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

客户端
import socket
import struct
import json
client = socket.socket()
client.connect(
	('127.0.0.1',8888)
)
#1.打开一个视频文件，获取视频数据大小
with open(r'D:json.mp4','rb')as f:
   movie_bytes = f.read()
   #关闭文件
#2.为视频文件组织一个字典，字典内有视频的名称，视频大小
send_dic = {
	'file_name':'json.mp4',
	'file_size':len(movie_bytes)
}
#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:json.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)

服务端
import socket
import json
import struct
server = socket.socket()
server.bind(
	('127.0.0.1',8888)
)
server.listen(5)
while True:
	conn,addr = server.accept()
	try:
		#先接受字典报头
		headers = conn.recv(4)
		
		#解包获取字典真实数据长度
		data_len = struct.unpack('i',headers)[]
		
		#获取字典真实数据
		bystes_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()

UDP

是一种传输协议

​ 不需要建立双向管道

​ 不会粘包

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

​ 数据容易丢失，数据不安全

​ TCP：好比在打电话

​ UDP:就好比在发短信

客户端
import socket
client =socket.socket(type = socket.SOCK_DGRAM)
server_ip_port = ('127.0.0.1',9527)

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)

服务端
import socket

#SOCK_DGRAM:代表UDP
server = socket.socket(type = socket.SOCK_DGRAM)

#服务端需要绑定ip+port
server.bind(
	('127.0.0.1')
)
#TCP
#conn,addr = server.accept()
#conn.recv()

#UDP
msg,addr =server.recvfrom(1024)
msg1,addr1 =server.recvfrom(1024)
msg2,addr2 =server.recvfrom(1024)

print(msg,msg1,msg2)

QQ聊天室

服务端
import socket
server = socket.socket(type = socket.SOCK_DGRAM)

server.bind(
	('127.0.0.1',9507)
)
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('utf-8'))
	print(msg1.decode('utf-8'))
	print(msg2.decode('utf-8'))
	
	#服务端往客户端发送消息
	send_msg = input('服务端发送消息：').encode('utf-8')
	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'9507)
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'))

复制2份

Socketserver

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

​ 简化TCP与UDP服务端代码

​ 必须创建一个类

服务端
import socketserver

#定义类
#TCP:必须继承BaseQequesHandler类
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')
        	   send_msg = data.upper()
        	   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.server_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'))