python 网页数据解析

🕗 发布于 2024-11-14 18:11 python 开发语言 算法

python 网页数据解析

文章目录

python 网页数据解析
- XPath解析
- BeautifulSoup解析

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

原文地址：https://blog.csdn.net/weixin_45882303/article/details/143727137

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：数据库运维实操优质文章文档分享（含Oracle、MySQL等） | 2024年10月刊
下一篇：Spring高手之路26——全方位掌握事务监听器

量化交易系统开发-实时行情自动化交易-3.4.3.3.期货市场深度数据
市场深度数据（Order Book Data）是了解市场供需力量的重要工具，显示了不同价位上买卖挂单的数量。通过分析市场深度数据，交易者可以识别支撑位和阻力位，了解流动性情况，为交易策略提供决策依据。
阅读更多2024-11-17
出现“ERR_CONNECTION_REFUSED”的原因及解决方法
通过尝试上述方法，您可能能够解决“ERR_CONNECTION_REFUSED”错误并成功访问该网站。如果问题仍然存在，可能需要进一步深入调查或与技术支持团队联系以解决问题。出现“ERR_CONNEC
阅读更多2024-11-17
聚类分析 | MSADBO优化Spectral谱聚类优化算法
聚类分析 | MSADBO优化Spectral谱聚类优化算法
阅读更多2024-11-17
应用层协议之WebSocket
WebSocket是一种强大的实时通信协议，它的双向通信和持久连接特性使得它在许多实时应用场景中发挥着重要作用。然而，在使用WebSocket时也需要注意其兼容性和安全性问题，并合理评估其对服务器资源
阅读更多2024-11-17
Python的秘密基地--Python基础知识
Python是一种高级、解释型、动态和多范式的编程语言，由Guido van Rossum于1989年底首次发布，1991年正式发布第一个版本。Python以简洁、易读和高效著称，非常适合初学者和专业
阅读更多2024-11-17
泛型11.16
①泛型是Java5的新特性，属于编译阶段的功能。②泛型可以让开发者在编写代码时指定集合中存储的数据类型③泛型作用：1.类型安全：指定了集合中元素的类型之后，编译器会在编译时进行类型检查，如果尝试将错误
阅读更多2024-11-17
Go语言24小时极速学习教程（三）常见标准库用法
常见标准库即Go语言自带的库，这里的所有包都可以通过import直接引入，如果你觉得实在是不好用，那么请先保证你学会了标准库的基础上，再学一下`Gookit`，特别是其中的`GoUtil`，千万不要轻
阅读更多2024-11-17
长连接配置以及断线重连
长连接配置以及断线重连
阅读更多2024-11-17
IDEA2024：右下角显示内存
实时知晓idea内存使用情况。
阅读更多2024-11-17
【Python】如何设置VSCode中的Pylint，消除各种没有必要的警告
最近打开VSCode，编辑之前创建的Python项目，突然发现多了一堆报错和警告，如下图所示。就非常吓人，因为之前这个项目是没有任何报错的，我赶紧试着运行了一下，还好，可以正常运行，那就说明是检测出了
阅读更多2024-11-17

python 网页数据解析

python 网页数据解析

文章目录

XPath解析

BeautifulSoup解析

相关文章