subprocess模块

? 作用：

? 1、可以通过代码执行操作系统的终端命令

? 2、并返回终端执行命令后的结果

用法：
import subprocess

cmd = inpu(&＃39;CMD >>>&＃39;)
obj = subprocess.Popen(
cmd.decode(&＃39;utf8&＃39;),
shell=True,
stdout= subprocess.PIPE,
stderr= subprocess.PIPE
)
result = obj.stdout.read() + obj.stderr.read()

print(result.decode(&＃39;gbk&＃39;))

TCP协议

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

黏包问题

? 原因：

? 1、无法预测需要接收的数据的长度

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

解决黏包问题： 告诉对端数据的确切长度。

-struct模块：

? 必须先发送报头，再发送数据：

? 1、自定义报头，将数据长度等数据的描述信息制作成字典，

? 2、将字典json.dumps序列化并编码转为bytes，用于传输

? 3、先将报头的长度，用struct.pack格式化成固定长度(4字节)

? 4、发送：先发送报头长度，再发送报头，然后发送数据正文

? 接收：

? 1、先接收到4个字节的报头长度信息，unpack解压得到报头的长度值

? 2、根据报头长度值接收报头，解码并json.load反序列得到数据正文的描述信息（包含数据长度）

? 3、根据数据长度接收数据正文，

? 用法：

import json,struct
#假设通过客户端上传10G:10000000的文件：小视频.txt
#为避免粘包,必须自定制报头
header={&＃39;file_size&＃39;:10000000,&＃39;file_name&＃39;:&＃39;小视频.txt&＃39;, &＃39;md5&＃39;:&＃39;8f6fbf8347faa4924a76856701edb0f3&＃39;} #10G数据,文件路径和md5值
#为了该报头能传送,需要序列化并且转为bytes
head_bytes=bytes(json.dumps(header),encoding=&＃39;utf-8&＃39;) #序列化并转成bytes,用于传输
#为了让客户端知道报头的长度,用struck将报头长度这个数字转成固定长度:4个字节
head_len_bytes=struct.pack(&＃39;i&＃39;,len(head_bytes)) #这4个字节里只包含了一个数字,该数字是报头的长度
#客户端开始发送
conn.send(head_len_bytes) #先发报头的长度,4个bytes
conn.send(head_bytes) #再发报头的字节格式
conn.sendall(文件内容) #然后发真实内容的字节格式
#服务端开始接收
head_len_bytes=s.recv(4) #先收报头4个bytes,得到报头长度的字节格式
x=struct.unpack(&＃39;i&＃39;,head_len_bytes)[0] #提取报头的长度
head_bytes=s.recv(x) #按照报头长度x,收取报头的bytes格式
header=json.loads(json.dumps(header)) #提取报头
#最后根据报头的内容提取真实的数据,比如
real_data_len=s.recv(header[&＃39;file_size&＃39;])
s.recv(real_data_len)

上传大文件

以上传视频为例：

客户端：

import socket
import struct
import json
client = socket.socket()
client.connect(
(&＃39;127.0.0.1&＃39;, 9527)
)
with open(r&＃39;C:\day 027\5 上传大文件.mp4&＃39;, &＃39;rb&＃39;)as f:
movie_bytes = f.read()
head_dic = {
&＃39;file_name&＃39;: &＃39;5 上传大文件.mp4&＃39;,
&＃39;file_size&＃39;: len(movie_bytes)
}
json_head = json.dumps(head_dic)
bytes_head = json_head.encode(&＃39;utf-8&＃39;)
headers = struct.pack(&＃39;i&＃39;, len(bytes_head))
client.send(headers)
client.send(bytes_head)
init_data = 0
num = 1
with open(r&＃39;C:\day 027\5 上传大文件.mp4&＃39;, &＃39;rb&＃39;)as f:
while init_data send_data = f.read(1024)
num += 1
client.send(send_data)
print(send_data, f&＃39;第{num}段数据发送完成&＃39;)
init_data += len(send_data)
print(&＃39;发送完毕！&＃39;)


服务端：

import socket
import json
import struct
server = socket.socket()
server.bind(
(&＃39;127.0.0.1&＃39;, 9527)
)
server.listen(5)
while True:
conn, addr = server.accept()
try:
headers = conn.recv(4)
head_len = struct.unpack(&＃39;i&＃39;, headers)[0]
byte_head = conn.recv(head_len)
head_dic = json.loads(byte_head.decode(&＃39;utf-8&＃39;))
print(head_dic)
file_name = head_dic.get(&＃39;file_name&＃39;)
file_size = head_dic.get(&＃39;file_size&＃39;)
init_data = 0
num = 1
with open(file_name, &＃39;wb&＃39;) as f:
while init_data data = conn.recv(1024)
print(f&＃39;第{num}段&＃39;,data)
f.write(data)
init_data += len(data)
print(f&＃39;{file_name}接收完毕！&＃39;)
except Exception as e:
print(&＃39;error:&＃39;, e)
break
conn.close()


UDP

? UDP是一种传输协议

? 1、不需要建立双向管道

? 2、不会黏包

? 3、客户端给服务端发送数据，不需要等服务端的回执

? 4、服务端只接收需要接收的数据，不管客户端传过来多少

服务端：

import socket
server = socket.socket(type=socket.SOCK_DGRAM)
server.bind(
(&＃39;127.0.0.1&＃39;, 9527)
)
msg1 = server.recvfrom(1024)
msg2 = server.recvfrom(1024)
msg3 = server.recvfrom(1024)
print(msg1, msg2, msg3)

客户端：

import socket
client =socket.socket(type=socket.SOCK_DGRAM)
server_ip_port = (&＃39;127.0.0.1&＃39;, 9527)
client.sendto(b&＃39;hello!&＃39;, server_ip_port)
client.sendto(b&＃39;hello!&＃39;, server_ip_port)
client.sendto(b&＃39;hello!&＃39;, server_ip_port)
client.sendto(b&＃39;hello!&＃39;, server_ip_port)
client.sendto(b&＃39;hello!&＃39;, server_ip_port)

执行结果：(b‘hello!‘, (‘127.0.0.1‘, 57182)) (b‘hello!‘, (‘127.0.0.1‘, 57182)) (b‘hello!‘, (‘127.0.0.1‘, 57182))

简易聊天室

基于TCP协议，用socket套接字实现一个服务端对多个客户端的简易聊天室：

服务端：

import socket
server = socket.socket(type=socket.SOCK_DGRAM)
server.bind(
(&＃39;127.0.0.1&＃39;, 9527)
)
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(&＃39;utf-8&＃39;))
print(msg1.decode(&＃39;utf-8&＃39;))
print(msg2.decode(&＃39;utf-8&＃39;))
# 服务端往客户端发送消息
send_msg = input(&＃39;服务端发送消息:&＃39;).encode(&＃39;utf-8&＃39;)
server.sendto(send_msg, addr)
server.sendto(send_msg, addr1)
server.sendto(send_msg, addr2)

客户端1：

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

客户端2：

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

客户端3：

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

先启动服务端，再依次启动客户端，可开始模拟聊天室聊天

SocketServer

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

import socket
class MyTcpServer(socketserver, BaseRequestHandler):
def handler(self):

data = self.request.recv(1024)
pirnt(data)
send_msg = input(&＃39;服务端：&＃39;).encode(&＃39;utf8&＃39;)
self.request.send(send_msg)