Python核心编程——第2章 网络编程 笔记

第2章 网络编程

2.1 Python 中的网络编程

2.1.1 socket()模块函数

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

socket(socket_family, socket_type, protocol=0)

其中，socket_family 是 AF_UNIX 或 AF_INET，socket_type 是 SOCK_STREAM或 SOCK_DGRAM（也如前所述）。 protocol 通常省略，默认为 0。
所以，为了创建 TCP/IP 套接字，可以用下面的方式调用 socket.socket()。

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()	将地址（主机名、端口号对）绑定到套接字上
s.listen()	设置并启动 TCP 监听器
s.accept()	被动接受 TCP 客户端连接，一直等待直到连接到达（阻塞）
客户端套接字方法
s.connect()	主动发起 TCP 服务器连接
s.connect_ex()	connect()的扩展版本，此时会以错误码的形式返回问题，而不是抛出一个异常
普通的套接字方法
s.recv()	接收 TCP 消息
s.recv_into()	接收 TCP 消息到指定的缓冲区
s.send()	发送 TCP 消息
s.sendall()	完整地发送 TCP 消息
s.recvfrom()	接收 UDP 消息
s.recvfrom_into()	接收 UDP 消息到指定的缓冲区
s.sendto()	发送 UDP 消息
s.getpeername()	连接到套接字（TCP）的远程地址
s.getsockname()	当前套接字的地址
s.getsockopt()	返回给定套接字选项的值
s.setsockopt()	设置给定套接字选项的值
s.shutdown()	关闭连接
s.close()	关闭套接字
s.detach()	在未关闭文件描述符的情况下关闭套接字，返回文件描述符
s.ioctl()	控制套接字的模式（仅支持 Windows）
面向阻塞的套接字方法
s.setblocking()	设置套接字的阻塞或非阻塞模式
s.settimeout()	设置阻塞套接字操作的超时时间
s.gettimeout()	获取阻塞套接字操作的超时时间
面向文件的套接字方法
s.fileno()	套接字的文件描述符
s.makefile()	创建与套接字关联的文件对象
数据属性
s.family	套接字家族
s.type	套接字类型
s.proto	套接字协议

2.1.2 创建 TCP 服务器

首先，我们将展现创建通用 TCP 服务器的一般伪代码，然后对这些代码的含义进行一般性的描述。需要记住的是，这仅仅是设计服务器的一种方式。一旦熟悉了服务器设计，那么你将能够按照自己的要求修改下面的伪代码来操作服务器。

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

所有套接字都是通过使用 socket.socket()函数来创建的。因为服务器需要占用一个端口并等待客户端的请求，所以它们必须绑定到一个本地地址。因为 TCP 是一种面向连接的通信系统，所以在 TCP 服务器开始操作之前，必须安装一些基础设施。特别地， TCP 服务器必须监听（传入）的连接。一旦这个安装过程完成后，服务器就可以开始它的无限循环。

调用 accept()函数之后，就开启了一个简单的（单线程）服务器，它会等待客户端的连接。默认情况下， accept()是阻塞的，这意味着执行将被暂停，直到一个连接到达。另外，套接字确实也支持非阻塞模式，可以参考文档或操作系统教材，以了解有关为什么以及如何使用非阻塞套接字的更多细节。

一旦服务器接受了一个连接，就会返回（利用 accept()）一个独立的客户端套接字，用来与即将到来的消息进行交换。使用新的客户端套接字类似于将客户的电话切换给客服代表。当一个客户电话最后接进来时，主要的总机接线员会接到这个电话，并使用另一条线路将这个电话转接给合适的人来处理客户的需求。

这将能够空出主线（原始服务器套接字），以便接线员可以继续等待新的电话（客户请求），而此时客户及其连接的客服代表能够进行他们自己的谈话。同样地，当一个传入的请求到达时，服务器会创建一个新的通信端口来直接与客户端进行通信，再次空出主要的端口，以使其能够接受新的客户端连接。

一旦创建了临时套接字，通信就可以开始，通过使用这个新的套接字，客户端与服务器就可以开始参与发送和接收的对话中，直到连接终止。当一方关闭连接或者向对方发送一个空字符串时，通常就会关闭连接。

