python网络编程

Socket是网络编程的一个抽象的概念。

通常我们用一个Socket表示“打开了一个网络链接”，而打开一个Socket需要知道目标计算机的IP地址和端口号，再指定协议类型即可。

套接字分类

套接字起源于 20 世纪 70 年代加利福尼亚大学伯克利分校版本的 Unix,即人们所说的 BSD Unix。 因此,有时人们也把套接字称为“伯克利套接字”或“BSD 套接字”。一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。

基于文件类型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基于文件的套接字调用的就是底层的文件系统来取数据，两个套接字进程运行在同一机器，可以通过访问同一个文件系统间接完成通信

基于网络类型的套接字家族

套接字家族的名字：AF_INET

(还有AF_INET6被用于ipv6，还有一些其他的地址家族，不过，他们要么是只用于某个平台，要么就是已经被废弃，或者是很少被使用，或者是根本没有实现，所有地址家族中，AF_INET是使用最广泛的一个，python支持很多种地址家族，但是由于我们只关心网络编程，所以大部分时候我么只使用AF_INET)

套接字工作流程

一个生活中的场景。你要打电话给一个朋友，先拨号，朋友听到电话铃声后提起电话，这时你和你的朋友就建立起了连接，就可以讲话了。等交流结束，挂断电话结束此次交谈。    生活中的场景就解释了这工作原理，也许TCP/IP协议族就是诞生于生活中，这也不一定。

先从服务器端说起。服务器端先初始化Socket，然后与端口绑定(bind)，对端口进行监听(listen)，调用accept阻塞，等待客户端连接。在这时如果有个客户端初始化一个Socket，然后连接服务器(connect)，如果连接成功，这时客户端与服务器端的连接就建立了。客户端发送数据请求，服务器端接收请求并处理请求，然后把回应数据发送给客户端，客户端读取数据，最后关闭连接，一次交互结束。

socket模块函数用法

import socket
socket.socket(socket_family,socket_type,protocal=0)
socket_family 可以是 AF_UNIX 或 AF_INET。socket_type 可以是 SOCK_STREAM 或 SOCK_DGRAM。protocol 一般不填,默认值为 0。

获取tcp/ip套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

获取udp/ip套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

由于 socket 模块中有太多的属性。我们在这里破例使用了'from module import *'语句。使用 'from socket import *',我们就把 socket 模块里的所有属性都带到我们的命名空间里了,这样能 大幅减短我们的代码。
例如tcpSock = socket(AF_INET, SOCK_STREAM)

　　

服务端套解字函数

s.bind()  绑定地址（host,port）到套接字， 在AF_INET下,以元组（host,port）的形式表示地址。

s.listen()开始TCP监听。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了

s.accept()被动接受TCP客户端连接,(阻塞式)等待连接的到来

客户端套接字

s.connect()　　主动初始化TCP服务器连接，。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误

s.connect_ex()   connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途套接字

s.recv()	接收TCP数据，数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。
s.send()	发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。
s.sendall()	完整发送TCP数据，完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
s.recvform()	接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
s.sendto()	发送UDP数据，将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。
s.close()	关闭套接字
s.getpeername()	返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
s.getsockname()	返回套接字自己的地址。通常是一个元组(ipaddr,port)
s.setsockopt(level,optname,value)	设置给定套接字选项的值。
s.getsockopt(level,optname[.buflen])	返回套接字选项的值。
s.settimeout(timeout)	设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）
s.gettimeout()	返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。
s.fileno()	返回套接字的文件描述符。
s.setblocking(flag)	如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。
s.makefile()	创建一个与该套接字相关连的文件

面向锁的套接字方法

s.setblocking() 设置套接字的阻塞与非阻塞模式

s.settimeout() 设置阻塞套接字操作的超时时间

s.gettimeout() 得到阻塞套接字操作的超时时间

面向文件的套接字的函数

s.fileno()　　套接字的文件描述符

s.makefile()　　创建一个与该套接字相关的文件

基于TCP的套接字

tcp服务端

t_s = socket()    #创建服务器套接字
t_s.bind()    #把地址绑定到套接字
t_s.listen()    #监听连接

while True:    #服务器无线循环     #这是用来循环接收不同的链接
    c_s = t_s.accept()    #等待接受客户端连接
    while    True:    #通信循环    #用来基于一次链接的循环的通信
        c_s.recv()    /    c_s.send()    #对话（接受与发送）
    c_s.close()    #关闭客户端的套接字
