python 网络编程

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()
posted @   宁采臣open  阅读(44)  评论(0)  编辑  收藏  举报
相关博文：
· Linux 网络管理
· Python 并发编程
· 网络编程-Python
· Python网络编程——基于tcp协议实现远程执行命令、udp协议没有粘包问题、解决粘包问题、socketserver模块的基本使用（基于tcp协议、基于udp协议的使用）
· 网络编程- 实现基于TCP/UDP协议的socket通信，及TCP通信过程中粘包问题和socketserver模块实现并发客户端
阅读排行：
· 全程不用写代码，我用AI程序员写了一个飞机大战
· DeepSeek 开源周回顾「GitHub 热点速览」
· 记一次.NET内存居高不下排查解决与启示
· MongoDB 8.0这个新功能碉堡了，比商业数据库还牛
· .NET10 - 预览版1新功能体验（一）
点击右上角即可分享
微信分享提示
AI FOR CODE 大赛