1、 网络编程

0x00：楔子

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

这个问题以你现在的知识就可以解决了，我们可以创建一个文件，把a.py想要传递的内容写到文件中，然后b.py从这个文件中读取内容就可以了。

但是当你的a.py和b.py分别在不同电脑上的时候，你要怎么办呢？
类似的机制有计算机网盘，qq等等。我们可以在我们的电脑上和别人聊天，可以在自己的电脑上向网盘中上传、下载内容。这些都是两个程序在通信。

二.软件开发的架构

我们了解的涉及到两个程序之间通讯的应用大致可以分为两种：
第一种是应用类：qq、微信、网盘、优酷这一类是属于需要安装的桌面应用
第二种是web类：比如百度、知乎、博客园等使用浏览器访问就可以直接使用的应用
这些应用的本质其实都是两个程序之间的通讯。而这两个分类又对应了两个软件开发的架构～

1.C/S架构

C/S即：Client与Server ，中文意思：客户端与服务器端架构，这种架构也是从用户层面（也可以是物理层面）来划分的。
这里的客户端一般泛指客户端应用程序EXE，程序需要先安装后，才能运行在用户的电脑上，对用户的电脑操作系统环境依赖较大。

2.B/S架构

B/S即：Browser与Server,中文意思：浏览器端与服务器端架构，这种架构是从用户层面来划分的。
Browser浏览器，其实也是一种Client客户端，只是这个客户端不需要大家去安装什么应用程序，只需在浏览器上通过HTTP请求服务器端相关的资源（网页资源），客户端Browser浏览器就能进行增删改查。
回

0x01：套接字（通信端点）

在任何类型的通信开始之前，网络应用程序必须创建套接字。

套接字： 最初为同一主机上的应用程序创建的，是主机上运行的一个程序（又名一个进程）与另外一个运行的程序进行通信。

有两种类型的套接字： 基于文件（AF_UNIX/AF_LOCAL）和面向网络（AF_INET）。

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

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

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

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

0x02： 套接字地址： 主机——端口对

一个网络地址有主机名和端口号对组成，有效的端口号范围为 0~ 65535（小于1024的端口号都预留给了系统），我们可以在 linux 系统下的 /etc/services 文件中找到预留端口号的列表。

0x03：面向连接的套接字与无连接的套接字

• 面向连接的套接字： 面向连接的通信提供序列化的、可靠性和不重复的数据交付，而且没有记录边界。 实现这种连接类型的主要协议是传输控制协议（TCP)。 使用 SOCK_STREAM 作为套接字类型。

• 无连接的套接字：在通信开始之前并不需要建立连接。在数据传输过程中无法保证它的顺序性、可靠性或重复性，保留了记录边界，。这就意味着消息是以整体发送的，并非首先分成多个片段。实现这种连接类型的主要协议是用户数据报协议（UDP）。必须使用SOCK_DGRAM作为套接字的类型。

1、tcp协议和udp协议

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

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

0x04：socket()模块函数

要创建套接字，必须使用 socket.socket()函数，一般的语法如下：

socket(socket_family, socket_type, protocol=0)
socket_family 是AF_UNIX 或 AF_INET , socket_type是sock_stream 或者 sock_dgram。portocol通常省略，默认为0.

套接字对象（内置）方法：

0x05：创建TCP服务端和客户端

Python3 TCP 时间戳服务端代码示例