在代码中，一个客户端连接关闭之后，服务器就会等待另一个客户端连接。最后一行代码是可选的，在这里关闭了服务器套接字。其实，这种情况永远也不会碰到，因为服务器应该在一个无限循环中运行。在示例中这行代码用来提醒读者，当为服务器实现一个智能的退出方案时，建议调用 close()方法。例如，当一个处理程序检测到一些外部条件时，服务器就应该关闭。在这些情况下，应该调用一个 close()方法。

TCP 时间戳服务器

# TCP时间戳服务器
from socket import *
from time import ctime
# 导入time.ctime()和 socket 模块的所有属性

# HOST 变量是空白的，这是对 bind()方法的标识，表示它可以使用任何可用的地址
HOST = ''
# 选择了一个随机的端口号，并且该端口号似乎没有被使用或被系统保留
PORT = 21567
# 对于该应用程序，将缓冲区大小设置为 1KB。可以根据网络性能和程序需要改变这个容量
BUFSIZ = 1024
ADDR = (HOST, PORT)

# 分配 TCP 服务器套接字
tcpSerSock = socket(AF_INET, SOCK_STREAM)
# 将套接字绑定到服务器地址
tcpSerSock.bind(ADDR)
# 连接被转接或拒绝之前，传入连接请求的最大数
tcpSerSock.listen(5)

while True:
    print('waiting for connection...')
    # （被动地）等待客户端的连接
    tcpCliSock, addr = tcpSerSock.accept()
    print('...connected from:', addr)

    while True:
        data = tcpCliSock.recv(BUFSIZ)
        # 如果消息是空白的，这意味着客户端已经退出，所以此时我们将跳出对话循环，关闭当前客户端连接
        if not data:
            break
        tcpCliSock.send(bytes('[%s] %s' % (ctime(), data), 'utf-8'))

    tcpCliSock.close()
#最后一行永远不会执行，它只是用来提醒，如果写了一个处理程序来考虑一个更加优雅的退出方式，那么应该调用 close()方法。
tcpSerSock.close()

2.1.3 创建TCP客户端

TCP 时间戳客户端

# TCP 时间戳客户端
from socket import *

# 服务器的主机名
HOST = '127.0.0.1'  # or 'localhost'
# 服务器的端口号
PORT = 21567
# 缓冲区大小设置为 1KB
BUFSIZ = 1024
ADDR = (HOST, PORT)

# 分配 TCP 客户端套接字
tcpCliSock = socket(AF_INET, SOCK_STREAM)
# 主动调用并连接到服务器
tcpCliSock.connect(ADDR)

while True:
    data = input('>')
    if not data:
        break
    tcpCliSock.send(bytes(data, 'utf-8'))
    data = tcpCliSock.recv(BUFSIZ)
    if not data:
        break
    print(data.decode('utf-8'))

tcpCliSock.close()

IPV6 TCP 时间戳客户端

# IPV6 TCP 时间戳客户端
from socket import *

# 服务器的主机名
HOST = '::1'
# 服务器的端口号
PORT = 21567
# 缓冲区大小设置为 1KB
BUFSIZ = 1024
ADDR = (HOST, PORT)

# 分配 TCP 客户端套接字
tcpCliSock = socket(AF_INET6, SOCK_STREAM)
# 主动调用并连接到服务器
tcpCliSock.connect(ADDR)

while True:
    data = input('>')
    if not data:
        break
    tcpCliSock.send(bytes(data, 'utf-8'))
    data = tcpCliSock.recv(BUFSIZ)
    if not data:
        break
    print(data.decode('utf-8'))

tcpCliSock.close()

2.1.4 创建 UDP 服务器

UDP 服务器不需要 TCP 服务器那么多的设置，因为它们不是面向连接的。除了等待传入的连接之外，几乎不需要做其他工作。

ss = socket() # 创建服务器套接字
ss.bind() # 绑定服务器套接字
inf_loop: # 服务器无限循环
    cs = ss.recvfrom()/ss.sendto() # 关闭（接收/发送）
ss.close() # 关闭服务器套接字

UDP 时间戳服务器

# UDP 时间戳服务器
from socket import *
from time import ctime

HOST = ''
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)

udpSerSock = socket(AF_INET, SOCK_DGRAM)
udpSerSock.bind(ADDR)

