python网络编程

在开始python网络编程之前，首先要了解一下套接字，套接字是一种计算机网络数据结构。套接字有两种，分别是基于文件型的和基于网络型的，前者如AF_UNIX，后者如AF_INET、AF_NETLINK。套接字端口就像电话号码一样，是通讯身份的唯一标识，合法的端口号范围为0到65535，其中，小于1024的端口号为系统保留端口，如果是Unix操作系统，保留的端口号使用可以通过/etc/services文件获得。

套接字的类型有两种，面向连接的套接字与无连接的套接字。前者提供了顺序的、可靠的、不会重复的数据传输，而且也不会加上数据边界，每一个要发送的信息，可能会被拆成多份，实现这种连接的主要协议就是传输控制协议TCP，套接字类型为SOCK_STREAM，使用IP来查找网络中的主机，这样就形成了整个系统。无连接的套接字，数据到达的顺序、可靠性及数据不重复性无法保证，数据报会保留数据边界，发送消息时不会拆成小块，虽有这么多缺点，但正是无连接的，所以不需要承担维持虚电路连接的负担，性能更好，实现这种连接的主要协议是用户数据报协议UDP，套接字类型为SOCK_DGRAM，也是通过IP来查找网络中的主机。

python网络编程使用socket模块，创建套接字用其socket()函数，语法如下：
socket(socket_family, socket_type, protocol = 0)
socket_family可以是AF_UNIX或AF_INET，socket_type可以是SOCK_STREAM或SOCK_DGRAM，protocol一般不写，默认为0。

当我们创建了套接字以后，所有的交互都将通过对该套接字对象的方法调用进行，下面列举一些套接字对象的常用函数。
服务器端——
bind()：绑定地址到套接字。
listen()：开始TCP监听。
accept()：被动接受TCP客户的连接，阻塞式等待连接的到来。
客户端——
connect()：主动初始化TCP服务器连接。
connect_ex()：上一个函数的扩展版本，出错时返回出错码，而不是抛出异常。
公共用途——
recv()：接收TCP数据。
send()：发送TCP数据。
sendall()：完整发送TCP数据。
recvfrom()：接收UDP数据。
sendto()：发送UDP数据。
getpeername()：连接到当前套接字的远端的地址。
getsockname()：当前套接字的地址。
getsockopt()：返回指定套接字的参数。
setsockopt()：设置指定套接字的参数。
close()：关闭套接字。
阻塞相关——
setblocking()：设置套接字的阻塞与非阻塞模式。
settimeout()：设置阻塞套接字操作的超时时间。
gettimetout()：得到阻塞套接字操作的超时时间。
面向文件——
fileno()：套接字的文件描述符。
makefile()：创建一个与该套接字关联的文件。

下面是TCP服务器的伪代码——

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

下面是TCP客户端的伪代码——

cs = socket()#创建客户套接字
cs.connect()#尝试连接服务器
comm_loop:#通讯循环
    cs.send()/cs.recv ()#对话，发送与接收
cs.close()#关闭客户套接字

下面以一个简单的例子作为介绍，服务器、客户端在同一台机子上，服务器充当时间戳的角色，客户端发送数据后返回一个带时间的相同数据。
TimeServer.py——

#!/usr/bin/env python 

from socket import * 
from time import ctime 

HOST = ‘‘ # any available 
PORT = 21567 # unused 
BUFSIZE = 1024 
ADDR = (HOST, PORT) 

tcpSerSock = socket(AF_INET, SOCK_STREAM) 
tcpSerSock.bind(ADDR) 
tcpSerSock.listen(5) # max concurrence access 

while True: 
    print ‘waiting for connection...‘ 
    tcpCliSock, addr = tcpSerSock.accept() # blocking and passive 
    print ‘...connected from: ‘, addr 

    while True: 
        data = tcpCliSock.recv(BUFSIZE) 
        if not data: 
            break 
        tcpCliSock.send(‘[%s] %s‘ %(ctime(), data) )

    tcpCliSock.close() 

