个人中心
gpt4 book ai didi

Python中的Socket 与 ScoketServer 通信及遇到问题解决方法

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 27 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Python中的Socket 与 ScoketServer 通信及遇到问题解决方法由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

Socket有一个缓冲区，缓冲区是一个流，先进先出，发送和取出的可自定义大小的，如果取出的数据未取完缓冲区，则可能存在数据怠慢。其中【recv(1024)】表示从缓冲区里取最大为1024个字节，但实际取值大小是不确定的，推荐其值小于等于8192.

黏包问题:

Socket发送两条连续数据时，可能最终会拼接成一条进行发送 。

解决方法一:

两条数据间进行延时发送，如【tiem.sleep(0.5) #延时0.5s】 。

解决方法二:

每次发送后等待对方确认接收信息数据，发送一条后就立即接收等待 。

解决方法三:

设定接收数据大小，发送端每次发送需要发送的数据的数据大小，接收端通过设置【recv(xx)】只接收确定的大小 。

Socket基本使用

简单的服务器:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
import socket
sser = socket.socket() #得到socket对象
sser.bind(( "0.0.0.0" , 2699 )) #建立监听
sser.listen( 3 )
print ( "等等客户端连接" )
conn,addr = sser.accept() #等待连接，会一直处于阻塞，返回连接对象和对方地址
print ( "有客户端已经连接,IP地址和端口为：" ,addr)
#接收数据，会一直阻塞，建议低于8192
#使用连接对象操作
rdata = conn.recv( 1024 )
print (rdata.decode( "gbk" ))
conn.send( "服务器返回，收到数据" .encode( "gbk" )) #发送数据，使用连接对象操作
#关闭连接
sser.close()

简单的客户端:

?
1
2
3
4
5
6
7
8
9
10
11
import socket
sclient = socket.socket() #得到socket对象
#连接服务器
#失败会报错：ConnectionRefusedError
sclient.connect(( "192.168.1.135" , 2699 ))
sclient.send( "东小东" .encode( "gbk" )) #发送数据
#接收数据，会一直阻塞，建议低于8192
rdata = sclient.recv( 1024 )
print (rdata.decode( "gbk" ))
#关闭连接
sclient.close()

Soket进阶:

服务器进阶:

实现客户循环连接及数据循环收发和判断客户端是否断开 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import socket
sser = socket.socket() #得到socket对象
sser.bind(( "0.0.0.0" , 2699 )) #建立监听
sser.listen( 3 )
while True :
   print ( "等等客户端连接" )
   conn,addr = sser.accept() #等待连接，会一直处于阻塞，返回连接对象和对方地址
   print ( "有客户端已经连接,IP地址和端口为：" ,addr)
   conn.send(( "服务器欢迎你：%s\r\n" % ( str (addr))).encode( "gbk" )) # 发送数据，使用连接对象操作
   while True :
     #接收数据，会一直阻塞
     #使用连接对象操作
     rdata = conn.recv( 1024 )
     if not rdata: break #判断客户端是否断开，断开则收到空数据
     print (rdata.decode( "gbk" ))
     conn.send( "服务器返回，收到数据\r\n" .encode( "gbk" )) #发送数据，使用连接对象操作
#关闭连接
sser.close()

客户端进阶:

实现循环收发和判断服务器是否断开 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
import socket
sclient = socket.socket() #得到socket对象
#连接服务器
#失败会报错：ConnectionRefusedError
sclient.connect(( "192.168.1.135" , 2699 ))
while True :
  #接收数据，会一直阻塞
  rdata = sclient.recv( 1024 )
  if not rdata: break # 判断服务器是否断开，断开则收到空数据
  print (rdata.decode( "gbk" ))
  sclient.send(( "客户端收到数据:%s\r\n" % rdata.decode( "gbk" )).encode( "gbk" )) # 发送数据
#关闭连接
sclient.close()

注意:

发送数据不可发送空字符，否则会卡住，解决方法为判断输入的是否为空值，空值则进行数据发送 。

