首页 > 编程语言 >python 网络编程

python 网络编程

时间：2023-10-24 16:27:03浏览次数：38  
标签：socket python res 编程 网络 client print recv size

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

相关文章

  • 关于Python正则式中的r和字符串中的r
     正则表达式也是字符串，但是不是普通的字符串，其中包含了正则转义和字符串转义。正则表达式前边加r是取消了字符串转义，但是正则转义还在。例1和例2的对比中，例2的正则表达式取消了普通字符串转义，但是\n在正则表达式里是匹配换行符。例2和例3的对比中，例3的被匹配对象实际是两个字......
  • 利用CloudFlare Workers实现自由网络
    1、打开官网https://www.cloudflare.com/zh-cn/注册登录2、左侧菜单点"Workers和Pages"——创建Workers3、部署"HelloWorld"脚本，部署后点击编辑4、替换代码，https://github.com/3Kmfi6HP/EDtunnel/blob/main/_worker.js5、替换代码中userID为你的uuid，可以使用客户端随机生成......
  • python 解析User-Agent
    需求：从User-Agent中获取浏览器信息和操作系统信息使用第三方库ua-parser安装pipinstallua-parser使用fromua_parser.user_agent_parserimportParse#解析user_agentparsed_user_agent=Parse(user_agent)print(parsed_user_agent)返回数据{"string":"Mozill......
  • Python打包为可执行exe
    为什么要打包exe有的时候只需要让别人运行某种功能，传输文件以及代码是需要别人配置好一定的环境才可以操作，而打包成exe文件就可以直接运行文件。pyinstaller打包python中常用的打包方式首先进行pyinstaller的安装，打开cmd输入pipinstallpyinstaller-ihttp://pypi.douban.c......
  • 【ChatGPT系列】Python自定义打印各种颜色的日志
    如何在控制台和文件中同时输出日志？要将日志同时输出到文件和控制台，可以创建并配置一个额外的StreamHandler，然后将其添加到Logger中。下面是一个示例代码，演示如何将日志同时输出到文件和控制台：importlogging#创建Logger对象logger=logging.getLogger("example_logger")......
  • 网络系列-1 TCP/IP 网络模型有哪几层
    问大家，为什么要有TCP/IP网络模型？对于同一台设备上的进程间通信，有很多种方式，比如有管道、消息队列、共享内存、信号等方式，而对于不同设备上的进程间通信，就需要网络通信，而设备是多样性的，所以要兼容多种多样的设备，就协商出了一套通用的网络协议。这个网络协议是分层的，每一层都有各自......
  • 图神经网络—GNN
    看了大佬的博客AGentleIntroductiontoGraphNeuralNetworks图图用来表示一些实体间的关系——》点VVertex顶点/nodeEEdge边/关系UGlobal全局（embedding）比如一个图中是否含有环就是一个全局信息VEU可以用向量来表示图分为有方向与无方向两种实体间的关......
  • 洛谷P5706 【深基2.例8】再分肥宅水（Python3）
    关键点：1.同一行输入两个数input().split()，然后list一下存到变量里，这个不多说2。输出两个数Python中默认end=‘\n’,所以不用多写一遍换行。3.输出三位小数这里用到了Python的格式化输出，与c++的格式化输出非常相近，只是符号不同。具体可看这篇blog 代码如下：a=list(input(......
  • python模块导入规则（相对导入和绝对导入）
    python模块可以相对导入和绝对导入，但这两者是不能替换使用的。本文主要讨论工作目录下模块之间的导入规则。其中相对导入前面有一个'.'，表示从该脚本所在目录开始索引，而绝对导入前面没有'.'，表示从根目录开始索引。首先明确一点，python认为的根目录为当前运行的脚本所在的目录，而......
  • [数据分析与可视化] 基于Python绘制简单动图
    动画是一种高效的可视化工具，能够提升用户的吸引力和视觉体验，有助于以富有意义的方式呈现数据可视化。本文的主要介绍在Python中两种简单制作动图的方法。其中一种方法是使用matplotlib的Animations模块绘制动图，另一种方法是基于Pillow生成GIF动图。目录1Animations模块1.1FuncA......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99