python 编程
目录一. 网络编程 socket
1.1 基于tcp 实现网络通讯
- 服务端
import socket
# 创建套接字对象
phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
phone.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它,在bind前加 重用端口
# 绑定地址
phone.bind(('127.0.0.1', 8081))
# 建立监听
phone.listen(5)
print('开始监听')
while True:
# 建立半连接池
conn, client_addr = phone.accept()
while True:
try:
# 接收消息
data = conn.recv(1024)
# 判断消息 是否为空
# 如果是空的 断开连接
if len(data) == 0:
break
print(f"{client_addr} 消息:", data.decode('utf-8'))
res = input('输入回复客户端信息: ').strip()
conn.send(res.encode('utf-8'))
except Exception:
break
conn.close()
phone.close()
#注意:字符串类型转为 bases类型 需要使用 encode进行转码 res.encode('utf-8')
- 客户端
import socket
#1、买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 流式协议=》tcp协议
#2、拨通服务端电话
phone.connect(('127.0.0.1',8081))
#3、通信
while True:
msg=input("输入发送消息>>> q[退出]: ").strip() #msg=''
if len(msg) == 0:
continue
if msg == 'q':
break
phone.send(msg.encode('utf-8'))
data=phone.recv(1024)
msg = data.decode('utf-8')
print(f'服务端回复>>>:{msg}')
#4、关闭连接(必选的回收资源的操作)
phone.close()
1.2 基于tcp 实现远程执行命令
1)粘包问题
- 服务端
# 服务端应该满足两个特点:
# 1、一直对外提供服务
# 2、并发地服务多个客户端
import subprocess
from socket import *
server=socket(AF_INET,SOCK_STREAM)
server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它,在bind前加
server.bind(('127.0.0.1',8082))
server.listen(5)
# 服务端应该做两件事
# 第一件事:循环地从板连接池中取出链接请求与其建立双向链接,拿到链接对象
while True:
conn,client_addr=server.accept()
# 第二件事:拿到链接对象,与其进行通信循环
while True:
try:
cmd=conn.recv(1024)
if len(cmd) == 0:break
obj=subprocess.Popen(cmd.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
)
stdout_res=obj.stdout.read()
stderr_res=obj.stderr.read()
print(len(stdout_res)+len(stderr_res))
# conn.send(stdout_res+stderr_res) # ???
conn.send(stdout_res)
conn.send(stderr_res)
# with open("1.mp4",mode='rb') as f:
# for line in f:
# conn.send(line)
except Exception:
break
conn.close()
- 客户端
from socket import *
client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8082))
while True:
cmd=input('请输入命令>>:').strip()
if len(cmd) == 0:continue
client.send(cmd.encode('utf-8'))
# 解决粘包问题思路:
# 1、拿到数据的总大小total_size
# 2、recv_size=0,循环接收,每接收一次,recv_size+=接收的长度
# 3、直到recv_size=total_size,结束循环
cmd_res=client.recv(1024) # 本次接收,最大接收1024Bytes
print(cmd_res.decode('utf-8')) # 强调:windows系统用gbk
# 粘包问题出现的原因
# 1、tcp是流式协议,数据像水流一样粘在一起,没有任何边界区分
# 2、收数据没收干净,有残留,就会下一次结果混淆在一起
# 解决的核心法门就是:每次都收干净,不要任何残留
2)自定义协议解决粘包问题
- 服务端
import struct
import subprocess
from socket import *
server = socket(AF_INET, SOCK_STREAM)
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server.bind(('127.0.0.1', 8081))
server.listen(5)
print('开始监听: ')
# 创建半连接池
while True:
conn, addr_client = server.accept()
# 获取消息 返回数据
try:
while True:
cmd = conn.recv(1024)
if len(cmd) == 0:
print(f"{addr_client} 已经断开连接")
break
print(f'{addr_client}: {cmd.decode("utf8")}')
# 执行命令 并返回正确输出和错误输出
obj = subprocess.Popen(cmd.decode('utf8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout_res = obj.stdout.read()
stderr_res = obj.stderr.read()
# 计算返回值大小
total_size = len(stdout_res) + len(stderr_res)
print(total_size)
# 解决粘包问题
# 先固定请求头长度 为4字节 :请求头存储数据的描述信息 存储本次发送信息大小
# int类型 --->> bytes类型 (内容大小) struct.pack('i' 等于固定4字节 并把int---bytes
header = struct.pack('i', total_size)
# 发送请求头信息
conn.send(header)
# 发送请求主体内容
conn.send(stdout_res)
conn.send(stderr_res)
except Exception:
break
conn.close()
- 客户端
from socket import *
import struct
client = socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8081))
while True:
cmd = input('请输入命令[q退出]>>:').strip()
if cmd == 'q':
break
if len(cmd) == 0:
continue
client.send(cmd.encode('utf8'))
# 解决粘包问题
# 01 服务端固定请求头长度,解析出数据描述信息 包括数据的总大小 total_size
header = client.recv(4)
print(struct.unpack('i',header))
total_size = struct.unpack('i',header)[0]
print(total_size)
# 02 循环接收本次数据总大小
# recv_size = 0 每次循环+ 1024 直至接收数据完毕 接收
recv_size = 0
while recv_size < total_size:
recv_data = client.recv(1024)
recv_size+=len(recv_data)
print(recv_data.decode('utf8'),end='')
else:
print()
client.close()
3)最终版 定义字典解决粘包问题
- 服务端
'''
# 粘包问题出现的原因
# 1、tcp是流式协议,数据像水流一样粘在一起,没有任何边界区分
# 2、收数据没收干净,有残留,就会下一次结果混淆在一起
# 解决的核心法门就是:每次都收干净,不要任何残留
方案如下:
1 创建请求头信息字典 里面包括请求主体大小:
header_dic = {
'file_name': "a.txt",
'total_size': total_size,
'md5':'sssn8shdc8dsh8cdsbcuds9ds',
'type':'text'
}
# 转为json字典 --->> json字符串---json bytes类型
json_str = json.dumps(header_dic)
header_json_str_bytes = json_str.encode('utf8')
2 把请求头长度信息 打包为4字节 首先发送客户端,客户端接收后 可以获取请求头信息
3 根据请求头信息 获取请求主体大小,
4 获取请求主体
'''
import struct
import subprocess
from socket import *
import json
server = socket(AF_INET, SOCK_STREAM)
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server.bind(('127.0.0.1', 8081))
server.listen(5)
print('开始监听: ')
# 创建半连接池
while True:
conn, addr_client = server.accept()
# 获取消息 返回数据
try:
while True:
cmd = conn.recv(1024)
if len(cmd) == 0:
print(f"{addr_client} 已经断开连接")
break
print(f'{addr_client}: {cmd.decode("utf8")}')
# 执行命令 并返回正确输出和错误输出
obj = subprocess.Popen(cmd.decode('utf8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout_res = obj.stdout.read()
stderr_res = obj.stderr.read()
# 计算返回值大小 total_size 请求主体大小
total_size = len(stdout_res) + len(stderr_res)
#01 制作请求头信息
header_dic = {
'file_name': "a.txt",
'total_size': total_size,
'md5':'sssn8shdc8dsh8cdsbcuds9ds',
'type':'text'
}
# 转为json字典 --->> json字符串---json bytes类型
json_str = json.dumps(header_dic)
header_json_str_bytes = json_str.encode('utf8')
#02 获取请求头长度 len(json_str_bytes) 计算请求头长度 并封装长度信息为 4字节
header_size = struct.pack('i',len(header_json_str_bytes))
## 客户端--->>接收请求头大小---->> 根据大小接收请求头内容信息 字典--->> 根据请求头 获取请求主体大小
#03 发送请求头长度信息
conn.send(header_size)
#04 发送请求头信息
conn.send(header_json_str_bytes)
#05 发送请求主体内容
conn.send(stdout_res)
conn.send(stderr_res)
print(stdout_res.decode('utf8'),stderr_res.decode('utf8'))
except Exception:
break
conn.close()
- 客户端
import json
import struct
from socket import *
client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8081))
while True:
cmd = input('请输入命令[q退出]>>:').strip()
if cmd == 'q':
break
if len(cmd) == 0:
continue
client.send(cmd.encode('utf8'))
# 01 获取请求头长度
header_tmp = client.recv(4)
header_size = struct.unpack('i', header_tmp)[0]
print(f'获取请求主体大小[bytes]--->>:{header_size}')
# 02 获取请求头信息 并取出字典内 total_size 值 json_str --->> json_dic 字符串类型转为字典类型
header_json_str_bytes = client.recv(header_size)
json_str = header_json_str_bytes.decode('utf8')
head_dic = json.loads(json_str)
print(head_dic)
# 03 获取请求返回数据 请求主体的数据
total_size = head_dic.get('total_size')
# 解决粘包问题
# 01 服务端固定请求头长度,解析出数据描述信息 包括数据的总大小 total_size0]
print(f'获取请求主体大小[bytes]--->>: {total_size}')
# 02 循环接收本次数据总大小
# recv_size = 0 每次循环+ 1024 直至接收数据完毕 接收
recv_size = 0
while recv_size < total_size:
recv_data = client.recv(1024)
recv_size += len(recv_data)
print(recv_data.decode('utf8'), end='')
else:
print()
client.close()
1.3 socketserver 实现并发
1)基于TCP实现
- 服务端
'''
# 服务端应该做两件事
# 第一件事:循环地从半连接池中取出链接请求与其建立双向链接,拿到链接对象
# 第二件事:拿到链接对象,与其进行通信循环===>handle
s.serve_forever()
# 等同于
# while True:
# conn,client_addr=server.accept()
# 启动一个线程(conn,client_addr)
'''
import socketserver
class MyRequestHandle(socketserver.BaseRequestHandler):
def handle(self):
print(self.request) # 如果是 tcp 协议 self.request ---conn 套接字 socket
print(self.client_address)
while True:
try:
data = self.request.recv(1024)
if len(data) == 0:
break
print(f"{self.client_address}: {data.decode('utf8')}")
self.request.send(data.upper())
except Exception:
break
self.request.close()
s = socketserver.ThreadingTCPServer(('127.0.0.1', 8888), MyRequestHandle)
s.serve_forever()
- 客户端
'''
实现并发
'''
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1',8888))
while True:
msg=input("输入发送消息>>> q[退出]: ").strip() #msg=''
if len(msg) == 0:
continue
if msg == 'q':
break
client.send(msg.encode('utf-8'))
data=client.recv(1024)
msg = data.decode('utf-8')
print(f'服务端回复>>>:{msg}')
client.close()
2)基于UDP实现
- 原本文件
## 服务端
import socket
server=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
server.bind(('127.0.0.1',8081))
while True:
data,client_adder = server.recvfrom(1024)
print(client_adder,data.decode('utf8'))
server.sendto(data.upper(),client_adder)
server.close()
## 客户端
import socket
client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
while True:
msg = input("输入发送内容--->>: ")
if len(msg) == 0:
continue
client.sendto(msg.encode('utf8'),('127.0.0.1',8081))
data = client.recv(1024)
print(data.decode('utf8'))
client.close()
##这是最基本的 udp通信模版 并不能实现并发
- 基于socketserver 实现
#服务端
import socketserver
class MyRequestHanlde(socketserver.BaseRequestHandler):
def handle(self):
print(self.request)
client_data=self.request[0]
server=self.request[1]
client_address=self.client_address
print('客户端发来的数据%s' %client_data)
server.sendto(client_data.upper(),client_address)
s=socketserver.ThreadingUDPServer(("127.0.0.1",8888),MyRequestHanlde)
s.serve_forever()
#客户端
import socket
client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) # 流式协议=》tcp协议
while True:
msg=input('>>>: ').strip()
client.sendto(msg.encode('utf8'),('127.0.0.1',8888))
res=client.recvfrom(1024)
print(res)
client.close()
标签:socket,python,res,编程,网络,client,print,recv,size
From: https://www.cnblogs.com/saas-open/p/17785072.html