tcpSerSock.close() # optional and never exec

TimeClient.py——

#!/usr/bin/env python 

from socket import * 

HOST = ‘localhost‘ # local host 
PORT = 21567 # the same port as the server 
BUFSIZE = 1024 
ADDR = (HOST, PORT) 

tc#!/usr/bin/env python 

from socket import * 
pCliSock = socket(AF_INET, SOCK_STREAM) 
tcpCliSock.connect(ADDR) 

while True: 
    data = raw_input(‘> ‘) 
    if not data: 
        break 
    tcpCliSock.send(data) 
    data = tcpCliSock.recv(BUFSIZE) 
    if not data: 
        break 
    print data 

tcpCliSock.close()

UDP相对TCP来说比较简单，因为是无连接的，所以服务端不需要listen和accept，客户端也不需要connect。
下面是UDP服务器的伪代码——

ss = socket()
ss.bind()#把地址绑定到套接字上
inf_loop:#服务器无限循环
    cs.recvfrom()/cs.sendto()#对话，接收与发送
ss.close()#关闭服务器套接字，可选

下面是UDP客户端的伪代码——

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

SocketServer模块是一个基于socket模块的高级别的套接字通讯模块，它支持在新的线程或进程中处理客户的请求。这个模块是标准库中一个高级别的模块，用于简化网络客户与服务器的实现，模块中已经实现了一些可供使用的类。下面用SocketServer实现上面的例子，即时间戳服务器。
timeSSSer.py——

#!/usr/bin/env python 

from SocketServer import (TCPServer as TCP, StreamRequestHandler as SRH) 
from time import ctime 

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

class MyRequestHandler(SRH): 
    def handler(self): 
        print ‘... connected from:‘, self.client_address 
        self.wfile.write(‘[%s] %s‘) %(ctime(), self.rfile.readline()) 

tcpServ = TCP(ADDR, MyRequestHandler) 
print ‘waiting for connection...‘ 
tcpServ.serve_forever()

timeSSCli.py——

#!/usr/bin/env python 

from socket import * 

HOST = ‘localhost‘ 
PORT = 21567 
BUFSIZE = 1024 
ADDR = (HOST, PORT) 

while True: 
    tcpCliSock = socket(AF_INET, SOCK_STREAM) # socket every time 
    tcpCliSock.connect(ADDR) 
    data = raw_input(‘> ‘) 
    if not data: 
        break 
    tcpCliSock.send(‘%s\r\n‘ %data) 
    data = tcpCliSock.recv(BUFSIZE) 
    if not data: 
        break 
    print data.strip() 
    tcpCliSock.close()

其它——
twisted模块是一个完全事件驱动的网络框架，可以用来开发完全异布的网络应用程序和协议，创建一个完整的系统，系统中可以有网络协议、线程、安全认证、即时通讯、数据库管理、网页、电子邮件、命令行参数、图形界面集成等。下面使用twisted模块实现上面例子中同样的功能。
timeTSSer.py——

#!/usr/bin/env python 

from twisted.internet import protocol, reactor 
from time import ctime 

PORT = 21567 

class TSServProtocol(protocol.Protocol): 
    def connectionMade(self): 
        self.clnt = self.transport.getPeer().host 
        print ‘...connected from:‘, self.clnt 
    def dataReceived(self, data): 
        print ‘...received from [%s]\n\t%s‘ %(self.clnt, data) 
        self.transport.write(‘[%s] %s‘ %(ctime(), data)) 

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

timeTSCli.py——

#!/usr/bin/env python 

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(data) 
        else: 
            self.transport.loseConnection() 

    def connectionMade(self): 
        self.sendData() 

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

factory = protocol.ClientFactory() 
factory.protocol = TSClntProtocol 
reactor.connectTCP(HOST, PORT, factory) 
reactor.run()

asyncore/asynchat模块，为能异步处理客户请求的网络应用程序提供底层功能。
select模块，在单线程网络服务器程序中，管理多个套接字连接。