socket 基础

一引子

内存空间相互之间是隔离的，物理层面隔离的；

硬盘空间是共享的，文件对应的硬盘空间

客户端和服务端在网络通信时，
客户端和服务端都只是操作系统之上的应用程序而已，应用程序不能直接来操作网卡来发送或接受数据，应用程序都是通过发送系统调用，让操作系统来操作计算机硬件。

应用程序发送和接收的数据都是存在于计算机的缓存中的：

发送端的应用软件发送数据也只是将数据发送到自己的计算机缓存中，由本机操作系统操作网卡将缓存中数据发送给接收端；

socket应用程序收发原理，如图所示：

二客户端/服务端架构

应用层=》客户端应用程序服务端应用软件
(传输层。。。物理层)->socket=> 操作系统操作系统
计算机硬件计算机硬件

三 socket层

socket 是应用层与 TCP/IP 协议族通信的中间软件抽象层，它是一组接口，在设计模式中，Socket 其实就是一个门面模式，它把负载的 TCP/IP协议族隐藏在 Socket 接口后面，对用户来收，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。socket已经为我们封装好了tcp/ip协议，我们只需要遵循socket的规定去编程，写出的程序自然就是遵循tcp/udp标准的。

四套接字工作流程

基于 tcp 协议通信的套接字工作流程如图所示：

服务端首先初始化 socket，即生成socket对象，并与 ip 地址和端口号绑定，同时对端口进行监听(listen),调用 accept进入阻塞态，等待客户端连接。客户端初始化一个 socket 对象，然后 connect（连接）服务器，如果连接成功，这时客户端与服务端的链接就建立起来了，客户端发送数据请求，服务端接收请求并处理请求，然后把回应数据送给客户端，客户端读取数据，最后关闭连接，一次交互结束。

1 基于tcp的套接字

注：tcp是基于链接的，必须先启动服务端，然后再启动客户端去链接服务端

tcp服务端：

ss = socket() #创建服务器套接字
ss.bind()      #把地址绑定到套接字
ss.listen()      #监听链接
inf_loop:      #服务器无限循环
    cs = ss.accept() #接受客户端链接
    comm_loop:         #通讯循环
        cs.recv()/cs.send() #对话(接收与发送)
    cs.close()    #关闭客户端套接字
ss.close()        #关闭服务器套接字(可选)

tcp客户端：

tcp客户端

1 cs = socket()    # 创建客户套接字
2 cs.connect()    # 尝试连接服务器
3 comm_loop:        # 通讯循环
4     cs.send()/cs.recv()    # 对话(发送/接收)
5 cs.close()            # 关闭客户套接字

socket通信流程与打电话流程类似，我们就以打电话为例来实现一个low版的套接字通信

基础版

#服务端

import socket

# 1、买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 流式协议=》tcp协议  

# 2、绑定手机卡
phone.bind(('127.0.0.1',8081)) # 0-65535, 1024以前的都被系统保留使用

# 3、开机
phone.listen(5) # 5指的是半连接池的大小
print('服务端启动完成，监听地址为:%s:%s' %('127.0.0.1',8080))
# 4、等待电话连接请求：拿到电话连接conn
conn,client_addr=phone.accept() #应该循坏地从半连接池中取出连接请求与其建立双向连接，拿到连接对象
# print(conn)
print("客户端的ip和端口：",client_addr)

# 5、通信：收发消息
data=conn.recv(1024) # 最大接收的数据量为1024Bytes，收到的是bytes类型
print("客户端发来的消息：",data.decode('utf-8'))
conn.send(data.upper())

# 6、关闭电话连接conn（必选的回收资源的操作)
conn.close()

# 7、关机（可选操作）
phone.close()


#客户端

import socket

#1、买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 流式协议=》tcp协议

#2、拨通服务端电话
phone.connect(('127.0.0.1',8081))

#3、通信
import time
time.sleep(10)
phone.send('hello egon 哈哈哈'.encode('utf-8'))
data=phone.recv(1024)
print(data.decode('utf-8'))

#4、关闭连接(必选的回收资源的操作)
phone.close()

上述程序为基础版，存在两个问题，如下：

问题一：