while True:
    print('waiting for message...')
    data, addr = udpSerSock.recvfrom(BUFSIZ)
    udpSerSock.sendto(bytes('[%s] %s' % (ctime(), data), 'utf-8'), addr)
    print('...received from and returned to:', addr)

udpSerSock.close()

2.1.5 创建 UDP 客户端

UDP 客户端的代码是最短的。它的伪代码如下所示。

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

一旦创建了套接字对象，就进入了对话循环之中，在这里我们与服务器交换消息。最后，当通信结束时，就会关闭套接字。

UDP 时间戳客户端

# UDP 时间戳客户端
from socket import *

# 服务器的主机名
HOST = '127.0.0.1'  # or 'localhost'
# 服务器的端口号
PORT = 21567
# 缓冲区大小设置为 1KB
BUFSIZ = 1024
ADDR = (HOST, PORT)

# 分配 TCP 客户端套接字
udpCliSock = socket(AF_INET, SOCK_DGRAM)

while True:
    data = input('>')
    if not data:
        break
    udpCliSock.sendto(bytes(data, 'utf-8'), ADDR)
    data, ADDR = udpCliSock.recvfrom(BUFSIZ)
    if not data:
        break
    print(data.decode('utf-8'))

udpCliSock.close()

socket 模块属性

属 性 名 称	描 述
数据属性
AF_UNIX、 AF_INET、 AF_INET6、AF_NETLINK、 AF_TIPC	Python 中支持的套接字地址家族
SO_STREAM、 SO_DGRAM	套接字类型（TCP=流， UDP=数据报）
has_ipv6	指示是否支持 IPv6 的布尔标记
异常
error	套接字相关错误
herror	主机和地址相关错误
gaierror	地址相关错误
timeout	超时时间
函数
socket()	以给定的地址家族、套接字类型和协议类型（可选）创建一个套接字对象
socketpair()	以给定的地址家族、套接字类型和协议类型（可选）创建一对套接字对象
create_connection()	常规函数，它接收一个地址（主机名，端口号）对，返回套接字对象
fromfd()	以一个打开的文件描述符创建一个套接字对象
ssl()	通过套接字启动一个安全套接字层连接；不执行证书验证
getaddrinfo()	获取一个五元组序列形式的地址信息
getnameinfo()	给定一个套接字地址，返回（主机名，端口号）二元组
getfqdn()	返回完整的域名
gethostname()	返回当前主机名
gethostbyname()	将一个主机名映射到它的 IP 地址
gethostbyname_ex()	gethostbyname()的扩展版本，它返回主机名、别名主机集合和 IP 地址列表
gethostbyaddr()	将一个 IP 地址映射到 DNS 信息；返回与 gethostbyname_ex()相同的 3 元组
getprotobyname()	将一个协议名（如‘tcp’）映射到一个数字
getservbyname()/getservbyport()	将一个服务名映射到一个端口号，或者反过来；对于任何一个函数来说，协议名都是可选的
ntohl()/ntohs()	将来自网络的整数转换为主机字节顺序
htonl()/htons()	将来自主机的整数转换为网络字节顺序
inet_aton()/inet_ntoa()	将 IP 地址八进制字符串转换成 32 位的包格式，或者反过来（仅用于 IPv4 地址）
inet_pton()/inet_ntop()	将 IP地址字符串转换成打包的二进制格式，或者反过来（同时适用于 IPv4 和 IPv6 地址）
getdefaulttimeout()/setdefaulttimeout()	以秒（浮点数）为单位返回默认套接字超时时间；以秒（浮点数）为单位设置默认套接字超时时间

2.2 *SocketServer 模块

SocketServer 是标准库中的一个高级模块（Python 3.x 中重命名为 socketserver），它的目标是简化很多样板代码，它们是创建网络客户端和服务器所必需的代码。这个模块中有为你创建的各种各样的类。

