【二十七】Python全栈之路--TCP_UDP_黏包

最新推荐文章于 2022-07-07 23:30:07 发布
最新推荐文章于 2022-07-07 23:30:07 发布
阅读量151 收藏
点赞数
分类专栏： Python 文章标签： python udp tcp/ip 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46818279/article/details/121738706
版权
本文详细介绍了Python中TCP和UDP协议下的socket使用，包括基本语法和循环发送消息的实现。同时，针对TCP协议的黏包现象，提出了临时性和永久性的解决方案，并利用struct模块进行了优化。通过实例展示了如何避免数据混淆，确保网络通信的准确性。
摘要由CSDN通过智能技术生成

文章目录

1. tcp协议下的socket使用

1.1 tcp基本语法

server.py

# ### socket 服务端
"""
一发一收是一对,不匹配会导致数据异常
send 发送 recv 接受
"""
import socket

# 1.创建一个socket对象
sk = socket.socket()

# 一个端口绑定多个程序(仅在测试时使用)
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

# 2.在网络中注册该主机(绑定对应的ip和端口号)
""" 默认本地ip : 127.0.0.1  => localhost """
sk.bind(  ("127.0.0.1" , 9000) )
# 3.开启监听
sk.listen()

# 4.三次握手
conn,addr = sk.accept()

# 5.收发数据的逻辑

# 接受数据
"""一次最多接受1024个字节"""
res = conn.recv(1024)
print(res)
print(res.decode())

# 发送数据
conn.send("好好学习,天天向上".encode())


# 6.四次挥手
conn.close()

# 7.退还端口
sk.close()

client.py：

# ### TCP协议 客户端
import socket
# 1.创建一个socket对象
sk = socket.socket()

# 2.与服务端建立连接
sk.connect( ("127.0.0.1" , 9000) )

# 3.收发数据的逻辑
"""发送的数据类型是二进制字节流"""
"""b开头的字符串是二进制字节流格式,要求字符类型必须是ascii编码"""
sk.send("今天我们学习网络编程".encode()) 

# 接受数据
res = sk.recv(1024)
print(res.decode())
# 4.关闭连接
sk.close()

1.2 tcp循环发消息

server.py：

# ### 服务端
import socket

# (1) 创建socket对象
sk = socket.socket()

# 一个端口绑定多个程序(仅在测试时使用)
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)

# (2) 在网络中注册该主机(绑定ip和端口号)
sk.bind(  ("127.0.0.1" , 9001)  )
# (3) 监听端口
sk.listen()
# (4) 三次握手
# conn,addr = sk.accept()
# (5) 收发数据的逻辑

"""
print(conn)
print(addr)
<socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9000), raddr=('127.0.0.1', 50176)>
('127.0.0.1', 50176)
"""

while True:
	conn,addr = sk.accept()
	while True:
		# 接受数据
		res = conn.recv(1024)
		print(res.decode())
		
		# 发送数据
		strvar = input("[服务端]请输入您要发送的数据>>>")
		conn.send(strvar.encode())
		
		# 退出
		if strvar == "q":
			break


	# (6) 四次挥手
	conn.close()
	
# (7) 退还端口
sk.close()

client.py

# ### 客户端
import socket

# (1) 创建socket对象
sk = socket.socket()
# (2) 连接服务端
sk.connect( ("127.0.0.1" , 9001) )
# (3) 收发数据的逻辑

while True:
	# 发送数据
	strvar = input("[客户端]请输入您要发送的数据>>>")
	sk.send(strvar.encode())
	
	# 接受数据
	res = sk.recv(1024)
	if res == b"q":
		break
	print(res.decode())
# (4) 关闭连接
sk.close()

2. udp协议下的socket使用

2.1 udp基本语法

server.py

# ### UDP协议 服务端
import socket 

# 1.创建udp对象
sk = socket.socket(type=socket.SOCK_DGRAM)

# 2.在网络中注册该主机(绑定ip和端口号)
sk.bind( ("127.0.0.1",9000) )

