网络编程

1  一.楔子
2  二.软件开发的架构
2.1  1.C/S架构
2.2  2.B/S架构
3  三.网络基础
3.1  ip和端口
3.2  osi七层模型
3.2.1   引子
3.2.2  osi七层模型
3.3  socket概念
3.3.1  socket层
3.3.2  理解socket
3.4  套接字（socket）的发展史...
3.4.1   基于文件类型的套接字家族
3.4.2   基于网络类型的套接字家族
3.5  tcp协议和udp协议
4  套接字（socket）初识
4.1  基于TCP协议的socket...
4.1.1  server端
4.1.2  client端
4.1.3  端口已被占用
4.2  基于UDP协议的socket...
4.2.1  简单使用
4.2.2  qq聊天
4.2.3  时间服务器
4.3  socket参数的详解
5  黏包
5.1  黏包现象
5.1.1  tcp协议的黏包问题
5.1.2  udp协议不会出现黏包
5.2  黏包成因
5.2.1  TCP协议中的数据传递
5.2.2  UDP不会发生黏包
5.2.3  会发生黏包的两种情况
5.2.4  总结
5.3  黏包的解决方案
5.3.1  解决方案一
5.3.2  解决方案进阶
6  socket的更多方法介绍
7  扩展：验证客户端链接的合法性
8  socketserver

1 一.楔子

　　假如写了两个python文件a.py和b.py，分别去运行，会发现这两个python的文件分别运行的很好。但是如果这两个程序之间想要传递一个数据，你要怎么做呢？

　　可以创建一个文件，把a.py想要传递的内容写到文件中，然后b.py从这个文件中读取内容就可以了。

　　类似的机制有计算机网盘，qq等等。我们可以在我们的电脑上和别人聊天，可以在自己的电脑上向网盘中上传、下载内容。这些都是两个程序在通信。

2 二.软件开发的架构

　　我们了解的涉及到两个程序之间通讯的应用大致可以分为两种：

　　第一种是应用类：qq、微信、网盘、优酷这一类是属于需要安装的桌面应用

　　第二种是web类：比如百度、知乎、博客园等使用浏览器访问就可以直接使用的应用

　　这些应用的本质其实都是两个程序之间的通讯。而这两个分类又对应了两个软件开发的架构。

2.1 1.C/S架构

　　C/S即：Client与Server ，中文意思：客户端与服务器端架构，这种架构也是从用户层面（也可以是物理层面）来划分的。

2.2 2.B/S架构

 　　B/S即：Browser与Server,中文意思：浏览器端与服务器端架构，这种架构是从用户层面来划分的。

　　 Browser浏览器，其实也是一种Client客户端，只是这个客户端不需要大家去安装什么应用程序，只需在浏览器上通过HTTP请求服务器端相关的资源（网页资源），客户端Browser浏览器就能进行增删改查。

3 网络基础

3.1 网络基础知识

3.1 socket概念　　

　　3.1.1 socket层

　　3.1.2 理解socket

　　Socket是应用层与 TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中， Socket其实就是一个门面模式，它把复杂的 TCP/IP协议族隐藏在 Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。

　　socket就是一个模块。我们通过调用模块中已经实现的方法建立 两个进程之间的连接和通信。也有人将socket说成ip+port，因为ip是用来标识互联网中的一台主机的位置，而port是用来标识这台机器上的一个应用程序。所以我们只要确立了ip和port就能找到一个应用程序，并且使用socket模块来与之通信。

3.3 套接字（socket）的发展史

　　一开始,套接字被设计用在同 一台主机上多个应用程序之间的通讯。这也被称进程间通讯,或 IPC。套接字有两种（或者称为有两个种族）,分别是基于文件型的和基于网络型的。

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

　　套接字家族的名字：AF_UNIX

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

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

　　套接字家族的名字：AF_INET

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