t_S.close()    #关闭服务器的套接字（可选）

#这是伪代码，只是了解socket

　　

tcp客户端

c_s = socket()    #创建客户套接字
c_s.connect()    #连接服务器

while True:
    c_s.send()    /    cs.recv()    #对话（发送/接收）
c_s.close()    #关闭客户套接字

#这是伪代码

　　

简单示例

server端

import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #创建基于tcp的网络 套接字 对象
phone.bind(("127.0.0.1",8000))   #把地址和端口号，绑定到套接字对象
print(">>>>>>>>>>>>>")
phone.listen(5)#监听连接
conn,addr = phone.accept()   #被动接受TCP客户端连接
msg = conn.recv(1024) #接收TCP数据，
print("客户端发来的消息是>>",msg.decode("utf-8"))
user = input("请给client发送的信息>>>")
conn.send(user.encode("utf-8"))#给client发送TCP数据， 在网络中传输必须是二进制的方式
conn.close()
phone.close()  #关闭套接字

#注：这是用自已本机做的测试

　　

client端

import socket
phone = socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #创建socket对象  tcp方式

phone.connect(("127.0.0.1",8000))
a = input(">>>")
phone.send(a.encode("utf-8"))
data = phone.recv(1024)
print("收到服务器发来的消息",data.decode("utf-8"))

　　

示范：

第一运行server端，等待client连接

>>>>>>>>>>>>>
客户端发来的消息是>> hello
请给client发送的信息>>>收到了

第二：连接server 端 相应的ip地址和端口好
给服务发信息>>>hello
收到服务器发来的消息 收到了

上面的示例，服务器只能接收一次链接，就断开连接了，实际情况应该是，服务端不断的接收链接，然后循环通信，通信完毕后关闭连接，服务器能够继续下一次连接，

修改版

server端 tcp方式

from socket import *
address = ("127.0.0.1",5666)
back_log = 5
buffersize = 1024
t_server = socket(AF_INET,SOCK_STREAM)
t_server.bind(address)  #这里不能写死了，需要向linux配置文件那样可以随便修改
t_server.listen(back_log)
while True: #循环不同的通讯连接
    print("server运行，等待客户端连接")
    conn,addr = t_server.accept() #等待客户端连接
    print("客户端的链接:>>",conn)
    print("客户端的地址:>>",addr)
    print("开始聊天".center(50, "#"))
    while True:
        msg = conn.recv(buffersize) #接收从哪个连接发来的信息，接收的字节大小是buffersize = 1024
        if not msg:break #如果不加，正在连接的客户端突然断开，recv便不再阻塞，会触发死循环
        print("客户端发来的信息是:》》",msg.decode("utf-8"))   #发的什么编码，就用什么编码打开
        conn.send(msg.upper())
    conn.close()
t_server.close()

　　

客户端 tcp方式

from socket import *
address = ("127.0.0.1",5666)
buffersize = 1024
t_client = socket(AF_INET,SOCK_STREAM)
t_client.connect(address)
while True:
    msg = input("请给服务端发信息[quit]:》》")
    if msg == "quit":break
    t_client.send(msg.encode("utf-8"))
    data = t_client.recv(buffersize)
    print("收到服务端发来的信息是:>>",data.decode("utf-8"))

　　

图片看看server端，client运行结果

1.运行server端，client没运行

2.先运行client，在运行client2

3.发信息测试

如果client端 强制断开链接，server端也会断开链接

如需要解决这种强制断开连接，server端也要继续正常运行，那么server端需要扑捉异常，来处理

修改版：加了异常处理

from socket import *
address = ("127.0.0.1",5666)
back_log = 5
buffersize = 1024
t_server = socket(AF_INET,SOCK_STREAM)
t_server.bind(address)  #这里不能写死了，需要向linux配置文件那样可以随便修改
t_server.listen(back_log)
while True: #循环不同通讯连接
    print("server运行，等待客户端连接")
    conn,addr = t_server.accept() #等待客户端连接
    print("客户端的链接:>>",conn)
    print("客户端的地址:>>",addr)
    print("开始聊天".center(50, "#"))
    while True:
        try:
            msg = conn.recv(buffersize) #接收从哪个连接发来的信息，接收的字节大小是buffersize = 1024
            if not msg:break #如果不加，正在连接的客户端突然断开，recv便不再阻塞，会触发死循环
            print("客户端发来的信息是:》》",msg.decode("utf-8"))   #发的什么编码，就用什么编码打开
            conn.send(msg.upper())
        except Exception as e:
            print("客户端强制断开了连接")
            break
    conn.close()
