Python爬虫 pyquery库详解#4

简介: pyquery 初始化,基本CSS选择器,查找节点,遍历,节点操作,伪类选择器【2月更文挑战第15天】

使用 pyquery

在上一节中,我们介绍了 Beautiful Soup 的用法,它是一个非常强大的网页解析库,你是否觉得它的一些方法用起来有点不适应?有没有觉得它的 CSS 选择器的功能没有那么强大?

如果你对 Web 有所涉及,如果你比较喜欢用 CSS 选择器,如果你对 jQuery 有所了解,那么这里有一个更适合你的解析库 ——pyquery。

接下来,我们就来感受一下 pyquery 的强大之处。


1. 准备工作

在开始之前,请确保已经正确安装好了 pyquery。若没有安装,可以参考第 1 章的安装过程。

2. 初始化

像 Beautiful Soup 一样,初始化 pyquery 的时候,也需要传入 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'))

image.gif

运行结果如下:

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

    URL 初始化

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

    from pyquery import PyQuery as pq
    headers = {
        'User-Agent': 'Mozilla/5.0 (',
    }
    doc = pq(url='https://blog.csdn.net/lizhongjun1005', headers=headers)
    print(doc('title'))

    image.gif

    运行结果:

    仲君Johnny-CSDN博客

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

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

    from pyquery import PyQuery as pq
    import requests
    headers = {
        'User-Agent': 'Mozilla/5.0 (',
    }
    doc = pq(requests.get('http://blog.csdn.net/lizhongjun1005', headers=headers).text)
    print(doc('title'))

    image.gif

    文件初始化

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

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

    image.gif

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

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

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

    image.gif

    运行结果:

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

    最后,将它的类型打印输出。可以看到,它的类型依然是 PyQuery 类型。

    4. 查找节点

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

    子节点

    查找子节点需要用到 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)

    image.gif

    运行结果:

       

    • first item
    •  

    • second item
    •  

    • third item
    •  

    • fourth item
    •  

    • fifth item
    • first item
    • second item
    • third item
    • fourth item
    • fifth item
    • 首先,我们选取 class 为 list 的节点,然后调用了 find() 方法,传入 CSS 选择器,选取其内部的 li 节点,最后打印输出。可以发现,find() 方法会将符合条件的所有节点选择出来,结果的类型是 PyQuery 类型。

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

      lis = items.children()

      print(type(lis))

      print(lis)

      运行结果如下:

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

      lis = items.children('.active')

      print(lis)

      运行结果:

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

      父节点

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

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

      image.gif

      运行结果如下:

       

               

      • first item
      •        

      • second item
      •        

      • third item
      •        

      • fourth item
      •        

      • fifth item
      •    

         

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

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

        但是如果想获取某个祖先节点,该怎么办呢?这时可以用 parents 方法:

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

        image.gif

        运行结果:

         

             

                     

        • first item
        •            

        • second item
        •            

        • third item
        •            

        • fourth item
        •            

        • fifth item
        •        

             

           

           

               

                       

          • first item
          •            

          • second item
          •            

          • third item
          •            

          • fourth item
          •            

          • fifth item
          •        

               

            可以看到,输出结果有两个:一个是 class 为 wrap 的节点,一个是 id 为 container 的节点。也就是说,parents() 方法会返回所有的祖先节点。

            如果想要筛选某个祖先节点的话,可以向 parents 方法传入 CSS 选择器,这样就会返回祖先节点中符合 CSS 选择器的节点:

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

            image.gif

            运行结果:

             

                 

                         

            • first item
            •            

            • second item
            •            

            • third item
            •            

            • fourth item
            •            

            • fifth item
            •        

                 

               

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

              兄弟节点

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

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

              image.gif

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

              运行结果:

            • second item
            • first item
            • fourth item
            • fifth item
            • 可以看到,这正是我们刚才所说的 4 个兄弟节点。

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

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

              image.gif

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

              我们再看一下运行结果:

            • fourth item
            • 5. 遍历

              刚才可以观察到,pyquery 的选择结果可能是多个节点,也可能是单个节点,类型都是 PyQuery 类型,并没有返回像 Beautiful Soup 那样的列表。

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

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

              image.gif

              运行结果:

            • third item
            • third item
            • 对于多个节点的结果,我们就需要遍历来获取了。例如,这里把每一个 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))

              image.gif

              运行结果如下:

            • first item
            • second item
            • third item
            • fourth item
            • fifth item
            • 可以发现,调用 items() 方法后,会得到一个生成器,遍历一下,就可以逐个得到 li 节点对象了,它的类型也是 PyQuery 类型。每个 li 节点还可以调用前面所说的方法进行选择,比如继续查询子节点,寻找某个祖先节点等,非常灵活。

              6. 获取信息

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

              获取属性

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

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

              image.gif

              运行结果如下:

              third item

              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)

              image.gif

              运行结果如下:

              second itemthird itemfourth itemfifth item

              link2.html

              link2.html

              照理来说,我们选中的 a 节点应该有 4 个,而且打印结果也应该是 4 个,但是当我们调用 attr 方法时,返回结果却只是第一个。这是因为,当返回结果包含多个节点时,调用 attr 方法,只会得到第一个节点的属性。

              那么,遇到这种情况时,如果想获取所有的 a 节点的属性,就要用到前面所说的遍历了:

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

              image.gif

              运行结果:

              third item

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

              image.gif

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

              运行结果:

              third item

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

              html = '''
              <div class="wrap">
                  <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())

              image.gif

              运行结果如下:

              second item

              second item third item fourth item fifth item

              结果可能比较出乎意料,html 方法返回的是第一个 li 节点的内部 HTML 文本,而 text 则返回了所有的 li 节点内部的纯文本,中间用一个空格分割开,即返回结果是一个字符串。

              所以这个地方值得注意,如果得到的结果是多个节点,并且想要获取每个节点的内部 HTML 文本,则需要遍历每个节点。而 text() 方法不需要遍历就可以获取,它将所有节点取文本之后合并成一个字符串。

              7. 节点操作

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

              由于节点操作的方法太多,下面举几个典型的例子来说明它的用法。

              addClass 和 removeClass

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

              html = '''

               

                   

                           

              • first item
              •            

              • second item
              •            

              • third item
              •            

              • fourth item
              •            

              • fifth item
              •        

                   

                 

                '''

                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)

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

                运行结果如下:

              • third item
              • third item
              • third item
              • 可以看到,一共输出了 3 次。第二次输出时,li 节点的 active 这个 class 被移除了,第三次 class 又添加回来了。

                所以说,addClass 和 removeClass 方法可以动态改变节点的 class 属性。

                attr、text、html

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

                html = '''

                     

                • third item
                • '''

                  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('changed item')

                  print(li)

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

                  运行结果如下:

                • third item
                • third item
                • changed item
                • changed item
                • 可以发现,调用 attr 方法后,li 节点多了一个原本不存在的属性 name,其值为 link。接着调用 text 方法,传入文本之后,li 节点内部的文本全被改为传入的字符串文本了。最后,调用 html 方法传入 HTML 文本后,li 节点内部又变为传入的 HTML 文本了。

                  所以说,如果 attr 方法只传入第一个参数的属性名,则是获取这个属性值;如果传入第二个参数,可以用来修改属性值。text 和 html 方法如果不传参数,则是获取节点内纯文本和 HTML 文本;如果传入参数,则进行赋值。

                  remove

                  顾名思义,remove 方法就是移除,它有时会为信息的提取带来非常大的便利。下面有一段 HTML 文本:

                  html = '''

                     Hello, World

                   

                  This is a paragraph.

                   

                  '''

                  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 的用法完全一致,详细的用法可以参考官方文档:pyquery – PyQuery complete API — pyquery 2.0.x documentation

                  8. 伪类选择器

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

                  html = '''

                   

                       

                               

                  • first item
                  •            

                  • second item
                  •            

                  • third item
                  •            

                  • fourth item
                  •            

                  • fifth item
                  •        

                       

                     

                    '''

                    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)

                    这里我们使用了 CSS3 的伪类选择器,依次选择了第一个 li 节点、最后一个 li 节点、第二个 li 节点、第三个 li 之后的 li 节点、偶数位置的 li 节点、包含 second 文本的 li 节点。

                    关于 CSS 选择器的更多用法,可以参考 CSS 教程

                    到此为止,pyquery 的常用用法就介绍完了。如果想查看更多的内容,可以参考 pyquery 的官方文档:pyquery: a jquery-like library for python — pyquery 2.0.x documentation

                    相关文章
                    Python
                    5 0
                    |
                    1天前
                    |
                    JSON 数据格式 索引
                    python 又一个点运算符操作的字典库:Munch
                    python 又一个点运算符操作的字典库:Munch
                    4 0
                    |
                    1天前
                    |
                    数据挖掘 数据处理 索引
                    如何使用Python的Pandas库进行数据筛选和过滤?
                    Pandas是Python数据分析的核心库,提供DataFrame数据结构。基本步骤包括导入库、创建DataFrame及进行数据筛选。示例代码展示了如何通过布尔索引、`query()`和`loc[]`方法筛选`Age`大于19的记录。
                    8 0
                    |
                    2天前
                    |
                    数据采集 存储 JSON
                    Python爬虫面试:requests、BeautifulSoup与Scrapy详解
                    【4月更文挑战第19天】本文聚焦于Python爬虫面试中的核心库——requests、BeautifulSoup和Scrapy。讲解了它们的常见问题、易错点及应对策略。对于requests,强调了异常处理、代理设置和请求重试;BeautifulSoup部分提到选择器使用、动态内容处理和解析效率优化;而Scrapy则关注项目架构、数据存储和分布式爬虫。通过实例代码,帮助读者深化理解并提升面试表现。
                    11 0
                    |
                    2天前
                    |
                    数据处理 Python
                    如何使用Python的Pandas库进行数据排序和排名
                    【4月更文挑战第22天】Pandas Python库提供数据排序和排名功能。使用`sort_values()`按列进行升序或降序排序,如`df.sort_values(by=&#39;A&#39;, ascending=False)`。`rank()`函数用于计算排名,如`df[&#39;A&#39;].rank(ascending=False)`。多列操作可传入列名列表,如`df.sort_values(by=[&#39;A&#39;, &#39;B&#39;], ascending=[True, False])`和分别对&#39;A&#39;、&#39;B&#39;列排名。
                    13 2
                    |
                    3天前
                    |
                    算法 Python
                    请解释Python中的关联规则挖掘以及如何使用Sklearn库实现它。
                    使用Python的mlxtend库,可以通过Apriori算法进行关联规则挖掘。首先导入TransactionEncoder和apriori等模块,然后准备数据集(如购买行为列表)。对数据集编码并转换后,应用Apriori算法找到频繁项集(设置最小支持度)。最后,生成关联规则并计算置信度(设定最小置信度阈值)。通过调整这些参数可以优化结果。
                    25 9
                    |
                    3天前
                    |
                    Python
                    如何使用Python的Pandas库进行数据缺失值处理?
                    Pandas在Python中提供多种处理缺失值的方法:1) 使用`isnull()`检查;2) `dropna()`删除含缺失值的行或列;3) `fillna()`用常数、前后值填充;4) `interpolate()`进行插值填充。根据需求选择合适的方法处理数据缺失。
                    31 9
                    |
                    3天前
                    |
                    索引 Python
                    如何在Python中使用Pandas库进行季节性调整?
                    在Python中使用Pandas和Statsmodels进行季节性调整的步骤包括:导入pandas和seasonal_decompose模块,准备时间序列DataFrame,调用`seasonal_decompose()`函数分解数据为趋势、季节性和残差,可选地绘制图表分析,以及根据需求去除季节性影响(如将原始数据减去季节性成分)。这是对时间序列数据进行季节性分析的基础流程。
                    19 2
                    |
                    4天前
                    |
                    缓存 自然语言处理 数据处理
                    Python自然语言处理面试:NLTK、SpaCy与Hugging Face库详解
                    【4月更文挑战第16天】本文介绍了Python NLP面试中NLTK、SpaCy和Hugging Face库的常见问题和易错点。通过示例代码展示了如何进行分词、词性标注、命名实体识别、相似度计算、依存关系分析、文本分类及预训练模型调用等任务。重点强调了理解库功能、预处理、模型选择、性能优化和模型解释性的重要性,帮助面试者提升NLP技术展示。
                    22 5
                    |
                    5天前
                    |
                    数据采集 JavaScript 前端开发
                    使用Python打造爬虫程序之破茧而出:Python爬虫遭遇反爬虫机制及应对策略
                    【4月更文挑战第19天】本文探讨了Python爬虫应对反爬虫机制的策略。常见的反爬虫机制包括User-Agent检测、IP限制、动态加载内容、验证码验证和Cookie跟踪。应对策略包括设置合理User-Agent、使用代理IP、处理动态加载内容、验证码识别及维护Cookie。此外,还提到高级策略如降低请求频率、模拟人类行为、分布式爬虫和学习网站规则。开发者需不断学习新策略,同时遵守规则和法律法规,确保爬虫的稳定性和合法性。