?
1
2
3
4
strx = input ( "输入：" ).strip() #得到控制台输入值
if ( len (strx) = = 0 ): continue #如果为空字符，则跳出本次循环
print (strx) #打印
sclient.send(strx.encode( "gbk" )) # 发送数据

发送大数据:

先发送总体数据大小，socket另一端判断实际接收的数据大小与总数据大小进行比较，循环recv()进行数据接收 。

 简单的ssh实现:

服务端:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import os
import socket
sser = socket.socket() #得到socket对象
sser.bind(( "0.0.0.0" , 2697 )) #建立监听
sser.listen( 3 )
while True :
   print ( "等等客户端连接" )
   conn,addr = sser.accept() #等待连接，会一直处于阻塞，返回连接对象和对方地址
   print ( "有客户端已经连接,IP地址和端口为：" ,addr)
   conn.send(( "服务器欢迎你：%s\r\n" % ( str (addr))).encode( "gbk" )) # 发送数据，使用连接对象操作
   while True :
     #接收数据，会一直阻塞
     rdata = conn.recv( 1024 )
     if not rdata: break #判断客户端是否断开，断开则收到空数据
     sendtox = os.popen(rdata.decode( "gbk" )).read() #执行命令
     conn.send( str ( len (sendtox)).encode( "gbk" )) #发送执行命令的结果长度
     #如果长度大于0 则发送命令结果数据
     if len (sendtox)> 0 :
     if conn.recv( 10 ).decode( "gbk" ) = = "1" :
      conn.sendall(sendtox.encode( "gbk" )) #发送最终数据
#关闭连接
sser.close()

客户端:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import socket
sclient = socket.socket() #得到socket对象
#连接服务器
#失败会报错：ConnectionRefusedError
sclient.connect(( "192.168.43.21" , 2697 ))
# 接收数据，会一直阻塞
rdata = sclient.recv( 1024 )
print (rdata.decode( "gbk" ))
while True :
  strx = input ( "请输入命令：" ).strip() # 得到控制台输入值
  if ( len (strx) = = 0 ): continue # 如果为空字符，则跳出本次循环
  sclient.send(strx.encode( "gbk" )) # 发送数据
  rdata = sclient.recv( 10 )
  if not rdata: break # 判断服务器是否断开，断开则收到空数据
  #判断命令是否执行成功，0为失败
  dataall = int (rdata.decode( "gbk" ))
  if dataall = = 0 :
   continue
  sclient.send( "1" .encode( "gbk" )) # 发送确认接收数据命令
  #循环接收数据
  datanew = 0
  while dataall ! = datanew:
   rdata = sclient.recv( 1024 ).decode( "gbk" )
   datanew + = len (rdata)
   print (rdata)
#关闭连接
sclient.close()

发送文件:

发送文件，使用read()读取文件数据后，可循环调用send（）发送数据，或者使用sendall()一次性发送所有数据，socket另一端接收可循环recv()进行数据接收，且每次接收的数据大小是不确定的。文件传输需要验证发送和接受的数据是否完全一致，可以通过数据大小加md5双重验证，发送端：md5在每次发送一条数据时进行update（），在数据发送完成后再发送md5值；接受端：md5在每次接收到一条数据后进行update(),在文件接收完成后再接收发送端发送的md5值，将两值进行比较，相同则表示传输无丢包，但加入md5校验，将会影响传输速率.

发送文件数据：先发送总体数据大小，socket另一端判断实际接收的数据大小与总数据大小进行比较，循环recv()进行数据接收 。

示例：客户端发送文件名，服务器判断文件是否存在，如果不存在或者是空文件则不进行传输，服务器进行文件发送，客户端实现文件接收 。

