Python学习笔记:常用内建模块7XML

前言

最近在学习深度学习，已经跑出了几个模型，但Pyhton的基础不够扎实，因此，开始补习Python了，大家都推荐廖雪峰的课程，因此，开始了学习，但光学有没有用，还要和大家讨论一下，因此，写下这些帖子，廖雪峰的课程连接在这里：廖雪峰
Python的相关介绍，以及它的历史故事和运行机制，可以参见这篇：python介绍
Python的安装可以参见这篇：Python安装
Python的运行模式以及输入输出可以参见这篇：Python IO
Python的基础概念介绍，可以参见这篇：Python 基础
Python字符串和编码的介绍，可以参见这篇：Python字符串与编码
Python基本数据结构：list和tuple介绍，可以参见这篇：Python list和tuple
Python控制语句介绍：ifelse，可以参见这篇：Python 条件判断
Python控制语句介绍：循环实现，可以参见这篇：Python循环语句
Python数据结构：dict和set介绍Python数据结构dict和set
Python函数相关：Python函数
Python高阶特性：Python高级特性
Python高阶函数：Python高阶函数
Python匿名函数：Python匿名函数
Python装饰器：Python装饰器
Python偏函数：Python偏函数
Python模块：Python模块
Python面向对象编程（1）：Python面向对象
Python面向对象编程（2）：Python面向对象（2）
Python面向对象编程（3）：Python面向对象（3）
Python面向对象编程（4）：Pyhton面向对象（4）
Python面向对象高级编程（上）：Python面向对象高级编程（上）
Python面向对象高级编程（中上）：Python面向对象高级编程（中上）
Python面向对象高级编程（中下）：Python面向对象高级编程（中下）
Python面向对象高级编程（完）：Python面向对象高级编程（完）
Python错误调试（起）：Python调试：起
Python错误调试（承）：Python调试：承
Python错误调试（转）：Python调试：转
Python错误调试（合）：python调试：合
Python文件IO编程：Python文件IO
Python文件IO编程2：Python文件IO2
Python文件IO编程3：PYthon文件IO3
Python进程和线程（起）：Python进程和线程起
Python进程和线程（承）：Python进程和线程承
Python进程和线程（转）：Python进程和线程转
Python进程和线程（合）：Python进程和线程合
Python正则表达式：Python正则表达式
Python学习笔记:常用内建模块1：Python学习笔记：常用内建模块1
Python学习笔记:常用内建模块2：Python学习笔记：常用内建模块2
Python学习笔记:常用内建模块3：Python学习笔记：常用内建模块3
Python学习笔记:常用内建模块4：Python学习笔记: 常用内建模块4
Python学习笔记:常用内建模块5：Python学习笔记: 常用内建模块5
Python学习笔记:常用内建模块6:Python学习笔记：常用内建模块6

目录

XML

XML虽然比JSON复杂，在Web中应用也不如以前多了，不过仍有很多地方在用，所以，有必要了解如何操作XML。

DOM vs SAX

操作XML有两种方法：DOM和SAX。DOM会把整个XML读入内存，解析为树，因此占用内存大，解析慢，优点是可以任意遍历树的节点。SAX是流模式，边读边解析，占用内存小，解析快，缺点是我们需要自己处理事件。

正常情况下，优先考虑SAX，因为DOM实在太占内存。

在Python中使用SAX解析XML非常简洁，通常我们关心的事件是start_element，end_element和char_data，准备好这3个函数，然后就可以解析xml了。

举个例子，当SAX解析器读到一个节点时：

<a href="/">python</a>

会产生3个事件：

 start_element事件，在读取<a href="/">时；

    char_data事件，在读取python时；

    end_element事件，在读取</a>时。

用代码实验一下：

from xml.parsers.expat import ParserCreate

class DefaultSaxHandler(object):
    def start_element(self, name, attrs):
        print('sax:start_element: %s, attrs: %s' % (name, str(attrs)))

    def end_element(self, name):
        print('sax:end_element: %s' % name)

    def char_data(self, text):
        print('sax:char_data: %s' % text)

xml = r'''<?xml version="1.0"?>
<ol>
    <li><a href="/python">Python</a></li>
    <li><a href="/ruby">Ruby</a></li>
</ol>
'''

handler = DefaultSaxHandler()
parser = ParserCreate()
parser.StartElementHandler = handler.start_element
parser.EndElementHandler = handler.end_element
parser.CharacterDataHandler = handler.char_data
parser.Parse(xml)

需要注意的是读取一大段字符串时，CharacterDataHandler可能被多次调用，所以需要自己保存起来，在EndElementHandler里面再合并。

除了解析XML外，如何生成XML呢？99%的情况下需要生成的XML结构都是非常简单的，因此，最简单也是最有效的生成XML的方法是拼接字符串：

L = []
L.append(r'<?xml version="1.0"?>')
L.append(r'<root>')
L.append(encode('some & data'))
L.append(r'</root>')
return ''.join(L)

如果要生成复杂的XML呢？建议你不要用XML，改成JSON。

小结

解析XML时，注意找出自己感兴趣的节点，响应事件时，把节点数据保存起来。解析完毕后，就可以处理数据.

练习