t_server.close()

#注：只修改了服务端，客户端没动

　　

如果同时运行多次server端

这是由于服务端任然四次挥手的time_wait状态在占用地址。

这时候我们就要深入研究：

1.连接过程的tcp三次握手，断开连接的四次挥手。

2.syn洪水攻击

3.服务器高并发情况下会有大量的time_wait状态的优化方法。

解决方法一：

t_server = socket(AF_INET,SOCK_STREAM)
t_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加,重新使用地址

　　

解决方法二：

发现系统存在大量TIME_WAIT状态的连接，通过调整linux内核参数解决，
vi /etc/sysctl.conf

编辑文件，加入以下内容：
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30

然后执行 /sbin/sysctl -p 让参数生效。

net.ipv4.tcp_syncookies = 1 表示开启SYN Cookies。当出现SYN等待队列溢出时，启用cookies来处理，可防范少量SYN攻击，默认为0，表示关闭；

net.ipv4.tcp_tw_reuse = 1 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭；

net.ipv4.tcp_tw_recycle = 1 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭。

net.ipv4.tcp_fin_timeout 修改系統默认的 TIMEOUT 时间

#这是linux的系统的配置文件

基于udp的套接字　

udp服务端

ss = socket()   #创建一个服务器的套接字
ss.bind()       #绑定服务器套接字
while True:       #服务器无限循环
     cs = ss.recvfrom()/ss.sendto() # 对话(接收与发送)
ss.close()  

#伪代码

　

udp客户端

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

#伪代码

　　

基于udp方式，来模仿qq聊天通信

由于udp无3次握手链接，所以可以同时多个客户端去跟服务端通信

server端

from socket import *

address = ("127.0.0.1",9000)
buffersize = 1024
u_server = socket(AF_INET,SOCK_DGRAM) #SOCK_DGRAM   数据报方式  udp
u_server.bind(address)

while True:

    qq_msg,addr = u_server.recvfrom(buffersize)
    print('来自[%s:%s]的一条消息:\033[1;33m %s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))
    back_msg = input("回复消息:>>")
    u_server.sendto(back_msg.encode("utf-8"),addr)

　　

udp客户端

from socket import *

u_client = socket(AF_INET,SOCK_DGRAM)
buffersize = 1024
qq_name_dict = {
    '唐僧':('127.0.0.1',9000),
    '猪头':('127.0.0.1',9000),
    '孙悟空':('127.0.0.1',9000),
    '白龙马':('127.0.0.1',9000),
}

while True:
    for i in qq_name_dict:
        print(i)
    qq_name = input("请选择聊天对象:>>")
    if not qq_name or qq_name not in qq_name_dict:continue
    while True:
        msg = input("请输入消息，回车发送:>>")
        if msg == "quit":break
        if not msg:continue
        u_client.sendto(msg.encode("utf-8"),qq_name_dict[qq_name])

        back_msg,addr = u_client.recvfrom(1024)
        # print(back_msg.decode("utf-8"))
        # print(addr)
        print("来自【%s ：%s】的一条信息\033[1;33m %s \033[0m"%(addr[0],addr[1],back_msg.decode("utf-8")))
u_client.close()

　　

recv和recvfrom的区别

发消息，都是将数据发送到己端的发送缓冲中，收消息都是从己端的缓冲区中收

tcp：send发送信息，recv信息

udp：sendto发送信息，recvfrom收消息

1.tcp协议

　　(1)如果收消息缓冲区里的数据为空，那么recv就会阻塞。

　　(2)tcp基于链接的通信，如果一端断开了链接，那另一端的链接也跟着完蛋recv将不会阻塞。

2.udp协议

　　(1)如果收信息缓冲区的数据为“空”,recvfrom不会阻塞

　　(2)recvfrom收的数据小于sendto发送的数据是，数据丢失

　　(3)只有sendto发送的数据没有recvfrom收数据，数据丢失。

3.总结

1.udp的sendinto不用管是否有一个正在运行的服务端，可以己端一个劲的发消息

2.udp的recvfrom是阻塞的，一个recvfrom(x)必须对一个一个sendinto(y),收完了x个字节的数据就算完成,若是y>x数据就丢失，这意味着udp根本不会粘包，但是会丢数据，不可靠

3.tcp的协议数据不会丢，己端总是在收到ack时才会清除缓冲区内容。数据是可靠的，但是会粘包。

粘包现象

基于tcp先制作一个远程执行命令的程序

server端

from socket import *
import subprocess

ip_port = ("127.0.0.1",8000)
buffersize = 1024
back_log = 5
tcp_socket_server = socket(AF_INET,SOCK_STREAM) #创建套接字
tcp_socket_server.bind(ip_port) #绑定套接字
tcp_socket_server.listen(back_log)

while True: #循环不同的通讯连接
    conn,addr = tcp_socket_server.accept() #等待client连接
    print("客户端",addr)
    while True: #信息通讯的循序
        try:    #非常正常关闭
            cmd = conn.recv(buffersize)  #从client接收的信息
            print("客户端发来的信息",cmd)
            if len(cmd) == 0:break  #如果收到是空消息，继续等待客户端发信息
            act_res = subprocess.Popen(cmd.decode("utf-8"),shell=True,   #shell=True 表示输入命令通过shell来执行
                                                  stdout = subprocess.PIPE,  #程序的标准输出句柄，NONE表示不进行重定向，继承父进程，PIPE表示创建管道
                                                  stdin = subprocess.PIPE,  #程序的标准输入句柄
                                                  stderr=subprocess.PIPE)  #程序的标准错误句柄
                                                    #把得到相应的信息，都放到管道中

            err = act_res.stderr.read()  ##从错误管道中读取相应信息
            if err: #如果有错误信息
                ret = err
            else:   #没有错误信息
                ret = act_res.stdout.read()
            conn.sendall(ret)#把相应的错误信息或正确信息发送给client端
        except Exception:
            break

    conn.close()

　　

执行命令的client端

import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8000)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)  #出错时返回出错码,而不是抛出异常

