精华内容
下载资源
问答
  • 《浅谈解析库XPath,bs4和pyquery》 作者:墨非墨菲非菲 前几天在CSDN看到一篇帖子,题目是“如何让自己像打王者一样发了疯,拼了命,石乐志的学习”。这里面讲到了阶段性反馈机制,我觉得蛮有意思的,正好前两天用...
  • 今天想使用pyquery库读取本地HTML文件时报错:UnicodeDecodeError: ‘gbk’ codec can’t decode byte 0xa1 in position 164: illegal multibyte sequence。...  排错过程: 我通过查看pyquery源码,企
  • 1、pyquery安装 pip方式安装: $pip install pyquery #它依赖cssselect和lxml包 pyquery==1.4.0 - cssselect [required: >0.7.9, installed: 1.0.3] #CSS选择器并将它转换为XPath表达式 - lxml [required: >
  • pyquery库是jQuery的Python实现,可以用于解析HTML网页内容,使用方法:复制代码 代码如下:from pyquery import PyQuery as pq1、可加载一段HTML字符串,或一个HTML文件,或是一个url地址,例:复制代码 代码如下:d ...
  • pyquery-1.4.1.zip

    2020-04-01 11:27:31
    python爬虫的好工具,pyquery-1.4.1,可以通过pip install pyquery来进行安装,但是有的时候安装会失败,比如我就失败了好多次,所以自己去官网找了这个包,直接下载下来使用,如果你也有需求,那么可以用我的这个
  • python爬虫-pyquery详解.ipynb代码python爬虫-pyquery详解.ipynb
  • pyquery-ql 使用轻量级客户端查询 什么是pyquery-ql? 它是一个使用和流行的笔记本查询GraphQL API时示例和提示的存储库。 它提供了有关使用优雅的库和熊猫进行数据收集和交互式数据浏览的示例。 pyquery-ql还是...
  • PyQuery

    2018-06-10 10:36:23
    安装pip install pyquery字符串初始化from pyquery import PyQuery as pq doc = pq(html) print(doc('li'))doc CSS选择器,输出5个"li"标签URL初始化from pyquery import PyQuery as pq doc = pq(url='...

    安装

    pip install pyquery

    字符串初始化

    from pyquery import PyQuery as pq
    doc = pq(html)
    print(doc('li'))

    doc CSS选择器,输出5个"li"标签

    URL初始化

    from pyquery import PyQuery as pq
    doc = pq(url='http://www.baidu.com')
    print(doc('head'))

    输出head标签

    文件初始化

    from pyquery import PyQuery as pq
    doc = pq(filename='demo.html')
    print(doc('li'))

    基本CSS选择器

    from pyquery import PyQuery as pq
    doc = pq(html)
    print(doc('#container .list li')

    id为# class为 .    查找id为container 下的class 为list的li标签

    查找元素

    items = doc('.list')
    print(type(items))
    lis = items.find('li')
    print(type(lis))
    print(lis)

    使用find方法,type is pyquery.pyquery.PyQuery

    lis = items.chilren()
    pirnt(type(lis))
    print(lis)

    使用chilren查找直接子元素

    lis = items.chilren('.active')
    print(lis)
    查找class为active的元素


    父元素

    from pyquery import PyQuery as pq
    doc = pq(html)
    items = doc('.list')
    container = items.parent()
    print(type(container))
    print(container)
    from pyquery import PyQuery as pq
    doc = pq(html)
    items = doc('.list')
    parents= items.parents()
    print(type(parents))
    print(parents)

    parent是查找父节点,parents是查找祖先节点

    parent = items.parents('.wrap')
    print(parent)

    可以继续筛选

    兄弟元素

    from pyquery import PyQuery as pq
    doc = pq(html)
    li = doc('.list item-0.active')
    print(li.siblings())
    

    active前面没有加空格,意味着是并列的意思,item-0和active是一个整体,现在要查找的是同时包含item-0和active的标签

    siblings方法是获取兄弟元素

    from pyquery import PyQuery as pq
    doc = pq(html)
    li = doc('.list item-0.active')
    print(li.siblings('.active'))

    siblings中加入参数,为筛选class为active的兄弟元素

    遍历

    单个元素

    from pyquery import PyQuery as pq
    doc = pq(html)
    li = doc('item-0.active')
    print(li)

    是输出单个元素

    from pyquery import PyQuery as pq
    doc = pq(html)
    lis = doc('li').items()
    print(type(lis))
    for li in lis:
     print(li)

    items方法为选择器

    获取信息

    获取属性

    from pyquery import PyQuery as pq
    doc = pq(html)
    a = doc('item-0.active a')
    print(a)
    print(a.attr('href'))
    print(a.attr.href)

    获取a元素的href属性内容

    获取文本

    from pyquery import PyQuery as pq
    doc = pq(html)
    li = doc('item-0.active')
    print(a)
    print(a.text())

    获取HTML

    from pyquery import PyQuery as pq
    doc = pq(html)
    a = doc('item-0.active')
    print(a)
    print(a.html())

    DOM操作

    addClass、removeClass

    from pyquery import PyQuery as pq
    doc = pq(html)
    li = doc('item-0.active')
    print(li)
    li.removeClass('active')
    print(li)
    li.addClass('active')
    print(li)

    attr、css

    from pyquery import PyQuery as pq
    doc = pq(html)
    li = doc('item-0.active')
    print(li)
    li.attr('nane','link')
    print(li)
    li.css('font-size','14px')
    print(li)

    remove

    from pyquery import PyQuery as pq
    doc = pq(html)
    wrap = doc('.wrap')
    print(wrap.text())
    wrap.find('p').remove()
    print(wrap.text())




    展开全文
  • 用Python爬虫PyQuery库简单爬取信息并录入数据库
  • 主要给大家介绍了关于Python网络爬虫神器PyQuery的基本使用教程,文中通过示例代码介绍的非常详细,对大家学习使用PyQuery具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧。
  • 主要介绍了Python爬虫PyQuery库基本用法,结合实例形式较为详细的分析了pyQuery库字符串初始化、打开网页、css属性、标签内容等获取、DOM基本操作等相关技巧与使用注意事项,需要的朋友可以参考下
  • 主要介绍了Python爬虫辅助利器PyQuery模块的安装使用攻略,PyQuery可以方便地用来解析HTML内容,使其成为众多爬虫程序开发者的大爱,需要的朋友可以参考下
  • 主要介绍了python爬虫开发之PyQuery模块详细使用方法与实例全解,需要的朋友可以参考下
  • pyquery-1.3.0

    2017-10-25 16:49:20
    pyquery-1.3.0.tar.gz python插件 python爬虫要用的 如果属性jquery很好入门
  • pyquery-1.4.1-py2.py3-none-any.whl 使用方式 pip install pyquery-1.4.1-py2.py3-none-any.whl安装
  • 19-爬虫解析利器pyquery详解

    千次阅读 多人点赞 2020-10-15 13:41:39
    如果你觉得正则写起来太麻烦,或者BeautifulSoup语法太难记,如果你熟悉jQuery的语法,那么pyquery就是最佳选择。它与jQuery api相同,可以无缝迁移 1.pyquery库的了解 pyquery库是jQuery的Python实现,能够以jQuery...

    强大灵活的网页解析库。如果你觉得正则写起来太麻烦,或者BeautifulSoup语法太难记,如果你熟悉jQuery的语法,那么pyquery就是最佳选择。它与jQuery api相同,可以无缝迁移

    1.pyquery库的了解

    pyquery库是jQuery的Python实现,能够以jQuery的语法来操作解析 HTML 文档,易用性和解析速度都很好。

    image

    1.1 pyquery库的安装方法:

    在cmd输入:pip install pyquery

    1.2 pyquery库的引用:(注意大小写)

    from pyquery import PyQuery as pq
    
    

    2.pyquery初始化

    像BeautifulSoup一样,PyQuery初始化的时候也需要传入HTML数据源来初始化一个操作对象,它的初始化方式有多种,比如直接传入字符串,传入URL,传文件名。下面我们来详细介绍一下。

    2.1直接传入字符串

    在这里我们首先引入了PyQuery这个对象,取别名为pq,然后声明了一个长HTML字符串,当作参数传递给PyQuery,这样就成功完成了初始化,然后接下来将初始化的对象传入CSS选择器,在这个实例中我们传入li节点,这样就可以选择所有的li节点,打印输出可以看到所有的li节点的HTML文本。

    html = '''
    <div>
        <ul>
             <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>
    '''
    
    >>> from pyquery import PyQuery as pq
    >>> doc=pq(html)
    >>> print(doc("li"))
    <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>
    
    

    2.2传入URL

    初始化的参数不仅可以以字符串的形式传递,还可以传入网页的URL,在这里只需要指定参数为url即可。

    >>> from pyquery import PyQuery as pq
    >>> doc=pq(url="http://www.baidu.com")
    >>> print(doc("head")) #输出head标签
    <head><meta http-equiv="content-type" content="text/html;charset=utf-8"/>
    <meta http-equiv="X-UA-Compatible" content="IE=Edge"/>
    <meta content="always" name="referrer"/>
    <link rel="stylesheet" type="text/css" href="http://s1.bdstatic.com/r/www/cache/bdorz/baidu.min.css"/>
    <title>百度</title>
    </head> 
    
    

    这样的话PyQuery会首先请求这个URL,然后用得到的HTML内容完成初始化,其实就相当于我们用网页的源代码以字符串的形式传递给PyQuery来初始化。

    它与下面的功能是相同的:

    >>> from pyquery import PyQuery as pq
    >>> import requests
    >>> doc=pq(requests.get("http://www.baidu.com").text)
    >>> print(doc("head"))
    <head><meta http-equiv="content-type" content="text/html;charset=utf-8"/><meta http-equiv="X-UA-Compatible" content="IE=Edge"/><meta content="always" name="referrer"/><link rel="stylesheet" type="text/css" href="http://s1.bdstatic.com/r/www/cache/bdorz/baidu.min.css"/>
    <title>百度</title>
    </head> 
    >>> 
    
    

    2.3传文件名

    当然除了传递一个URL,还可以传递本地的文件名,参数指定为filename即可。

    image

    当然在这里需要有一个本地HTML文件demo.html,内容是待解析的HTML字符串。这样它会首先读取本地的文件内容,然后用文件内容以字符串的形式传递给PyQuery来初始化。

    以上三种初始化方式均可,当然最常用的初始化方式还是以字符串形式传递。

    3.基本CSS选择器

    从这一节开始,我们就要对PyQuery对象进行操作,获得我们想要的各种数据。你会看到解析网页,不论什么库,基本原理实际上是没有区别的,学会了一种解析库。再看其他解析库文档,是很容易理解的。

    在 CSS 中,选择器是一种模式,用于选择需要添加样式的元素。

    image

    本文只讲clas id 和element最常见的css选择器。对css不太懂了,也没关系,可以去w3c的css选择器

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

    在这里我们初始化PyQuery对象之后,传入了一个CSS选择器,#container .list li,意思是选取id为container的节点内部的class为list的节点内部的所有li节点。然后打印输出,可以看到成功获取到了符合条件的节点。

    然后我们将它的类型打印输出,可以看到它的类型依然是PyQuery类型。有层级的关系需要用空格隔开.

    >>> from pyquery import PyQuery as pq
    >>> doc=pq(html)
    >>> print(doc("#container .list li"))
    <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>
    
    

    4.查找元素

    下面我们介绍一些常用的查询函数,这些函数和jQuery中的函数用法也完全相同。

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

    4.1子元素

    查找子节点需要用到find()方法,传入的参数是CSS选择器,我们还是以上面的HTML为例。可以使用层层嵌套的方式.

    '''
    >>> from pyquery import PyQuery as pq
    >>> doc=pq(html)
    >>> items=doc(".list")
    >>> print(type(items))
    <class 'pyquery.pyquery.PyQuery'>
    
    >>> print(items)
    <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>
    
    >>> list=items.find("li")
    >>> print(type(list))
    <class 'pyquery.pyquery.PyQuery'>
    >>> print(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>
    
    

    首先我们选取了class为list的节点,然后我们调用了find()方法,传入了CSS选择器,选取其内部的li节点,最后都打印输出即可观察到对应的查询结果,可以发现find()方法会将符合条件的所有节点选择出来,结果的类型是PyQuery类型。

    其实find()的查找范围是节点的所有子孙节点,而如果我们只想查找子节点,那可以用children()方法。

    >>> list = items.children()
    >>> print(type(list))
    <class 'pyquery.pyquery.PyQuery'>
    >>> print(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>
    
    

    如果要筛选所有子节点中符合条件的节点,比如我们想筛选出子节点中classactive的节点,可以向children()方法传入CSS选择器.active

    >>> list = items.children('.active')
    >>> print(list)
    <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>
    
    

    4.2父元素

    4.2.1parent()方法

    我们可以用parent()方法来获取某个节点的父节点,我们用一个实例来感受一下:

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

    以下案例分析:

    • 在这里我们首先用.list选取了class为list的节点,然后调用了parent()方法,得到其父节点,类型 依然是PyQuery类型

    • 这里的父节点是该节点的直接父节点,也就是说,它不会再去查找父节点的父节点,即祖先节点。

    >>> from pyquery import PyQuery as pq
    >>> doc = pq(html)
    >>> items = doc('.list')
    >>> container = items.parent()
    >>> print(type(container))
    <class 'pyquery.pyquery.PyQuery'>
    >>> print(container)
    <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>
    
    
    4.2.2parents()方法

    以下案例:但是如果我们想获取某个祖先节点怎么办呢?可以用parents()方法。

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

    parents查找所有的父亲节点,返回两个结果.

    >>> from pyquery import PyQuery as pq
    >>> doc = pq(html)
    >>> items = doc('.list')
    >>> parents = items.parents()
    >>> print(type(parents))
    <class 'pyquery.pyquery.PyQuery'>
    >>> print(parents)
    <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><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>
    
    

    parents可进行再次筛选

    >>> parent = items.parents('.wrap')
    >>> print(parent)
    <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>
    >>> 
    
    

    4.3兄弟元素

    在上面我们说明了子节点和父节点的用法,还有一种节点那就是兄弟节点,如果要获取兄弟节点可以使用siblings()方法。我们还是以上面的HTML代码为例来感受一下:

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

    属性没有加空格表表示同一个标签列里面,是并列的意思.在这里我们首先选择了class为list的节点内部的class为item-0和active的节点,也就是第三个li节点。

    那么很明显它的兄弟节点有四个,那就是第一、二、四、五个li节点。可以看到运行结果也正是我们刚才所说的四个兄弟节点。

    >>> from pyquery import PyQuery as pq
    >>> doc = pq(html)
    >>> li = doc('.list .item-0.active')
    >>> print(li.siblings())
    <li class="item-1"><a href="link2.html">second item</a></li>
                 <li class="item-0">first item</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>
    
    

    果要筛选某个兄弟节点,我们依然可以向方法传入CSS选择器,这样就会从所有兄弟节点中挑选出符合条件的节点了。

    在这里我们筛选了class为active的节点,通过刚才的结果我们可以观察到class为active的兄弟节点只有第四个li节点,所以结果应该是一个,如下:

    >>> from pyquery import PyQuery as pq
    >>> doc = pq(html)
    >>> li = doc('.list .item-0.active')
    >>> print(li.siblings('.active'))
    <li class="item-1 active"><a href="link4.html">fourth item</a></li>
    
    

    5.遍历

    我们刚才可以观察到,PyQuery的选择结果可能是多个节点,可能是单个节点,类型都是PyQuery类型,并没有返回像BeautifulSoup一样的列表。

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

    5.1单个元素

    对于单个节点来说,我们可以直接打印输出,也可直接转成字符串。

    >>> from pyquery import PyQuery as pq
    >>> doc = pq(html)
    >>> li = doc('.item-0.active')
    >>> print(li)
    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    

    5.2多个元素

    如下案例:

    • 对于多个节点的结果,我们就需要遍历来获取了,例如这里我们把每一个li节点进行遍历,,需要调用items()方法
    • 在这里我们可以发现调用items()方法后,会得到一个生成器,遍历一下,就可以逐个得到li节点对象了,它的类型也是PyQuery类型,所以每个li标签还可以调用前面所说的方法进行选择,比如继续查询子节点,寻找某个祖先节点等等,非常灵活。
    >>> from pyquery import PyQuery as pq
    >>> doc = pq(html)
    >>> lis=doc("li").items()
    >>> print(type(list))
    <class 'pyquery.pyquery.PyQuery'>
    >>> for li in lis:
        print(li)
    
    <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>
    
    

    6.获取信息

    提取到节点之后,我们的最终目的当然是提取节点所包含的信息了,比较重要的信息有两类,一是获取属性,二是获取文本,下面我们分别进行说明。

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

    6.1获取属性

    提取到某个PyQuery类型的节点之后,我们可以调用attr()方法来获取属性,有两种方式可以进行获取,如下:

    >>> from pyquery import PyQuery as pq
    >>> doc = pq(html)
    >>> a = doc('.item-0.active a')#这里有个空格,则选择里面的标签
    >>> print(a)
    <a href="link3.html"><span class="bold">third item</span></a>
    >>> print(a.attr('href'))#方法一
    link3.html
    >>> print(a.attr.href)#方法二
    link3.html
    
    

    注意:

    • 当返回结果包含多个节点时,调用attr()方法只会得到第一个节点的属性。
    • 在进行属性获取的时候观察一下返回节点是一个还是多个,如果是多个,则需要遍历才能依次获取每个节点的属性。

    6.2获取文本

    获取节点之后的另一个主要的操作就是获取其内部的文本了,我们可以调用text()方法来获取

    >>> from pyquery import PyQuery as pq
    >>> doc = pq(html)
    >>> a = doc('.item-0.active a')
    >>> print(a)
    <a href="link3.html"><span class="bold">third item</span></a>
    >>> print(a.text())
    third item
    
    

    我们首先选中了一个a节点,然后调用了text()方法,就可以获取其内部的文本信息了,它会忽略掉标签内部包含的所有HTML,只返回纯文字内容。

    6.3获取HTML

    但如果我们想要获取这个节点内部的HTML文本,就可以用html()方法

    >>> from pyquery import PyQuery as pq
    >>> doc = pq(html)
    >>> li = doc('.item-0.active')
    >>> print(li)
    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    >>> print(li.html())
    <a href="link3.html"><span class="bold">third item</span></a>
    
    

    这里我们选中了第三个li节点,然后调用了html()方法,它返回的结果应该是li标签内的所有HTML文本。

    6.4获取属性/文本/HTML总结

    注意:这里同样有一个问题,如果我们选中的结果是多个节点,text()或html()会返回什么内容?

    • 我们选中的是所有的li节点,可以发现html()方法返回的是第一个li节点的内部HTML文本,而text()则返回了所有的li节点内部纯文本,中间用一个空格分割开,实际上是一个字符串。
    • 如果我们得到的结果是多个节点,如果要获取每个节点的内部HTML文本,则需要遍历每个节点,而text()方法不需要遍历就可以获取,它是将所有节点取文本之后合并成一个字符串。

    7.DOM操作

    PyQuery提供了一系列方法来对节点进行动态修改操作,比如为某个节点添加一个class,移除某个节点等等,这些操作有时候会为提取信息带来极大的便利。

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

    7.1addClass、removeClass

    首先我们选中了第三个li节点,然后调用了removeClass()方法,将li的active这个class移除,后来又调用了addClass()方法,又将class添加回来,每执行一次操作,就打印输出一下当前li节点的内容。

    >>> from pyquery import PyQuery as pq
    >>> doc = pq(html)
    >>> li = doc('.item-0.active')
    >>> print(li)
    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    >>> li.removeClass('active')#[<li.item-0>]
    >>> print(li)
    <li class="item-0"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    >>> li.addClass('active')#[<li.item-0.active>]
    >>> print(li)
    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    

    可以看到一共进行了三次输出,第二次输出li标签的active这个class被移除了,第三次class又添加回来了。
    所以说我们addClass()、removeClass()这些方法可以动态地改变节点的class属性。

    7.2attr、css

    7.2.1attr

    当然除了操作class这个属性,也有attr()方法来专门针对属性进行操作

    >>> from pyquery import PyQuery as pq
    >>> doc = pq(html)
    >>> li = doc('.item-0.active')
    >>> print(li)
    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    >>> li.attr('name', 'link')#[<li.item-0.active>]
    >>> print(li)
    <li class="item-0 active" name="link"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    

    在这里我们首先选中了li标签,然后调用attr()方法来修改/增加属性,第一个参数为属性名,第二个参数为属性值.如原来存在,则修改属性值,如不存在,则增加.

    7.2.2css
    >>> from pyquery import PyQuery as pq
    >>> doc = pq(html)
    >>> li = doc('.item-0.active')
    >>> print(li)
    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    >>> li.css('font-size', '14px')#[<li.item-0.active>]
    >>> print(li)
    <li class="item-0 active" name="link" style="font-size: 14px"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    

    7.3remove

    remove顾名思义移除,remove()方法有时会为信息的提取带来非常大的便利。这个用的比较频繁下面我们看一个实例:

    html = '''
    <div class="wrap">
        Hello, World
        <p>This is a paragraph.</p>
     </div>
    '''
    
    

    在这里有一段HTML文本,我们现在想提取Hello, World这个字符串,而不要p节点内部的字符串,这个怎样来提取?

    >>> from pyquery import PyQuery as pq
    >>> doc = pq(html)
    >>> wrap = doc('.wrap')
    >>> print(wrap.text())
    Hello, World
    This is a paragraph.
    >>> wrap.find('p').remove()#[<p>]
    >>> print(wrap.text())
    Hello, World
    
    

    注意:

    • 在这里我们直接先尝试提取class为wrap的节点的内容,看看是不是我们想要的,运行结果是Hello, World,This is a paragraph.
    • 然而这个结果还包含了内部的p节点的内容,也就是说text()把所有的纯文本全提取出来了。如果我们想去掉p节点内部的文本,可以选择再把p节点内的文本提取一遍,然后从整个结果中移除这个子串,但这个做法明显比较繁琐。
    • 那这是remove()方法就可以派上用场了,我们可以接着这么做,我们首先选中了p节点,然后调用了remove()方法将其移除,然后这时wrap内部就只剩下Hello, World这句话了,然后再利用text()方法提取即可。
    • 所以说,remove()方法可以删除某些冗余内容,来方便我们的提取。在适当的时候使用可以极大地提高效率。

    其他DOM方法

    8.伪类选择器

    CSS选择器之所以强大,还有一个很重要的原因就是它支持多种多样的伪类选择器。例如选择第一个节点、最后一个节点、奇偶数节点、包含某一文本的节点等等,我们用一个实例感受一下:

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

    计数是从0开始的

    from pyquery import PyQuery as pq
    doc = pq(html)
    li = doc('li:first-child')#节点、第一个
    print(li)
    li = doc('li:last-child')#节点、最后一个
    print(li)
    li = doc('li:nth-child(2)')#节点、第二个
    print(li)
    li = doc('li:gt(2)')#获取序号比2大的标签
    print(li)
    li = doc('li:nth-child(2n)')#获取偶数的标签,2n+1则是获得奇数
    print(li)
    li = doc('li:contains(second)')#包含second文本的
    print(li)
    
    <li class="item-0">first item</li>
    
    <li class="item-0"><a href="link5.html">fifth item</a></li>
    
    <li class="item-1"><a href="link2.html">second item</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>
    
    <li class="item-1"><a href="link2.html">second item</a></li>
                 <li class="item-1 active"><a href="link4.html">fourth item</a></li>
    
    <li class="item-1"><a href="link2.html">second item</a></li>
    
    ```python
    
    更多CSS选择器可以查看
    [http://www.w3school.com.cn/css/index.asp](https://link.jianshu.com?t=http%3A%2F%2Fwww.w3school.com.cn%2Fcss%2Findex.asp)
    官方文档
    [http://pyquery.readthedocs.io/](https://link.jianshu.com?t=http%3A%2F%2Fpyquery.readthedocs.io%2F)
    
    作者:田小田txt
    链接:https://www.jianshu.com/p/5def029dbdf8
    

    在线练习:https://www.520mg.com/it
    IT 入门感谢关注
    IT 入门 感谢关注

    展开全文
  • 主要介绍了使用selenium和pyquery爬取京东商品列表过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • pyquery

    2018-08-03 19:52:58
    https://www.cnblogs.com/lei0213/p/7676254.html
    展开全文
  • 主要介绍了基于xpath选择器、PyQuery、正则表达式的格式清理工具,本文给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • python + selenium +pyquery 爬虫 爬取 1688详情图片 阿里巴巴详情图片 与标题 下载图片并进行压缩 仅供学习交流使用
  • 解析库pyquery的使用

    2021-11-02 13:28:00
    文章目录1.准备工作2.初始化字符串初始化URL初始化...这篇文章所讲的pyquery会有一些更强大的功能。 1.准备工作 在开始之前,需要安装pyquery。如果没有安装,可以使用pip命令或者pycharm插件进行安装。 2.初始化 像


    之前的文章中介绍了Beautiful Soup的用法,它是一个非常强大的网页解析库,但是它的CSS选择器的功能可能没有那么强大。这篇文章所讲的pyquery会有一些更强大的功能。

    1.准备工作

    在开始之前,需要安装pyquery。如果没有安装,可以使用pip命令或者pycharm插件进行安装。

    2.初始化

    像Beautiful Soup一样,初始化的时候,也需要传入HTML文本来初始化一个PyQuery对象。它的初始化方式有很多种,比如直接传入字符串,传入URL,传入文件名,等等。

    字符串初始化

    我们可以先用一个实例来感受:

    html='''
    <div>
    <ul>
    <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>
    '''
    from pyquery import PyQuery as pq
    doc = pq(html)
    print(doc('li'))
    

    运行结果如下

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

    这里首先引入PyQuery这个对象,取别名pq。然后声明了一个长HTML字符串,并将其当作参数传递给pyQuery类,这样就完成了初始化。接下来,将初始化的对象传入CSS选择器。在这个实例中,我们传入li节点,这样就可以选择所有的节点。

    URL初始化

    初始化的参数不仅可以以字符串的形式传递,还可以传入网页的URL,此时只需要指定参数为url即可:

    from pyquery import PyQuery as pq
    doc = pq(url='https://cuiqingcai.com')
    print(doc('title'))
    

    运行结果

    <title>静觅丨崔庆才的个人站点</title>
    

    这样的话,PyQuery对象会首先请求这个URL,然后用得到的HTML内容完成初始化,这其实就相当于用网页的源代码以字符串的形式传递给PyQuery类来初始化。
    这样写是一样的

    from pyquery import PyQuery as pq
    import requests
    doc = pq(requests.get('https://cuiqingcai.com').text)
    print(doc('title'))
    

    文件初始化

    除了传递URL,还可以传递本地文件名,此时将参数指定为filename即可:

    from pyquery import PyQuery as pq
    doc = pq(filename='test.html')
    print(doc('li'))
    

    当然,这里需要本地有一个HTML文件为test.html,其内容是待解析的HTML字符串。这样它会首先读取本地的文件内容,然后用文件内容以字符串的形式传递给PyQuery类来初始化。

    3.CSS选择器

    首先,先用一个实例来感受pyquery的CSS选择器的用法:

    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>
    '''
    from pyquery import PyQuery as pq
    doc = pq(html)
    print(doc('#container .list li'))
    print(type(doc('#container .list li')))
    

    运行结果如下

    <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>
    
    <class 'pyquery.pyquery.PyQuery'>
    

    这里我们初始化PyQuery对象后,传入了一个CSS选择器#container .list li,它的意思是先选取id为container的节点,然后再选择其内部的class为list的节点内部的所有li节点。然后,打印输出。可以看到,我们成功获取到了符合条件的节点。
    最后,将它的类型打印输出。可以看到,它的类型依然是PyQuery类型。

    4.查找节点

    子节点

    查找子节点时,需要用到find()方法,此时传入的参数是CSS选择器。这里还是以前面的HTML为例:

    from pyquery import PyQuery as pq
    doc = pq(html)
    items = doc('.list')
    print(type(items))
    print(items)
    lis = items.find('li')
    print(type(lis))
    print(lis)
    

    运行结果:

    <class 'pyquery.pyquery.PyQuery'>
    <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>
    
    <class 'pyquery.pyquery.PyQuery'>
    <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>
    

    首先,我们选取class为list的节点,然后调用了find()方法,传入CSS选择器,选取其内部的li节点,最后打印输出。
    其实find()的查找范围是节点的所有子孙节点,而我们如果只想查找子节点,可以用children()方法:

    lis = items.children()
    print(type(lis))
    print(lis)
    

    运行结果如下:

    <class 'pyquery.pyquery.PyQuery'>
    <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>
    

    如果要筛选所有子节点中符合条件的节点。比如想筛选出子节点中class为active的节点,可以向children()方法传入CSS选择器.active:

    lis = items.children('.active')
    print(lis)
    

    运行结果:

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

    可以看到,输出结果已经做了筛选,留下了class为active的节点。

    父节点

    我们可以用parent()方法来获取某个节点的父节点,例如:

    html='''
    <div class="warp">
    <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>
    '''
    from pyquery import PyQuery as pq
    doc = pq(html)
    items = doc('.list')
    cotainer = items.parent()
    print(type(cotainer))
    print(cotainer)
    

    运行结果如下:

    <class 'pyquery.pyquery.PyQuery'>
    <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>
    

    这里我们首先用.list选取class为list的节点,然后调用parent()方法得到其父节点,其类型依然是PyQuery类型。
    这里的父节点是该节点的直接父节点,也就是说,它不会再去查找父节点的父节点,即祖先节点。
    但是如果想获取某个祖先节点,该怎么办?我们可以用parents方法:

    from pyquery import PyQuery as pq
    doc = pq(html)
    items = doc('.list')
    cotainer = items.parents()
    print(type(cotainer))
    print(cotainer)
    

    运行结果如下:

    <class 'pyquery.pyquery.PyQuery'>
    <div class="warp">
    <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><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>
    

    可以看到,输出结果有两个:一个是class为wrap的节点,一个是id为container的节点。也就是说,parents()方法会返回所有的祖先节点。
    如果想要筛选某个祖先节点的话,可以向parents()方法传入CSS选择器,这样就会返回祖先节点中符合CSS选择器的节点:

    parent = items.parents('.warp')
    print(parent)
    

    运行结果如下

    <div class="warp">
    <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>
    

    可以看到,输出少了一个节点,只保留了class为wrap的节点

    兄弟节点

    前面说了子节点和父节点的用法,还有一种节点,那就是兄弟节点。如果要获取兄弟节点,可以使用siblings(0方法。这里还是以上面的HTML代码为例:

    from pyquery import PyQuery as pq
    doc = pq(html)
    li = doc('.list .item-0.active')
    print(li.siblings())
    

    这里首先选择class为list的节点内部class为item-0和active的节点,也就是第三个li节点。那么,很明显,它的兄弟节点有4个,那就是第一、二、四、五个li节点
    运行结果如下

    <li class="item-1"><a href="link2.html">second item</a></li>
    <li class="item-0">first item</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>
    

    如果要筛选某个兄弟节点,我们依然可以向siblings方法传入CSS选择器,这样就会从所有兄弟节点中挑选出符合条件的节点:

    from pyquery import PyQuery as pq
    doc = pq(html)
    li = doc('.list .item-0.active')
    print(li.siblings('.active'))
    

    这里我们筛选了class为active的节点,通过刚才的结果可以观察到,class为active的兄弟节点只有第四个li节点,所以结果应该是一个。
    我们再看一下运行结果:

    <li class="item-1 active"><a href="link4.html">fourth item</a></li>
    

    5.遍历

    刚才可以观察到,pyquery的选择结果可能是多个节点,也可能是单个节点,类型都是PyQuery类型,并没有返回像Beautiful Soup那样的列表。
    对于单个节点来说,可以直接打印输出,也可以直接转成字符串:

    from pyquery import PyQuery as pq
    doc = pq(html)
    li = doc('.item-0.active')
    print(li)
    print(str(li))
    

    运行结果:

    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    

    对于多个节点的结果,我们就需要遍历来获取了。例如,这里吧每一个li节点进行遍历,需要调用items()方法:

    from pyquery import PyQuery as pq
    doc = pq(html)
    lis = doc('li').items()
    print(type(lis))
    for li in lis:
        print(li,type(li))
    

    运行结果如下:

    <class 'generator'>
    <li class="item-0">first item</li>
     <class 'pyquery.pyquery.PyQuery'>
    <li class="item-1"><a href="link2.html">second item</a></li>
     <class 'pyquery.pyquery.PyQuery'>
    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
     <class 'pyquery.pyquery.PyQuery'>
    <li class="item-1 active"><a href="link4.html">fourth item</a></li>
     <class 'pyquery.pyquery.PyQuery'>
    <li class="item-0"><a href="link5.html">fifth item</a></li>
     <class 'pyquery.pyquery.PyQuery'>
    

    可以发现,调用items()方法后,会得到一个生成器,遍历一下,就可以逐个得到li节点对象le,它的类型也是PyQury类型。每个li节点好可以调用前面所说的方法进行选择,比如继续查询字节但,寻找某个祖先节点等,非常灵活。

    6.获取信息

    提取到节点之后,我们的最终目的当然是提取节点所包含的信息了。比较重要的信息有两类,一是获取属性,二是获取文本,下面分别进行说明。

    获取属性

    提取到某个PyQuery类型的节点后,就可以调用attr()方法来获取属性:

    html='''
    <div class="warp">
    <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>
    '''
    from pyquery import PyQuery as pq
    doc = pq(html)
    a = doc('.item-0.active a')
    print(a,type(a))
    print(a.attr('href'))
    

    运行结果如下:

    <a href="link3.html"><span class="bold">third item</span></a> <class 'pyquery.pyquery.PyQuery'>
    link3.html
    

    这里首先选中class为item-0和active的li节点内的a节点,它的类型是PyQuery类型。
    然后调用attr()方法。在这个方法中传入属性的名称,就可以得到这个属性值了。
    此外,也可以通过attr属性来获取属性,用法如下:

    print(a.attr.href)
    

    运行结果

    link3.html
    

    这两种方法的结果完全一样。
    如果选中的是多个元素,然后调用attr()方法,会出现怎样的结果?我们实验一下:

    a = doc('a')
    print(a,type(a))
    print(a.attr('href'))
    print(a.attr.href)
    

    运行结果如下:

    <a href="link2.html">second item</a><a href="link3.html"><span class="bold">third item</span></a><a href="link4.html">fourth item</a><a href="link5.html">fifth item</a> <class 'pyquery.pyquery.PyQuery'>
    link2.html
    link2.html
    

    照理说,我们选中的a节点应该有4个,而且打印结果也应该有4个,但是当我们调用attr()方法时,返回结果却是第一个。这是因为,当返回结果包含多个节点时,调用attr()方法,只会得到第一个节点的属性。
    那么,遇到这种情况时,如果想获取所有的a节点的属性,就要用到i前所说的遍历:

    from pyquery import PyQuery as pq
    doc = pq(html)
    a = doc('a')
    for item in a.items():
        print(item.attr('href'))
    

    运行结果

    link2.html
    link3.html
    link4.html
    link5.html
    

    因此,在进行属性获取时,可以观察返回节点是一个还是多个。如果是多个,则需要遍历才能依次获取每个节点的属性。

    获取文本

    获取节点之后的另一个主要操作就是获取其内部的文本了,此时可以调用text()方法来实现:

    html='''
    <div class="warp">
    <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>
    '''
    from pyquery import PyQuery as pq
    doc = pq(html)
    a = doc('.item-0.active a')
    print(a)
    print(a.text())
    

    运行结果:

    <a href="link3.html"><span class="bold">third item</span></a>
    third item
    

    这里首先选中一个a节点,然后调用text()方法,就可以获取其内部的文本信息。此时它会忽略掉节点内部包含的所有HTML,只返回纯文字内容。
    但如果想获取这个节点内部的HTML文本,就要用html()方法了

    from pyquery import PyQuery as pq
    doc = pq(html)
    li = doc('.item-0.active')
    print(li)
    print(li.html())
    

    这里我们选中了第三个li节点,然后调用了html()方法,它返回的结果应该是li节点内的所有HTML文本。
    运行结果如下:

    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    <a href="link3.html"><span class="bold">third item</span></a>
    

    这里同样有一个问题,如果我们选中的结果是多个节点,text()或html()会返回什么内容?我们用实例来看一下:

    html='''
    <div class="warp">
    <div id="container">
    <ul class="list">
    <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>
    '''
    from pyquery import PyQuery as pq
    doc = pq(html)
    li = doc('li')
    print(li.html())
    print(li.text())
    print(type(li.text()))
    

    运行结果:

    <a href="link2.html">second item</a>
    second item third item fourth item fifth item
    <class 'str'>
    

    结果可能比较出乎意料,html()方法返回的是第一个li节点的内部HTML文本,而text()则返回了所有的li节点内部的纯文本,中间用一个空格分隔开,即返回结果是一个字符串。
    所以这个地方值得注意,如果得到结果是多个节点,并且想要获取每个节点的内部HTML文本,则需要遍历每个节点,而text()方法不需要遍历就可以获取,它将所有节点取文本之后合并成一个字符串。

    7.节点操作

    pyquery提供了一系列方法来对节点进行动态修改,比如为某个节点添加一个class,移除某个节点等,这些操作有时候会为提取信息带来极大的便利。
    我们来看几个方法

    addClass和removeClass

    html='''
    <div class="warp">
    <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>
    '''
    from pyquery import PyQuery as pq
    doc = pq(html)
    li = doc('.item-0.active')
    print(li)
    li.remove_class('active')
    print(li)
    li.add_class('active')
    print(li)
    

    首先选中了第三个li节点,然后调用removeClass()方法,将li节点的active这个class移除,后来又调用addClass()方法,将class添加回来。每执行一次操作,就打印输出当前li节点的内容。
    运行结果如下:

    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    <li class="item-0"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    

    可以看到,一共输出了3次。第二次输出时,li节点的active这个class被移除了,第三次class又添加回来了。
    所以说,addClass()和removeClass()这些方法可以动态改变节点的class属性。

    attr、text和html

    当然,除了操作class这个属性外,也可以用attr()方法对属性进行操作。此外,还可以用text()和html()方法来改变节点内部的内容。例如

    html = '''
    <ul class="list">
    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    '''
    from pyquery import PyQuery as pq
    doc= pq(html)
    li = doc('.item-0.active')
    print(li)
    li.attr('name','link')
    print(li)
    li.text('changed item')
    print(li)
    li.html('<span>changed item</span>')
    print(li)
    

    这里我们首先选中li节点,然后调用attr()方法来修改属性,其中该方法的第一个参数为属性名,第二个参数为属性值。接着,调用text()和html()方法来改变节点内部的内容。三次操作后、分别打印输出当前的li节点。
    运行结果如下:

    <li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    <li class="item-0 active" name="link"><a href="link3.html"><span class="bold">third item</span></a></li>
    
    <li class="item-0 active" name="link">changed item</li>
    
    <li class="item-0 active" name="link"><span>changed item</span></li>
    

    可以发现,调用attr()方法后,li节点多了一个原本不存在的属性name,其值为link。接着调用text()方法,传入文本之后,li节点内部的文本全被改为传入的字符串文本了。最后,调用html()方法传入HTML文本后,li节点内部又变为传入的HTML文本了。
    所以说,如果attr()方法只传入第一个参数的属性名,则是获取这个属性值;如果传入第二个参数,可以用来修改属性值。text()和html()方法如果不传参数,则是获取节点内纯文本和HTML文本;如果传入参数,则进行赋值。

    remove()

    html = '''
    <div class="wrap">
       Hello,World
    <p>This is a paragraph.</p>
    </div>
    '''
    from pyquery import PyQuery as pq
    doc = pq(html)
    wrap = doc('.wrap')
    print(wrap.text())
    

    现在想提取Hello,World这个字符串,而不要p节点内部的字符串,需要怎样操作?
    这里直接先尝试提取class为wrap的节点的内容,看看是不是我们想要的。运行结果如下:

    Hello,World
    This is a paragraph.
    

    这个结果还包含了p节点的内容,也即是说text()把所有的纯文本全提取出来了。如果我们想去掉p节点内部的文本,可以选择再把p节点内的文本提取一遍,然后从整个结果中移除这个子串,但这个做法比较烦琐。
    这时可以用remove

    wrap.find('p').remove()
    print(wrap.text())
    

    首先选中p节点,然后调用了remove()方法将其移除,然后这时wrap内部就只剩下Hello,World这句话了,然后利用text()方法。
    另外,其实还有很多节点操作的方法,比如append()、empty()和prepend()等方法,它们和jQuery的用法完全一致,详细的用法可以参考官方问文档:http://pyquery.readthedocs.io/en/latest/api.html

    8.伪类选择器

    CSS选择器之所以强大,还有一个重要的原因,那就是它支持多种多样的伪类选择器,例如选择第一个、最后一个、奇偶数节点、包含某一文本的节点等。示例如下:

    html='''
    <div class="warp">
    <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>
    '''
    from pyquery import PyQuery as pq
    doc = pq(html)
    li = doc('li:first-child')
    print(li)
    li = doc('li:last-child')
    print(li)
    li = doc('li:nth-child(2)')
    print(li)
    li = doc('li:gt(2)')
    print(li)
    li = doc('li:nth-child(2n)')
    print(li)
    li = doc('li:contains(second)')
    print(li)
    

    运行结果如下:

    <li class="item-0">first item</li>
    
    <li class="item-0"><a href="link5.html">fifth item</a></li>
    
    <li class="item-1"><a href="link2.html">second item</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>
    
    <li class="item-1"><a href="link2.html">second item</a></li>
    <li class="item-1 active"><a href="link4.html">fourth item</a></li>
    
    <li class="item-1"><a href="link2.html">second item</a></li>
    

    这里我们使用了CSS3的伪类选择器,依次选择了第一个li节点、最后一个li节点、第二个li节点,第三个li之后的li节点、偶数位置的li节点、包含second文本的li节点。
    关于CSS选择器的更多用法,可以参考http://www.w3school.com.cn/css/index.asp
    到此为止,pyquery的常用用法就介绍完了。如果想了解更多内容,可以参考pyquery的官方文档:http://pyquery.readthedocs.io.

    展开全文
  • pyquery-1.4.0.tar.gz

    2019-05-12 23:29:37
    pyquery-1.4.0
  • pyquery - PyQuery完整的API

    千次阅读 2018-06-11 17:49:29
    class pyquery.pyquery.PyQuery(*args, **kwargs)类pyquery.pyquery.PyQuery (* args,** kwargs )主要类 Fn 类 构建自定义函数(如jQuery.fn):&gt;&gt;&gt; fn = lambda: this.map(lambda i, ...
  • Python爬虫之PyQuery模块

    2020-06-24 14:57:58
    Python爬虫之PyQuery模块一:PyQuery简介二:初始化2.1 字符串的初始化2.2 URL初始化2.3 文件初始化三:基本CSS选择器3.1 查找子节点3.2 查找父节点3.3 查找兄弟节点四:遍历五:获取信息5.1 获取属性5.2 获取文本六...
  • pyquery:类似于python的jquery库
  • python pyquery 库是学习爬虫必备的一个库,它解析强大,有超高的应用场景,可以帮你快速解析网页,找到你想找到的内容
  • lxml与pyquery解析html

    2019-10-29 08:23:07
    首先来了解一下lxml,很多常用的解析html的库都用到了lxml这个库,例如BeautifulSoup、pyquery。 下面我们介绍一下lxml关于html解析的3个Element。 _Element _Element获取 from lxml import etree text = '''...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,673
精华内容 3,869
关键字:

pyquery