3.4 tcp协议和udp协议拓展

 　　TCP （Transmission Control Protocol）可靠的、面向连接的协议（eg:打电话）、传输效率低全双工通信（发送缓存&接收缓存）、面向字节流。使用TCP的应用：Web浏览器；电子邮件、文件传输程序。

　 　UDP （User Datagram Protocol）不可靠的、无连接的服务，传输效率高（发送前时延小），一对一、一对多、多对一、多对多、面向报文，尽最大努力服务，无拥塞控制。使用UDP的应用：域名系统 (DNS)；视频流；IP语音(VoIP)。

4 套接字（socket）初识

4.1 基于TCP协议的socket

　　Tcp是基于链接的，必须先启动服务端，然后再启动客户端去连接服务端。

　　4.1.1 server端

import socket
sk = socket.socket()
sk.bind(('127.0.0.1',8898))   # 把地址绑定到套接字
sk.listen()                        # 监听链接
conn,addr = sk.accept()  # 接受客户端链接
ret = conn.recv(1024)  # 接收客户端信息
print(ret)                  # 打印客户端信息
conn.send(b'hi')       # 向客户端发送信息
conn.close()            # 关闭客户端套接字
sk.close()            # 关闭服务器套接字(可选)

　　4.1.2 client端

import socket
sk = socket.socket()  # 创建客户套接字
sk.connect(('127.0.0.1',8898))  # 尝试连接服务器
sk.send(b'hello!')
ret = sk.recv(1024)  # 对话(发送/接收)
print(ret)
sk.close()  # 关闭客户套接字

　　4.1.3 端口已被占用

# Windows系统解决方法：

# ① 换一个端口就行了

# ② 加入一条socket配置，重用ip和端口
import socket
from socket import SOL_SOCKET,SO_REUSEADDR
sk = socket.socket()
sk.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)  # 就是它，在bind前加
sk.bind(('127.0.0.1',8898))  # 把地址绑定到套接字
sk.listen()  # 监听链接
conn,addr = sk.accept() # 接受客户端链接
ret = conn.recv(1024)   # 接收客户端信息
print(ret)  # 打印客户端信息
conn.send(b'hi')  # 向客户端发送信息
conn.close()  # 关闭客户端套接字
sk.close()  # 关闭服务器套接字(可选)

4.2 基于UDP协议的socket

# udp的server 不需要进行监听也不需要建立连接
# 在启动服务之后被动的等待客户端发送消息过来
# 客户端发送消息的同时也会自带地址信息
# 服务端消息回复的时候，不仅需要发送消息，还需要把对方的地址填写上

　　4.2.1 简单使用

# server端
import socket
udp_sk = socket.socket(type=socket.SOCK_DGRAM)   #创建一个服务器的套接字
udp_sk.bind(('127.0.0.1',9000))        #绑定服务器套接字

msg,addr = udp_sk.recvfrom(1024)
print(msg.decode('utf8'))
udp_sk.sendto(b'hi',addr)                 # 对话(接收与发送)
udp_sk.close()                         # 关闭服务器套接字

# client端

import socket
ip_port=('127.0.0.1',9000)
udp_sk=socket.socket(type=socket.SOCK_DGRAM)
udp_sk.sendto(b'hello',ip_port)
back_msg,addr=udp_sk.recvfrom(1024)
print(back_msg.decode('utf-8'),addr)

　　4.2.2 qq聊天

#_*_coding:utf-8_*_
import socket
ip_port=('127.0.0.1',8081)
udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udp_server_sock.bind(ip_port)