tcp协议(它是流式协议)下：
基于tcp协议通信时，客户端和服务端是建立连接的，tcp协议是流式协议，它的数据是面向字节流的，是一个整体。
client.send：发数据时不会阻塞，它只是将数据发送到自己计算机的缓存中，当发送数据为空时，即缓冲中发送数据大小时为0的，操作系统接收到了发送数据的请求，发现缓存中数据为空时，是不会发送数据的。此时服务端是没有接收到数据的，一直处于wait状态.所以看到的现象就是client.recv阻塞在那里，client.recv：收数据时会阻塞，它是跟自己计算机要数据，此时自己计算机缓存中接收数据为空。
同样：
sever.recv(1024):只是从自己计算机的缓存中拿数据

客户端发送十次，服务端只接受一次也是可以的，因为不管接收端还是发送端都只是跟自己计算机的缓存要数据，
所以从计算机底层来看无论收发数据都是根对方是没有关系的，都是跟自己的缓存有关系

问题二：

基于tcp协议通信时：
当客户端异常断开时(即没有四次挥手断开),此时服务端还是存于wait状态,客户端异常断开，服务端会一直接收到空数据，此时服务端(unix系统)会处于死循环状态，或者服务器(windows系统)抛出异常，所以服务端程序要避免由于接到到空数据而进入死循环或者抛出异常

改进版：加上链接循环与通信循环，解决上述两个问题

服务单应该做两件事：

1、循环地从半连接池取出连接请求与其建立双向连接，拿到连接对象

2、拿到连接对象，与其进行通信循环

# 服务端应该满足的特点：
# 1、一直提供服务 
# 2、并发地提供服务
import socket

# 1、买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 流式协议=》tcp协议

# 2、绑定手机卡
phone.bind(('127.0.0.1',8080)) # 0-65535, 1024以前的都被系统保留使用

# 3、开机
phone.listen(5) # 5指的是半连接池的大小
print('服务端启动完成，监听地址为:%s:%s' %('127.0.0.1',8080))

# 4、等待电话连接请求：拿到电话连接conn
# 加上链接循环
while True:
    conn,client_addr=phone.accept()

    # 5、通信：收发消息
    while True:
        try:
            data=conn.recv(1024) # 最大接收的数据量为1024Bytes，收到的是bytes类型
            if len(data) == 0:
                # 在unix系统洗，一旦data收到的是空
                # 意味着是一种异常的行为：客户度非法断开了链接
                break
            print("客户端发来的消息：",data.decode('utf-8'))
            conn.send(data.upper())
        except Exception:
            # 针对windows系统
            break

    # 6、关闭电话连接conn（必选的回收资源的操作)
    conn.close()

# 7、关机（可选操作）
phone.close()



#客户端

import socket

#1、买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM) # 流式协议=》tcp协议

#2、拨通服务端电话
phone.connect(('127.0.0.1',8080))

#3、通信
while True:
    msg=input("输入要发送的消息>>>: ").strip() #msg=''
    if len(msg) == 0:continue
    phone.send(msg.encode('utf-8'))
    print('======?')
    data=phone.recv(1024)
    print(data.decode('utf-8'))

#4、关闭连接(必选的回收资源的操作)
phone.close()

简单案例：使用 tcp 协议的socket 建立远程发送命令

#服务端

# coding:utf-8
import socket
import subprocess

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('127.0.0.1', 8081))
server.listen(4)
while True:
    print('服务端正在运行中...')
    conn, client_addr = server.accept()
    while True:
        try:
            data_bytes = conn.recv(1024)  # 最大接收数据为 1024bytes
            if len(data_bytes) == 0:
                break
            data = data_bytes.decode('utf-8')
            print('接收到客户端命令：', data)

            obj = subprocess.Popen(data, shell=True,
                             stdout=subprocess.PIPE, #正确的结果被放入该管道
                             stderr=subprocess.PIPE, #错误的结果被放入该管道)
                                   )
            #查看正确管道内的内容
            str_true = obj.stdout.read() #读出的是 bytes 类型
            #查看错误管道内的内容
            str_error = obj.stderr.read() ##读出的是 bytes 类型
            if str_true:
                print('发送了正确管道内的内容')
                conn.send(str_true)
            if str_error:
                print('发送了错误管道内的内容')
                conn.send(str_error)

        except Exception as e:
            break

    conn.close()

    
#客户端

