模型压缩——基于粒度剪枝

python 网页数据解析

文章目录

• python 网页数据解析
• • XPath解析
  • BeautifulSoup解析
  • PyQuery 解析

XPath解析

<div>
<ul>
<li class="item-0"><a href="link1.html"><span>first item</span></a></li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-inactive"><a href="link3.html">third item</a></li>
<li class="item-1"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
<li class="item-0 item-1"><a href="link5.html">attributeMultiValueMatching</a></li>
<li class="item-0 item-1"  name ='multiple-attributes'><a href="link5.html">multiple-attributes</a></li>
</ul>
</div>

from cgitb import reset

from lxml import etree

def etreeParse():
    # etree模块，会成功构造一个Xpath解析对象，这里etree模块自动修正HTML文本
    # 并且还会自动添加了body html节点

    text = '''
    <div>
    <u1>
    <li class="item-0"><a href="link1.html">first item</a></li>
    <li class="item-1"><a href="link2.html">second item</a</li>
    <li class="item-inactive"><a href="link3.html">third item</a></li>
    <li class="item-1"><a href="link4.html">fourth item</a></li>
    <li class="item-0"><a href="link5.html">fifth item</a>
    </u1>
    </div>
    '''
    html = etree.HTML(text)  #这里调用HTML文本初始化，返回一构造Xpath解析对象
    result = etree.tostring(html)
    print(result.decode('utf-8'))


def etreeParseFromFile():
    # 这里使用从文本读书html解析，首先也是先生成一个Xpath解析对象
    # 我们会使用 // 开头的Xpath规则来选取所有符合要求的结点
    html = etree.parse('test.html',etree.HTMLParser())
    result = html.xpath('//*')  # 使用*代表匹配所有结点，也就是整个HTML文本中所有的结点都会被获取到
    result2 = html.xpath('//li') # 获取所有的li结点
    # 我们可以通过 / 即可查找元素的子节点
    # 我们可以通过 // 即可查找元素的子孙节点
    # 假设我们想选择li结点的所有直接的a的子节点
    result3 = html.xpath('//li/a')
    # 假设我们想选择li结点的所有a的子孙节点
    result4 = html.xpath('//li//a')
    print(result4)

html = etree.parse('./test.html',etree.HTMLParser())
def etreeParseParentNode():
# 知道子节点查找父节点 可以使用..
# 现在首先选中href为link4.html的a节点，然后再获取其父亲节点，然后在获取其class 相关属性，相关代码如下：
result = html.xpath('//a[@href="link4.html"]/../@class')
# 同时也可以使用parent::来获取父亲节点
result = html.xpath('//a[@href="link4.html"]/parent::*/@class')
# 可以使用@ 符号进行属性过滤，比如选足球class 为item-1的li节点
result = html.xpath('//li[@class="item-0"]')
print(result)

def etreeParseTextNode():
# 方式一 先选取a节点 在获取文本
result = html.xpath('//li[@class="item-0"]/a/text()')
# 方式二 选取所有子孙节点的文本，里面或许包含一些特殊的字符
result = html.xpath('//li[@class="item-0"]//text()')
print(result)

def etreeParseNodeProperties():
# 通过@xxx 即可获取属性
result = html.xpath('//li/@class')
print(result)

def attributeMultiValueMatching():
# 当一个节点有多个属性时，可以使使用contains() 方法，第一个参数传入属性名字，第二个参数传入属性值
# 只要此属性包含所传入的属性值，就可以完成匹配
result = html.xpath('//li[contains(@class,"item-0")]/a/text()')
print(result)

def multipleAttributes():
# 多属性匹配 当我们需要更具多个属性确定一个节点，这时需要我们同事匹配多个属性  此时可以使用运算符and 来连接
# 此外还有很多运算符 or 或者 and
result = html.xpath('//li[contains(@class,"item-0") and @name = "multiple-attributes"]/a/text()')
print(result)

