• html.parser —- 简单的 HTML 和 XHTML 解析器
    • HTML 解析器的示例程序
    • HTMLParser 方法
    • 示例

    html.parser —- 简单的 HTML 和 XHTML 解析器

    源代码：Lib/html/parser.py

    这个模块定义了一个 HTMLParser 类，为 HTML（超文本标记语言）和 XHTML 文本文件解析提供基础。

    • class html.parser.HTMLParser(*, convert_charrefs=True)
    • 创建一个能解析无效标记的解析器实例。

    如果 convert_charrefs 为 True (默认值)，则所有字符引用( script/style 元素中的除外)都会自动转换为相应的 Unicode 字符。

    一个 HTMLParser 类的实例用来接受 HTML 数据，并在标记开始、标记结束、文本、注释和其他元素标记出现的时候调用对应的方法。要实现具体的行为，请使用 HTMLParser 的子类并重载其方法。

    这个解析器不检查结束标记是否与开始标记匹配，也不会因外层元素完毕而隐式关闭了的元素引发结束标记处理。

    在 3.4 版更改: convert_charrefs 关键字参数被添加。

    在 3.5 版更改: convert_charrefs 参数的默认值现在为 True。

    HTML 解析器的示例程序

    下面是简单的 HTML 解析器的一个基本示例，使用 HTMLParser 类，当遇到开始标记、结束标记以及数据的时候将内容打印出来。

    1. from html.parser import HTMLParser
    2.  
    3. class MyHTMLParser(HTMLParser):
    4.     def handle_starttag(self, tag, attrs):
    5.         print("Encountered a start tag:", tag)
    6.  
    7.     def handle_endtag(self, tag):
    8.         print("Encountered an end tag :", tag)
    9.  
    10.     def handle_data(self, data):
    11.         print("Encountered some data  :", data)
    12.  
    13. parser = MyHTMLParser()
    14. parser.feed('<html><head><title>Test</title></head>'
    15.             '<body><h1>Parse me!</h1></body></html>')

    输出是:

    1. Encountered a start tag: html
    2. Encountered a start tag: head
    3. Encountered a start tag: title
    4. Encountered some data  : Test
    5. Encountered an end tag : title
    6. Encountered an end tag : head
    7. Encountered a start tag: body
    8. Encountered a start tag: h1
    9. Encountered some data  : Parse me!
    10. Encountered an end tag : h1
    11. Encountered an end tag : body
    12. Encountered an end tag : html

    HTMLParser 方法

    HTMLParser 实例有下列方法：

    • HTMLParser.feed(data)

    • 填充一些文本到解析器中。如果包含完整的元素，则被处理；如果数据不完整，将被缓冲直到更多的数据被填充，或者 close() 被调用。data 必须为 str 类型。

    • HTMLParser.close()

    • 如同后面跟着一个文件结束标记一样，强制处理所有缓冲数据。这个方法能被派生类重新定义，用于在输入的末尾定义附加处理，但是重定义的版本应当始终调用基类 HTMLParser 的 close() 方法。

    • HTMLParser.reset()

    • 重置实例。丢失所有未处理的数据。在实例化阶段被隐式调用。

    • HTMLParser.getpos()

    • 返回当前行号和偏移值。

    • HTMLParser.get_starttag_text()

    • 返回最近打开的开始标记中的文本。 结构化处理时通常应该不需要这个，但在处理“已部署”的 HTML 或是在以最小改变来重新生成输入时可能会有用处（例如可以保留属性间的空格等）。

    下列方法将在遇到数据或者标记元素的时候被调用。他们需要在子类中重载。基类的实现中没有任何实际操作（除了 handle_startendtag() ）：

    • HTMLParser.handlestarttag(_tag, attrs)
    • 这个方法在标签开始的时候被调用（例如： <div id="main"> ）。

    tag 参数是小写的标记名。attrs 参数是一个 (name, value) 形式的列表，包含了所有在标记的 <> 括号中找到的属性。name 转换为小写，value 的引号被去除，字符和实体引用都会被替换。

    实例中，对于标签 <A HREF="https://www.cwi.nl/"&gt;，这个方法将以下列形式被调用 handle_starttag('a', [('href', 'https://www.cwi.nl/&#39;)]) 。

    html.entities 中的所有实体引用，会被替换为属性值。

    • HTMLParser.handleendtag(_tag)
    • 此方法被用来处理元素的结束标记（例如： </div> ）。

    tag 参数是小写的标签名。

    • HTMLParser.handlestartendtag(_tag, attrs)

    • 类似于 handle_starttag(), 只是在解析器遇到 XHTML 样式的空标记时被调用（ <img … />）。这个方法能被需要这种特殊词法信息的子类重载；默认实现仅简单调用 handle_starttag() 和 handle_endtag() 。

    • HTMLParser.handledata(_data)

    • 这个方法被用来处理任意数据（例如：文本节点和 <script>…</script> 以及 <style>…</style> 中的内容）。

    • HTMLParser.handleentityref(_name)

    • 这个方法被用于处理 &name; 形式的命名字符引用（例如 &gt;），其中 name 是通用的实体引用（例如： 'gt'）。如果 convert_charrefs 为 True，该方法永远不会被调用。

    • HTMLParser.handlecharref(_name)

    • 这个方法被用来处理 &#NNN; 和 &#xNNN; 形式的十进制和十六进制字符引用。例如，&gt; 等效的十进制形式为 &#62; ，而十六进制形式为 &#x3E; ；在这种情况下，方法将收到 '62' 或 'x3E' 。如果 convert_charrefs 为 True ，则该方法永远不会被调用。

    • HTMLParser.handlecomment(_data)

    • 这个方法在遇到注释的时候被调用（例如： <!—comment—> ）。

    例如， <!— comment —> 这个注释会用 ' comment ' 作为参数调用此方法。

    Internet Explorer 条件注释（condcoms）的内容也被发送到这个方法，因此，对于 <!—[if IE 9]>IE9-specific content<![endif]—> ，这个方法将接收到 '[if IE 9]>IE9-specific content<![endif]' 。

    • HTMLParser.handledecl(_decl)
    • 这个方法用来处理 HTML doctype 申明（例如 <!DOCTYPE html> ）。

    decl 形参为 <!…> 标记中的所有内容（例如： 'DOCTYPE html' ）。

    • HTMLParser.handlepi(_data)
    • 此方法在遇到处理指令的时候被调用。data 形参将包含整个处理指令。例如，对于处理指令 <?proc color='red'> ，这个方法将以 handle_pi("proc color='red'") 形式被调用。它旨在被派生类重载；基类实现中无任何实际操作。

    注解

    HTMLParser 类使用 SGML 语法规则处理指令。使用 '?' 结尾的 XHTML 处理指令将导致 '?' 包含在 data 中。

    • HTMLParser.unknowndecl(_data)
    • 当解析器读到无法识别的声明时，此方法被调用。

    data 形参为 <![…]> 标记中的所有内容。某些时候对派生类的重载很有用。基类实现中无任何实际操作。

    示例

    下面的类实现了一个解析器，用于更多示例的演示:

    1. from html.parser import HTMLParser
    2. from html.entities import name2codepoint
    3.  
    4. class MyHTMLParser(HTMLParser):
    5.     def handle_starttag(self, tag, attrs):
    6.         print("Start tag:", tag)
    7.         for attr in attrs:
    8.             print("     attr:", attr)
    9.  
    10.     def handle_endtag(self, tag):
    11.         print("End tag  :", tag)
    12.  
    13.     def handle_data(self, data):
    14.         print("Data     :", data)
    15.  
    16.     def handle_comment(self, data):
    17.         print("Comment  :", data)
    18.  
    19.     def handle_entityref(self, name):
    20.         c = chr(name2codepoint[name])
    21.         print("Named ent:", c)
    22.  
    23.     def handle_charref(self, name):
    24.         if name.startswith('x'):
    25.             c = chr(int(name[1:], 16))
    26.         else:
    27.             c = chr(int(name))
    28.         print("Num ent  :", c)
    29.  
    30.     def handle_decl(self, data):
    31.         print("Decl     :", data)
    32.  
    33. parser = MyHTMLParser()

    解析一个文档类型声明:

    1. >>> parser.feed('<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" '
    2. ...             '"http://www.w3.org/TR/html4/strict.dtd">')
    3. Decl     : DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"

    解析一个具有一些属性和标题的元素:

    1. >>> parser.feed('<img src="python-logo.png" alt="The Python logo">')
    2. Start tag: img
    3.      attr: ('src', 'python-logo.png')
    4.      attr: ('alt', 'The Python logo')
    5. >>>
    6. >>> parser.feed('<h1>Python</h1>')
    7. Start tag: h1
    8. Data     : Python
    9. End tag  : h1

    script 和 style 元素中的内容原样返回，无需进一步解析:

    1. >>> parser.feed('<style type="text/css">#python { color: green }</style>')
    2. Start tag: style
    3.      attr: ('type', 'text/css')
    4. Data     : #python { color: green }
    5. End tag  : style
    6.  
    7. >>> parser.feed('<script type="text/javascript">'
    8. ...             'alert("<strong>hello!</strong>");</script>')
    9. Start tag: script
    10.      attr: ('type', 'text/javascript')
    11. Data     : alert("<strong>hello!</strong>");
    12. End tag  : script

    解析注释:

    1. >>> parser.feed('<!-- a comment -->'
    2. ...             '<!--[if IE 9]>IE-specific content<![endif]-->')
    3. Comment  :  a comment
    4. Comment  : [if IE 9]>IE-specific content<![endif]

    解析命名或数字形式的字符引用，并把他们转换到正确的字符（注意：这 3 种转义都是 '>' ）:

    1. >>> parser.feed('&gt;&#62;&#x3E;')
    2. Named ent: >
    3. Num ent  : >
    4. Num ent  : >

    填充不完整的块给 feed() 执行，handle_data() 可能会多次调用（除非 convert_charrefs 被设置为 True ）:

    1. >>> for chunk in ['<sp', 'an>buff', 'ered ', 'text</s', 'pan>']:
    2. ...     parser.feed(chunk)
    3. ...
    4. Start tag: span
    5. Data     : buff
    6. Data     : ered
    7. Data     : text
    8. End tag  : span

    解析无效的 HTML (例如：未引用的属性）也能正常运行:

    1. >>> parser.feed('<p><a class=link href=#main>tag soup</p ></a>')
    2. Start tag: p
    3. Start tag: a
    4.      attr: ('class', 'link')
    5.      attr: ('href', '#main')
    6. Data     : tag soup
    7. End tag  : p
    8. End tag  : a