尧图网页设计 
不管服务器类采用何种网络协议, 其体现出的外部方法都归于相同范畴, 并且外部属性也同样归于相同范畴。服务器创建的说明在继承图中有五个类其中四个代表四种类型的同步服务器:------------ | BaseServer | ------------ | v ----------- ------------------ | TCPServer |-------| UnixStreamServer | ----------- ------------------ | v ----------- -------------------- | UDPServer |-------| UnixDatagramServer | ----------- --------------------要留意, 是从……派生而来, 并非从……派生而来 --- IP与Unix服务器仅有的差别是地址族。..可以使用这些混合类来创建每种服务器类型的分叉版本, 也可以使用这些混合类来创建每种服务器类型的线程版本。例如, 如下是其创建方式。class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass先是混合类出现, 这缘由于它对在其中定义的一个方法进行了重载。设置各类属性, 其也会使得下层服务器机制的行为发生改变。跟下文所讲到的分叉类别, 仅仅是在对其予以支持的POSIX系统平台范围之内才能够使用。会等待直到所有子进程完成除非 属性为 False。会等待直到所有非守护线程完成除非 属性为 False。确定要设定的与此同时处置请求的子进程数量, 要是达到了这般限定, 那新的请求就会等候着, 直至有某个子进程终结。能够通过把它设为 True 来运用守护线程, 进而不需要等待线程结束, 对于这样的情况。3.7 版本出现变更, 和, 如今会等候直至所有子进程以及非守护线程完结, 新增了一个类属性用以挑选 3.7 版以前的行为。.....ver.erver.erver.这些类都是使用混合类来预定义的。在3.12中添加的内容为: 增添了ver类、erver类。欲达成一项服务, 你得自某类派生一个类, 重新定义其相关方法。而后, 你能够凭借将某种服务器类型与你的请求处理器类相结合, 去运行各类版本的服务。对于请求处理器类而言, 针对数据报服务和流服务必定是不一样的。此情形可借由运用处理器子类或者其他方式予以隐匿。当然, 你依旧得费点心思比如说, 要是服务涵盖那种会被各异请求改动的内存状态, 那选用分叉服务器就没什么道理, 因为于子进程里所做的修改, 永远都没法影响到保存在父进程中的初始状态, 也无法传递至各个子进程。在这种情形下, 你能够采用线程服务器, 不过你或许得借助锁来保障共享数据的一致性。然而, 换个情形来讲下, 要是你正着手编写一个需要将全部数据存储于外部像是文件系统这般的HTTP服务器, 那么此时同步类实际上会在处理某一个请求的阶段“变聋”, 就是说, 倘若有某个客户端在接收其请求的所有相关数据之际速度极为迟缓, 这迟缓的时长可能会是相当漫长的, 在这种情形下, 线程或者分叉服务器会更适宜被采用。当处于某些情形时, 恰当的做法乃是同步地处置请求的一部分, 然而要依据请求数据于分叉产生的子进程里达成处理。此情形得以借助运用同步服务器并于请求处理器类当中做显式分叉予以达成。在一种环境里, 该环境既不支持线程, 对于本服务而言, 这两者的开销还过大或者不适用此时存在另一种处理多个同时请求的方式, 那就是维护一张显式的部分完成的请求表, 接着通过某种动作来决定后续要处理哪个请求或者究竟是否要处理一个新传入的请求。另外, 这对于流式服务来讲尤为重要, 因为万一不能使用线程或子进程, 每个客户端有可能连接很长的时长。对象.(, )这般模样乃是于本模块里头所有具备性质的对象所从属的超类别, 这类超类别对下文陈列出来的接口实施了定义, 然而却并未将大部分的方法予以落实, 那些方法应当在子类别当中去达成, 两个具备形态属性参数的, 所留存的位置处在与之相对的属性以及属性这个状态之中。()让返回的文件描述符, 那是以整数形式呈现的、服务器正在监听的套接字的, 该函数常常被传递给, 为了能够在同一个进程里对多个服务器进行监控。()去处理单独一个请求, 存在这样一个函数, 它会依照次序逐个去调用下面列举这类的方法。倘若用户所给予的处理器类之中相应特定一个的方法引发了异常状况, 那么就会调用服务器给定的那个方法。要是在规定相应时间之中没有接收到请求, 便将会依照要求做出具体执行和呈现内容那样的被调将会返回。(0.5)对请求予以处理直到接收到显式的请求, 每隔一定秒数对特定对象进行轮询, 忽略某属性, 它还会调用某个操作, 这能被子类或者混合类用以提供某个给定服务专有的操作, 举例来说, 某类使用特定方法来清理僵尸子进程。在 3.3 版本发生变更: 将 调用添加到 方法。()在循环里, 此方法会被调用, 此方法能够被子类或者混合类进行重载, 以此去执行某个给定服务的专属操作, 像清理操作这种的。()要通知, 循环得停止并等待其完成。必须在它运行于不同线程时被调用那种特定的情况之时调用才行, 否则就将会发生死锁。()清理服务器。此方法可被重载。为服务器套接字赋予所属协议族, 存在着一些常见示例呀 , 像是这样的和那样的等。倘若你有着获取IPv6服务器类的需求 , 那就得对这个模块里的TCP或UDP服务器类进行子类化操作 , 并且还要设置类属性等于这个呢。用户提供的请求处理器类将为每个请求创建该类的实例。被服务器监听之下的那种地址就叫监听地址, 该地址的格式会因为具体特定的相应不同协议簇存在不尽相同的状况呢若你想要知道详尽情况的话, 那就务必要去参阅 模块的系列文档方可透彻理解详情了。针对于互联网协议而言的情形下, 这样的地址将会是一种元组, 此元组之中会包含着一个用来表示地址的字符串, 以及单独一个用来表示端口号的整数, 举个例子来说吧: (127.0.0.1, 80)。将由服务器用于监听入站请求的套接字对象。服务器类支持下列类变量服务器可不可以允许地址进行重复使用呢, 其默认的数值是 , 而且能够在子类里面进行设置以便更改策略。请求队列所具有的长度, 要是处理单个请求需耗费很长的时间, 那么当服务器处于忙碌状态时抵达的任何请求都会被添加到队列之中最多能够添加若干个请求, 一旦队列被填满, 来自客户端的更多请求将会收到相应错误, 其默认值是5, 不过能够在子类里进行重载。服务器使用的套接字类型常见的有 和 这两个值。以秒数来表示超时限制, 或者呢假设无相应时限, 那此值便为。要是 , 在超时限制这个期限以内都没接收到传入请求的话, 那么就会去调用 方法。存在多个服务器方法, 这些方法能够被服务器基类的子类进行重载, 比如说, 存在这样的子类, 这些方法对于服务器对象的外部用户而言, 是没有用处的。(, )通过实例化 并调用其 方法来实际处理请求。()得要接纳源自套接字的请求, 接着返回一个二元组, 这个二元组里装有可用于跟客户端通信刚产生的套接字对象, 还有客户端的地址。(, )此函数会在实例的方法引发异常之际被调用, 默认行为是把回溯信息打印到标准错误且继续处理其他请求。在3.6版本出现了变更, 此变更为, 如今仅在针对派生自类的异常情况时, 才会调用这个方法。()此函数, 会在此时, 属性, 被设为, 以外, 的值, 并且, 在, 超出, 时限, 之后, 仍未, 收到, 请求, 时, 被调用句号分又服务器, 的, 默认, 行为, 是, 收集, 任何, 已退出, 的, 子进程, 状态, 而在线程服务器, 中, 此方法, 则不做, 任何, 操作句号。(, )调用, 用以创建, 其实例。若有需此函数能够创建一个全新的进程, 或者线程, 用以处理请求, 和类可达成此任务。()服务器的激活, 是通过服务器的构造器进行调用达成的。TCP 服务器它的默认行为, 仅仅是在服务器的套接字之上启动调用行为。它具备可以被重载的这样一种特性。()可由服务器的构造器进行调用, 目的在于将套接字绑定到所需的地址, 此行为能够被重载。(, )只能要返回来一个布尔类型的数值才行呐一旦这个数值是这样的情况时, 那相关的请求就会被着手处理起来。然而若这个数值变成了另外一种情形时, 那相应的请求就将会被予以拒绝掉。 这个函数能够凭借被多重加载的方式去达成对于服务器的访问方面的控制目的。它默认的那种实现情况一直都是返回 True 这个结果。3.6版本有变更, 添加了对协议的支持, 退出上下文管理器与调用等效。请求处理器对象.这是超类, 是所有请求处理器对象的。它定义 了接口, 是下文列出的。一个子类是实体请求处理器, 必须定义方法, 是新的, 并且可重载方法, 是任何其他的。针对每个请求, 都会创建实例, 是一个新的子类的。setup()会在方法早先, 被调用从而去执行任何必备的初始化行为, 默认的实现不会执行任何行动。()此函数得非得去执行那满足为请求予以服务所必需的全部各种操作才行。那默认的实现做法是不会去执行任何操作这般情况的。它存在那么几个属于能够被使用的实例属性呢请求是这样一种情况为 客户端与之对应的所要涉及到的地址是为 服务器所对应的实例作为是为 , 就是在假设它倘若有存在需要去访问特定服务器相关的那些信息的这种状况的时候。面临数据报或者流服务的, 类型存在差异。面向流服务, 是某个套接字对象针对数据报服务, 是一组字符串以及套接字。()调用在那方法之后, 用以去执行任何所需的清理操作, 默认的实现并不执行任何操作, 要是引发了异常, 此函数将不会被调用。将被用于同客户端通信的 新 对象。所返回的客户端地址。用于处理请求的 对象。..er这些 子类重载了 和 方法并提供了 和 属性。rfile用于读取所接受请求的文件对象。支持 可读接口。wfile用于写入所回复内容的文件对象。支持 可写接口。在 3.6 版本发生变更: 也支持 可写接口。例子示例以下是服务端:import socketserver class MyTCPHandler(socketserver.BaseRequestHandler): The request handler class for our server. It is instantiated once per connection to the server, and must override the handle() method to implement communication to the client. def handle(self): # self.request 是连接到客户端的 TCP 套接字 pieces [b] total 0 while b\n not in pieces[-1] and total 10_000: pieces.append(self.request.recv(2000)) total len(pieces[-1]) self.data b.join(pieces) print(fReceived from {self.client_address[0]}:) print(self.data.decode(utf-8)) # 发回同样的数据但转为大写形式 self.request.sendall(self.data.upper()) # 在我们返回后套接字将被关闭。 if __name__ __main__: HOST, PORT localhost, 9999 # 创建服务器绑定到 localhost 的 9999 端口 with socketserver.TCPServer((HOST, PORT), MyTCPHandler) as server: # 激活服务器它将持续运行直到你 # 使用 Ctrl-C 中断程序 server.serve_forever()一个替代请求处理器类, 它使用流, 这个流是通过提供标准文件接口来简化通信的、属于文件型的对象。class MyTCPHandler(socketserver.StreamRequestHandler): def handle(self): # self.rfile 是由该处理器创建的文件型对象。 # 我们现在可以使用 readline() 代替原始 recv() 调用 # 我们自己限制为 10000 字节以避免被发送方滥用。 self.data self.rfile.readline(10000).rstrip() print(f{self.client_address[0]} wrote:) print(self.data.decode(utf-8)) # 类似地self.wfile 是用于写回到客户端的 # 文件型对象 self.wfile.write(self.data.upper())其不同之处在于, 在第二个处理器里的()调用, 会多次去调用recv(), 一直到碰到一个换行符才停止, 然而第一个处理器得借助一个recv()循环, 来积累数据, 直至碰到一个换行符。要是它仅仅使用一个不带循环的recv(), 那只会返回当下已经从客户端接收到的内容。TCP是基于流的数据会按照其发送的顺序抵达, 不过在客户端send() 或()调用与服务端接收它所需要的recv()调用次数之间, 不存在关联。以下是客户端:import socket import sys HOST, PORT localhost, 9999 data .join(sys.argv[1:]) # 创建一个套接字 (SOCK_STREAM 表示一个 TCP 套接字) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock: # 连接到服务器并发送数据 sock.connect((HOST, PORT)) sock.sendall(bytes(data, utf-8)) sock.sendall(b\n) # 从服务器接收数据并关闭 received str(sock.recv(1024), utf-8) print(Sent: , data) print(Received:, received)这个示例程序的输出应该是像这样的服务器$ python TCPServer.py 127.0.0.1 wrote: bhello world with TCP 127.0.0.1 wrote: bpython is nice客户端$ python TCPClient.py hello world with TCP Sent: hello world with TCP Received: HELLO WORLD WITH TCP $ python TCPClient.py python is nice Sent: python is nice Received: PYTHON IS NICE示例以下是服务端:import socketserver class MyUDPHandler(socketserver.BaseRequestHandler): This class works similar to the TCP handler class, except that self.request consists of a pair of data and client socket, and since there is no connection the client address must be given explicitly when sending data back via sendto(). def handle(self): data self.request[0].strip() socket self.request[1] print(f{self.client_address[0]} wrote:) print(data) socket.sendto(data.upper(), self.client_address) if __name__ __main__: HOST, PORT localhost, 9999 with socketserver.UDPServer((HOST, PORT), MyUDPHandler) as server: server.serve_forever()以下是客户端:import socket import sys HOST, PORT localhost, 9999 data .join(sys.argv[1:]) # SOCK_DGRAM 是用于 UDP 套接字的套接字类型 sock socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 如你所见没有 connect() 调用UDP 没有连接。 # 数据是通过 sendto() 直接发给接收方的。 sock.sendto(bytes(data \n, utf-8), (HOST, PORT)) received str(sock.recv(1024), utf-8) print(Sent: , data) print(Received:, received)这个示例程序的输出应该是与 TCP 服务器示例相一致的。异步混合类要构建异步处理器请使用 和 类。类的示例:import socket import threading import socketserver class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler): def handle(self): data str(self.request.recv(1024), ascii) cur_thread threading.current_thread() response bytes({}: {}.format(cur_thread.name, data), ascii) self.request.sendall(response) class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer): pass def client(ip, port, message): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock: sock.connect((ip, port)) sock.sendall(bytes(message, ascii)) response str(sock.recv(1024), ascii) print(Received: {}.format(response)) if __name__ __main__: # 端口 0 表示选择任意一个未使用的端口 HOST, PORT localhost, 0 server ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler) with server: ip, port server.server_address # 启动一个服务器线程 -- 该线程将在此后 # 为每个请求再启动一个线程 server_thread threading.Thread(targetserver.serve_forever) # 在主线程终结时退出服务器线程 server_thread.daemon True server_thread.start() print(Server loop running in thread:, server_thread.name) client(ip, port, Hello World 1) client(ip, port, Hello World 2) client(ip, port, Hello World 3) server.shutdown()这个示例程序的输出应该是像这样的$ python ThreadedTCPServer.py Server loop running in thread: Thread-1 Received: Thread-2: Hello World 1 Received: Thread-3: Hello World 2 Received: Thread-4: Hello World 3类的运用方式是一样的, 不同之处在于服务器会针对每个请求生成一个全新的进程, 并且只在支持的POSIX系统平台上才能够使用。 用于网络服务器的框架
不管服务器类采用何种网络协议, 其体现出的外部方法都归于相同范畴, 并且外部属性也同样归于相同范畴。服务器创建的说明在继承图中有五个类其中四个代表四种类型的同步服务器:------------ | BaseServer | ------------ | v ----------- ------------------ | TCPServer |-------| UnixStreamServer | ----------- ------------------ | v ----------- -------------------- | UDPServer |-------| UnixDatagramServer | ----------- --------------------要留意, 是从……派生而来, 并非从……派生而来 --- IP与Unix服务器仅有的差别是地址族。..可以使用这些混合类来创建每种服务器类型的分叉版本, 也可以使用这些混合类来创建每种服务器类型的线程版本。例如, 如下是其创建方式。class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass先是混合类出现, 这缘由于它对在其中定义的一个方法进行了重载。设置各类属性, 其也会使得下层服务器机制的行为发生改变。跟下文所讲到的分叉类别, 仅仅是在对其予以支持的POSIX系统平台范围之内才能够使用。会等待直到所有子进程完成除非 属性为 False。会等待直到所有非守护线程完成除非 属性为 False。确定要设定的与此同时处置请求的子进程数量, 要是达到了这般限定, 那新的请求就会等候着, 直至有某个子进程终结。能够通过把它设为 True 来运用守护线程, 进而不需要等待线程结束, 对于这样的情况。3.7 版本出现变更, 和, 如今会等候直至所有子进程以及非守护线程完结, 新增了一个类属性用以挑选 3.7 版以前的行为。.....ver.erver.erver.这些类都是使用混合类来预定义的。在3.12中添加的内容为: 增添了ver类、erver类。欲达成一项服务, 你得自某类派生一个类, 重新定义其相关方法。而后, 你能够凭借将某种服务器类型与你的请求处理器类相结合, 去运行各类版本的服务。对于请求处理器类而言, 针对数据报服务和流服务必定是不一样的。此情形可借由运用处理器子类或者其他方式予以隐匿。当然, 你依旧得费点心思比如说, 要是服务涵盖那种会被各异请求改动的内存状态, 那选用分叉服务器就没什么道理, 因为于子进程里所做的修改, 永远都没法影响到保存在父进程中的初始状态, 也无法传递至各个子进程。在这种情形下, 你能够采用线程服务器, 不过你或许得借助锁来保障共享数据的一致性。然而, 换个情形来讲下, 要是你正着手编写一个需要将全部数据存储于外部像是文件系统这般的HTTP服务器, 那么此时同步类实际上会在处理某一个请求的阶段“变聋”, 就是说, 倘若有某个客户端在接收其请求的所有相关数据之际速度极为迟缓, 这迟缓的时长可能会是相当漫长的, 在这种情形下, 线程或者分叉服务器会更适宜被采用。当处于某些情形时, 恰当的做法乃是同步地处置请求的一部分, 然而要依据请求数据于分叉产生的子进程里达成处理。此情形得以借助运用同步服务器并于请求处理器类当中做显式分叉予以达成。在一种环境里, 该环境既不支持线程, 对于本服务而言, 这两者的开销还过大或者不适用此时存在另一种处理多个同时请求的方式, 那就是维护一张显式的部分完成的请求表, 接着通过某种动作来决定后续要处理哪个请求或者究竟是否要处理一个新传入的请求。另外, 这对于流式服务来讲尤为重要, 因为万一不能使用线程或子进程, 每个客户端有可能连接很长的时长。对象.(, )这般模样乃是于本模块里头所有具备性质的对象所从属的超类别, 这类超类别对下文陈列出来的接口实施了定义, 然而却并未将大部分的方法予以落实, 那些方法应当在子类别当中去达成, 两个具备形态属性参数的, 所留存的位置处在与之相对的属性以及属性这个状态之中。()让返回的文件描述符, 那是以整数形式呈现的、服务器正在监听的套接字的, 该函数常常被传递给, 为了能够在同一个进程里对多个服务器进行监控。()去处理单独一个请求, 存在这样一个函数, 它会依照次序逐个去调用下面列举这类的方法。倘若用户所给予的处理器类之中相应特定一个的方法引发了异常状况, 那么就会调用服务器给定的那个方法。要是在规定相应时间之中没有接收到请求, 便将会依照要求做出具体执行和呈现内容那样的被调将会返回。(0.5)对请求予以处理直到接收到显式的请求, 每隔一定秒数对特定对象进行轮询, 忽略某属性, 它还会调用某个操作, 这能被子类或者混合类用以提供某个给定服务专有的操作, 举例来说, 某类使用特定方法来清理僵尸子进程。在 3.3 版本发生变更: 将 调用添加到 方法。()在循环里, 此方法会被调用, 此方法能够被子类或者混合类进行重载, 以此去执行某个给定服务的专属操作, 像清理操作这种的。()要通知, 循环得停止并等待其完成。必须在它运行于不同线程时被调用那种特定的情况之时调用才行, 否则就将会发生死锁。()清理服务器。此方法可被重载。为服务器套接字赋予所属协议族, 存在着一些常见示例呀 , 像是这样的和那样的等。倘若你有着获取IPv6服务器类的需求 , 那就得对这个模块里的TCP或UDP服务器类进行子类化操作 , 并且还要设置类属性等于这个呢。用户提供的请求处理器类将为每个请求创建该类的实例。被服务器监听之下的那种地址就叫监听地址, 该地址的格式会因为具体特定的相应不同协议簇存在不尽相同的状况呢若你想要知道详尽情况的话, 那就务必要去参阅 模块的系列文档方可透彻理解详情了。针对于互联网协议而言的情形下, 这样的地址将会是一种元组, 此元组之中会包含着一个用来表示地址的字符串, 以及单独一个用来表示端口号的整数, 举个例子来说吧: (127.0.0.1, 80)。将由服务器用于监听入站请求的套接字对象。服务器类支持下列类变量服务器可不可以允许地址进行重复使用呢, 其默认的数值是 , 而且能够在子类里面进行设置以便更改策略。请求队列所具有的长度, 要是处理单个请求需耗费很长的时间, 那么当服务器处于忙碌状态时抵达的任何请求都会被添加到队列之中最多能够添加若干个请求, 一旦队列被填满, 来自客户端的更多请求将会收到相应错误, 其默认值是5, 不过能够在子类里进行重载。服务器使用的套接字类型常见的有 和 这两个值。以秒数来表示超时限制, 或者呢假设无相应时限, 那此值便为。要是 , 在超时限制这个期限以内都没接收到传入请求的话, 那么就会去调用 方法。存在多个服务器方法, 这些方法能够被服务器基类的子类进行重载, 比如说, 存在这样的子类, 这些方法对于服务器对象的外部用户而言, 是没有用处的。(, )通过实例化 并调用其 方法来实际处理请求。()得要接纳源自套接字的请求, 接着返回一个二元组, 这个二元组里装有可用于跟客户端通信刚产生的套接字对象, 还有客户端的地址。(, )此函数会在实例的方法引发异常之际被调用, 默认行为是把回溯信息打印到标准错误且继续处理其他请求。在3.6版本出现了变更, 此变更为, 如今仅在针对派生自类的异常情况时, 才会调用这个方法。()此函数, 会在此时, 属性, 被设为, 以外, 的值, 并且, 在, 超出, 时限, 之后, 仍未, 收到, 请求, 时, 被调用句号分又服务器, 的, 默认, 行为, 是, 收集, 任何, 已退出, 的, 子进程, 状态, 而在线程服务器, 中, 此方法, 则不做, 任何, 操作句号。(, )调用, 用以创建, 其实例。若有需此函数能够创建一个全新的进程, 或者线程, 用以处理请求, 和类可达成此任务。()服务器的激活, 是通过服务器的构造器进行调用达成的。TCP 服务器它的默认行为, 仅仅是在服务器的套接字之上启动调用行为。它具备可以被重载的这样一种特性。()可由服务器的构造器进行调用, 目的在于将套接字绑定到所需的地址, 此行为能够被重载。(, )只能要返回来一个布尔类型的数值才行呐一旦这个数值是这样的情况时, 那相关的请求就会被着手处理起来。然而若这个数值变成了另外一种情形时, 那相应的请求就将会被予以拒绝掉。 这个函数能够凭借被多重加载的方式去达成对于服务器的访问方面的控制目的。它默认的那种实现情况一直都是返回 True 这个结果。3.6版本有变更, 添加了对协议的支持, 退出上下文管理器与调用等效。请求处理器对象.这是超类, 是所有请求处理器对象的。它定义 了接口, 是下文列出的。一个子类是实体请求处理器, 必须定义方法, 是新的, 并且可重载方法, 是任何其他的。针对每个请求, 都会创建实例, 是一个新的子类的。setup()会在方法早先, 被调用从而去执行任何必备的初始化行为, 默认的实现不会执行任何行动。()此函数得非得去执行那满足为请求予以服务所必需的全部各种操作才行。那默认的实现做法是不会去执行任何操作这般情况的。它存在那么几个属于能够被使用的实例属性呢请求是这样一种情况为 客户端与之对应的所要涉及到的地址是为 服务器所对应的实例作为是为 , 就是在假设它倘若有存在需要去访问特定服务器相关的那些信息的这种状况的时候。面临数据报或者流服务的, 类型存在差异。面向流服务, 是某个套接字对象针对数据报服务, 是一组字符串以及套接字。()调用在那方法之后, 用以去执行任何所需的清理操作, 默认的实现并不执行任何操作, 要是引发了异常, 此函数将不会被调用。将被用于同客户端通信的 新 对象。所返回的客户端地址。用于处理请求的 对象。..er这些 子类重载了 和 方法并提供了 和 属性。rfile用于读取所接受请求的文件对象。支持 可读接口。wfile用于写入所回复内容的文件对象。支持 可写接口。在 3.6 版本发生变更: 也支持 可写接口。例子示例以下是服务端:import socketserver class MyTCPHandler(socketserver.BaseRequestHandler): The request handler class for our server. It is instantiated once per connection to the server, and must override the handle() method to implement communication to the client. def handle(self): # self.request 是连接到客户端的 TCP 套接字 pieces [b] total 0 while b\n not in pieces[-1] and total 10_000: pieces.append(self.request.recv(2000)) total len(pieces[-1]) self.data b.join(pieces) print(fReceived from {self.client_address[0]}:) print(self.data.decode(utf-8)) # 发回同样的数据但转为大写形式 self.request.sendall(self.data.upper()) # 在我们返回后套接字将被关闭。 if __name__ __main__: HOST, PORT localhost, 9999 # 创建服务器绑定到 localhost 的 9999 端口 with socketserver.TCPServer((HOST, PORT), MyTCPHandler) as server: # 激活服务器它将持续运行直到你 # 使用 Ctrl-C 中断程序 server.serve_forever()一个替代请求处理器类, 它使用流, 这个流是通过提供标准文件接口来简化通信的、属于文件型的对象。class MyTCPHandler(socketserver.StreamRequestHandler): def handle(self): # self.rfile 是由该处理器创建的文件型对象。 # 我们现在可以使用 readline() 代替原始 recv() 调用 # 我们自己限制为 10000 字节以避免被发送方滥用。 self.data self.rfile.readline(10000).rstrip() print(f{self.client_address[0]} wrote:) print(self.data.decode(utf-8)) # 类似地self.wfile 是用于写回到客户端的 # 文件型对象 self.wfile.write(self.data.upper())其不同之处在于, 在第二个处理器里的()调用, 会多次去调用recv(), 一直到碰到一个换行符才停止, 然而第一个处理器得借助一个recv()循环, 来积累数据, 直至碰到一个换行符。要是它仅仅使用一个不带循环的recv(), 那只会返回当下已经从客户端接收到的内容。TCP是基于流的数据会按照其发送的顺序抵达, 不过在客户端send() 或()调用与服务端接收它所需要的recv()调用次数之间, 不存在关联。以下是客户端:import socket import sys HOST, PORT localhost, 9999 data .join(sys.argv[1:]) # 创建一个套接字 (SOCK_STREAM 表示一个 TCP 套接字) with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock: # 连接到服务器并发送数据 sock.connect((HOST, PORT)) sock.sendall(bytes(data, utf-8)) sock.sendall(b\n) # 从服务器接收数据并关闭 received str(sock.recv(1024), utf-8) print(Sent: , data) print(Received:, received)这个示例程序的输出应该是像这样的服务器$ python TCPServer.py 127.0.0.1 wrote: bhello world with TCP 127.0.0.1 wrote: bpython is nice客户端$ python TCPClient.py hello world with TCP Sent: hello world with TCP Received: HELLO WORLD WITH TCP $ python TCPClient.py python is nice Sent: python is nice Received: PYTHON IS NICE示例以下是服务端:import socketserver class MyUDPHandler(socketserver.BaseRequestHandler): This class works similar to the TCP handler class, except that self.request consists of a pair of data and client socket, and since there is no connection the client address must be given explicitly when sending data back via sendto(). def handle(self): data self.request[0].strip() socket self.request[1] print(f{self.client_address[0]} wrote:) print(data) socket.sendto(data.upper(), self.client_address) if __name__ __main__: HOST, PORT localhost, 9999 with socketserver.UDPServer((HOST, PORT), MyUDPHandler) as server: server.serve_forever()以下是客户端:import socket import sys HOST, PORT localhost, 9999 data .join(sys.argv[1:]) # SOCK_DGRAM 是用于 UDP 套接字的套接字类型 sock socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 如你所见没有 connect() 调用UDP 没有连接。 # 数据是通过 sendto() 直接发给接收方的。 sock.sendto(bytes(data \n, utf-8), (HOST, PORT)) received str(sock.recv(1024), utf-8) print(Sent: , data) print(Received:, received)这个示例程序的输出应该是与 TCP 服务器示例相一致的。异步混合类要构建异步处理器请使用 和 类。类的示例:import socket import threading import socketserver class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler): def handle(self): data str(self.request.recv(1024), ascii) cur_thread threading.current_thread() response bytes({}: {}.format(cur_thread.name, data), ascii) self.request.sendall(response) class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer): pass def client(ip, port, message): with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock: sock.connect((ip, port)) sock.sendall(bytes(message, ascii)) response str(sock.recv(1024), ascii) print(Received: {}.format(response)) if __name__ __main__: # 端口 0 表示选择任意一个未使用的端口 HOST, PORT localhost, 0 server ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler) with server: ip, port server.server_address # 启动一个服务器线程 -- 该线程将在此后 # 为每个请求再启动一个线程 server_thread threading.Thread(targetserver.serve_forever) # 在主线程终结时退出服务器线程 server_thread.daemon True server_thread.start() print(Server loop running in thread:, server_thread.name) client(ip, port, Hello World 1) client(ip, port, Hello World 2) client(ip, port, Hello World 3) server.shutdown()这个示例程序的输出应该是像这样的$ python ThreadedTCPServer.py Server loop running in thread: Thread-1 Received: Thread-2: Hello World 1 Received: Thread-3: Hello World 2 Received: Thread-4: Hello World 3类的运用方式是一样的, 不同之处在于服务器会针对每个请求生成一个全新的进程, 并且只在支持的POSIX系统平台上才能够使用。