类	描 述
BaseServer	包含核心服务器功能和 mix-in 类的钩子；仅用于推导，这样不会创建这个类的实例；可以用 TCPServer 或 UDPServer
TCPServer/UDPServer	基础的网络同步 TCP/UDP 服务器
UnixStreamServer/UnixDatagramServer	基于文件的基础同步 TCP/UDP 服务器
ForkingMixIn/ThreadingMixIn	核心派出或线程功能；只用作 mix-in 类与一个服务器类配合实现一些异步性；不能直接实例化这个类
ForkingTCPServer/ForkingUDPServer	ForkingMixIn 和 TCPServer/UDPServer 的组合
ThreadingTCPServer/ThreadingUDPServer	ThreadingMixIn 和 TCPServer/UDPServer 的组合
BaseRequestHandler	包含处理服务请求的核心功能；仅仅用于推导，这样无法创建这个类的实例；可以使用 StreamRequestHandler 或 DatagramRequestHandler
StreamRequestHandler/DatagramRequestHandler	实现 TCP/UDP 服务器的服务处理器

2.2.1 创建 SocketServer TCP 服务器

SocketServer 时间戳 TCP 服务器

# SocketServer 时间戳 TCP 服务器
from socketserver import TCPServer as TCP, StreamRequestHandler as SRH
from time import ctime

HOST = ''
PORT = 21567
ADDR = (HOST, PORT)


# MyRequestHandler作为SocketServer中StreamRequestHandler 的一个子类，并重写了它的 handle()方法
class MyRequestHandler(SRH):
    def handle(self):
        print('...connected from:',
              self.client_address,
              self.wfile.write(bytes('[%s] %s' % (ctime(), self.rfile.readline()), 'utf-8')))


# 创建 TCP 服务器
tcpServ = TCP(ADDR, MyRequestHandler)
print('waiting for connection...')
# 无限循环地等待并服务于客户端请求
tcpServ.serve_forever()

2.2.2 创建 SocketServer TCP 客户端

SocketServer 时间戳 TCP 客户端

# SocketServer 时间戳 TCP 客户端
from socket import *

HOST = 'localhost'
PORT = 21567
BUFSIZ = 1024
ADDR = (HOST, PORT)

while True:
    # 分配 TCP 客户端套接字
    tcpCliSock = socket(AF_INET, SOCK_STREAM)
    # 主动调用并连接到服务器
    tcpCliSock.connect(ADDR)
    data = input('>')
    if not data:
        break
    tcpCliSock.send(bytes('%s\r\n' % data, 'utf-8'))
    data = tcpCliSock.recv(BUFSIZ)
    if not data:
        break
    print(data.strip())
    tcpCliSock.close()

2.3 *Twisted 框架介绍

Twisted 是一个完整的事件驱动的网络框架，利用它既能使用也能开发完整的异步网络应用程序和协议。因为它还不是 Python 标准库的一部分，所以必须单独下载并安装它。它提供了大量的支持来建立完整的系统，包括网络协议、线程、安全性和身份验证、聊天/ IM、 DBM 及 RDBMS 数据库集成、 Web/因特网、电子邮件、命令行参数、 GUI 集成工具包等。

2.3.1 创建 Twisted Reactor TCP 服务器

Twisted Reactor 时间戳 TCP 服务器

# Twisted Reactor 时间戳 TCP 服务器
from twisted.internet import protocol, reactor
from time import ctime

PORT = 21567


class TSServProtocol(protocol.Protocol):
    def connectionMade(self):
        clnt = self.clnt = self.transport.getPeer().host
        print('...connected from:', clnt)

    def dataReceived(self, data):
        self.transport.write(bytes('[%s] %s' % (ctime(), data), 'utf-8'))


factory = protocol.Factory()
factory.protocol = TSServProtocol
print('waiting for connection...')
reactor.listenTCP(PORT, factory)
reactor.run()

2.3.2 创建 Twisted Reactor TCP 客户端

Twisted Reactor 时间戳 TCP 客户端

# Twisted Reactor 时间戳 TCP 客户端
from click._compat import raw_input
from twisted.internet import protocol, reactor

HOST = 'localhost'
PORT = 21567


class TSClntProtocol(protocol.Protocol):
    def sendData(self):
        data = raw_input('>')
        if data:
            print('...sending %s...' % data)
            self.transport.write(bytes(data, 'utf-8'))
        else:
            self.transport.loseConnection()

    def connectionMade(self):
        self.sendData()

    def dataReceived(self, data):
        print(data)
        self.sendData()


class TSClntFactory(protocol.ClientFactory):
    protocol = TSClntProtocol
    clientConnectionLost = clientConnectionFalied = lambda self, connector, reason: reactor.stop()


reactor.connectTCP(HOST, PORT, TSClntFactory())
reactor.run()

end