# coding:utf-8
import socket
client = socket.socket()
client.connect(('127.0.0.1', 8081))
print('客户端正在运行中...')
while True:
    cmd = input('请输入cmd命令：').strip()
    if len(cmd) == 0:
        continue
    client.send(cmd.encode('utf-8'))
    data_bytes = client.recv(1024)
    data = data_bytes.decode('utf-8')
    print('接收到服务端数据：', data)

client.close()

2 基于udp的套接字

udp是无连接的，先启动哪一端都可以，不会报错

udp 服务端

1 ss = socket()   #创建一个服务器的套接字
2 ss.bind()       #绑定服务器套接字
3 inf_loop:       #服务器无限循环
4     cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送)
5 ss.close()                         # 关闭服务器套接字

udp客户端：

cs = socket()   # 创建客户套接字
comm_loop:      # 通讯循环
    cs.sendto()/cs.recvfrom()   # 对话(发送/接收)
cs.close()                      # 关闭客户套接字

简单示例：

#服务端


import socket
server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
server.bind(('127.0.0.1', 8080))
print('服务端正在运行中...')
while True:
    res = server.recvfrom(1024)  #拿到的是元组(数据，（地址))
    print('接收的客户端数据：', res) #(b'qq', ('127.0.0.1', 64933))
    data_bytes, addr = res
    print('不包含客户端地址的真实数据', data_bytes.decode('utf-8'))
    if data_bytes.decode('utf-8') == 'q':
        break
    server.sendto(data_bytes.upper(), addr)

print('服务端结束运行')
server.close()


#客户端
import socket
client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
print('客户端正在运行中...')
while True:
    msg = input('请输入命令：').strip()
    if msg == 'q':
        break
    data_send = msg.encode('utf-8')
    client.sendto(data_send, ('127.0.0.1', 8080))
    res = client.recvfrom(1204)  #拿到的是元组(数据，(addr))
    print('接收到的服务端数据:', res) #(b'QQ', ('127.0.0.1', 8080))
    data_bytes,addr = res
    print('不包含服务端地址的真实数据：', data_bytes.decode('utf-8'))

print('客户端结束运行')
client.close()

'''
当客户端输入命令为空时，服务端接收到的数据为(b'', ('127.0.0.1', 64933))
也就是说基于udp协议通信时想要，发送的数据可以为空，是因为发送的数据在缓存中时是元组类型，
元组中总是包含地址的，所以发送的数据长度永远不为空
'''

总结：

当客户端输入命令为空时，服务端接收到的数据为(b'', ('127.0.0.1', 64933))，也就是说基于udp协议通信时想要，发送的数据可以为空，是因为发送的数据在缓存中时是元组类型，元组中总是包含地址的，所以发送的数据长度永远不为空。

五粘包问题

只有 tcp 有粘包现象，udp 永远不会粘包。

发送端每次发送数据不一样，可以发 1k、2k，而接收端也可以接收 1k或 3k，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的。TCP协议是面向流的协议，当每次去缓存中取数据时，如果这一次没有取完，剩余的数据还是会存在缓存中，当下次接收数据时就会接到到上一次剩余的数据。这是tcp 协议容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，所以不会产生粘包现象，只会出现数据丢失现象。

1、粘包问题产生原因

1、tcp是流式协议，数据像水流一样黏在一起，没有任何边界区分
2、收到数据没有收干净，缓存中有残留，就会和下一次结果混在一起

tcp协议下，是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。
UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。

必知：

tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住，而udp是基于数据报的，即便是你输入的是空内容（直接回车），那也不是空消息，udp协议会帮你封装上消息头

1）udp的 recvfrom 是阻塞的，一个 recvfrom(x)必须对应唯一一个 sendto(y)，当 sendto()发送的y数据大于recvfrom()接收的 x 数据时，就会发生数据丢失，不可靠

2）tcp的协议数据不会丢，没有收完包，下次接收，会继续上次继续接收，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

2、发生粘包的两种情况

1）发生端需要等待缓冲区满才发生出去，造成粘包

发送数据时间间隔很短，且数据量小时，会将缓存中数据整合到一起，一块发送

2）接收方不及时接收缓存区的包，造成多个包一起接收

客户端发送了一段数据，服务端只接收了一小部分，服务端下次再收的时候，还是会从缓存区拿上次遗留的数据，便产生了粘包现象

注：send的字节流是先放入己端缓存，然后由协议控制将缓存内容发往对端，如果待发送的字节流大小大于缓存剩余空间，那么就会发生数据丢失，用sendall就会循环调用send，数据不会丢失