def selectInOrder():
# 按序选择  如果我们同时匹配了多个节点，但是只要想要其中的某个节点，如第一或者第二个或者最后一个节点
# 这时可以利用中括号传入索引的方法获取特定次序的节点
result = html.xpath('//li[1]/a/text()')
print(result)
result = html.xpath('//li[last()]/a/text()')
print(result)
result = html.xpath('//li[position()<3]/a/text()')
print(result)
result = html.xpath('//li[last()-2]/a/text()')
print(result)

def nodeAxisSelection():
# 调用ancestor，可以获取所有祖先节点，表示匹配所有节点，因此返回结果是第一个li节点的返回祖先节点
result = html.xpath('//li[1]/ancestor::')
print(result)
# 返回结果是第一个li节点的div祖先节点
result = html.xpath('//li[1]/ancestor::div')
print(result)
# attribute，因此返回结果是第一个li节点的属性值
result = html.xpath('//li[1]/attribute::')
print(result)
# 调用chlid轴，可以直接获取所有子节点，选取herf属性为link1.html的a节点
result = html.xpath('//li[1]/child::a[@href="link1.html"]')
print(result)
# 调用descendant轴 可以获取所有子孙节点，这里又加了限定条件获取span节点，所以返回节点只包含span节点而不含a节点
result = html.xpath('//li[1]/descendant::span')
print(result)
# 调用了following 轴，可以获取当前节点之后的所有节点，但是后面加了索引，所以只获取了第二个节点
result = html.xpath('//li[1]/following::[2]')
print(result)
# 调用了following-sibling 轴，可以获取当前节点之后的所有同级节点
result = html.xpath('//li[1]/following-sibling::*')
print(result)

etreeParseFromFile()

BeautifulSoup解析

from bs4 import BeautifulSoup

html = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="dromouse"><b>The Dormouse's story</b></p>
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
"""
soup = BeautifulSoup(html, 'lxml')
def BeautifulSoupInit():
    # prettify可以把要解析的字符串以标准的缩进格式输出
    print(soup.prettify())
    print(soup.title.string)

def nodeSelector():
    # 节点选择器
    # 直接调用节点的名称就可以选择节点元素，再调用string属性就可以得到节点内的文本了
    print(soup.title)
    print(type(soup.title))
    print(soup.title.string)
    print(soup.head)
    # 当有多个节点时，这种选择方式只会选择到第一个匹配的节点，其他的后面节点都会忽略
    print(soup.p)
    # 调用 name属性就可以得到节点名称：
    print(soup.title.name)
    # 调用attrs获取所有属性：
    print(soup.p.attrs)
    # 调用attrs获取name属性：
    print(soup.p.attrs['name'])
    # ----------等价写法------
    print(soup.p['name'])
    print(soup.p['class'])
    # ----------------------

def relatedSelection():
    html = """
    <html>
        <head>
            <title>The Dormouse's story</title>
        </head>
        <body>
            <p class="story">
                Once upon a time there were three little sisters; and their names were
                <a href="http://example.com/elsie" class="sister" id="link1">
                    <span>Elsie</span>
                </a>
                <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> 
                and
                <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>
                and they lived at the bottom of a well.
            </p>
            <p class="story">...</p>
    """
    soup = BeautifulSoup(html, 'lxml')
    # 关联选择
    # 选取节点元素之后，如果想要获取它的直接子节点，可以调用contents属性
    # 得到的结果是直接子节点的列表
    print(soup.p.contents)
    # 可以调用children属性得到相应的结果
    print(soup.p.children)  # 这里返回的是生成器类型
    for i,child in enumerate(soup.p.children):  # 这里使用for循环遍历输出
        print(i,child)
    # 如果要得到所有的子孙节点的话，可以调用descendants属性：
    for i,child in enumerate(soup.p.descendants):  # 这里使用for循环遍历输出
        print(i,child)

def queryTheFatherNode():
    # 查询父亲节点
    html = """
    <html>
        <head>
            <title>The Dormouse's story</title>
        </head>
        <body>
            <p class="story">
                Once upon a time there were three little sisters; and their names were
                <a href="http://example.com/elsie" class="sister" id="link1">
                    <span>Elsie</span>
                </a>
            </p>
            <p class="story">...</p>
    """
    soup = BeautifulSoup(html, 'lxml')
    # 如果要获取某个节点元素的父节点，可以调用 parent 属性：
    # print(soup.a.parent)
    # 如果想获取所有的祖先节点，可以调用 parents 属性
    print(list(enumerate(soup.a.parents)))

def querySiblingNodes():
    # 查询兄弟节点
    # 这里调用了 4 个属性，其中 next_sibling 和 previous_sibling 分别获取节点的下一个和上一个兄弟元素
    # next_siblings 和 previous_siblings 则分别返回后面和前面的兄弟节点。
    html = """
    <html>
        <body>
            <p class="story">
                Once upon a time there were three little sisters; and their names were
                <a href="http://example.com/elsie" class="sister" id="link1">
                    <span>Elsie</span>
                </a>
                Hello
                <a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> 
                and
                <a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>
                and they lived at the bottom of a well.
            </p>
    """
    soup = BeautifulSoup(html, 'lxml')
    print('Next Sibling', soup.a.next_sibling)
    print('Prev Sibling', soup.a.previous_sibling)
    print('Next Siblings', list(enumerate(soup.a.next_siblings)))
    print('Prev Siblings', list(enumerate(soup.a.previous_siblings)))  #190


def extractInfo():
    # 提取信息
    html = """
    <html>
        <body>
            <p class="story">
                Once upon a time there were three little sisters; and their names were
                <a href="http://example.com/elsie" class="sister" id="link1">Bob</a><a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> 
            </p>
    """
    # 注意事项：
    # 如果返回结果是单个节点，那么可以直接调用 string、attrs 等属性获得其文本和属性；
    # 如果返回结果是多个节点的生成器，则可以转为列表后取出某个元素，然后再调用 string、attrs 等属性获取其对应节点的文本和属性。
    soup = BeautifulSoup(html, 'lxml')
    print('Next Sibling:')
    print(type(soup.a.next_sibling))
    print(soup.a.next_sibling)
    print(soup.a.next_sibling.string)
    print('Parent:')
    print(type(soup.a.parents))
    print(list(soup.a.parents)[0])
    print(list(soup.a.parents)[0].attrs['class'])

# 方法选择器
def methodSelector():
    # find_all() 方法可以查找所有符合条件的节点，并返回一个列表。
    # find_all api ：soup.find_all(name=None, attrs=None, recursive=True, string=None, **kwargs)
    # name：节点名称，可以是字符串或列表。
    # attrs：节点属性，可以是字典或列表。
    # recursive：是否递归查找子孙节点。
    # string：节点文本，可以是字符串或正则表达式。
    # **kwargs：其他关键字参数，比如 limit、offset 等。
    # 示例：
    html = '''
    <div class="panel">
        <div class="panel-heading">
            <h4>Hello</h4>
        </div>
        <div class="panel-body">
            <ul class="list" id="list-1">
                <li class="element">Foo</li>
                <li class="element">Bar</li>
                <li class="element">Jay</li>
            </ul>
            <ul class="list list-small" id="list-2">
                <li class="element">Foo</li>
                <li class="element">Bar</li>
            </ul>
        </div>
    </div>
    '''
    soup = BeautifulSoup(html, 'lxml')
    print(soup.find_all(name='ul'))
    print(type(soup.find_all(name='ul')[0]))
    # 继续查询内部节点
    for ul in soup.find_all(name='ul'):
        # 继续查询 li 节点
        for li in ul.find_all(name='li'):
            print(li.string)

# 方法选择器 - 根据属性选择节点
def methodSelectorByAttrs():
    html = '''
        <div class="panel">
            <div class="panel-heading">
                <h4>Hello</h4>
            </div>
            <div class="panel-body">
                <ul class="list" id="list-1" name = "elements">
                    <li class="element">Foo</li>
                    <li class="element">Bar</li>
                    <li class="element">Jay</li>
                </ul>
                <ul class="list list-small" id="list-2">
                    <li class="element">Foo</li>
                    <li class="element">Bar</li>
                </ul>
            </div>
        </div>
        '''
    soup = BeautifulSoup(html, 'lxml')
    # 查找id属性为list-1的ul节点
    print(soup.find_all(attrs={'id': 'list-1'}))
    # 查找name属性为elements 的ul节点
    print(soup.find_all(attrs={'name': 'elements'}))
    # 对于一些常用的属性 我们可以不用attrs参数，直接传入属性名和属性值
    # 查询id属性为list-1的ul节点
    print(soup.find_all(id='list-1'))


# 方法选择器 - 根据文本选择节点
def methodSelectorByString():
    # string 参数可用来匹配节点的文本，传入的形式可以是字符串，可以是正则表达式对象
    html = '''
    <div class="panel">
        <div class="panel-body">
            <a>Hello, this is a link</a>
            <a>Hello, this is a link, too</a>
        </div>
    </div>
    '''
    soup = BeautifulSoup(html, 'lxml')
    # 查找文本包含 link 的 结点
    print(soup.find_all(string=re.compile('link')))
    # 这里有两个 a 节点，其内部包含文本信息。这里在 find_all() 方法中传入 text 参数，该参数为正则表达式对象，结果返回所有匹配正则表达式的节点文本组成的列表。


# 方法选择器 - find方法
def methodSelectorFind():
    # find 方法可以查找符合条件的第一个节点，并返回节点对象。
    # 与find_all()方法的区别：
    # find_all()方法返回的是一个列表，而find()方法返回的是一个节点对象。
    html = '''
    <div class="panel">
        <div class="panel-heading">
            <h4>Hello</h4>
        </div>
        <div class="panel-body">
            <ul class="list" id="list-1">
                <li class="element">Foo</li>
                <li class="element">Bar</li>
                <li class="element">Jay</li>
            </ul>
            <ul class="list list-small" id="list-2">
                <li class="element">Foo</li>
                <li class="element">Bar</li>
            </ul>
        </div>
    </div>
    '''
    soup = BeautifulSoup(html, 'lxml')
    # 查找第一个ul节点
    print(soup.find(name='ul'))
    # 查找class属性为list的ul节点
    print(soup.find(attrs={'class': 'list'}))

# css 选择器
def cssSelector():
    # CSS 选择器是一种基于选择器语法的语言，可以用来选择 HTML 文档中的元素。
    # 语法：
    # 选择器：选择器可以是标签名、类名、ID名、属性、伪类等。
    # 组合器：可以组合多个选择器，如后代选择器、子选择器、相邻兄弟选择器等。
    # 示例：
    html = '''
    <div class="panel">
        <div class="panel-heading">
            <h4>Hello</h4>
        </div>
        <div class="panel-body">
            <ul class="list" id="list-1">
                <li class="element">Foo</li>
                <li class="element">Bar</li>
                <li class="element">Jay</li>
            </ul>
            <ul class="list list-small" id="list-2">
                <li class="element">Foo</li>
                <li class="element">Bar</li>
            </ul>
        </div>
    </div>
    '''
    soup = BeautifulSoup(html, 'lxml')
    print(soup.select('.panel .panel-heading')) # 选择 class 为 panel 的 div 元素下的 class 为 panel-heading 的 h4 元素
    print(soup.select('#list-1 .element'))  # 选择 id 为 list-1 的 ul 元素下的 class 为 element 的 li 元素
    print(soup.select('ul li'))  # 选择 ul 元素下的 li 元素
    print(soup.select('#list-2 .element'))  # 选择 id 为 list-2 的 ul 元素下的 class 为 element 的 li 元素
    print(type(soup.select('ul')[0]))  # 选择第一个 ul 元素

# 嵌套选择器
def nestedSelector():
    # 嵌套选择器可以选择子元素的子元素。
    # 语法：
    # 选择器1 选择器2
    # 示例：
    html = '''
        <div class="panel">
            <div class="panel-heading">
                <h4>Hello</h4>
            </div>
            <div class="panel-body">
                <ul class="list" id="list-1">
                    <li class="element">Foo</li>
                    <li class="element">Bar</li>
                    <li class="element">Jay</li>
                </ul>
                <ul class="list list-small" id="list-2">
                    <li class="element">Foo</li>
                    <li class="element">Bar</li>
                </ul>
            </div>
        </div>
        '''
    soup = BeautifulSoup(html, 'lxml')
    for ul in soup.select('ul'):  # 选择所有的 ul 元素
        print(ul.select('li'))  # 选择 ul 元素下的 li 元素
    # 获取属性值
    for ul in soup.select('ul'):
        print(ul['id'])
        print(ul.attrs['id'])

nestedSelector()

PyQuery 解析

from pyquery import PyQuery as pq
html = '''
<div id="container">
<ul class="list">
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
'''

#字符串初始化方法
def init():
    doc = pq(html) # 解析html
    print(doc('li')) # 输出所有li标签

# URL初始化方法
def init_url():
    # 初始化的参数不仅可以以字符串的形式传递， 还可以传入网页的 URL，此时只需要指定参数为
    # url 即可：
    url = 'http://cuiqingcai.com'
    doc = pq(url=url) # 解析url
    print(doc('title')) # 输出title标签


# PyQuery 初始化参数说明：
# 1. 字符串初始化方法：
# 传入一个字符串参数，PyQuery 会自动解析该字符串并返回一个 PyQuery 对象，该对象可以进行各种操作，如查找元素、获取属性、设置属性、添加类、删除类等。
# 2. URL初始化方法：
# 传入一个 url 参数，PyQuery 会自动向该 URL 发送请求，获取网页内容，并解析返回的 HTML 内容，返回一个 PyQuery 对象，该对象可以进行各种操作，如查找元素、获取属性、设置属性、添加类、删除类等。
# 3. 文件初始化方法：
# 传入一个文件路径参数，PyQuery 会自动读取该文件内容，并解析返回的 HTML 内容，返回一个 PyQuery 对象，该对象可以进行各种操作，如查找元素、获取属性、设置属性、添加类、删除类等。
# 基本CSS选择器：
def basic_selector():
    doc = pq(html) # 解析html
    print(doc('#container .list li')) # 输出id为container的div下class为list的所有li标签
    print(type(doc('#container .list li')))  #输出id为container的div下class为list的所有li标签的类型


# 查找子节点
def find_child():
    doc = pq(html) # 解析html
    # 传入css 选择器
    # find 方法查找范围节点是所有的子孙节点
    # 如果我们只想查找子节点 则可以使用 children 方法
    items = doc('.list')
    print(items)
    print(type(items))
    lis = items.children()
    print(lis)
    print(type(lis))
    # 选择子节点中class 为 active 的元素
    lis = items.children('.active')
    print(lis)

# 查找父节点
def find_parent():
    # 这是查找直接父亲节点的示例
    doc = pq(html) # 解析html
    item  = doc('.list')
    container = item.parent()    # 父节点
    print(container)
    print(type(container))

# 查找父亲的父亲的节点
def find_grand_parent():
    # 这是查找父亲的父亲节点的示例
    doc = pq(html) # 解析html
    item  = doc('.list')
    container = item.parents()
    print(container)
    print(type(container))

# 查找兄弟节点
def find_sibling():
    # 这是查找兄弟节点的示例
    doc = pq(html) # 解析html
    item  = doc('.list .item-0.active')
    siblings = item.siblings()  # 兄弟节点
    print(siblings)
    # 选择兄弟节点中class 为 active 的元素
    siblings = item.siblings('.active')
    print(siblings)

# 返回多个节点 可以遍历
def return_multiple_nodes():
    # 这是返回多个节点的示例
    doc = pq(html) # 解析html
    # 调用items（）方法后，会得到一个生成器，遍历一下，就可以逐个得到 li节点对象了，
    # 它的类型也是PyQuery类型。每个 li节点还可以调用前面所说的方法进行选择，比如继续查询子节点，
    # 寻找某个祖先节点等，非常灵活。
    items = doc('.list .item-0').items()  # 多个节点
    for item in items:
        print(str(item))

# 获取属性
def get_attr():
    # 这是获取属性的示例
    doc = pq(html) # 解析html
    item  = doc('.item-0.active a')
    print(item,type(item))
    print(item.attr('href'))  # 获取href属性
    # 此外也可以使用attr 属性 来获取属性值 如：
    print(item.attr.href)  # 等价于上面的方法
    a = doc('a')
    print(a)
    for i in a.items():
        print(i.attr.href)  # 遍历所有a标签的href属性值

# 获取文本
def get_text():
    # 这是获取文本的示例
    # text() 方法可以获取元素的文本内容
    doc = pq(html) # 解析html
    item  = doc('.item-0.active a')
    print(item.text())  # 获取文本内容
    ## 对比text() 方法和html() 方法：
    # 例如：
    li = doc('li')
    print(li.text())  # 获取li标签的文本内容
    print(li.html())  # 获取li标签的html内容
    # 这两个方法的区别在于：
    # 结果可能比较出乎意料， html（）方法返回的是第一个 li 节点的内部 HTML文本，而text（）则返
    # 回了所有的li节点内部的纯文本，中间用一个空格分割开，即返回结果是一个字符串。

# 节点操作
def node_operation():
    # pyquery 提供了一系列方法来对节点进行动态修改，比如为某个节点添加一个class，
    # 移除某个节点等，这些操作有时候会为提取信息带来极大的便利。
    doc = pq(html) # 解析html
    li = doc('.item-0.active')
    print(li)
    #  addClass（）和 removeClass（）这些方法可以动态改变节点的 class 属性
    # 添加class
    li.addClass('new-class')
    print(li)
    # 移除class
    li.removeClass('active')
    print(li)
    # 当然，除了操作class这个属性外，也可以用 attr（）方法对属性进行操作。此外，还可以用text()
    # 和html（）方法来改变节点内部的内容。


# 其他的结点操作方法：
def other_node_operation():
    html = '''
    <ul class="list">
         <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    </ul>
    '''
    doc = pq(html)
    li = doc('.item-0.active')
    print(li)
    li.attr('name', 'link') # 设置name 属性
    print(li)
    li.text('changed item')  # 设置文本内容
    print(li)
    li.html('<span>changed item</span>')  # 设置html内容
    print(li)

# 伪类选择器
def pseudo_selector():
    html = '''
    <div class="wrap">
        <div id="container">
            <ul class="list">
                 <li class="item-0">first item</li>
                 <li class="item-1"><a href="link2.html">second item</a></li>
                 <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
                 <li class="item-1 active"><a href="link4.html">fourth item</a></li>
                 <li class="item-0"><a href="link5.html">fifth item</a></li>
             </ul>
         </div>
     </div>
    '''
    doc = pq(html)
    li = doc('li:first-child')  # 选择第一个子节点
    print(li)
    li = doc('li:last-child')  # 选择最后一个子节点
    print(li)
    li = doc('li:nth-child(2)')  # 选择第2个子节点
    print(li)
    li = doc('li:gt(2)')  # 选择第3个及以后的子节点
    print(li)
    li = doc('li:nth-child(2n)')  # 选择偶数个子节点
    print(li)
    li = doc('li:contains(second)')  # 选择包含second的子节点
    print(li)


other_node_operation() # 207