服务器 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import os
import socket
sser = socket.socket() #得到socket对象
sser.bind(( "0.0.0.0" , 2697 )) #建立监听
sser.listen( 3 )
while True :
   print ( "等等客户端连接" )
   conn,addr = sser.accept() #等待连接，会一直处于阻塞，返回连接对象和对方地址
   print ( "有客户端已经连接,IP地址和端口为：" ,addr)
   conn.send(( "服务器欢迎你：%s\r\n" % ( str (addr))).encode( "gbk" )) # 发送数据，使用连接对象操作
   while True :
     #接收数据，会一直阻塞
     rdata = conn.recv( 1024 )
     if not rdata: break #判断客户端是否断开，断开则收到空数据
     filesize = 0
     filenamex = rdata.decode( "gbk" )
     if os.path.isfile(filenamex): #判断是否是文件
      filesize = os.stat(filenamex).st_size #得到文件大小
     conn.send( str (filesize).encode( "gbk" )) #不是文件则发送0，是文件则是实际大小
     #如果文件大小大于0 则发送文件
     if filesize> 0 :
     if conn.recv( 10 ).decode( "gbk" ) = = "1" : #等待确认接收命令
      #一行一行发送数据
      f = open (filenamex, "rb" )
      for linex in f:
       conn.sendall(linex) #发送最终数据
#关闭连接
sser.close()

客户端 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import socket
sclient = socket.socket() #得到socket对象
#连接服务器
#失败会报错：ConnectionRefusedError
sclient.connect(( "192.168.43.21" , 2697 ))
# 接收数据，会一直阻塞
rdata = sclient.recv( 1024 )
print (rdata.decode( "gbk" ))
while True :
  filenamex = input ( "请输入文件名：" ).strip() # 得到控制台输入值
  if ( len (filenamex) = = 0 ): continue # 如果为空字符，则跳出本次循环
  sclient.send(filenamex.encode( "gbk" )) # 发送数据
  rdata = sclient.recv( 10 )
  if not rdata: break # 判断服务器是否断开，断开则收到空数据
  #判断命令是否执行成功，0为失败
  dataall = int (rdata.decode( "gbk" ))
  if dataall = = 0 :
   print ( "文件不存在或者为空" )
   continue
  sclient.send( "1" .encode( "gbk" )) # 发送确认接收数据命令
  #打开文件
  f = open (filenamex, "wb" )
  #循环接收数据
  datanew = 0
  while dataall ! = datanew:
   rdata = sclient.recv( 1024 )
   datanew + = len (rdata)
   f.write(rdata)
  print ( "文件（%s)接收完毕" % filenamex)
  f.close() #关闭文件
#关闭连接
sclient.close()

ScoketServer 。

服务端实现多并发效果，可以同时接入多个客户端 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import socketserver
#建立一个类，必须继承 socketserver.BaseRequestHandler 类
class DongSocket(socketserver.BaseRequestHandler):
  #必须重写handle方法
  def handle( self ):
   print ( "建立新连接，对方地址为：{}" . format ( self .client_address))
   while True :
    try :
     self .datax = self .request.recv( 1024 ).decode( "gbk" ) #接收数据
     print ( "接收的数据为：%s" % self .datax)
     self .request.send(( "服务器返回数据：%s" % self .datax).encode( "gbk" ))
    except Exception as e:
     print ( "断开，再见：{}" . format ( self .client_address))
     break
#参数：（（"ip",端口），自定义类）
#ss=socketserver.TCPServer(("0.0.0.0",2351),DongSocket) #与之前的socket服务器效果一致，同时只能连接一个客户端
ss = socketserver.ThreadingTCPServer(( "0.0.0.0" , 2351 ),DongSocket) #同时可以连接多个客户端，多并发
ss.serve_forever()

总结 。

以上所述是小编给大家介绍的Python中的Socket 与 ScoketServer 通信及遇到问题解决方法 ，希望对大家有所帮助，如果大家有任何疑问请给我留言，小编会及时回复大家的。在此也非常感谢大家对我网站的支持！ 。

原文链接：https://www.cnblogs.com/dongxiaodong/p/10495735.html 。

最后此篇关于Python中的Socket 与 ScoketServer 通信及遇到问题解决方法的文章就讲到这里了,如果你想了解更多关于Python中的Socket 与 ScoketServer 通信及遇到问题解决方法的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

27 4 0
文章推荐： jupyter notebook保存文件默认路径更改方法汇总(亲测可以)
文章推荐： vs code 配置python虚拟环境的方法
文章推荐： Django rest framework如何自定义用户表
文章推荐： VScode编译C++ 头文件显示not found的问题
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com