12、Python-网络编程

1、套接字
1.1 socket模块
套接字是网络编程中的一个基本组件，一般包括服务器端套接字和客户端套接字。

创建服务器端过程如下：

 import socket

 s = socket.socket()

 host = socket.gethostname()
 port = 1234
 try:
     s.bind((host, port))
 except Exception, e:
     print e
     s.close()

 s.listen(5)
 while True:
     c, addr = s.accept()
     print 'Got connection from', addr
     c.send('Thank you for connecting')
 c.close()

创建客户端过程如下：

 import socket, time

 s = socket.socket()

 host = socket.gethostname()
 port = 1234

 s.connect((host, port))
 print s.recv(1024)
 while True:
     command = 'hello\n'
     s.send(command)
 time.sleep(1)

该过程的通讯方式是一问一答的形式，所以又称为阻塞或者同步网络编程。
1.2 SocketServer和它的朋友们
　　SocketServer模块是标准库中很多服务器框架的基础，这些服务器框架包括BaseHTTPServer、SimpleHTTPServer、CGIHTTPServer、SimpleXMLRPCServer和DocXMLRPCServer，所有的这些服务器框架都为基础服务器增加了特定的功能。
　　SocketServer包含4个基本的类：针对TCP套接字流的TCPServer；针对UDP数据报套接字的UDPServer；以及针对性不强的UnixStreamServer和UnixDatagramServer。
　　在使用SocketServer服务器框架时，每当服务器收到一个请求，就会实例化一个请求处理程序，并且它的各种处理方法（handler methods）会在处理请求时被调用。基本的BaseRequestHandler类把所有的操作都放到了处理器的一个叫做handle的方法中，这个方法会被服务器调用。然后在这个方法内就可以访问属性self.request中的客户端套接字。如果使用的是流（TCPServer），那么可以使用StreamRequestHandler类，创建它的两个属性，self.rfile（用于读取）和self.wfile（用于写入）。

 from SocketServer import TCPServer, StreamRequestHandler

 class Handler(StreamRequestHandler):

     def handle(self):
         addr = self.request.getpeername()

         print 'Got connection from', addr
         self.wfile.write('Thank you for connecting')
 server = TCPServer(('', 1234), Handler)
 server.serve_forever()

2、多连接
　　同时可以有多个客户机连接服务端进行请求处理。有3个主要的方法能实现这个目的：分叉（forking）、线程（threading）以及异步I/O（asynchronous I/O）。它们有各自的缺点：分叉占资源，如果有太多的客户端时，分叉不能很好地分叉；线程处理能导致同步问题。
　　什么是分叉：当分叉一个进程（一个运行的程序）时，基本上是复制了它，并且分叉后的两个进程都从当前的执行点继续运行，并且每个进程都有自己的内存副本（比如变量）。一个进程（原来的那个）成为父进程，另一个（复制的）成为子进程。因为分叉的进程是并行运行的，客户端之间不必相互等待。但分叉有点消耗资源（每个分叉出来的进程都需要自己的内存），这就存在了另一个选择：线程。
　　什么是线程：线程是轻量级的进程或子进程，所有的线程都存在于相同的（真正的）进程中，共享内存。资源消耗的下降伴随着一个缺陷：因为线程共享内存，所以必须确保它们的变量不会冲突，或者是在同一时间修改同一内容，这就会造成混乱。
使用SocketServer框架创建分叉或者线程服务器太简单了，几乎不需要解释。注意，Windows不支持分叉。
使用分叉技术的服务器：

 from SocketServer import TCPServer, ForkingMixIn, StreamRequestHandler

 class Server(ForkingMixIn, TCPServer): pass

 class Handler(StreamRequestHandler):

     def handle(self):
         addr = self.request.getpeername()
         print 'Got connection from', addr
         self.wfile.write('Thank you for connecting')

 server = Server(('', 1234), Handler)
 server.serve_forever()

使用线程处理的服务器：

from SocketServer import TCPServer, ThreadingMixIn, StreamRequestHandler

class Server(ThreadingMixIn, TCPServer): pass

class Handler(StreamRequestHandler):

    def handle(self):
        addr = self.request.getpeername()
        print 'Got connection from', addr
        self.wfile.write('Thank you for connecting')

server = Server(('', 1234), Handler)
server.serve_forever()

　　什么是异步I/O：当一个服务器与一个客户端通信时，来自客户端的数据可能是不连续的。如果使用分叉或线程处理，那就不是问题。当一个程序在等待数据，另一个并行的程序可以继续处理它们自己的客户端。另外的处理方法是只处理在给定时间内真正要进行通信的客户端。
　　这是asyncore/asynchat框架采用的方法，这种功能的基础是select函数，如果poll函数可用，那也可以是它，这两个函数都来自select模块。其中poll函数的伸缩性要更好，但只能用在UNIX系统中。
　　Select函数有3个序列作为它的必选参数，还有一个可选的超时时间作为第4个参数。这3个序列是套接字文件描述符，用于输入、输出以及异常情况。如果没有给定超时时间，select会阻塞，处于等待状态，直到一个文件描述符已经为行动做好了准备；如果给定超时时间，select最多阻塞给定的超时时间；如果给定的超时时间是0，select就不阻塞。Select的返回值是3个序列，一个长度为3的元组，每个代表相应参数的一个活动子集。

 import socket, select

 s = socket.socket()

 host = socket.gethostname()
 port = 1234
 s.bind((host, port))

 s.listen(5)
 inputs = [s]
 while True:
     rs, ws, es = select.select(inputs, [], [])
     for r in rs:
         if r is s:
             c, addr = s.accept()
             print 'Got connection from', addr
             inputs.append(c)
         else:
             try:
                 data = r.recv(1024)
                 disconnected = not data
             except socket.error:
                 disconnected = True
             if disconnected:
                 print r.getpeername(), 'disconnected'
                 inputs.remove(r)
             else:
                 print data

　　poll方法使用起来比select简单。在调用poll时，会得到一个poll对象。然后使用poll对象的register方法注册一个文件描述符（或者是带有fileno方法的对象）。注册后可以使用unregister方法移除注册的对象。注册完套接字对象之后可以调用poll方法（带有一个可选的超时时间参数）并得到一个（fd, event）格式列表（可能是空的），其中fd是文件描述符，event则告诉你发生了什么。event对象是一个位掩码，可以使用按位与操作来判断事件的类型.
select模块中的polling事件常量
事件名     　　  描述
POLLIN     　　读取来自文件描述符的数据
POLLPRI     　 读取来自文件描述符的紧急数据
POLLOUT     　文件描述符已经准备好数据，写入时不会发生阻塞
POLLERR        与文件描述符有关的错误情况
POLLHUP   　　挂起，连接丢失
POLLNVAL 　　无效请求，连接没有打开

 import socket, select

 s = socket.socket()

 host = socket.gethostname()
 port = 1234
 s.bind((host, port))

 fdmap = {s.fileno(): s}

 s.listen(5)
 p = select.poll()
 p.register(s)
 while True:
     events = p.poll()
     for fd, event in events:
         if fdmap[fd] is s:
             c, addr = s.accept()
             print 'Got connection from', addr
             p.register(c)
             fdmap[c.fileno()] = c
         elif event & select.POLLIN:
             data = fdmap[fd].recv(1024)
             if not data: # No data -- connection closed
                 print fdmap[fd].getpeername(), 'disconnected'
                 p.unregister(fd)
                 del fdmap[fd]
             else:
                 print data