当前位置:脚本大全 > > 正文

pythonsocket详细用法(Python中的Socket 与 ScoketServer 通信及遇到问题解决方法)

时间:2021-10-26 11:57:32类别:脚本大全

pythonsocket详细用法

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()
  • 标签:
    上一篇下一篇

    猜您喜欢

    热门推荐