请利用SAX编写程序解析Yahoo的XML格式的天气预报，获取天气预报：
https://query.yahooapis.com/v1/public/yql?q=select%20*%20from%20weather.forecast%20where%20woeid%20%3D%202151330&format=xml

from urllib import request
from xml.parsers.expat import ParserCreate

def get_xml(url):
    with request.urlopen(url) as f:
        data = f.read()
        return data.decode('utf-8')


class weatherHandler(object):
    def __init__(self):
        self.result = {}
        self.L = []

    def start_element(self, name, attrs):
        # print('name:', name, 'attrs:', str(attrs))
        if 'location' in name:
            self.result['city'] = attrs['city']
        if 'date' in str(attrs) and 'day' in str(attrs) and 'high' in str(attrs) and 'low' in str(attrs) and 'weather' in str(attrs):
            forecase = {
                'date': attrs['date'],
                'day':  attrs['day'],
                'high': attrs['high'],
                'low': attrs['low'],
                'weather': attrs['text']
            }
            self.L.append(forecase)

    def end_element(self, name):
        if name == 'query':
            self.result['forecase'] = self.L

    def char_data(self, text):
        pass

def paseXml(xml_str):
    handler = weatherHandler()
    parser = ParserCreate()
    parser.StartElementHandler = handler.start_element
    parser.EndElementHandler = handler.end_element
    parser.CharacterDataHandler = handler.char_data
    parser.Parse(xml_str)
    return handler.result

xml_str = get_xml('https://query.yahooapis.com/v1/public/yql?q=select%20*%20from%20weather.forecast%20where%20woeid%20%3D%202151330&format=xml')
result = paseXml(xml_str)

HTMLParser

如果我们要编写一个搜索引擎，第一步是用爬虫把目标网站的页面抓下来，第二步就是解析该HTML页面，看看里面的内容到底是新闻、图片还是视频。

假设第一步已经完成了，第二步应该如何解析HTML呢？

HTML本质上是XML的子集，但是HTML的语法没有XML那么严格，所以不能用标准的DOM或SAX来解析HTML。

好在Python提供了HTMLParser来非常方便地解析HTML，只需简单几行代码：

from html.parser import HTMLParser
from html.entities import name2codepoint

class MyHTMLParser(HTMLParser):

    def handle_starttag(self, tag, attrs):
        print('<%s>' % tag)

    def handle_endtag(self, tag):
        print('</%s>' % tag)

    def handle_startendtag(self, tag, attrs):
        print('<%s/>' % tag)

    def handle_data(self, data):
        print(data)

    def handle_comment(self, data):
        print('<!--', data, '-->')

    def handle_entityref(self, name):
        print('&%s;' % name)

    def handle_charref(self, name):
        print('&#%s;' % name)

parser = MyHTMLParser()
parser.feed('''<html>
<head></head>
<body>
<!-- test html parser -->
    <p>Some <a href=\"#\">html</a> HTML&nbsp;tutorial...<br>END</p>
</body></html>''')

feed()方法可以多次调用，也就是不一定一次把整个HTML字符串都塞进去，可以一部分一部分塞进去。

特殊字符有两种，一种是英文表示的 ，一种是数字表示的Ӓ，这两种字符都可以通过Parser解析出来。

小结

利用HTMLParser，可以把网页中的文本、图像等解析出来。

练习

找一个网页，例如https://www.python.org/events/python-events/，用浏览器查看源码并复制，然后尝试解析一下HTML，输出Python官网发布的会议时间、名称和地点。

example

# -*- coding: utf-8 -*-
# @Time    : 2018/6/16 16:03
# @Author  : mike
# @Email   : [email protected]
# @File    : ex_HTMLPASER_2.py
# @Software: PyCharm

from html.parser import HTMLParser
from html.entities import name2codepoint
from urllib import request
import re


class MyHTMLParser(HTMLParser):
    a_t1 = False
    a_t2 = False
    a_t3 = False
    def __init__(self):
        HTMLParser.__init__(self)
        self.information = []
        self.information_all = {}


    def handle_starttag(self, tag, attrs):
        def _attr(attrlist, attrname):
            for attr in attrlist:
                if attr[0] == attrname:
                    return attr[1]
            return None

        if tag=="time" :
            self.a_t1 = True
        elif tag=="span" and _attr(attrs, 'class')=="event-location":
            self.a_t2 = True
        elif tag=="h3" and _attr(attrs, 'class')=="event-title":
            self.a_t3 = True


    def handle_data(self, data):
        if self.a_t1 is True:
            if re.match(r'^\s\d{4}', data):
                self.information.append(dict(year=data))
            else:
                self.information.append(dict(day=data))
        elif self.a_t2 is True:
            self.information.append(dict(event_location=data))
        elif self.a_t3 is True:
            self.information.append(dict(event_title=data))


    def handle_endtag(self, tag):
        if tag == "time":
            self.a_t1 = False
        elif tag =="span":
            self.a_t2 = False
        elif tag == "h3":
            self.a_t3 = False



def parseHTML(html_str):
    parser = MyHTMLParser()
    parser.feed(html_str)
    for i, val in enumerate(parser.information):
        i +=  1
        print(val)
        if i%4==0:

            print('--------------------------------------------')


URL = 'https://www.python.org/events/python-events/'
with request.urlopen(URL, timeout=4) as f:
    data = f.read()

parseHTML(data.decode('utf-8'))