3、解决粘包问题方法

解决的核心法门就是：每次都收干净，不要任何残留

核心思想：

为字节流加上自定义固定长度报头，报头中包含字节流长度，然后一次send到对端，对端在接收时，先从缓存中取出定长的报头，然后再取真实数据

简单版

# 服务端
import socket
import subprocess
import struct

#服务端应该满足两个特点：
'''
1、一直对外提供服务
2、并发地服务多个客户端
'''

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加
server.bind(('127.0.0.1', 8080))
server.listen(5)
#服务端要做两件事
'''
第一件事，循环地从半连接池取出连接请求，建立双向连接，拿到连接对象
第二件事，拿到连接对象，与其进行通信循环
'''
print('服务端正在运行中...')
#第一件事：循环地从半连接池取出连接请求，建立双向连接，拿到连接对象
while True:
    conn, addr = server.accept()
    #第二件事：拿到连接对象，与其进行通信循环
    while True:
       try:
           msg = conn.recv(1024)
           if len(msg) == 0: break
           print(msg.decode('utf-8'))
           obj = subprocess.Popen(msg.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))

           total_size = len(stdout_res) + len(stderr_res)
           #1、定制报头
           # int -->固定长度的 bytes：对数据描述信息
           header = struct.pack('i', total_size)  #i模式下，只能针对 int类型
           #2、先发送报头
           conn.send(header)

           #3、再发送真实数据
           conn.send(stdout_res)
           conn.send(stderr_res)

       except Exception:
           break

    conn.close()
    
    
#客户端

import socket
import struct

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8080))
print('客户端正在运行中...')

while True:
    cmd = input('请输入命令：').strip()
    if len(cmd) == 0: continue
    client.send(cmd.encode('utf-8'))

    #解决黏包问题的思路：
    #1、先接收固定长度的报头：通过报头解析出数据的描述信息。包括数据的总大小 total_size
    header = client.recv(4)
    #根据报头，解析出数据长度
    # print(struct.unpack('i', header)) #(32,)
    total_size = struct.unpack('i', header)[0] #解析报头拿到的元组类型，所以需要加上索引取到数据长度
    #2、根据解析出来的描述信息，接收真实的数据
    # recv_size = 0 循环接收数据，每接收一次， recv_size += 接收的数据长度
    # 直到 recv_size = total_size，结束循环
    recv_size = 0
    while recv_size < total_size:
        recv_data = client.recv(1024)
        recv_size += len(recv_data)
        print(recv_data.decode('utf-8'), end='')
    else:
        print()


client.close()

#结果展示：
'''
客户端正在运行中...
请输入命令：123
(32,)
/bin/sh: 123: command not found
'''

终极版

制作字典类型报头

# 服务端
import socket
import subprocess
import struct
import json


#服务端应该满足两个特点：
'''
1、一直对外提供服务
2、并发地服务多个客户端
'''

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,1) #就是它，在bind前加
server.bind(('127.0.0.1', 8081))
server.listen(5)
#服务端要做两件事
'''
第一件事，循环地从半连接池取出连接请求，建立双向连接，拿到连接对象
第二件事，拿到连接对象，与其进行通信循环
'''
print('服务端正在运行中...')
#第一件事：循环地从半连接池取出连接请求，建立双向连接，拿到连接对象
while True:
    conn, addr = server.accept()
    #第二件事：拿到连接对象，与其进行通信循环
    while True:
       try:
           msg = conn.recv(1024)
           if len(msg) == 0: break
           print(msg.decode('utf-8'))
           obj = subprocess.Popen(msg.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))
           #总数据长度
           total_size = len(stdout_res) + len(stderr_res)

           #1、定制报头
           header_dic = {
               'filename':'a.txt', #示例
               'total_size':total_size, #总数据长度
               'md5':'1232312421234'
           }
           #2、为了其他语言客户端也可以接收数据，所以将报头json 序列化
           header_json_bytes = json.dumps(header_dic).encode('utf-8')

           #3、将报头数据长度转成固定长bytes数据信息，并发送头长度
           header = struct.pack('i', len(header_json_bytes))
           conn.send(header)

           #4、再发送报头信息
           conn.send(header_json_bytes)

           #5、最后发送真实数据
           conn.send(stdout_res)
           conn.send(stderr_res)

       except Exception:
           break

    conn.close()
    
    
    