from socket import *        # 导入套接字模块
from time import ctime      # 导入时间戳模块
HOST = ''      # 内容为空，表示任何可用的地址
PORT = 21567    # 设置端口号
BUFSIZ = 1024   # 缓冲区大小为1KB
ADDR = (HOST,PORT)    # 元组的形式保存ip 地址和端口
tcpSer = socket(AF_INET,SOCK_STREAM)     # 创建套接字
tcpSer.bind(ADDR)                           # 绑定套接字的地址
tcpSer.listen(5)                         # 设置TCP服务端的监听器
while True:                              # 循环
    print('wating  for  connection....')
    tcpCli,addr = tcpSer.accept()       # 接受TCP客户端的连接
    print('.... connected from: ',addr)
    while True:                          # 再创建一个子循环
        data = tcpCli.recv(BUFSIZ).decode()    #服务器接受到客户端发送来的数据是字节类型，需要转换为字符串类型
        if not data:                     # 判断消息是否为空，为空就停止
            break
        tcpCli.send(('[%s] %s' % (ctime(),data)).encode())     #  # 网络传输数据前将字符串数据转化为字节类型
    tcpCli.close()      # 断开客户端的连接
tcpSer.close()

Python3 TCP 时间戳客户端代码示例

from socket import  *      # 导入套接字模块
HOST = '127.0.0.1'       # 服务器的主机名
PORT = 21567             # 端口号
BUFFER_SIZE = 1024       # 缓冲区大小为 1KB
ADDR = (HOST,PORT)       # 元组的形式存储 ip 地址和端口
tcpCli = socket(AF_INET,SOCK_STREAM)   # 创建套接字
tcpCli.connect(ADDR)      # 与服务端进行连接
while True:                # 创建循环
    data = input('> ')    # 用户输入数据
    if not data:           # 对用户的输入数据进行判断，如果为空，跳出循环
        break
    tcpCli.send(data.encode())     # 用户发送字符串数据
    data = tcpCli.recv(BUFFER_SIZE).decode()       # 客户端收到加了时间戳的字符串
    if not data:
        break
    print(data)
tcpCli.close()

0x06：创建UDP服务端和客户端

Python3 UDP 时间戳服务端代码示例

from  socket import *        # 导入socket模块
from time  import ctime      # 导入时间戳模块
HOST = ''                   # 设置主机
PORT = 21567                # 设置端口
BUFSIZ = 1024               # 消息的缓存大小
ADDR = (HOST,PORT)          # 将主机和端口保存为元组
udpSer = socket(AF_INET,SOCK_DGRAM)     # 建立UDP的套接字
udpSer.bind(ADDR)                       # 绑定套接字的地址和端口
while  True:                            # 创建一个循环
    print(' wating  for  message ....')
    data,addr = udpSer.recvfrom(BUFSIZ)   #接受客户端发送来的数据
    print(data.decode())
    udpSer.sendto(ctime().encode(),addr )  #给客户端发送消息
    print(' ..... received from and returned to:',addr)
udpSer.close()

Python3 UDP 时间戳客户端代码示例

from  socket import *      # 导入socket模块
HOST = '127.0.0.1'          # 设置服务器主机
PORT = 21567                # 设置端口
BUFSIZ = 1024               # 消息的缓存大小
ADDR = (HOST,PORT)          # 将主机和端口保存为元组
udpCli = socket(AF_INET,SOCK_DGRAM)      # 建立UDP的套接字
while True:
    data = input('> ')              # 判断输入的数据是否为空
    if not data:
        break
    udpCli.sendto((data.encode()),ADDR)          # 客户端向服务端发送消息   
    data,ADDR = udpCli.recvfrom(BUFSIZ)          # 接受服务端发来的消息
    data = data.decode()
    if not data:
        break
    print(data)
udpCli.close()

0x07：SocketServer 模块

事件包括消息的发送和接收，事实上，你会看到类定义只包括一个用来接收客户端消息的事件处理程序。所有的其他功能都来自使用的 SocketServer 类。

在原始服务器循环中，我们阻塞等待请求，当收到请求时就对其提供服务，然后继续等待。再此处的服务器循环中，并非在服务器中创建代码，而是定义一个处理程序，这样当服务器接收到一个传入的请求时，服务器就可以调用你的函数。

创建SocketServer TCP 服务端