while True:
    msg=input('>>: ').strip()
    if len(msg) == 0:continue
    if msg == 'quit':break

    s.send(msg.encode('utf-8'))
    act_res=s.recv(BUFSIZE)

    print("命令执行的结果是：>>",act_res.decode('gbk'),end='')

　　

client执行dir ,ipconfig,连续多执行几次,第二次执行的命令的结果会有上一次命令执行结果出现的就会出现粘包的现象

什么是粘包

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

我们需要知道socket收发消息的原理

发送端可以是一K一K地发送数据，而接收端的应用程序可以两K两K地提走数据，当然也有可能一次提走3K或6K数据，或者一次只提走几个字节的数据，也就是说，应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的，因此TCP协议是面向流的协议，这也是容易出现粘包问题的原因。而UDP是面向消息的协议，每个UDP段都是一条消息，应用程序必须以消息为单位提取数据，不能一次提取任意字节的数据，这一点和TCP是很不同的。怎样定义消息呢？可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

例如基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束

所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

所谓粘包问题主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

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

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

两种情况下会发生粘包

1.发送端需要等缓冲区满才会发送出去，造成粘包（发生数据时间的间隔很短，数据量很小，回合到一起，产生粘包）

2.接收方不及时接收缓冲区的包，造成多个包接收（客户端发送一段数据，客户端发送了一段数据，服务端只收了一小部份，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生的粘包）

拆包发生的情况

当应用程序一次性发送的数据大于缓冲区的长度的时候，tcp会将这次发送的数据拆成几个数据包发送出去

补充问题一：为何tcp是可靠传输，udp是不可靠传输

基于tcp的数据传输请参考另一篇文章http://www.cnblogs.com/linhaifeng/articles/5937962.html，tcp在数据传输时，发送端先把数据发送到自己的缓存中，然后协议控制将缓存中的数据发往对端，对端返回一个ack=1，发送端则清理缓存中的数据，对端返回ack=0，则重新发送数据，所以tcp是可靠的

而udp发送数据，对端是不会返回确认信息的，因此不可靠

补充问题二：send(字节流)和recv(1024)及sendall

recv里指定的1024意思是从缓存里一次拿出1024个字节的数据

send的字节流是先放入己端缓存，然后由协议控制将缓存内容发往对端，如果待发送的字节流大小大于缓存剩余空间，那么数据丢失.

sendall就会循环调用send，数据不会丢失.

解决粘包的方法

根源在于：

接收端不知道发送端将要传送的字节流的长度，所以解决粘包的方法就是围绕，如何让发送端在发送数据前，把自己将要发送的字节流总大小让接收端知晓，然后接收端来一个死循环接收完所有数据

server端代码示例