while True:
    qq_msg,addr=udp_server_sock.recvfrom(1024)
    print('来自[%s:%s]的一条消息:33[1;44m%s33[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))
    back_msg=input('回复消息: ').strip()

    udp_server_sock.sendto(back_msg.encode('utf-8'),addr)

#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

qq_name_dic={
    '金老板':('127.0.0.1',8081),
    '哪吒':('127.0.0.1',8081),
    'egg':('127.0.0.1',8081),
    'yuan':('127.0.0.1',8081),
}

while True:
    qq_name=input('请选择聊天对象: ').strip()
    while True:
        msg=input('请输入消息,回车发送,输入q结束和他的聊天: ').strip()
        if msg == 'q':break
        if not msg or not qq_name or qq_name not in qq_name_dic:continue
        udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])

        back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)
        print('来自[%s:%s]的一条消息:33[1;44m%s33[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))

udp_client_socket.close()

　　4.2.3 时间服务器

# _*_coding:utf-8_*_
from socket import *
from time import strftime

ip_port = ('127.0.0.1', 9000)
bufsize = 1024

udp_server = socket(AF_INET, SOCK_DGRAM)
udp_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)   #防止端口被占用报错
udp_server.bind(ip_port)

while True:
    msg, addr = udp_server.recvfrom(bufsize)
    print('===>', msg)

    if not msg:
        time_fmt = '%Y-%m-%d %X'
    else:
        time_fmt = msg.decode('utf-8')
    back_msg = strftime(time_fmt)

   udp_server.sendto(back_msg.encode('utf-8'), addr)

udp_server.close()

#_*_coding:utf-8_*_
from socket import *
ip_port=('127.0.0.1',9000)
bufsize=1024

udp_client=socket.socket(AF_INET,SOCK_DGRAM)

while True:
    
    msg=input('请输入时间格式(例%Y %m %d)>>: ').strip()
    udp_client.sendto(msg.encode('utf-8'),ip_port)

    data=tcp_client.recvfrom(bufsize)
    print(data.decode('utf8'))

udp_client.close()

　　4.3 socket参数的详解

socket.socket(family=AF_INET,type=SOCK_STREAM,proto=0,fileno=None)
# 一般参数默认就行，可不写

　　创建socket对象的参数说明：

family	地址系列应为AF_INET(默认值),AF_INET6,AF_UNIX,AF_CAN或AF_RDS。  （AF_UNIX 域实际上是使用本地 socket 文件来通信）
type	套接字类型应为SOCK_STREAM(默认值),SOCK_DGRAM,SOCK_RAW或其他SOCK_常量之一。  SOCK_STREAM 是基于TCP的，有保障的（即能保证数据正确传送到对方）面向连接的SOCKET，多用于资料传送。  SOCK_DGRAM 是基于UDP的，无保障的面向消息的socket，多用于在网络上发广播信息。
proto	协议号通常为零,可以省略,或者在地址族为AF_CAN的情况下,协议应为CAN_RAW或CAN_BCM之一。
fileno	如果指定了fileno,则其他参数将被忽略,导致带有指定文件描述符的套接字返回。  与socket.fromfd()不同,fileno将返回相同的套接字,而不是重复的。  这可能有助于使用socket.close()关闭一个独立的插座。

5 黏包

5.1 黏包现象

　　5.1.1 tcp协议的黏包问题，不出现丢包

　　　　①没有接受完   ②接收多了

#_*_coding:utf-8_*_
from socket import *
import subprocess

ip_port=('127.0.0.1',8888)
BUFSIZE=1024

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)

while True:
    conn,addr=tcp_socket_server.accept()
    print('客户端',addr)

    while True:
        cmd=conn.recv(BUFSIZE)
        if len(cmd) == 0:break

        res=subprocess.Popen(cmd.decode('utf-8'),shell=True,
                         stdout=subprocess.PIPE,
                         stdin=subprocess.PIPE,
                         stderr=subprocess.PIPE)

        stderr=res.stderr.read()
        stdout=res.stdout.read()
        conn.send(stderr)
        conn.send(stdout)

#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8888)

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('utf-8'),end='')

　　5.1.2 udp协议不会出现黏包，会出现丢包

5.2 黏包成因

　　5.2.1 TCP协议中的数据传递

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