from socketserver import TCPServer as TCP
from socketserver import StreamRequestHandler as SRH
from time import ctime
HOST  = ''
PORT = 21567
ADDR = (HOST,PORT)
class MyRequestHandler(SRH):  # 重写自己的RequestHandlerClass类
    def handle(self):
        # 打印客户端的地址信息，该信息被储存在self.client_address中
        print('...connected from:',self.client_address)
        # self.rfile.readline()读取客户端发送的信息(bytes类型)，并解码为字符串类型
        # 写入字符串类型信息，编码为bytes(此处没有send()方法)
        self.wfile.write(('[%s] %s ' % (ctime(),self.rfile.readline().decode())).encode())
# 构造socketserver.TCPServer类，传入地址和handler方法参数
tcpServ = TCP(ADDR,MyRequestHandler)
print('wating  for connection...')
# 开启该服务，直至中断
tcpServ.serve_forever()

创建SocketServer TCP 客户端

from socket import *
HOST  = '127.0.0.1'
PORT = 21567
ADDR = (HOST,PORT)
BUFSIZ = 1024
while True:
    tcpCli  = socket(AF_INET,SOCK_STREAM)
    tcpCli.connect(ADDR)
    data = input('> ')
    if not data:
        break
    tcpCli.send('{}\r\n'.format(data).encode('utf8'))    #发送数据
    data = tcpCli.recv(BUFSIZ).decode()                                        #接收数据
    if not data:
        break
    print(data.strip())
    tcpCli.close()

0x08：Twisted框架

Twisted 是一个完整的事件驱动的网络框架，利用它既能使用也能完整的开发异步网络应用程序和协议。提供了大量的支持来建立完整的系统，包括网络线程、安全性和身份效验、聊天/IM、DBM 、Web/因特网、电子邮件、GUI集成工具包等。

创建 Twisted Reactor TCP 服务器

from  twisted.internet import  protocol,reactor     #使用 Twisted internet类，导入 protocol,reactor 模块
from time import  ctime
PORT = 21568
class TCP(protocol.Protocol):               # 定义一个类
    def connectionMade(self):               #重写connectionMade方法
        clnt = self.clnt = self.transport.getPeer().host    # 获取到客户端的连接的信息
        print('...connected from:',clnt)
    def dataReceived(self, data):    #重写dataReceived方法
        # self.transport.write('[%s] %s' % (ctime(),data))        # 向客户端发送数据
        data = ('[%s] %s' %(ctime(),data.decode()))
        print(data)
        self.transport.write(data.encode())
factory = protocol.Factory()          #创建一个工厂
factory.protocol = TCP                # 调用一个类
# 使用reactor安装一个TCP监听器，检查服务请求。
# 当它接收到一个请求时,就会创建一个TSServProtocol实例来处理那个客户端的事务
print('wating for connection ...')
reactor.listenTCP(PORT, factory)        #监听器的作用
reactor.run()                           # 运行reactor ，启动服务端

创建 Twisted Reactor TCP 客户端

from  twisted.internet import  protocol,reactor    #使用 Twisted internet类，导入 protocol,reactor 模块
HOST = '127.0.0.1'          #服务端的IP
PORT = 21568                # 服务器的端口
class TCPCli(protocol.Protocol):     #自定义一个类
    def sendData(self):             #自定义方法sendData
        data = input('> ')
        if data:
            print('.....sending %s...' %data)
            self.transport.write(data.encode())     #给服务端发送消息
        else:
            self.transport.loseConnection()         # 与服务器丢失连接
    def connectionMade(self):                     #重写connectionMade方法，与服务器进行连接时，调用此方法
        self.sendData()                           #调用senData 方法
    def dataReceived(self, data):                #重写dataReceived方法，接受服务的消息
        print(data.decode())
        self.sendData()
class TCPClifac(protocol.ClientFactory):            # 创建一个类，定义一个工厂
    protocol = TCPCli                               # 给之前的类赋值
    clientConnectionLost = clientConnectionFailed = \     
        lambda self,connector,reason: reactor.stop()
                                                    #连接失败停止reactor
reactor.connectTCP(HOST,PORT,TCPClifac())           # 与服务器进行连接
reactor.run()