#客户端
import socket
import struct
import json


client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8081))

while True:
    cmd = input('请输入命令：').strip()
    if len(cmd) == 0:continue
    client.send(cmd.encode('utf-8'))

    #1.先接收报头 并解析报头拿到报头数据长度
    header = client.recv(4) #报头数据是固定长度：4
    header_len = struct.unpack('i', header)[0]  #拿到报头数据长度

    #2、通过报头数据长度，接收报头数据(bytes类型的json数据）
    header_json_bytes = client.recv(header_len)

    #3、解码报头数据，拿到json格式报头数据， 并反序列化拿到真实报头字典
    header_json = header_json_bytes.decode('utf-8')
    header_dic = json.loads(header_json)  #拿到报头字典
    print("header_dic:", header_dic)

    #4、通过报头字典中的真实数据长度，来接收真实数据
    total_size = header_dic['total_size']
    recv_size = 0
    while recv_size < total_size:
        data_recv = client.recv(1024)
        recv_size += len(data_recv)
        print(data_recv.decode('utf-8'), end='')
    else:
        print()

client.close()

六 socketserver实现并发

基于tcp的套接字，关键就是两个循环，一个链接循环，一个通信循环

socketserver模块中分两大类：server类（解决链接问题）和request类（解决通信问题）

#服务端
import socketserver


#自定义的类：作用是处理建立连接后的请求
class MyRequestHandle(socketserver.BaseRequestHandler):
    #handle方法名是固定的，拿到连接对象之后进行通信循环
    def handle(self): #handle方法，当有客户端建立连接时，自动触发
        # print(self) #<__main__.MyRequestHandle object at 0x10ecb8fd0>
        # 如果tcp协议，self.request=>conn
        # print(self.request) #<socket.socket fd=4, family=AddressFamily.AF_INET,
        # type=SocketKind.SOCK_STREAM,
        # proto=0, laddr=('127.0.0.1', 8889), raddr=('127.0.0.1', 50201)>
        print(self.client_address) #('127.0.0.1', 50201)
        # print(self.server) #server套接字对象 <socketserver.ThreadingTCPServer object at 0x10814c198>
        while True:
            try:
                msg = self.request.recv(1024)
                if len(msg) == 0: break
                self.request.send(msg.upper())
            except Exception:
                break
        self.request.close()


#  服务端应该做两件事
# 第一件事：循环地从半连接池中取出链接请求与其建立双向链接，拿到链接对象
s=socketserver.ThreadingTCPServer(('127.0.0.1',8081), MyRequestHandle) #拿到server套接字对象
print(s) #服务端套接字 <socketserver.ThreadingTCPServer object at 0x10814c198>
s.serve_forever()
# 等同于
# while True:
#     conn,client_addr=server.accept() #建立连接
#     启动一个线程(conn,client_addr)   #

#s.server_forever():
'''
 当半连接池有新的连接请求时，服务端socket对象会拿到请求新建一个连接，
 每新建一个连接都会启一个线程，然后将连接对象和客户端地址等信息都丢给这个线程，线程中拿到连接对象，与其进行通信循环===》handle
'''
# 第二件事：拿到链接对象，与其进行通信循环===>handle


#客户端

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8081))

while True:
    msg=input('请输入命令>>：').strip()
    if len(msg) == 0:continue
    client.send(msg.encode('utf-8'))

    res=client.recv(1024)
    print(res.decode('utf-8'))

基于 udp 的并发编程：

#服务端

import socketserver

class MyRequestHanlde(socketserver.BaseRequestHandler):
    def handle(self):
        client_data=self.request[0]  #self.resquest()拿到的是元组(第一个元素是客户端发来的数据，第二元素是服务端的 udp 套接字对象)
        server=self.request[1]  #udp 套接字对象
        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()
# 相当于:服务端套接字对象只负责循环地收，每建一个连接就会启动一个线程来处理后续的事情
# while True:
#     data,client_addr=server.recvfrom(1024)
#     启动一个线程处理后续的事情(data,client_addr)


#客户端
import socket

client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) # 数据报协议

while True:
    msg=input('>>>: ').strip()
    client.sendto(msg.encode('utf-8'),('115.29.65.16',8888))
    res=client.recvfrom(1024)
    print(res)

client.close()