动手写的Python的HTML语法分析器（面向对象）

最新推荐文章于 2021-06-03 12:08:14 发布

ciedecem

最新推荐文章于 2021-06-03 12:08:14 发布

阅读量1.2k

点赞数

分类专栏： Python 文章标签： python 正则表达式

Python 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

动手写的Python的HTML语法分析器（面向对象）

原文link： http://www.cnblogs.com/lzhenf/archive/2012/03/06/2382056.html

主要包括4个文件，util.py文件主要负责截取每个块。

rules.py文件定义两个类，超类Rule和分别对应的子类，子类定义了不同的划分块的要求,子类包换action函数，调用handler处理

handlers.py定义了处理类，超类定义了方法，子类通过名字调用

markup.py定义了超类parser，定义了子类basicTextParser,超类主要负责创造过滤器，添加规则，对每个块执行处理。

#handler.py
# -*- coding: cp936 -*-
class Handler:
    """
    处理从parser调用的方法对象

    这个解析器会在每个块的开始部分调用start（）和end()方法，使用合适的块名作为参数。sub()会用于
    正则表达式替换中，当使用了'emphasis'这样的名字调用时，它会返回核实的替换函数
    """
    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:
                result = match.group(1)
            return result
        return substitution
class HTMLRenderer(Handler):
        """
                        用于生成HTML的具体处理程序
                        类中所有的方法都可以通过超类处理程序的START（）、end()、sub()方法来访问，他们实现了HTML的基本标签
        """
        def start_document(self):
            print '<html><head><title>...</title></head><body>'
        def end_document(self):
            print '</body></html>'
        def start_paragraph(self):
            print '<p>'
        def end_paragraph(self):
            print '</p>'
        def start_heading(self):
            print '<h2>'
        def end_heading(self):
            print '<h2>'
        def start_list(self):
            print '<ul>'
        def end_list(self):
            print '</ul>'
        def start_listitem(self):
            print '<li>'
        def end_listitem(self):
            print '</li>'
        def start_title(self):
            print '<h1>'
        def end_title(self):
            print '</h1>'
        def sub_emphasis(self,match):
            return '<em>%s<em>' % match.group(1)
        def sub_url(self ,match):
            return '<a href="%s">%s</a>' % (match.group(1),match.group(1))
        def sub_mail(self,match):
            return '<a href="mailto:%s">%s</a>' % (match.group(1),match.group(1))
        def feed(self,data):
            print data

# -*- coding: cp936 -*-
#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):
    """
    标题占一行，且标题的数目不大于70个字符，且最后不能以冒号结尾
    """
    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
    
    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

#util.py
def lines(file):
    for line in file:yield line
    yield '\n'

def blocks(file):
    block =[]
    for line in lines(file):
        if line.strip():
            block.append(line)
        elif block:
            yield ''.join(block).strip()
            block=[]

#markup.py
import sys , re 
from handlers import *
from util import *
from rules import *

class Parser:
    """
    the processer of this , read data ,then use rule , and control to process data block
    """
    #initial
    def __init__(self,handler):
        self.handler = handler
        self.rules =[]
        self.filters =[]
    #addrule to the Parser
    def addRule(self,rule):
        self.rules.append(rule)
    #add filter to the Parser
    def addFilters(self,patten,name):
        def filter(block , handler):
            return re.sub(patten,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,hanler):
        Parser.__init__(self,handler)
        self.addRule(ListRule())
        self.addRule(ListItemRule())
        self.addRule(TitleRule())
        self.addRule(HeadingRule())
        self.addRule(ParagraphRule()) 
        
        self.addFilters(r'\*(.+?)\*', 'emphasis')
        self.addFilters(r'(http://[\.a-zA-z/]+)', 'url')
        self.addFilters(r'([\.a-zA-Z/]+@[\.a-zA-z]+[a-zA-Z]+)', 'mail')


handler = HTMLRenderer()
parser = BasicTextParser(handler)
f= open(r'D://python27/input.txt')
parser.parse(f)

block = filter(block , self.handler) 
这个调用的时候 走到了def filter(block , handler):这个函数 return re.sub(patten,handler.sub(name),block)  
这边多出来的一个参数是addfilter函数的 这个参数该是啥  这个搞不明白啊

其实这里的完整调用是

for filter in self.filters:
                block = filter(block , self.handler)

很明显，这调用的是数组对象中函数对象元素，这里的也可以修改为:

for elem in self.filters:
                block = elem(block , self.handler)

这样的话，就不会直接跳到def filter上了，而且更容易想到这是个数组。

而且即便ｆｉｌｔｅｒｓ数组是空的，也不会报错，因为ｆｏｒ循环就不会进去执行了。

另外，　

class BasicTextParser(Parser):

是类继承关系的调用。

ciedecem

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录