python项目练习一：即时标记 60837°C

这是《python基础教程》后面的实践，照着写写，一方面是来熟悉python的代码方式，另一方面是练习使用python中的基本的以及非基本的语法，做到熟能生巧。

这个项目一开始比较简单，不过重构之后就有些复杂了，但是更灵活了。

按照书上所说，重构之后的程序，分为四个模块：处理程序模块，过滤器模块，规则（其实应该是处理规则），语法分析器。 先来说处理程序模块，这个模块的作用有两个，一个是提供那些固定的html标记的输出（每一个标记都有start和end），另一个是对这个标记输出的开始和结束提供了一个友好的访问接口。来看下程序handlers.py：

class Handler: ''' ''' def callback(self, prefix, name, *args): method = getattr(self,prefix+name,None) if callable(method): return method(*args) def start(self, name): self.callback('start_', name) def end(self, name): self.callback('end_', name) def sub(self, name): def substitution(match): result = self.callback('sub_', name, match) if result is None: match.group(0) return result return substitution class HTMLRenderer(Handler): ''' ''' def start_document(self): print '' def end_document(self): print '' def start_paragraph(self): print '

' def end_paragraph(self): print '

' def start_heading(self): print '

' def end_heading(self): print '

' def start_list(self): print '

' def end_list(self): print '

' 1

def start_listitem(self): print '

' def end_listitem(self): print '

' def start_title(self): print '

' def end_title(self): print '