# TCP协议是面向流的协议
    
    基于tcp的套接字客户端往服务端上传文件，发送时文件内容是按照一段一段的字节流发送的，在接收方看了，根本不知道该文件的字节流从何处开始，在何处结束。也就是说应用程序所看到的数据是一个整体，或说是一个流（stream），一条消息有多少字节对应用程序是不可见的。
    此外，发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。若连续几次需要send的数据都很少，通常TCP会根据优化方法（Nagle算法）把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

# 对于空消息：
    tcp是基于数据流的，于是收发的消息不能为空，这就需要在客户端和服务端都添加空消息的处理机制，防止程序卡住。

# 消息定义：
    可以认为对方一次性write/send的数据为一个消息，需要明白的是当对方send一条信息的时候，无论底层怎样分段分片，TCP协议层会把构成整条消息的数据段排序完成后才呈现在内核缓冲区。

　　5.2.2 UDP不会发生黏包

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

# UDP是无连接的，面向消息的，提供高效率服务。
    不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。

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

　　5.2.3 会发生黏包的两种情况

 #用UDP协议发送时，
    用sendto函数最大能发送数据的长度为：65535- IP头(20) – UDP头(8)＝65507字节。用sendto函数发送数据时，如果发送数据长度大于该值，则函数会返回错误。（丢弃这个包，不进行发送）

#用TCP协议发送时，
    由于TCP是数据流协议，因此不存在包大小的限制（暂不考虑缓冲区的大小），这是指在用send函数时，数据长度参数不受限制。而实际上，所指定的这段数据并不一定会一次性发送出去，如果这段数据比较长，会被分段发送，如果比较短，可能会等待和下一次数据一起发送。

　　（1）发送方的缓存机制

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

#_*_coding:utf-8_*_
from socket import *
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)


conn,addr=tcp_socket_server.accept()


data1=conn.recv(10)
data2=conn.recv(10)

print('----->',data1.decode('utf-8'))
print('----->',data2.decode('utf-8'))

conn.close()

#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)


s.send('hello'.encode('utf-8'))
s.send('egg'.encode('utf-8'))

　　（2）接收方的缓存机制

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

#_*_coding:utf-8_*_
from socket import *
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)


conn,addr=tcp_socket_server.accept()


data1=conn.recv(2)   #一次没有收完整
data2=conn.recv(10)  #下次收的时候,会先取旧的数据,然后取新的

print('----->',data1.decode('utf-8'))
print('----->',data2.decode('utf-8'))

conn.close()

#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)


s.send('hello egg'.encode('utf-8'))

　　5.2.4 总结

　　黏包现象只发生在tcp协议中：

　　（1）从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。

　　（2）实际上， 主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

5.3 黏包的解决方案

　　5.3.1 解决方案一

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

#_*_coding:utf-8_*_
import socket,subprocess
ip_port=('127.0.0.1',8080)
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

s.bind(ip_port)
s.listen(5)

while True:
    conn,addr=s.accept()
    print('客户端',addr)
    while True:
        msg=conn.recv(1024)
        if not msg:break
        res=subprocess.Popen(msg.decode('utf-8'),shell=True,
                            stdin=subprocess.PIPE,
                         stderr=subprocess.PIPE,
                         stdout=subprocess.PIPE)
        err=res.stderr.read()
        if err:
            ret=err
        else:
            ret=res.stdout.read()
        data_length=len(ret)
        conn.send(str(data_length).encode('utf-8'))
        data=conn.recv(1024).decode('utf-8')
        if data == 'recv_ready':
            conn.sendall(ret)
    conn.close()

#_*_coding:utf-8_*_
import socket,time
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(('127.0.0.1',8080))

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

    s.send(msg.encode('utf-8'))
    length=int(s.recv(1024).decode('utf-8'))
    s.send('recv_ready'.encode('utf-8'))
    send_size=0
    recv_size=0
    data=b''
    while recv_size < length:
        data+=s.recv(1024)
        recv_size+=len(data)


    print(data.decode('utf-8'))