# 3.收发数据的逻辑
"""udp协议下,默认第一次只能接收数据(没有三次握手,不清楚对方的ip和端口号)"""
# 接受数据
msg , addr  = sk.recvfrom(1024)
print(msg.decode())
print(addr)

# 发送数据
sk.sendto( "我喜欢你个锤子".encode()  , addr )

# 4.关闭连接
sk.close()

client.py

# ### UDP协议 客户端
import socket 

# 1.创建udp对象
sk = socket.socket(type=socket.SOCK_DGRAM)

# 2.收发数据的逻辑
# 发送数据
msg = "你喜欢我么~"
# sendto(  二进制字节流 , ip端口号  )
sk.sendto(   msg.encode() ,  ("127.0.0.1",9000) )

# 接受数据
msg , addr = sk.recvfrom(1024)
print(msg.decode())
print(addr)

# 3.关闭连接
sk.close()

2.2 udp循环发消息

server.py

# ### udp 服务端
import socket 

sk = socket.socket(type=socket.SOCK_DGRAM)
sk.bind( ("127.0.0.1",9000) )

while True:
	# 接受数据
	msg , addr = sk.recvfrom(1024)
	print(msg.decode())
	print(addr)
	
	# 发送数据
	strvar = input("[服务端]请输入您要发送的内容>>>")
	sk.sendto( strvar.encode() ,  addr)
sk.close()

client.py

# ### udp 客户端
import socket

sk = socket.socket(type=socket.SOCK_DGRAM)

while True:
	# 发送数据
	strvar = input("[客户端]请输入您要发送的内容>>>")
	sk.sendto( strvar.encode() , ("127.0.0.1",9000) )
	
	# 接受数据
	msg , addr = sk.recvfrom(1024)
	print(msg.decode())
	
sk.close()

3. 黏包

3.1 黏包的现象

server.py

# ### 服务端
import socket
import time
"""
黏包现象:
	(1)发送端,数据小,时间间隔短,造成黏包
	(2)接收端,没有及时接受数据,可能把多次发送的数据当成一条截取.
"""

sk = socket.socket()
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sk.bind( ("127.0.0.1",9001) )
sk.listen()
conn,addr = sk.accept()

# 收发数据的逻辑
conn.send("world,".encode())
time.sleep(1)
conn.send("hello".encode())

conn.close()
sk.close()

client.py

# ### 客户端
import socket
import time 

sk = socket.socket()
sk.connect( ("127.0.0.1",9001)  )

time.sleep(2)
# 收发数据的逻辑
res1 = sk.recv(1024)
print(res1.decode() , "<==1===>")
res2 = sk.recv(1024)
print(res2.decode() , "<==2===>")

sk.close()

3.2 临时性解决黏包

server.py

# ### 服务端
import socket
import time
"""
黏包现象:
	(1)发送端,数据小,时间间隔短,造成黏包
	(2)接收端,没有及时接受数据,可能把多次发送的数据当成一条截取.
"""

sk = socket.socket()
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sk.bind( ("127.0.0.1",9001) )
sk.listen()
conn,addr = sk.accept()

# 收发数据的逻辑

# 第一步,先把接下来要发送的数据的字节大小发送过去
conn.send("6".encode())
# 第二部,发送真实的数据
conn.send("world,".encode())
conn.send("hello".encode())

conn.close()
sk.close()

client.py

# ### 客户端
import socket
import time 

sk = socket.socket()
sk.connect( ("127.0.0.1",9001)  )

time.sleep(2)
# 收发数据的逻辑
# 第一步,先接受接下来要发送的数据的总大小
res = sk.recv(1)
num = int(res.decode())

# 第二部,在接受真实的数据
res1 = sk.recv(num)
print(res1.decode() , "<==1===>")
res2 = sk.recv(1024)
print(res2.decode() , "<==2===>")

sk.close()

3.3 永久性解决黏包

server.py