from socket import *
import subprocess
ip_port = ("127.0.0.1",8000)
back_log = 5
buffersize = 1024
tcp_server = socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
    conn,addr = tcp_server.accept()
    print("新的客户端的链接:》》",addr)
    while True:
        try:
            cmd = conn.recv(buffersize)
            if not cmd:break
            print("客户端命令是:》》",cmd.decode("utf-8"))
            res = subprocess.Popen(cmd.decode("utf-8"),shell=True,
                                   stdout=subprocess.PIPE,
                                   stdin=subprocess.PIPE,
                                   stderr=subprocess.PIPE)
            err = res.stderr.read()
            #发
            if err:
                ret = err
            else:
                ret = res.stdout.read()
            if not ret: #如果没有相应的返回信息
                ret="执行成功".encode("gbk")    #就返回一个自定义的信息

            #解决粘包方法
            data_length = len(ret)  #统计返回信息的长度
            conn.send(str(data_length).encode("utf-8"))  #第一次  把统计信息的长度，发送给客户端
            data = conn.recv(buffersize)    #第二次接收相应字节数据   print(data)
            print(">>>>>>>>",data)
            if data == b"ready":    #判断接收相应的字节数据
                conn.send(ret)　　　#继续发送ret的数据

        except Exception:
            break
    conn.close()

　　

client代码示例

from socket import *
ip_port = ("127.0.0.1",8000)
buffersize = 1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
    cmd = input(":>>>")
    if not cmd:continue
    if cmd == "quit":break
    tcp_client.send(cmd.encode("utf-8"))  #发送相应的命令

    #解决粘包
    length = int(tcp_client.recv(buffersize).decode("utf-8"))#接收第一次收到的信息长度

    tcp_client.send(b"ready")   #第二次直接发送字节数据

    recv_size = 0   #接收的字节大小，初始化为0
    recv_msg = b""  #接收的字节数据
    while recv_size < length: #每次接收的字节大小，跟第一次接收字节的大小相比 。 直到大于第一出现的字节，就不会出现粘包了
        recv_msg += tcp_client.recv(buffersize) #加上每一次收的字节大小
        recv_size = len(recv_msg)   #等于上一次接收字节数据
    print("命令执行结果是",recv_msg.decode("gbk"))
tcp_client.close()

　　

上面的有点low，容易懵逼

程序的运行速度远快与网络传输速度所以在发送一段字节前，先用send去发送该字节流长度，这种方式会放大网络延迟带来的性能损耗

利用浅析模块，解决粘包

struct模块解释：http://www.cnblogs.com/coser/archive/2011/12/17/2291160.html

server端：

from socket import *
import subprocess
import struct
ip_port = ("127.0.0.1",8000)
back_log = 5
buffersize = 1024
tcp_server = socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
while True:
    conn,addr = tcp_server.accept()
    print("新的客户端的链接:》》",addr)
    while True:
        try:
            cmd = conn.recv(buffersize)
            if not cmd:break
            print("客户端命令是:》》",cmd.decode("utf-8"))
            res = subprocess.Popen(cmd.decode("utf-8"),shell=True,
                                   stdout=subprocess.PIPE,
                                   stdin=subprocess.PIPE,
                                   stderr=subprocess.PIPE)
            err = res.stderr.read()
            #发
            if err:
                ret = err
            else:
                ret = res.stdout.read()
            if not ret: #如果没有相应的返回信息
                ret="执行成功".encode("gbk")    #就返回一个自定义的信息

            #解决粘包方法
            length = len(ret)  #统计返回信息的长度
            data_length = struct.pack("i",length) #把length的整型数据，封装bytes字节类型  该类型的产长度为4
            conn.send(data_length)
            conn.send(ret)      #会粘包到一起，因为client第一次收的时候已经知道 收多少字节，就不会粘包了

        except Exception:
            break
    conn.close()

　　

client端

from socket import *
import struct
ip_port = ("127.0.0.1",8000)
buffersize = 1024
tcp_client = socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)
while True:
    cmd = input(":>>>")
    if not cmd:continue
    if cmd == "quit":break
    tcp_client.send(cmd.encode("utf-8"))  #发送相应的命令

    #解决粘包
    length_data= tcp_client.recv(4) #接收第一次相应字节长度 4  "i"
    length = struct.unpack("i",length_data)[0]
    recv_size = 0
    recv_msg = b""
    while recv_size < length:
        recv_msg += tcp_client.recv(buffersize)
        recv_size = len(recv_msg)
    print("客户端收到的信息是:>>",recv_msg.decode("gbk"))

tcp_client.close()