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'))