# ### 服务端
import socket
import time
"""
黏包现象:
	(1)发送端,数据小,时间间隔短,造成黏包
	(2)接收端,没有及时接受数据,可能把多次发送的数据当成一条截取.
"""

sk = socket.socket()
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sk.bind( ("127.0.0.1",9001) )
sk.listen()
conn,addr = sk.accept()

# 收发数据的逻辑

# 第一步,先把接下来要发送的数据的字节大小发送过去
conn.send("00000180".encode())
# 第二部,发送真实的数据
msg = "world," * 30
conn.send(msg.encode())
conn.send("hello".encode())

conn.close()
sk.close()

client.py

# ### 客户端
import socket
import time 

sk = socket.socket()
sk.connect( ("127.0.0.1",9001)  )

time.sleep(2)
# 收发数据的逻辑
# 第一步,先接受接下来要发送的数据的总大小
res = sk.recv(8)
num = int(res.decode())  # 180

# 第二部,在接受真实的数据
res1 = sk.recv(num)
print(res1.decode() , "<==1===>")
res2 = sk.recv(1024)
print(res2.decode() , "<==2===>")

sk.close()

3.4 struct模块解决黏包(最终优化)

struct模块

# ### struct 模块使用
import struct
"""
pack     打包 
	把任意长度数字转换成具有固定4个字节长度的字节流
unpack   解包
	把4个字节长度的值恢复成原来的数字,返回元组
	
"""

# pack
# i => int  要转换的当前类型是整型
"""范围: -21亿~21亿左右 控制在1.8G之内"""
res = struct.pack("i" , 999999998)
print(res , len(res))

res = struct.pack("i" , 1111111119)
print(res , len(res))

res = struct.pack("i" , 3)
print(res , len(res))


res = struct.pack("i" , 2000000000)
print(res , len(res))

# unpack
# i => 把对应的数据转化成整型
tup = struct.unpack("i" , res)
print(tup) #(2000000000,)
print(tup[0])
 
 
"""
#解决黏包场景:
	应用场景在实时通讯时,需要阅读此次发的消息是什么
#不需要解决黏包场景:
	下载或者上传文件的时候,最后要把包都结合在一起,黏包无所谓.
"""

server.py

# ### 服务端
import socket
import time
import struct

"""
黏包现象:
	(1)发送端,数据小,时间间隔短,造成黏包
	(2)接收端,没有及时接受数据,可能把多次发送的数据当成一条截取.
"""

sk = socket.socket()
sk.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1)
sk.bind( ("127.0.0.1",9001) )
sk.listen()
conn,addr = sk.accept()

# 收发数据的逻辑
strvar = input("[服务端]请输入您要发送的数据")
msg = strvar.encode()
length = len(msg)
res = struct.pack("i",length)

# 第一次发送数据 (数据长度)
conn.send(res)

# 第二次发送数据 (真实数据)
conn.send(msg)

# 第三次发送数据 (真实数据)
conn.send(b"world,hello")


conn.close()
sk.close()

client.py

# ### 客户端
import socket
import time 
import struct

sk = socket.socket()
sk.connect( ("127.0.0.1",9001)  )

time.sleep(2)
# 收发数据的逻辑


# 第一次接受数据 (数据长度)
num = sk.recv(4)
tup = struct.unpack("i",num)
print(tup[0])

# 第二次接受数据 (真实数据)
res = sk.recv(tup[0])
print(res.decode())

# 第三次接受数据 (真实数据)
res = sk.recv(1024)
print(res.decode())

sk.close()

小提示：tcp是面向连接的无边界(会产生黏包)协议，udp是面向无连接的有边界的协议

