python 网页数据解析

文章目录

[python 网页数据解析](#python 网页数据解析)
- XPath解析
- BeautifulSoup解析

XPath解析

html 复制代码

<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>

python 复制代码

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解析

python 复制代码

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()