　　存在的问题：

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

　　5.3.2 解决方案进阶

　　可以借助一个模块，这个模块可以把要发送的数据长度转换成固定长度的字节。这样客户端每次接收消息之前只要先接受这个固定长度字节的内容看一看接下来要接收的信息大小，那么最终接受的数据只要达到这个值就停止，就能刚好不多不少的接收完整的数据了。　　

　　借助struct模块，我们知道长度数字可以被转换成一个标准大小的4字节数字。因此可以利用这个特点来预先发送数据长度。

发送时	接收时
先发送struct转换好的数据长度4字节	先接受4个字节使用struct转换成数字来获取要接收的数据长度
再发送数据	再按照长度接收数据

#解决黏包现象
    # 首先发送一下这个数据到底有多大
    # 再按照数据的长度接收数据
import socket

sk = socket.socket()
sk.bind(('127.0.0.1',8090))
sk.listen()

conn,addr = sk.accept()
while True:
    cmd = input('>>>')
    if cmd == 'q':
        conn.send(b'q')
        break
    conn.send(cmd.encode('gbk'))
    num = conn.recv(1024).decode('utf-8')
    conn.send(b'get number')

    res = conn.recv(int(num)).decode('gbk')   # 确定了我到底要接收多大的数据量
    print(res)
conn.close()
sk.close()
----------------------------------------------------------------------------------------
# 好处：确定了我到底要接收多大的数据量 【一般不会超过 recv（4096）】
    # 要在文件中配置一个配置项：就是每一次recv的大小
    # 当我们要发送大数据的时候，要明确的告诉接收方要发送多大的数据，以便接收方能够准确的接收到所有数据
    # 多用在文件传输的过程中
        # 大文件的传输：一定是按照字节读，每一次读固定的字节
        # 传输的过程中：一边读一边传，一边收一边写
        # send这个大文件之前，35672字节：send(4096) 35762-4096-4096-... ---> 0
        # recv这个大文件，recv(2048) 2048+2048+... ---> 35762
        
# 缺点：多了一次交互
# send sendto在超过一定的范围的时候都会报错
# 程序的内存管理

#解决黏包现象
    # 首先发送一下这个数据到底有多大
    # 再按照数据的长度接收数据
import socket
import subprocess

sk = socket.socket()
sk.connect(('127.0.0.1',8090))