熬夜泡枸杞
关注
专栏目录
《Python全栈开发：Python TCP/UDP》
yexiangCSDN的专栏
12-24 1977
一、基于TCP的套接字 tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端 tcp服务端 ss = socket() #创建服务器套接字 ss.bind() #把地址绑定到套接字 ss.listen() #监听链接 inf_loop: #服务器无限循环 cs = ss.accept() #接受客户端链接 comm_loop: #通讯循环 cs.recv()/cs.send() #对话(接收与发
Python全栈（四）高级编程技巧之6.Socket编程-TCP客户端和服务端
CUFEECR的博客
02-03 5029
TCP协议是一种面向连接的、可靠的、基于字节流的传输层通信协议，特点是面向连接、可靠传输；TCP客户端构建流程包括创建socket、连接服务器、收发数据、 关闭套接字；TCP服务端构建过程包括socket创建套接字、信息绑定、listen使套接字变为可以被动连接、accept等待客户端的连接、收发数据、关闭套接字；多客户端实现需要使用多个循环；文件下载器时客户端发送文件请求，服务器端读取文件传输数据，客户端进行保存。
Python网络与并发编程 02 TCP粘包
weixin_43422005的博客
07-11 398
TCP/Socket与subprocess 我们准备做一个可以在Client端远程执行Server端的shell命令并拿到其执行结果的程序，而涉及到网络通信就必然会使用到socket模块，此外还需要subprocess模块拿到命令执行结果。 关于传输层协议的选择我们采用TCP协议，因为它是可靠传输协议且一次传输的数据量要比UDP协议更大。 以下是Server端的代码实现： import subprocess from socket import * # 默认直接实例化socket是IPV4 + TCP协议
Python解决TCP黏包问题
TinnCHEN的博客
05-23 302
以控制命令行为例 Server端 import socket import struct sk = socket.socket() sk.bind(('127.0.0.1', 8080)) sk.listen() conn, addr = sk.accept() while True: cmd = input('>>>') if cmd == 'q' conn.send(b'q') break conn.send(cmd.encode('gbk')
Python笔记_27_UDP协议_黏包现象
OldBoy Python学习笔记
05-31 204
- UDP协议 - 黏包现象 - socketserver模块
python笔记(解决TCP黏包问题)
小小龙的博客
11-28 553
@几个重要的协议:tcp,udp,ip,arp @应用层的协议:http（https）,ftp,smtp(邮件相关的协议) 1、黏报现象：数据已经乱了，没接收完，接收多了 UDP:不会黏包，但丢包 TCP:会黏包，但不丢包(优化算法) 解决黏包问题： 好处：确定了我到底要接收多大的数据 1、要在文件中配置一个配置项:就是每一次recy的大小 buffer=4096 2、当我们要发送大数据的时候,要...
Python全栈（四）高级编程技巧之5.Socket编程-基本概念、UDP发送与接收数据
CUFEECR的博客
02-02 4000
IP用来标记网络上的一台电脑，根据版本分为IPv4和Ipv6，根据IP分为A、B、C类等；端口是为了识别不同的应用程序而分配给不同的应用的，分为知名端口和动态端口；TCP/IP定义了电子设备如何连入因特网，以及数据如何在它们之间传输的标准，分为四层，应用程序通过套接字向网络发出请求或者应答网络请求，socket的使用过程分为创建、收发数据、关闭；sendto(self, data, address)用于UDP发送数据，recvfrom(self, bufsize, flags)用于接收数据。
python全栈工程师作业.zip
最新发布
06-14
【Python全栈工程师作业】是针对大学生的Python学习资源，旨在帮助他们巩固所学知识，提升编程技能。这个压缩包中的“ljg_resource”文件可能是包含一系列的学习资料、练习题或者项目实例，对于深入理解Python编程...
《云计算全栈》-python篇：创建UDP时间戳服务器、创建UDP时间戳客户端
解启超
03-08 413
4 案例4：创建UDP时间戳服务器 4.1 问题 创建udp_time_serv.py脚本，编写一个UDP服务器： 服务器监听在0.0.0.0的21567端口上 收到客户端数据后，将其加上时间戳后回送给客户端 4.2 方案 UDP的通信与TCP相类似，使用UDP的通信双方也分为客户端和服务器，服务器首先需要创建Socket对象，设置socket选项，服务器要绑定一个端口接收来自客户端的数据，并向...
python3 tcp黏包情况一
ddxr5515的博客
05-26 124
客户端没有及时接收缓冲区的包，造成多个包接收（服务端发送了一段数据，客户端只收了一小部分，客户端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包） -------------------------------------------tcp_stickybag_server.py-------------------------------------------# codin...
Python基础 | 如何解决 TCP 的粘包问题
你必须十分努力，才能看起来毫不费力！
04-21 689
什么是粘包问题？ 多个数据包被连续存储于连续的缓存中，在对数据包进行读取时由于无法确定发生方的发送边界，而采用某一估测值大小来进行数据读出，若双方的size不一致时就会使指发送方发送的若干包数据到接收方接收时粘成一包，从接收缓冲区看，后一包数据的头紧接着前一包数据的尾。 总结：粘包问题出现的原因 tcp是流式协议，数据像水流一样粘在一起，没有任何边界区分 收数据没收干净，有残留，就会下一次...
python之黏包和黏包解决方案
hellogril前端库
01-09 321
黏包现象主要发生在TCP连接,&nbsp;基于TCP的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看来，根本不知道该文件的字节流从何处开始，在何处结束. 两种黏包现象: 1 连续的小包可能会被优化算法给组合到一起进行发送 2 第一次如果发送的数据大小2000B接收端一次性接受大小为1024,这就导致剩下的内容会被下一次recv接收到,导致结果错乱 解决黏包现象...
Python UDP DEMO
wo446100076的专栏
09-29 304
def unpack(bytes4): #print(bytes4) b4 = bytes([bytes4[3] , bytes4[2] , bytes4[1] , bytes4[0]]) return struct.unpack("f", b4)[0] def udp_oldfactory(): now = datetime.now() PORT...
python TCP避免粘包的一种分装
weixin_43134049的博客
12-03 2422
python2，python3 均运行可用，具体解释见参考 server端 #!/usr/bin/env python2.7 #coding:utf-8 # -*- coding: utf-8 -*- from socket import * import json import struct import time import threading class Server_link(): """用于初始化。tcp服务端""" def __init__(self,HOST = '127
python tcp处理_python中TCP粘包问题解决方案
weixin_39765625的博客
12-23 896
TCP协议中的粘包问题1.粘包现象基于TCP写一个远程cmd功能#服务端importsocketimportsubprocesssever=socket.socket()sever.bind(('127.0.0.1', 33521))sever.listen()whileTrue:client, address=sever.accept()whileTrue:try:cmd= client.rec...
Python笔记 UDP 黏包
Steal_knowledge的博客
07-07 468
Python笔记 UDP 黏包
python解析数据包_python – 解析UDP数据包
weixin_39959126的博客
12-12 1534
我正在构建一个UDP服务器来解析和验证传入的UDP数据包.我能够接收和解析数据包,但标头值不是我所期望的.这是传入数据包的结构包ID(4个字节)包序列(4个字节)XOR密钥(2个字节)数据包中的校验和数(2个字节)循环校验和CRC32(变量)要发送数据包,with open('payloadfile.bin') as op:payload = pickle.load(op)sock = socke...
python接收udp包函数_python udp报文接收
weixin_39940154的博客
12-19 253
#coding=utf-8#!/usr/bin/env pythonfrom PyQt5.QtCore importQPoint, QRect, QSize, Qtfrom PyQt5.QtWidgets import(QApplication, QLayout, QPushButton, QSizePolicy,QVBoxLayout,QWidget)from PyQt5.Qt importQT...
Python全栈开发：从基础到运维的实战路线图
在"Python web全栈学习路线.docx"文档中，提供了详尽的Python全栈开发教学大纲，涵盖了多个关键领域，旨在帮助学习者全面掌握Python在Web开发中的应用。以下是一份详细的概述： 1. **Linux运维基础 + Python基础**...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值