python即时标记

最新推荐文章于 2021-08-09 19:51:14 发布

weixin_30760895

最新推荐文章于 2021-08-09 19:51:14 发布

阅读量154

点赞数

文章标签： python

原文链接：http://www.cnblogs.com/soul-mate/p/7462390.html

版权

将纯文本文件改写成标记语言格式的文件（如Html语言）

python版本3.6.2

准备文档test_input.txt

Welcome to World Wide Spam. Inc.



These are the corporate web pages of *World Wide Spam*,Inc.We hope
you find your stay enjoyable,and that you will sample many of our
products.

A short history if the company

World Wide Spam was started in the summer of 2000.The business
concept was to ride the dot-com wave ande to make money both through
bulk email and by selling canned meat online.

After receiving several complaints from customers who weren't
satisfied by their bulk email.World Wide Spam altered their profile,
and focused 100%on canned goods.Today,they rank as the world's
13,892nd online supplier of SPAM.

Destinations

From this page you may visit several of our intersting web pages:

-What is SPAM?(http://wwspam.fu/whatisspam)

-How do they make it?(http://wwspam.fu/howtomakeit)

-Why should I eat it?(http://wwspam.fu/whyeatif)

How to get in touch with us

You can get in touch with us in *many* ways: By phone (555-1234),by
email (wwspam@wwspam.fu) or by visiting our customer feedback page
(http://wwspam.fu/feedback).

初次实现，找出文本块

找出块的一个简单的方法就是收集行，直到遇到一个空行，就返回之前收集的行，这些返回的行就是一个块，然后接着收集，不要收集空行也不需要放回空块

文本块生成器util.py

#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=[]

lines生成器只是在文件的最后一行追加一个空行，blocks生成器基本完成了块的收集

向收集到代表块的字符串添加标记（例如：页面开始标记，段落标记）

simple_markuo.py

#! /usr/bin/env python
#coding=utf-8
#simple_markup.py

import sys, re
from util import *

print('<html><head><title>...</title><body>')

title=True
for block in blocks(sys.stdin):
    block=re.sub(r'\*(.+?)\*',r'<em>\1</em>',block)
    if title:
        print('<h1>')
        print(block)
        print('</h1>')
        title=False
    else:
        print('<p>')
        print(block)
        print('</p>')
print('</body></html>')

我是在windows下运行的在控制台执行

python mark.py <test_input.txt> test_input.html

接下来进一步实现更具体的功能，对其进行扩展。

handlers.py

#! /usr/bin/env python
#coding=utf-8
#handler.py

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(0)
            return result
        return substitution
    
class HTMLRenderer(Handler):
    """
    用于生成HTML的具体处理程序
    
    HTMLRenderer内的方法都可以通过超类处理程序的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_heading(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)

rules.py

#! /usr/bin/env python
#coding=utf-8
#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(slef,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

mark.py

#! /usr/bin/env python
#coding=utf-8
#mark.py
#控制台执行命令   python mark.py <test_input.txt> test_input.html

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())
        self.addRule(HeadingRule())
        self.addRule(ParagraphRule())
        
        self.addFilter(r'\*(.+?)\*','emphasis')
        self.addFilter(r'(http://[\.a-zA-Z/]+)','url')
        self.addFilter(r'([\.a-zA-Z]+@[\.a-zA-Z]+[a-zA-Z]+)','mail')
        
handler=HTMLRenderer()
parser=BasicTextParser(handler)
parser.parse(sys.stdin)