' def sub_emphasis(self, match): return '%s' % match.group(1) def sub_url(self, match): return '%s' % (match.group(1),match.group(1)) def sub_mail(self, match): return '%s' % (match.group(1),match.group(1)) def feed(self, data): print data 这个程序堪称是整个“项目”的基石所在：提供了标签的输出，以及字符串的替换。理解起来也比较简单。 再来看第二个模块“过滤器”，这个模块更为简单，其实就是一个正则表达式的字符串。相关代码如下： self.addFilter(r'\\*(.+?)\\*', 'emphasis') self.addFilter(r'(http://[\\.a-z0-9A-Z/]+)', 'url') self.addFilter(r'([\\.a-zA-Z]+@[\\.a-zA-Z]+[a-zA-Z]+)','mail') 这就是三个过滤器了，分别是：强调牌过滤器（用×号标出的），url牌过滤器，email牌过滤器。熟悉正则表达式的同学理解起来是没有压力的。

再来看第三个模块“规则”，这个模块，抛开那祖父类不说，其他类应该有的两个方法是condition和action，前者是用来判断读进来的字符串是不是符合自家规则，后者是用来执行操作的，所谓的执行操作就是指调用“处理程序模块”，输出前标签、内容、后标签。 来看下这个模块的代码，其实这个里面几个类的关系，画到类图里面看会比较清晰。 rules.py: class Rule: def action(self, block, handler): handler.start(self.type) handler.feed(block) handler.end(self.type) return True class HeadingRule(Rule): type = 'heading' def condition(self, block): return not '\\n' in block and len(block) <= 70 and not block[-1] == ':' class TitleRule(HeadingRule): type = 'title' first = True 2

def condition(self, block): if not self.first: return False self.first = False return HeadingRule.condition(self, block) class ListItemRule(Rule): type = 'listitem' def condition(self, block): return block[0] == '-' def action(self,block,handler): handler.start(self.type) handler.feed(block[1:].strip()) handler.end(self.type) return True class ListRule(ListItemRule): type = 'list' inside = False def condition(self, block): return True def action(self,block, handler): if not self.inside and ListItemRule.condition(self,block): handler.start(self.type) self.inside = True elif self.inside and not ListItemRule.condition(self,block): handler.end(self.type) self.inside = False return False class ParagraphRule(Rule): type = 'paragraph' def condition(self, block): return True 补充utils.py: def line(file): for line in file:yield line yield '\\n' def blocks(file): block = [] for line in lines(file): if line.strip(): block.append(line) 3

elif block: yield ''.join(block).strip() block = [] 最后隆重的来看下“语法分析器模块”，这个模块的作用其实就是协调读入的文本和其他模块的关系。在往重点说就是，提供了两个存放“规则”和“过滤器”的列表，这么做的好处就是使得整个程序的灵活性得到了极大的提高，使得规则和过滤器变成的热插拔的方式，当然这个也归功于前面在写规则和过滤器时每一种类型的规则（过滤器）都单独的写成了一个类，而不是用if..else来区分。 看代码： import sys, re from handlers import * from util import * from rules import * class Parser: def __init__(self,handler): self.handler = handler self.rules = [] self.filters = [] def addRule(self, rule): self.rules.append(rule) def addFilter(self,pattern,name): def filter(block, handler): return re.sub(pattern, handler.sub(name),block) self.filters.append(filter) def parse(self, file): self.handler.start('document') for block in blocks(file): for filter in self.filters: block = filter(block, self.handler) for rule in self.rules: if rule.condition(block): last = rule.action(block, self.handler) if last:break self.handler.end('document') class BasicTextParser(Parser): def __init__(self,handler): Parser.__init__(self,handler) self.addRule(ListRule()) self.addRule(ListItemRule()) self.addRule(TitleRule()) 4

self.addRule(HeadingRule()) self.addRule(ParagraphRule()) self.addFilter(r'\\*(.+?)\\*', 'emphasis') self.addFilter(r'(http://[\\.a-z0-9A-Z/]+)', 'url') self.addFilter(r'([\\.a-zA-Z]+@[\\.a-zA-Z]+[a-zA-Z]+)','mail') handler = HTMLRenderer() parser = BasicTextParser(handler) parser.parse(sys.stdin) 这个模块里面的处理思路是，遍历客户端（也就是程序执行的入口）给插进去的所有的规则和过滤器，来处理读进来的文本。 有一个细节的地方也要说一下，其实是和前面写的呼应一下，就是在遍历规则的时候通过调用condition这个东西来判断是否符合当前规则。

我觉得这个程序很像是命令行模式，有空可以复习一下该模式，以保持记忆网节点的牢固性。

最后说一下我以为的这个程序的用途， 1、用来做代码高亮分析，如果改写成js版的话，可以做一个在线代码编辑器。 2、可以用来学习，供我写博文用。

还有其他的思路，可以留下您的真知灼见。

补充一个类图，很简陋，但是应该能说明之间的关系。另外我还是建议如果看代码捋不清关系最好自己画图，自己画图才能熟悉整个结构。

python项目练习二：画幅好画 22982°C

作者：the5fire | 标签： pythonpdf python实战 | 发布：2011-12-18 3:35 p.m. 这是《python基础教程》中的第二个项目，关于python操作PDF 涉及到的知识点

• •

1、urllib的使用 2、reportlab库的使用

这个例子着实很简单，不过我发现在python里面可以直接在数组［］里面写for循环，真是越用越方便。 下面是代码：

5

from urllib import urlopen from reportlab.graphics.shapes import * from reportlab.graphics.charts.lineplots import LinePlot from reportlab.graphics.charts.textlabels import Label from reportlab.graphics import renderPDF URL = 'http://www.swpc.noaa.gov/ftpdir/weekly/Predict.txt' COMMENT_CHARS = '#:' drawing = Drawing(400, 200) data = [] for line in urlopen(URL).readlines(): pred = [row[2] for row in data] high = [row[3] for row in data] low = [row[4] for row in data] times = [row[0] + row[1]/12.0 for row in data] lp = LinePlot() lp.x = 50 lp.y = 50 lp.height = 125 lp.width = 300 lp.data = [zip(times, pred),zip(times,high),zip(times, low)] lp.lines[0].strokeColor = colors.blue lp.lines[1].strokeColor = colors.red lp.lines[2].strokeColor = colors.green drawing.add(lp) drawing.add(String(250,150, 'Sunspots',fontSize=14,fillColor=colors.red)) renderPDF.drawToFile(drawing, 'report3.pdf','Sunspots') python项目练习三：万能的XML 13869°C

作者：the5fire | 标签： python实战 | 发布：2011-12-20 3:18 p.m.

这个项目的名称与其叫做万能的XML不如叫做自动构建网站，根据一份XML文件，生成对应目录结构的网站，不过只有html还是太过于简单了，如果要是可以连带生成css那就比较强大了。这个有待后续研发，先来研究下怎么html网站结构。 既然是通过XML结构生成网站，那所有的事情都应该由这个XML文件来。先来看下这个XML文件，website.xml：

Welcome to my Home page

if not line.isspace() and not line[0] in COMMENT_CHARS: data.append([float(n) for n in line.split()]) 6

Hi, there. My name is Mr.gumby,and this is my home page,here are some of my int:

• Shouting
• Sleeping
• Eating

shouting page

....

sleeping page

...

Eating page

....

有了这个文件，下面应该来看怎么通过这个文件生成网站。

首先我们要解析这个xml文件，python解析xml和在java中一样，有两种方式，SAX和DOM，两种处理方式不同点在于速度和范围，前者讲究的是效率，每次只处理文档的一小部分，快速而能有效的利用内存，后者是相反的处理方式，先把所有的文档载入到内存，然后再进行处理，速度比较慢，也比较消耗内存，唯一的好处就是可以操作整个文档。

在python中使用sax方式处理xml要先引入xml.sax中的parse函数，还有xml.sax.handler中的ContentHandler，后面的这个类是要和parse函数来配合使用的。使用方式如下： parse('xxx.xml',xxxHandler),这里面的xxxHandler要继承上面的ContentHandler，不过只要继承就行，不需要有所作为。 然后这个parse函数在处理xml文件的时候，会调用xxxHandler中的startElement函数和endElement函数来一个xml中的标签的开始和结束，中间的过程使用一个名为characters的函数来处理标签内部的所有字符串。

有了上面的这些认识，我们已经知道如何处理xml文件了，然后再来看那个罪恶的源头website.xml文件，分析其结构，只有两个节点：page和directory，很明显page表示一个页面，directory表示一个目录。

所以处理这个xml文件的思路就变的清晰了。读取xml文件的每一个节点，然后判断是page还是directory如果是page则创建html页面，然后把节点中的内容写到文件里。如果遇到directory就创建一个文件夹，然后再处理其内部的page节点（如果存在的话）。

下面来看这部分代码，书中的实现比较复杂，比较灵活。先来看，然后在分析。 from xml.sax.handler import ContentHandler from xml.sax import parse import os class Dispatcher: 7

def dispatch(self, prefix, name, attrs=None): mname = prefix + name.capitalize() dname = 'default' + prefix.capitalize() method = getattr(self, mname, None) if callable(method): args = () else: method = getattr(self, dname, None) args = name, if prefix == 'start': args += attrs, if callable(method): method(*args) def startElement(self, name, attrs): self.dispatch('start', name, attrs) def endElement(self, name): self.dispatch('end', name) class WebsiteConstructor(Dispatcher, ContentHandler): passthrough = False def __init__(self, directory): self.directory = [directory] self.ensureDirectory() def ensureDirectory(self): path = os.path.join(*self.directory) print path print '----' if not os.path.isdir(path): os.makedirs(path) def characters(self, chars): if self.passthrough: self.out.write(chars) def defaultStart(self, name, attrs): if self.passthrough: self.out.write('<' + name) for key, val in attrs.items(): self.out.write(' %s=\"%s\"' %(key, val)) self.out.write('>') def defaultEnd(self, name): if self.passthrough: self.out.write('' % name) 8

def startDirectory(self, attrs): self.directory.append(attrs['name']) self.ensureDirectory() def endDirectory(self): print 'endDirectory' self.directory.pop() def startPage(self, attrs): print 'startPage' filename = os.path.join(*self.directory + [attrs['name']+'.html']) self.out = open(filename, 'w') self.writeHeader(attrs['title']) self.passthrough = True def endPage(self): print 'endPage' self.passthrough = False self.writeFooter() self.out.close() def writeHeader(self, title): self.out.write('\\n \\n \\n \\n \\n') def writeFooter(self): self.out.write('\\n \\n\\n') parse('website.xml',WebsiteConstructor('public_html')) 看起来这个程序上面分析的复杂了一些，不过伟人毛毛说过，任何复杂的程序都是纸老虎。那我们再来分析一下这个程序。 首先看到这个程序是有两个类，其实完全可以当作一个类，因为有了继承。

然后再来看它多了些什么，除了我们分析出来的startElement和endElement以及characters，多出来了startPage，endPage;startDirectory，endDirectory;defaultStart，defaultEnd;ensureDirectory;writeHeader，writeFooter;和dispatch，这些个函数。除了dispatch，前面的函数都很好理解，每一对函数都是单纯的处理对应的html标签以及xml节点。而dispatch比较复杂，复杂之处在于他是用来动态拼合函数并且进行执行的。

dispatch的处理思路是，首先根据传递的参数（就是操作名称以及节点名称）判断是否存在对应的函数如startPage，如果不存在则执行default+操作名称：如defaultStart。

一个函数一个函数搞清楚之后，就知道整个处理流程是什么样了。首先创建一个public_html的文件，存放整个网站，然后读xml的节点，通过startElement和endElement调用dispatch进行处理。然后就是dispatch怎么调用具体的处理函数了。 到此为止，这个项目算是分析完了。

主要掌握的内容一个是python中使用SAX处理XML，另一个就是python中的函数的使用，比如getattr，传参数时的星号…… python项目练习四：新闻聚合 13729°C

9

作者：the5fire | 标签： python实战 | 发布：2011-12-26 2:07 p.m.

书中的第四个练习，新闻聚合。现在很少见的一类应用，至少我从来没有用过，又叫做Usenet。这个程序的主要功能是用来从指定的来源（这里是Usenet新闻组）收集信息，然后讲这些信息保存到指定的目的文件中（这里使用了两种形式：纯文本和html文件）。这个程序的用处有些类似于现在的博客订阅工具或者叫RSS订阅器。 先上代码，然后再来逐一分析： from nntplib import NNTP from time import strftime,time,localtime from email import message_from_string from urllib import urlopen import textwrap import re day = 24*60*60 def wrap(string,max=70): ''' ''' return '\\n'.join(textwrap.wrap(string)) + '\\n' class NewsAgent: ''' ''' def __init__(self): self.sources = [] self.destinations = [] def addSource(self,source): self.sources.append(source) def addDestination(self,dest): self.destinations.append(dest) def distribute(self): items = [] for source in self.sources: items.extend(source.getItems()) for dest in self.destinations: dest.receiveItems(items) class NewsItem: def __init__(self,title,body): self.title = title 10

self.body = body class NNTPSource: def __init__(self,servername,group,window): self.servername = servername self.group = group self.window = window def getItems(self): start = localtime(time() - self.window*day) date = strftime('%y%m%d',start) hour = strftime('%H%M%S',start) server = NNTP(self.servername) ids = server.newnews(self.group,date,hour)[1] for id in ids: lines = server.article(id)[3] message = message_from_string('\\n'.join(lines)) title = message['subject'] body = message.get_payload() if message.is_multipart(): body = body[0] yield NewsItem(title,body) server.quit() class SimpleWebSource: def __init__(self,url,titlePattern,bodyPattern): self.url = url self.titlePattern = re.compile(titlePattern) self.bodyPattern = re.compile(bodyPattern) def getItems(self): text = urlopen(self.url).read() titles = self.titlePattern.findall(text) bodies = self.bodyPattern.findall(text) for title.body in zip(titles,bodies): yield NewsItem(title,wrap(body)) 11

class PlainDestination: def receiveItems(self,items): for item in items: print item.title print '-'*len(item.title) print item.body class HTMLDestination: def __init__(self,filename): self.filename = filename def receiveItems(self,items): out = open(self.filename,'w') print >> out,'''

Today's News ''' print >> out, '

' id = 0 for item in items: id += 1 print >> out, '
• %s
' % (id,item.title) print >> out, '

' id = 0 for item in items: id += 1 print >> out, '

%s

' % (id,item.title) print >> out, '

%s

' % item.body print >> out, ''' ''' def runDefaultSetup(): agent = NewsAgent() 12

bbc_url = 'http://news.bbc.co.uk/text_only.stm' bbc_title = r'(?s)a href=\"[^\"]*\">\\s*\\s*(.*?)\\s*' bbc_body = r'(?s)\\s*
\\s*(.*?)\\s*<' bbc = SimpleWebSource(bbc_url, bbc_title, bbc_body) agent.addSource(bbc) clpa_server = 'news2.neva.ru' clpa_group = 'alt.sex.telephone' clpa_window = 1 clpa = NNTPSource(clpa_server,clpa_group,clpa_window) agent.addSource(clpa) agent.addDestination(PlainDestination()) agent.addDestination(HTMLDestination('news.html')) agent.distribute() if __name__ == '__main__': runDefaultSetup() 这个程序，首先从整体上进行分析，重点部分在于NewsAgent，它的作用是存储新闻来源，存储目标地址，然后在分别调用来源服务器（NNTPSource以及SimpleWebSource）以及写新闻的类（PlainDestination和HTMLDestination）。所以从这里也看的出，NNTPSource是专门用来获取新闻服务器上的信息的，SimpleWebSource是获取一个url上的数据的。而PlainDestination和HTMLDestination的作用很明显，前者是用来输出获取到的内容到终端的，后者是写数据到html文件中的。 有了这些分析，然后在来看主程序中的内容，主程序就是来给NewsAgent添加信息源和输出目的地址的。 这确实是个简单的程序，不过这个程序可是用到了分层了。 python项目练习五：虚拟茶话会 11638°C

作者：the5fire | 标签： python实战，socket编程 | 发布：2011-12-30 3:31 p.m.

几乎在学习、使用任何一种编程语言的时候，关于socket的练习从来都不会少，尤其是会写一些局域网的通信的东西。所以书上的这个项目刚好可以练习一下socket编程。

这个练习的整体思路首先有一个聊天的服务器，这个服务器的功能主要是提供客户端socket的连接、存储每个客户端的连接session，处理每个连接发送的消息、解析客户端发送的数据。就这些，至于客户端方面不需要写代码，用系统的telnet工具即可。

我觉得有了上面的分析，剩下的这个程序就没有什么说的了，当然，除了那两个把socket封装的类之外。

自己使用python中的socket类尝试这个编写了一个简单的通信程序，不过不知为什么，通信中总是出现意外。这段简单的代码如下： server.py import socket 13

mysocket = socket.socket(socket.AF_INET,socket.SOCK_STREAM) mysocket.bind(('',8888)) mysocket.listen(5) while True: connection,addr = mysocket.accept() revStr = connection.recv(1024) connection.send('Server:' + revStr) connection.close() clinet.py import socket import time clientsocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) clientsocket.connect(('',8888)) while True: time.sleep(2) clientsocket.send('hello the5fire') print clientsocket.recv(1024) clientsocket.close()

这个程序出错的原因没有去细揪，因为python中提供了两个封装好的类来完成socket通信过程：asynchat中的async_chat和asyncore中的dispatcher以及asyncore本身。前面的类是用来处理客户端同服务器的每一次会话，后面的类主要是用来提供socket连接服务。并且将每一个socket连接都托管给前者（async_chat）来处理。

来看代码： from asyncore import dispatcher from asynchat import async_chat import socket, asyncore PORT = 5005 NAME = 'TestChat' class EndSession(Exception):pass class CommandHandler: 14

def unknown(self, session, cmd): session.push('Unknown command: %s\\r\\n' % cmd) def handle(self, session, line): if not line.strip(): return parts = line.split(' ',1) cmd = parts[0] try: line = parts[1].strip() except IndexError: line = '' meth = getattr(self, 'do_'+cmd, None) try: meth(session, line) except TypeError: self.unknown(session,cmd) class Room(CommandHandler): def __init__(self, server): self.server = server self.sessions = [] def add(self, session): self.sessions.append(session) def remove(self, session): self.sessions.remove(session) def broadcast(self, line): for session in self.sessions: session.push(line) def do_logout(self, session, line): raise EndSession class LoginRoom(Room): def add(self,session): Room.add(self,session) self.broadcast('Welcome to %s\\r\\n' % self.server.name) 15

def unknown(self, session, cmd): session.push('Please log in \\nUse \"login\"\\r\\n') def do_login(self, session, line): name = line.strip() if not name: session.push('Please enter a name\\r\\n') elif name in self.server.users: session.push('The name \"%s\" is taken.\\r\\n' % name) sessoin.push('Please try again.\\r\\n') else: session.name = name session.enter(self.server.main_room) class ChatRoom(Room): def add(self, session): self.broadcast(session.name + ' has entered the room.\\r\\n') self.server.users[session.name] = session Room.add(self, session) def remove(self, session): Room.remove(self, session) self.broadcast(session.name + ' has left the room.\\r\\n') def do_say(self, session, line): self.broadcast(session.name + ': ' + line + '\\r\\n') def do_look(self, session, line): session.push('The following are in this room:\\r\\n') for other in self.sessions: session.push(other.name + '\\r\\n') def do_who(self, session, line): session.push('The following are logged in:\\r\\n') for name in self.server.users: session.push(name + '\\r\\n') class LogoutRoom(Room): def add(self, session): 16

try: del self.server.users[session.name] except KeyError: pass class ChatSession(async_chat): def __init__(self, server, sock): async_chat.__init__(self,sock) self.server = server self.set_terminator('\\r\\n') self.data = [] self.name = None self.enter(LoginRoom(server)) def enter(self, room): try: cur = self.room except AttributeError: pass else: cur.remove(self) self.room = room room.add(self) def collect_incoming_data(self, data): self.data.append(data) def found_terminator(self): line = ''.join(self.data) self.data = [] try: self.room.handle(self, line) except EndSession: self.handle_close() def handle_close(self): async_chat.handle_close(self) self.enter(LogoutRoom(self.server)) class ChatServer(dispatcher): def __init__(self, port, name): dispatcher.__init__(self) self.create_socket(socket.AF_INET, socket.SOCK_STREAM) self.bind(('',port)) 17

self.listen(5) self.name = name self.users = {} self.main_room = ChatRoom(self) def handle_accept(self): conn, addr = self.accept() ChatSession(self,conn) if __name__ == '__main__': s = ChatServer(PORT, NAME) try: asyncore.loop() except KeyboardInterrupt: print

整个程序分为我一开始说的三个部分： 提供客户端的socket连接：ChatServer类。

存储每个客户端的连接session，处理每个连接发送的消息：ChatSession类，这个类的作用很简单，接受数据，判断是否有终结符，如果有调用found_terminator这个方法。

解析客户端发送的数据：就是剩下的room相关的类，这些类分别用来处理客户端发送的字符串和命令，都是继承自CommandHandler。

18

最终截图：

19