python 网络编程
一、网络知识的一些介绍
socket是网络连接端点。例如当你的Web浏览器请求www.pythontik.com上的主页时,你的Web浏览器创建一个socket并命令它去连接www.pythontik.com的Web服务器主机,Web服务器也对来自的请求在一个socket上进行监听。两端使用各自的socket来发送和接收信息。
在使用的时候,每个socket都被绑定到一个特定的IP地址和端口。IP地址是一个由4个数组成的序列,这4个数均是范围0~255中的值(例如,220,176,36,76);端口数值的取值范围是0~65535。端口数小于1024的都是为众所周知的网络服务所保留的(例如Web服务使用的80端口);最大的保留数被存储在socket模块的IPPORT_RESERVED变量中。你也可以为你的程序使用另外的端口数值。
不是所有的IP地址都对世界的其它地方可见。实际上,一些是专门为那些非公共的地址所保留的(比如形如192.168.y.z或10.x.y.z)。地址127.0.0.1是本机地址;它始终指向当前的计算机。程序可以使用这个地址来连接运行在同一计算机上的其它程序。
IP地址不好记,你可以花点钱为特定的IP地址注册一个主机名或域名(比如使用www.pythontik.com代替222.76.216.16)。域名服务器(DNS)处理名字到IP地址的映射。每个计算机都可以有一个主机名,即使它没有在官方注册。
多少信息通过一个网络被传送基于许多因素,其中之一就是使用的协议。许多的协议是基于简单的、低级协议以形成一个协议栈。例如HTTP协议,它是用在Web浏览器与Web服务器之间通信的协议,它是基于TCP协议,而TCP协议又基于IP协议。
当在你自己的两个程序间传送信息的时候,你通常选择TCP或UDP协议。TCP协议在两端间建立一个持续的连接,并且你所发送的信息有保证的按顺序到达它们的目的地。UDP不建立连接,它的速度快但不可靠。你发送的信息也可能到不了另一端;或它们没有按顺序到达。有时候一个信息的多个复制到达接收端,即使你只发送了一次。
二、使用地址和主机名
socket模块提供了几个函数用于使用主机名和地址来工作。
gethostname()返回运行程序所在的计算机的主机名:
import socket
socket.gethostname()
'lenovo'
gethostbyname(name)尝试将给定的主机名解释为一个IP地址。首先将检查当前计算机是否能够解释。如果不能,一个解释请求将发送给一个远程的DNS服务器(远程的DNS服务器还可能将解释请求转发给另一个DNS服务器,直到该请求可以被处理)。gethostbyname函数返回这个IP地址或在查找失败后引发一个异常。
socket.gethostbyname('lenovo')
'192.168.1.4'
socket.gethostbyname('www.pythontik.com')
'222.76.216.16'
一个扩展的形式是gethostbyname_ex(name),它返回一个包含三个元素的元组,分别是给定地址的主要的主机名、同一IP地址的可选的主机名的一个列表、关于同一主机的同一接口的其它IP地址的一个列表(列表可能都是空的)。
socket.gethostbyname('www.163.com')
'60.191.81.49'
socket.gethostbyname_ex('www.163.com')
('www.cache.split.netease.com', ['www.163.com'], ['60.191.81.48', '60.191.81.49
, '60.191.81.50', '60.191.81.51', '60.191.81.52', '60.191.81.53', '60.191.81.54
, '220.181.28.50', '220.181.28.51', '220.181.28.52', '220.181.28.53', '220.181.
8.54', '220.181.31.182', '220.181.31.183', '220.181.31.184'])
gethostbyaddr(address)函数的作用与gethostbyname_ex相同,只是你提供给它的参数是一个IP地址字符串:
socket.gethostbyaddr('202.165.102.205')
('homepage.vip.cnb.yahoo.com', ['www.yahoo.com.cn'], ['202.165.102.205'])
getservbyname(service,protocol)函数要求一个服务名(如'telnet'或'ftp')和一个协议(如'tcp'或'udp'),返回服务所使用的端口号:
socket.getservbyname('http','tcp')
80
socket.getservbyname('telnet','tcp)
23
通常,非Python程序以32位字节包的形式存储和使用IP地址。inet_aton(ip_addr)和inet_ntoa(packed)函数在这个形式和IP地址间作转换:
socket.inet_aton('222.76.216.16')
'/xdeL/xd8/x10'
socket.inet_ntoa('/xdeL/xd8/x10')
'222.76.216.16'
socket也定义了一些变量来代表保留的IP地址。INADDR_ANY和INADDR_BROADCAST是被保留的IP地址分别代表任意IP地址和广播地址;INADDR_LOOPBACK代表loopback设备,总是地址127.0.0.1。这些变量是32位字节数字形式的。
getfqdn([name])函数返回关于给定主机名的全域名(如果省略,则返回本机的全域名)。
三、使用低级的socket通信
尽管Python提供了一些封装,使得使用socket更容易,但是你也可以直接使用socket来工作。
1、创建和销毁socket
socket模块中的socket(family,type[,proto])函数创建一个新的socket对象。family的取值通常是AF_INET。type的取值通常是SOCK_STREAM(用于定向的连接,可靠的TCP连接)或SOCK_DGRAM(用于UDP):
from socket import *
s=socket(AF_INET,SOCK_STREAM)
family和type参数暗指了一个协议,但是你可以使用socket的第三个可选的参数(proto的取值如IPPROTO_TCP或IPPROTO_RAW)来指定所使用的协议。代替使用IPPROTO_XX变量,你可以使用函数getprotobyname:
getprotobyname('tcp')
6
IPPROTO_TCP
6
fromfd(fd,type[,proto])是一个很少被使用的函数,它用来从打开的一个文件描述符创建一个socket对象(文件描述符由文件的fileno()方法返回)。文件描述符与一个真实的socket连接,而非一个文件。socket对象的fileno()方法返回关于这个socket的文件描述符。
当你使用完工socket对象时,你应调用close()方法显式的关闭socket以尽快释放资源(尽管socket被垃圾回收器回收时将自动被关闭)。另外,你也可以使用shutdown(how)方法来关闭连接一边或两边。参数0阻止socket接收数据,1阻止发送,2阻止接收和发送。
2、连接socket
当两个socket连接时(例如使用TCP),一端监听和接收进来的连接,而另一端发起连接。临听端创建一个socket,调用bind(address)函数去绑定一个特定的地址和端口,调用listen(backlog)来临听进来的连接,最后调用accept()来接收这个新的,进来的连接,下面是在服务器端的代码:
s=socket(AF_INET,SOCK_STREAM)
s.bind(('127.0.0.1',44444))
s.listen(1)
q,v=s.accept() #返回socket q和地址v
注意:上面的代码将一直处于等待直到连接被建立。下面我们再打开另一个Python解释器,用作客户端;然后键入如下代码:
from socket import *
s=socket(AF_INET,SOCK_STREAM)
s.connect(('127.0.0.1',44444) #发起连接
好了,我们验证一下连接是否建立了。我们在服务器端键入以下代码来发送一条信息:
q.send('hello,i come from pythontik.com')
31 #发送的字节数
在客户端键入以下代码来接收信息:
s.recv(1024)
'hello,i come from pythontik.com'
你传递给bind和connect的地址是一个关于AF_INET的socket的元组(ipAddress,port)。代替connect,你也可以调用connect_ex(address)方法。如果背后对C的connect的调用返回一个错误,那么connect_ex也将返回一个错误(否则返回0代表成功),代替引发一个异常。
当你调用listen时,你给了它一个参数,这个数值表示在等待队列中允许放置的进来的连接总数。当等待队列已满时,如果有更多的连接到达,那么远程端将被告知连接被拒绝。在socket模块中的SOMAXCONN变量表明了等待队列所能容纳的最大量。
accept()方法返回形如bind和connect的一个地址,代表远程socket的地址。下面显示变量v的值:
v
('127.0.0.1', 1334)
UDP是不定向的连接,但是你仍然可以使用给定的目的地址和端口来调用connect去关联一个socket。
3、发送和接收数据
函数send(string[,flags])发送给定的字符串到远程socket。sendto(string[,flags],address)发送给定的字符串到一个特定的地址。通常,send方法用于可靠连接的socket,sendto方法用于不可靠连接的socket,但是如果你在一个UDP socket上调用connect来使它与一个特定的目标建立联系,那么这时你也可以使用send方法来代替sendto。
send和sendto都返回实际发送的字节数。当你快速发送大量的数据的时候,你可能想去确保全部信息已被发送,那么你可以使用如下的一个函数:
def safeSend(sock,msg):
sent=0
while msg:
i=sock.send(msg)
if i==-1: #发生了错误
return -1
sent+=i
msg=msg[i:]
time.sleep(25)
return sent
recv(bufsize[,flags])方法接收一个进来的消息。如果有大量的数据在等待,它只返回前面的bufsize字节数的数据。recvfrom(bufsize[,flags])做同样的事,除了它使用AF_INET socket的返回值是(data,(ipAddress,port)),这便于你知道消息来自哪儿(这对于非连接的socket是有用的)。
send,sendto,recv和recvfrom方法都有一个可选的参数flags,默认值为0。你可以通过对socket.MSG_*变量进行组合(按位或)来建立flags的值。这些值因平台而有所不同,但是最通用的值如下所示:
MSG_OOB :处理带外数据(既TCP紧急数据)。
MSG_DONTROUTE :不使用路由表;直接发送到接口。
MSG_PEEK :返回等待的数据且不把它们从队列中删除。
例如,如果你有一个打开的socket,它有一个消息等待被接收,你可以接收这个消息后并不把它从进来的数据的队列中删除:
q.recv(1024,MSG_PEEK)
'hello'
q.recv(1024,MSG_PEEK) #因为没有删除,所以你可以再得到它。
'hello'
makefile([mode[,bufsize]])方法返回一个文件类对象,其中封装了socket,以便于你以后将它传递给要求参数为一个文件的代码(或许你喜欢使用文件的方法来代替send和recv)。这个可选的mode和bufsize参数的取值和内建的open函数一样。
4、使用socket选项
socket对象的getpeername()和getsockname()方法都返回包含一个IP地址和端口的二元组(这个二元组的形式就像你传递给connect和bind的)。getpeername返回所连接的远程socket的地址和端口,getsockname返回关于本地socket的相同信息。
在默认情况下,socket是阻塞式的,意思就是socket的方法的调用在任务完成之前是不会返回的。例如,如果存储向外发送的数据的缓存已满,你又企图发送更多的数据,那么你对send的调用将被阻塞直到它能够将更多的数据放入缓存。你可以通过调用setblocking(flag)方法(其中flag取值是0,setblocking(0))来改变这个默认行为,以使socket为非阻塞式。当socket为非阻塞式的时候,如果所做的动作将导致阻塞,将会引起error异常。下面一段代码将试图不断地接受新的连接并使用函数processRequest来处理。如果一个新连接无效,它将间隔半秒再试。另一方法是在你的监听socket上调用select或poll来检测一个新的连接的到达。
别的socket的选项可以使用setsockopt(level,name,value)和getsockopt(level,name[,buflen])方法来设置和获取。socket代表了一个协议栈的不同层,level参数指定了选项应用于哪一层。level的取值以SOL_开头(SOL_SOCKET,SOL_TCP等等)。name表明你涉及的是哪个选项。对于value,如果该选项要求数值的值,value只能传入数字值。你也可以传递入一个缓存(一个字符串),但你必须使用正确的格式。对getsockopt,不指定buflen参数意味你要求一个数字值,并返回这个值。如果你提供了buflen,getsockopt返回代表一个缓存的字符串,它的最大长度是buflen的字节数。下面的例子设置了一个socket的用于发送的缓存尺寸为64KB:
s=socket(AF_INET,SOCK_STREAM)
s.setsockopt(SOL_SOCKET,SO_SNDBUF,65535)
要得到一个包在被路由丢弃前所能有的生命周期(TTL)和跳数,你可以使用如下代码:
s.getsockopt(SOL_IP,IP_TTL)
32
5、数值转换
由于不同平台的字节顺序不一样,所以当在网络中传输数据时我们使用标准的网络字节顺序。nthol(x)和ntohs(x)函数要求一个网络字节顺序的数值并把它转换为当前主机字节顺序的相同数值,而htonl(x)和htons(x)则相反:
import.socket
socket.htons(20000) #转换为一个16位的值
8270
socket.htonl(20000) #转换为一个32位的值
541982720
socket.ntohl(541982720)
20000
SocketServers模块为一组socket服务类定义了一个基类,这组类压缩和隐藏了监听、接受和处理进入的socket连接的细节。
1、SocketServers家族
TCPServer和UDPServer都是SocketServer的子类,它们分别处理TCP和UDP信息。
注意:SocketServer也提供UnixStreamServer(TCPServer的子类)和UNIXdatagramServer(UDPServer的子类),它们都如同其父类一样除了在创建监听socket时使用AF_UNIX代替了AF_INET。
默认情况下,socket服务一次处理一个连接,但是你可以使用ThreadingMixIN和ForkingMixIn类来创建任一SocketServer的线程和子进程。实际上,SocketServer模块提供了一些对些有用的类来解决你的麻烦,它们是:ForkingUDPServer、ForkingTCPServer、ThreadingUDPServer、ThreadingTCPServer、ThreadingUnixStreamServer和ThreadingUnixDatagramServer。
SocketServer以通常的方法处理进入的连接;要使它更有用,你应该提供你自己的请求处理器类给它以便它传递一个socket去处理。SocketServer模块中的BaseRequestHandler类是所有请求处理器的父类。假设,例如你需要写一个多线程的电子邮件服务器,首先你要创建一个MailRequestHandler,它是BaseRequestHandler的子类,然后把它传递给一个新创建的SocketServer:
import SocketServer
...#创建你的MailRequestHandler
addr=('220.172.20.6',25) #监听的地址和端口
server=SocketServer.ThreadingTCPServer(addr,MailRequestHandler)
server.serve_forever()
每次一个新的连接到来时,这个server创建一个新的MailRequestHandler实例并调用它的handle()方法来处理这个新的请求。因为server继承自ThreadingTCPServer,对于每个新的请求它都启动一个单独的线程来处理这个请求,以便于多个请求能够被同时处理。如果用handle_request()代替server_forever,它将一个一个的处理连接请求。server_forever 只是反复调用handle_request而已。
一般来说,你只需使用socket服务之一,但是如果你需要创建你自己的子类的话,你可以覆盖我们下面提到的方法来定制它。
当服务被第一次创建的时候,__init__函数调用server_bind()方法来绑定监听socket(self.socket)到正确的地址(self.server_address)。然后调用server_activate()来激活这个服务(默认情况下,调用socket的listen方法)。
这个socket服务不做任何事情直到调用了handle_request或serve_forever方法。handle_request调用get_request()去等待和接收一个新的socket连接,然后调用verify_request(request,client_address)去看服务是否会处理这个连接(你可以在访问控制中使用这个,默认情况下verify_request总是返回true)。如果会处理这个请求,handle_request然后调用process_request(request,client_address),如果process_request(request,client_address)导致一个异常的话,将调用handle_error(request,client_address)。默认情况下,process_request简单地调用finish_request(request,client_address);子进程和线程类覆盖了这个行为去开始一新的进程或线程,然后调用finish_request。finish_request实例化一个新的请求处理器,请求处理器轮流调用它们的handle()方法。
当SocketServer创建一个新的请求处理器时,它传递给这个处理器的__init__函数的self变量,以便于这个处理器能够访问关于这个服务的信息。
SocketServer的fileno()方法返回监听socket的文件描述符。address_family成员变量指定了监听socket的socket族(如AF_INET),server_address包含了监听socket被绑定到的地址。socket变量包含监听socket自身。
2、请求处理器
请求处理器有setup()、handle()和finish()方法,你可以覆盖它们来定制你自己的行为。一般情况下,你只需要覆盖handle方法。BaseRequestHandler的__init__函数调用setup()方法来做初始化的工作,handle()服务于请求,finish()用于执行清理工作,如果handle或setup导致一个异常,finish不会被调用。记住,你的请求处理器会为每个请求创建一个新的实例。
request成员变量有关于流(TCP)服务的最近接受的socket;对于数据报服务,它是一个包含进入消息和监听socket的元组。client_address包含发送者的地址,server有对SocketServer的一个引用(通过这你可以访问它的成员,如server_address)。
下面的例子实现了一个EchoRequestHandler,这作为一个服务端它将客户端所发送的数据再发送回客户端:
import SocketServer
class EchoRequestHandler(SocketServer.BaseRequestHandler):
... def handle(self):
... print 'Got new connection!'
... while 1:
... mesg=self.request.recv(1024)
... if not msg:
... break
... print 'Received:',msg
... self.request.send(msg)
... print 'Done with connection'
server=SocketServer.ThreadingTCPServer(('127.0.0.1',12321),EchoReuestHandler)
server.handle_request() #执行后将等待连接
Got new connection!
Received: Hello!
Received: I like Tuesdays!
Done with connection
打开另一个Python解释器作为客户端,然后执行如下代码:
from socket import *
s=socket(AF_INET,SOCK_STREAM)
s.connect(('120.0.0.1',12321))
s.send('Hello!')
6
print s.recv(1024)
Hello!
s.send('I like Tuesdays!')
16
print s.recv(1024)
I like Tuesdays!
s.close()
SocketServer模块也定义了BaseRequestHandler的两个子类:StreamRequestHandler和DatagramRequestHandler。它们覆盖了setup和finish方法并创建了两个文件对象rfile和wfile,你可以用这两个文件对象来向客户端读写数据,从而代替使用socket方法。
使用SocketServers
socket的阻塞或同步编程
一、使用socket
网络编程中最基本的部分就是socket(套接字)。socket有两种:服务端socket和客户端 socket。在你创建了一个服务端socket之后,你告诉它去等待连接。然后它将监听某个网络地址(形如:xxx.xxx.xxx.xxx:xxx) 直到客户端连接。然后这两端就可以通信了。
处理客户端socket通常比处理服务端socket要容易一点,因为服务端必须时刻准备处理来自客户端的连接,并且它必须处理多个连接,而客户端只需要简单的连接,然后做点什么,然后断开连接。
实例化一个socket时,可以指定三个参数:地址系列(默认为socket.AF_INET)、流socket(这是个默认值: socket.SOCK_STREAM)或数据报socket(socket.SOCK_DGRAM)、协议(默认值是0)。对于简单的socket,你可以不指定任何参数而全部使用默认值。
服务端socket在使用bind方法之后调用listen方法去监听一个给定的地址。然后,客户端socket就可以通过使用connect方法(connect方法所使用的地址参数与bind相同)去连接服务端。listen方法要求一个参数,这个参数就是等待连接队列中所能包含的连接数。
一旦服务端socket调用了listen方法,就进入了临听状态,然后通常使用一个无限的循环:1、开始接受客房端的连接,这通过调用accept方法来实现。调用了这个方法后将处于阻塞状态(等待客户端发起连接)直到一个客户端连接,连接后,accept返回形如(client,address)的一个元组,其中client是一个用于与客户端通信的socket,address是客户端的形如xxx.xxx.xxx.xxx:xxx的地址;2、然后服务端处理客户端的请求;3、处理完成之后又调用1。
关于传输数据,socket有两个方法:send和recv。send使用字符串参数发送数据;recv参数是字节数,表示一次接受的数据量,如果你不确定一次该接受的数据量的话,最好使用1024。
下面给出一个最小的服务器/客户机的例子:
服务端:
import socket
s = socket.socket()
host = socket.gethostname()
port = 1234
s.bind((host, port))
s.listen(5)
while True:
c, addr = s.accept()
print 'Got connection from', addr
c.send('Thank you for connecting')
c.close()
客户端:
import socket
s = socket.socket()
host = socket.gethostname()
port = 1234
s.connect((host, port))
print s.recv(1024)
注意:如果你使用Ctrl-C来停止服务端的话,如果再次使用相同的端口可能需要等待一会儿。
二、使用SocketServer
SocketServer模块简单化了编写网络服务器的工作。
它提供了四个基本的服务类:TCPServer(使用TCP协议)、UDPServer(使用数据报)、UnixStreamServer、
UnixDatagramServer。UnixStreamServer和UnixDatagramServer用于类Unix平台。
这四个类处理请求都使用同步的方法,也就是说,在下一个请求处理开始之前当前的请求处理必须已完成
。
用SocketServer创建一个服务器需要四步:
1、通过子类化BaseRequestHandler类和覆盖它的handle()方法来创建一个请求处理器类,用于处理进来
的请求;
2、实例化服务类如TCPServer,并传递给它参数:服务器地址和请求处理器类;
3、调用服务实例对象的handle_request()或serve_forever()方法去处理请求。
下面使用SocketServer用同步的方法写一个最简单的服务器:
from SocketServer import TCPServer, StreamRequestHandler
第一步。其中StreamRequestHandler类是BaseRequestHandler类的子类,它为流socket定义了
rfile和wfile方法
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)
第三步。serve_forever()导致进入循环状态
server.serve_forever()
注意:使用阻塞或同步的方法一次只能连接一个客户端,处理完成后才能连接下一个客户端。
非阻塞或异步编程
例如,对于一个聊天室来说,因为有多个连接需要同时被处理,所以很显然,阻塞或同步的方法是不合适的,这就像买票只开了一个窗口,佷多人排队等一样。那么我们如何解决这个问题呢?主要有三种方法:forking、threading、异步I/O。
Forking和threading的方法非常简单,通过使用SocketServer服务类的min-in类就可以实现。forking只适用于类Unix平台;threading需要注意内存共享的问题。
异步I/O如果底层的方法来实现是有点困难的。要简单点,我们可以考虑使用标准库中的框架或Twisted(Twisted是一个非常强大的异步网络编程的框架)。
一、用ScoketServer实现Forking和threading
下面我们使用两个例子来分别创建forking服务器和threading服务器。
Forking 服务器 :
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()
threading服务器 :
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()
二、使用select实现异步I/O
所谓异步I/O,打个比方,就是如果一大群人都想你听他说话,那么你就给他们每人一分钟的时间说,大家轮流说,没说完的待会儿轮到时再继续说。也就是一个时间片的方法。
要实现异步I/O,我们可以通过使用框架asyncore/asynchat或Twisted,它们都是基于select函数或poll函数(poll只适于类Unix系统)的。select和poll函数都来自select模块。
select函数要求三个必须序列作为参数和一个可选的以秒为单位的超时值。序列中是表示文件描述符的整数值,它们是我们要等待的连接。这三个序列是关于输入、输出和异常条件的。如果超时值没有给出的话,select将处于阻塞状态(也就是等待)直到有文件描述符准备动作。如果超时值给出了,那么select只阻塞给定的时间。如果超时值是0的话,那么将不阻塞。select返回的值是一个由三个序列组成的元组,它们分别代表相应参数的活动的子集。例如,第一个序列返回的是用于读的输入文件描述符构成的序列。
序列可以包含文件对象(不适于Windows)或socket。下面这个例子创建一个使用select去服务几个连接的服务器(注意:服务端的socket自身也提供给了select,以便于它能够在有新的连接准备接受时发出信号通知)。这个服务器只是简单地打印接受自客户端的数据。你可以使用telnet(或写一个基于socket的简单的客户端)来连接测试它。
select server
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
三、Twisted
Twisted是针对Python的一个事件驱动的网络框架,最初是为了网络游戏而开发的,但是现在被应用于各类网络软件。用Twisted,你可以实现事件处理器,非常类似用GUI工具包(Tk, GTK, Qt, wxWidgets)。这部分我将介绍一些基本的概念和演示如何使用Twisted来做一些相对简单的网络编程。Twisted是非常强大的框架并提供了大量的支持,如:Web服务器和客户端、SSH2, SMTP, POP3, IMAP4, AIM, ICQ, IRC, MSN,Jabber, NNTP, DNS等等。
早先我们所写的基于socket的服务器,它们都有一个显示的事件循环:寻找新的连接和新的数据;基于SocketServer的服务器有一个隐含的循环:寻找连接和为连接创建处理器。但时处理器仍然时显示的读数据。
而Twisted使用了更多的基于事件的方式。要写一个基本的服务器,你要实现事件处理器,它处理诸如一个新的客户端连接、新的数据到达和客户端连接中断等情况。在Twisted中,你的事件处理器定义在一个protocol中;你也需要一个factory,当一个新的连接到达时它能够构造这个protocol对象,但是如果你仅仅想创建一个自定义的Protocol类的实例的话,你可以使用来自Twisted的factory,Factory类在模块twisted.internet.protocol中。当你写你的protocol时,使用twisted.internet.protocol模块中的Protocol作为你的父类。当你得到一个连接时,事件处理器connectionMade被调用;当你丢失了一个连接时,connectionLost被调用。从客户端接受数据使用处理器dataReceived。但是你不能使用事件处理策略向客户端发送数据;要向客户端发送数据,你可以使用self.transport,它有一个write方法。它也有一个client属性,其中包含了客户端的地址(主机名和端口)。
下面这个例子是一个Twisted版的服务器。其中实例化了Factory并设置了它的protocol属性以便它知道使用哪个protocol与客户端通信(这就是所谓的你的自定义protocol)。然后你使用factory开始监听指定的端口,factory通过实例化的protocol对象处理连接。监听使用reactor模块中的listenTCP函数。最后,你通过调用reactor模块中的run函数来开始服务器。
from twisted.internet import reactor
from twisted.internet.protocol import Protocol, Factory
定义你Protocol类
class SimpleLogger(Protocol):
def connectionMade(self):
print 'Got connection from', self.transport.client
def connectionLost(self, reason):
print self.transport.client, 'disconnected'
def dataReceived(self, data):
print data
实例化Factory
factory = Factory()
设置factory的protocol属性以便它知道使用哪个protocol与客户端通信(这就是所谓的你的自定义
protocol)
factory.protocol = SimpleLogger
监听指定的端口
reactor.listenTCP(1234, factory)
开始运行主程序
reactor.run()
为你的处理目的而写一个自定义的protocol是很容易的。模块twisted.protocols.basic中包含了几个有用的已存在的protocol,其中的LineReceiver执行dataReceived并在接受到了一个完整的行时调用事件处理器lineReceived。如果当你在接受数据时除了使用lineReceived,还要做些别的,那么你可以使用LineReceiver定义的名为rawDataReceived事件处理器。下面是一使用LineReceiver的服务器例子:
from twisted.internet import reactor
from twisted.internet.protocol import Factory
from twisted.protocols.basic import LineReceiver
class SimpleLogger(LineReceiver):
def connectionMade(self):
print 'Got connection from', self.transport.client
def connectionLost(self, reason):
print self.transport.client, 'disconnected'
def lineReceived(self, line):
print line
factory = Factory()
factory.protocol = SimpleLogger
reactor.listenTCP(1234, factory)
reactor.run()
urllib和urllib2
urllib和urllib2的工作大同小异,它们让你能够通过网络访问文件,就像访问自己电脑上的一样。通过简单的函数调用,URL所定位的资源就可以被你作为输入使用到你的程序中。如果再配以re模块,那么你就能够下载Web页面、提取信息、自动创建你所寻找的东西的报告。
urllib2更流行一些。对于简单的下载任务,urllib比较好。如果你需要HTTP验证或cookies,或你想写一些扩展去处理你自己的协议的话,那么urllib2是正确的选择。
一、打开远程文件
打开远程文件的操作和本地差不多,不同的是只能使用读模式,并且使用urllib模块的urlopen:
from urllib import urlopen
webpage=urlopen(' http://www.python.org ')
如果你在线的话,变量webpage现在就包含了一个关联Web页: http://www.python.org 的文件类对象。
注意:如果你当前没有联网,而你又想练习一下urllib的话,你可以用如下形式访问本地文件:
localpage=urlopen(r'file:c:/test.txt')
由urlopen返回的文件类对象支持close,read,readline,readlines等方法。
下面的代码抽取出了Python官方主页中“Documentation”链接的URL:
import re
text = webpage.read()
m = re.search('<a href="([^"]+)">Documentation', text, re.IGNORECASE)
m.group(1)
' http://docs.python.org/ '
二、获取远程文件
urlopen函数给你一个文件类对象,你可以读取它。如果你使用urlib时只关心下载文件并存储一个复本到本地文件的话,你可以使用urlretrieve替而代之。urlretrieve返回一个元组(filename, headers),filename是本地文件(复本)的名字(它由urllib自动创建),headers包含关于远程文件的一些信息。
如果你想为复本指定一个名字的话,你可以提供第二个参数:
urlretrieve('http://www.python.org ', 'C://python_webpage.html' )
这将获取Python官方主页并存储到本地C:/python_webpage.html中。如果你不指定复本的文件名,那么文件将放到一个临时的地方,你能够使用open函数打开它,如果你要清除这些临时的复本,你可以调用urlcleanup函数而不带任何参数,它将为你完成清除工作。
python 网络编程的更多相关文章
- Python 网络编程(二)
Python 网络编程 上一篇博客介绍了socket的基本概念以及实现了简单的TCP和UDP的客户端.服务器程序,本篇博客主要对socket编程进行更深入的讲解 一.简化版ssh实现 这是一个极其简单 ...
- Python 网络编程(一)
Python 网络编程 socket通常也称作"套接字",用于描述IP地址和端口,是一个通信链的句柄,应用程序通常通过"套接字"向网络发出请求或者应答网络请求. ...
- Python学习(22)python网络编程
Python 网络编程 Python 提供了两个级别访问的网络服务.: 低级别的网络服务支持基本的 Socket,它提供了标准的 BSD Sockets API,可以访问底层操作系统Socket接口的 ...
- Day07 - Python 网络编程 Socket
1. Python 网络编程 Python 提供了两个级别访问网络服务: 低级别的网络服务支持基本的 Socket,它提供了标准的 BSD Sockets API,可以访问底层操作系统Socket接口 ...
- python网络编程-01
python网络编程 1.socket模块介绍 ①在网络编程中的一个基本组件就是套接字(socket),socket是两个程序之间的“信息通道”. ②套接字包括两个部分:服务器套接字.客户机套接字 ③ ...
- 《Python网络编程》学习笔记--使用谷歌地理编码API获取一个JSON文档
Foundations of Python Network Programing,Third Edition <python网络编程>,本书中的代码可在Github上搜索fopnp下载 本 ...
- Python网络编程基础pdf
Python网络编程基础(高清版)PDF 百度网盘 链接:https://pan.baidu.com/s/1VGwGtMSZbE0bSZe-MBl6qA 提取码:mert 复制这段内容后打开百度网盘手 ...
- python 网络编程(Socket)
# from wsgiref.simple_server import make_server## def RunServer(environ,start_response):# start_resp ...
- python 网络编程 IO多路复用之epoll
python网络编程——IO多路复用之epoll 1.内核EPOLL模型讲解 此部分参考http://blog.csdn.net/mango_song/article/details/4264 ...
- 自学Python之路-Python网络编程
自学Python之路-Python网络编程 自学Python之路[第一回]:1.11.2 1.3
随机推荐
- winform(四)——简单计算器制作
效果图: 代码区: using System; using System.Collections.Generic; using System.ComponentModel; using System. ...
- HDFS开发实例
1.列出HDFS中的文件 package com.hdfs.test; import java.io.BufferedReader; import java.io.IOException; impor ...
- 004.测试解析php,安装discuz
一.配置解析php 编辑nginx配置文件/usr/local/nginx/conf/nginx.conf [root@huh ~]# vim /usr/local/nginx/conf/nginx. ...
- #ifndef _LED_H #endif啥意思?
#ifndef _LED_H#ifndef _LED_H ...... ...... #endif 避免重复引用头文件的内容.
- MongoDb 创建、更新以及删除文档常用命令
mongodb由C++写就,其名字来自humongous这个单词的中间部分,从名字可见其野心所在就是海量数据的处理.关于它的一个最简洁描述为:scalable, high-performance, o ...
- 让IE8在win7下面能显示使用window.showmodaldialog弹出窗口的地址状态栏
问题来源:最近又要对老的系统进行改善,由于用到了window.showmodaldialog这个方法弹出窗口,比如从主界面弹出新增或者修改窗口,如下图所示,显示没有地址栏,进行代码修改还要找到相应的文 ...
- 线程同步之 yield() wait()
yield()没有参数. sleep 方法使当前运行中的线程睡眼一段时间,进入不可运行状态,这段时间的长短是由程序设定的,yield 方法使当前线程让出CPU占有权,但让出的时间是不可设定的.yiel ...
- python_面向对象编程
一.编程范式 程序员通过特定的语法+数据结构+算法告诉计算机如果执行任务,实现这个过程有不同的编程方式,对这些不同的编程方式进行归纳总结得出来的编程方式类别,即为编程范式 编程范式:面向过程编程.面向 ...
- WebService基本使用
不使用任何框架,纯粹使用JDK开发一个服务端与客户端 服务端 package org.zln.ws.server;import org.slf4j.Logger;import org.slf4j.Lo ...
- ES5基础之正则表达式02:范围类、预定义类和边界字符
1.范围类 //元字符 /* * 正则表达式由两种基本字符类型组成 * 1.原义文本字符:例如123abc * 2.元字符:元字符是在正则表达式中有特殊含义的非字母字符 */ //常见特殊符号:. * ...