while True:
    cmd = sk.recv(1024).decode('gbk')
    if cmd == 'q':
        break
    res = subprocess.Popen(cmd,shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
    # 管道中的数据只能取一次，像队列一样
    std_out = res.stdout.read()
    std_err = res.stderr.read()
    sk.send(str(len(std_out)+len(std_err)).encode('utf-8'))   #本来就是黏包的，黏在一起的
    sk.recv(1024)

    sk.send(std_out)
    sk.send(std_err)
sk.close()

6 socket的更多方法介绍

# 服务端套接字函数
s.bind()    绑定(主机,端口号)到套接字
s.listen()  开始TCP监听
s.accept()  被动接受TCP客户的连接,(阻塞式)等待连接的到来

# 客户端套接字函数
s.connect()     主动初始化TCP服务器连接
s.connect_ex()  connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

# 公共用途的套接字函数
s.recv()            接收TCP数据
s.send()            发送TCP数据
s.sendall()         发送TCP数据
s.recvfrom()        接收UDP数据
s.sendto()          发送UDP数据
s.getpeername()     连接到当前套接字的远端的地址
s.getsockname()     当前套接字的地址
s.getsockopt()      返回指定套接字的参数
s.setsockopt()      设置指定套接字的参数
s.close()           关闭套接字

# 面向锁的套接字方法
s.setblocking()     设置套接字的阻塞与非阻塞模式
s.settimeout()      设置阻塞套接字操作的超时时间
s.gettimeout()      得到阻塞套接字操作的超时时间

# 面向文件的套接字的函数
s.fileno()          套接字的文件描述符
s.makefile()        创建一个与该套接字相关的文件

# socket.send(string[, flags])

    send()的返回值是发送的字节数量，这个数量值可能小于要发送的string的字节数，也就是说可能无法发送string中所有的数据。如果有错误则会抛出异常。


# socket.sendall(string[, flags])

    sendall()尝试发送string的所有数据，成功则返回None，失败则抛出异常。
-------------------------------------------------------------------------------------------

故，下面两段代码是等价的：

#sock.sendall('Hello world
')

#buffer = 'Hello world
'
#while buffer:
#    bytes = sock.send(buffer)
#    buffer = buffer[bytes:]

7 扩展

7.1 验证客户端链接的合法性

# 检测一下客户端是否合法【不知道加密方式；不知道加密的密钥】
# 不依靠登录认证
import hmac           # hashlib
h = hmac.new()        # secret_key，你想进行加密的bytes
密文 = h.digest()
hmac.compare_digest()   # 对比 自己加密的密文 和 收到的密文

# os模块
import os
print(os.urandom(32))   #随机生成一个32位的字节

import socket
import os
import hmac

secret_key = b'egg'
sk = socket.socket()
sk.bind(('127.0.0.1',8090))
sk.listen()

def check_conn(conn):
    msg = os.urandom(32)
    conn.send(msg)
    h = hmac.new(secret_key,msg)
    digest = h.digest()        #加密后的
    client_digest = conn.recv(1024)
    return hmac.compare_digest(digest,client_digest)

conn,addr = sk.accept()
res = check_conn(conn)
if res:
    print('合法的客户端')
    conn.close()
else:
    print('不合法的客户端')
    conn.close()

import socket
import hmac

secret_key = b'egg111'
sk = socket.socket()
sk.connect(('127.0.0.1',8090))

msg = sk.recv(1024)
h = hmac.new(secret_key,msg)
digest = h.digest()
sk.send(digest)

sk.close()

7.2 ftp：上传下载文件

import socket
import struct
import json
import subprocess
import os

class MYTCPServer:
    address_family = socket.AF_INET

    socket_type = socket.SOCK_STREAM

    allow_reuse_address = False

    max_packet_size = 8192

    coding='utf-8'

    request_queue_size = 5

    server_dir='file_upload'

    def __init__(self, server_address, bind_and_activate=True):
        """Constructor.  May be extended, do not override."""
        self.server_address=server_address
        self.socket = socket.socket(self.address_family,
                                    self.socket_type)
        if bind_and_activate:
            try:
                self.server_bind()
                self.server_activate()
            except:
                self.server_close()
                raise

    def server_bind(self):
        """Called by constructor to bind the socket.
        """
        if self.allow_reuse_address:
            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.socket.bind(self.server_address)
        self.server_address = self.socket.getsockname()

    def server_activate(self):
        """Called by constructor to activate the server.
        """
        self.socket.listen(self.request_queue_size)

    def server_close(self):
        """Called to clean-up the server.
        """
        self.socket.close()

    def get_request(self):
        """Get the request and client address from the socket.
        """
        return self.socket.accept()

    def close_request(self, request):
        """Called to clean up an individual request."""
        request.close()

    def run(self):
        while True:
            self.conn,self.client_addr=self.get_request()
            print('from client ',self.client_addr)
            while True:
                try:
                    head_struct = self.conn.recv(4)
                    if not head_struct:break

                    head_len = struct.unpack('i', head_struct)[0]
                    head_json = self.conn.recv(head_len).decode(self.coding)
                    head_dic = json.loads(head_json)

                    print(head_dic)
                    #head_dic={'cmd':'put','filename':'a.txt','filesize':123123}
                    cmd=head_dic['cmd']
                    if hasattr(self,cmd):
                        func=getattr(self,cmd)
                        func(head_dic)
                except Exception:
                    break

    def put(self,args):
        file_path=os.path.normpath(os.path.join(
            self.server_dir,
            args['filename']
        ))

        filesize=args['filesize']
        recv_size=0
        print('----->',file_path)
        with open(file_path,'wb') as f:
            while recv_size < filesize:
                recv_data=self.conn.recv(self.max_packet_size)
                f.write(recv_data)
                recv_size+=len(recv_data)
                print('recvsize:%s filesize:%s' %(recv_size,filesize))


tcpserver1=MYTCPServer(('127.0.0.1',8080))

tcpserver1.run()

import socket
import struct
import json
import os


class MYTCPClient:
    address_family = socket.AF_INET

    socket_type = socket.SOCK_STREAM

    allow_reuse_address = False

    max_packet_size = 8192

    coding='utf-8'

    request_queue_size = 5

    def __init__(self, server_address, connect=True):
        self.server_address=server_address
        self.socket = socket.socket(self.address_family,
                                    self.socket_type)
        if connect:
            try:
                self.client_connect()
            except:
                self.client_close()
                raise

    def client_connect(self):
        self.socket.connect(self.server_address)

    def client_close(self):
        self.socket.close()

    def run(self):
        while True:
            inp=input(">>: ").strip()
            if not inp:continue
            l=inp.split()
            cmd=l[0]
            if hasattr(self,cmd):
                func=getattr(self,cmd)
                func(l)


    def put(self,args):
        cmd=args[0]
        filename=args[1]
        if not os.path.isfile(filename):
            print('file:%s is not exists' %filename)
            return
        else:
            filesize=os.path.getsize(filename)

        head_dic={'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize}
        print(head_dic)
        head_json=json.dumps(head_dic)
        head_json_bytes=bytes(head_json,encoding=self.coding)

        head_struct=struct.pack('i',len(head_json_bytes))
        self.socket.send(head_struct)
        self.socket.send(head_json_bytes)
        send_size=0
        with open(filename,'rb') as f:
            for line in f:
                self.socket.send(line)
                send_size+=len(line)
                print(send_size)
            else:
                print('upload successful')




client=MYTCPClient(('127.0.0.1',8080))

client.run()

客户端

7.3  socketsrver

import socketserver

class MyServer(socketserver.BaseRequestHandler):
    def handle(self):                  # self.request 相当于一个conn
        while True:
            msg = self.request.recv(1024).decode('utf-8')
            if msg == 'q':
                self.request.close()
                break

            print(msg)
            info = input('>>>')
            self.request.send(info.encode('utf-8'))

if __name__ == 'main':
    # 设置allow_reuse_address允许服务器重用地址
    socketserver.TCPServer.allow_reuse_address = True
    # 创建一个server, 将服务地址绑定到
    server = socketserver.ThreadingTCPServer(('127.0.0.1',8080),MyServer)
    # 让server永远运行下去，除非强制停止程序
    server.serve_forever()

# 看源码思路：
    # 多个类之间的继承关系要先整理
    # 每一个类中有哪些方法，要大致列出来
    # 所有的self对象调用要清楚的了解 到底是谁的对象
    # 所有的方法调用要退回到最子类的类中开始i寻找，逐级向上

import socket

sk = socket.socket()
sk.connect(('127.0.0.1',8080))

while True:
    msg = input('>>>')
    if msg == 'q':
        sk.send(b'q')
        break
    sk.send('美团：'+msg.encode('utf-8'))
    ret = sk.recv(1024).decode('utf-8')
    print(ret)

sk.close()

import socket

sk = socket.socket()
sk.connect(('127.0.0.1',8080))

while True:
    msg = input('>>>')
    if msg == 'q':
        sk.send(b'q')
        break
    sk.send('大众点评：'+msg.encode('utf-8'))
    ret = sk.recv(1024).decode('utf-8')
    print(ret)

sk.close()