[Python] Web crawler (12) : Premiers pas avec le premier exemple de robot du framework de robot Scrapy

Nous utilisons le site Web dmoz.org comme plate-forme permettant à Xiaozhuazhua de montrer ses compétences.

Tout d'abord, je dois répondre à une question.

Q : Combien d'étapes faut-il pour installer un site Web dans un robot ?

La réponse est simple, quatre étapes :

Nouveau projet : créez un nouveau projet d'exploration

Effacer les objectifs (éléments) : clarifiez ce que vous souhaitez explorer Objectif

Créer un robot (Spider) : créer un robot pour commencer à explorer les pages Web

Stocker le contenu (Pipeline) : concevoir un pipeline pour stocker le contenu exploré

D'accord, maintenant que le processus de base est déterminé, complétez-le simplement étape par étape.

1. Créer un nouveau projet (Projet)

Maintenez la touche Maj enfoncée et faites un clic droit dans le répertoire vide, sélectionnez "Ouvrir la fenêtre de commande ici " et entrez la commande suivante :

scrapy startproject tutorial

où tutoriel est le nom du projet.

Vous pouvez voir qu'un dossier de didacticiel sera créé avec la structure de répertoires suivante :

tutorial/  
    scrapy.cfg  
    tutorial/  
        __init__.py  
        items.py  
        pipelines.py  
        settings.py  
        spiders/  
            __init__.py  
            ...

Ce qui suit est une brève introduction au rôle de chaque fichier :

• scrapy.cfg : Le fichier de configuration du projet
  

• tutoriel/ : Le module Python du projet, le code sera référencé à partir d'ici

• tutorial/items.py : Le fichier des éléments du projet

• tutorial/pipelines.py : Le fichier des pipelines du projet

• tutoriel/settings.py : Fichier de paramètres du projet

• tutorial/spiders/ : Répertoire pour stocker les robots

2. Clear Target (Item)

Dans Scrapy, les éléments sont des conteneurs utilisés pour charger le contenu exploré, un peu comme Dic en Python, qui est un dictionnaire, mais offrent une protection supplémentaire pour réduire les erreurs.

De manière générale, les éléments peuvent être créés à l'aide de la classe scrapy.item.Item et les propriétés peuvent être définies à l'aide de l'objet scrapy.item.Field (qui peut être compris comme une relation de mappage similaire à ORM).

Ensuite, nous commençons à construire le modèle d'élément.

Tout d'abord, le contenu que nous souhaitons est :

• Nom (nom)

• Lien (url)

• Description

Modifiez le fichier items.py dans le répertoire du tutoriel et ajoutez-le après le cours d'origine. Notre propre classe.

Parce que nous voulons capturer le contenu du site Web dmoz.org, nous pouvons le nommer DmozItem :

# Define here the models for your scraped items  
#  
# See documentation in:  
# http://doc.scrapy.org/en/latest/topics/items.html  
  
from scrapy.item import Item, Field  
  
class TutorialItem(Item):  
    # define the fields for your item here like:  
    # name = Field()  
    pass  
  
class DmozItem(Item):  
    title = Field()  
    link = Field()  
    desc = Field()

Cela peut sembler un peu flou au début, mais définir ces éléments peut laisser vous savez quels sont vos éléments lorsque vous utilisez d'autres composants.

Item peut être simplement compris comme un objet de classe encapsulé.

3. Créer un robot (Spider)

Pour créer un robot, il y a deux étapes : ramper d'abord, puis récupérer.

C'est-à-dire que vous devez d'abord récupérer tout le contenu de la page Web entière, puis retirer les parties qui vous sont utiles.

3.1 Exploration

Spider est une classe écrite par l'utilisateur pour explorer les informations d'un domaine (ou d'un groupe de domaines).

Ils définissent une liste d'URL à télécharger, un schéma de suivi des liens et un moyen d'analyser le contenu Web pour en extraire des éléments.

Pour créer un Spider, vous devez créer une sous-classe avec scrapy.spider.BaseSpider et déterminer trois attributs obligatoires :

name : le nom d'identification du robot, qui doit être unique, Vous devez définir différents noms dans différents robots d'exploration.

start_urls : liste d'URL explorées. Le robot d'exploration commence à récupérer les données à partir d'ici, donc le premier téléchargement de données commencera à partir de ces URL. D'autres sous-URL seront générées en héritant de ces URL de départ.

parse() : La méthode d'analyse. Lors de l'appel, transmettez l'objet Response renvoyé par chaque URL comme seul paramètre. Il est responsable de l'analyse et de la correspondance des données capturées (analysées en éléments), ainsi que du suivi. URL.

Ici, vous pouvez vous référer aux idées mentionnées dans le didacticiel du robot d'exploration de largeur pour vous aider à comprendre. Livraison du didacticiel : [Java] Zhihu Chin Épisode 5 : Utilisation de la boîte à outils HttpClient et du robot d'exploration de largeur.

Autrement dit, l'URL est stockée et diffusée progressivement sur cette base comme point de départ, en récupérant toutes les URL de pages Web qui remplissent les conditions et en les stockant pour continuer l'exploration.

Écrivons le premier robot, nommé dmoz_spider.py, et enregistrons-le dans le répertoire tutorielspiders.

Le code dmoz_spider.py est le suivant :

from scrapy.spider import Spider  
  
class DmozSpider(Spider):  
    name = "dmoz"  
    allowed_domains = ["dmoz.org"]  
    start_urls = [  
        "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/",  
        "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/"  
    ]  
  
    def parse(self, response):  
        filename = response.url.split("/")[-2]  
        open(filename, 'wb').write(response.body)

allow_domains est la plage de noms de domaine à rechercher, qui est également la zone de contrainte du robot. Il stipule que le robot explore uniquement les pages Web. sous ce nom de domaine.

Comme le montre la fonction d'analyse, les deux dernières adresses du lien sont extraites et stockées sous forme de noms de fichiers.

Ensuite, exécutez-le et jetez un œil. Maintenez la touche Maj enfoncée et faites un clic droit dans le répertoire du didacticiel, ouvrez la fenêtre de commande ici, entrez :

scrapy crawl dmoz

Le résultat en cours d'exécution est comme le montre la figure :

Erreur signalée :

UnicodeDecodeError : le codec 'ascii' ne peut pas décoder l'octet 0xb0 en position 1 : ordinal hors de portée (128)

J'obtiens une erreur lorsque je lance le premier projet Scrapy, ce qui est vraiment dommage.

Il devrait y avoir un problème de codage. J'ai trouvé la solution après une recherche sur Google :

Créez un nouveau sitecustomize.py dans le dossier Libsite-packages de python :

import sys    
sys.setdefaultencoding('gb2312')

Lancez-le à nouveau, OK, le problème est résolu, regardez le résultat :

最后一句INFO: Closing spider (finished)表明爬虫已经成功运行并且自行关闭了。

包含 [dmoz]的行 ，那对应着我们的爬虫运行的结果。

可以看到start_urls中定义的每个URL都有日志行。

还记得我们的start_urls吗？

http://www.dmoz.org/Computers/Programming/Languages/Python/Books
http://www.dmoz.org/Computers/Programming/Languages/Python/Resources

因为这些URL是起始页面，所以他们没有引用(referrers)，所以在它们的每行末尾你会看到 (referer: )。

在parse 方法的作用下，两个文件被创建：分别是 Books 和 Resources，这两个文件中有URL的页面内容。

那么在刚刚的电闪雷鸣之中到底发生了什么呢？

首先，Scrapy为爬虫的 start_urls属性中的每个URL创建了一个 scrapy.http.Request 对象 ，并将爬虫的parse 方法指定为回调函数。

然后，这些 Request被调度并执行，之后通过parse()方法返回scrapy.http.Response对象，并反馈给爬虫。

3.2取

爬取整个网页完毕，接下来的就是的取过程了。

光存储一整个网页还是不够用的。

在基础的爬虫里，这一步可以用正则表达式来抓。

在Scrapy里，使用一种叫做 XPath selectors的机制，它基于 XPath表达式。

如果你想了解更多selectors和其他机制你可以查阅资料：点我点我

这是一些XPath表达式的例子和他们的含义

/html/head/title: 选择HTML文档

元素下面的'] In [3]: sel.xpath('//title/text()') Out[3]: [] In [4]: sel.xpath('//title/text()').extract() Out[4]: [u'Open Directory - Computers: Programming: Languages: Python: Books'] In [5]: sel.xpath('//title/text()').re('(\w+):') Out[5]: [u'Computers', u'Programming', u'Languages', u'Python']

当然title这个标签对我们来说没有太多的价值，下面我们就来真正抓取一些有意义的东西。

使用火狐的审查元素我们可以清楚地看到，我们需要的东西如下：

我们可以用如下代码来抓取这个

标签：

sel.xpath('//ul/li')

从

标签中，可以这样获取网站的描述：

sel.xpath('//ul/li/text()').extract()

可以这样获取网站的标题：

sel.xpath('//ul/li/a/text()').extract()

可以这样获取网站的超链接：

sel.xpath('//ul/li/a/@href').extract()

当然，前面的这些例子是直接获取属性的方法。

我们注意到xpath返回了一个对象列表，

那么我们也可以直接调用这个列表中对象的属性挖掘更深的节点

（参考：Nesting selectors andWorking with relative XPaths in theSelectors）：

sites = sel.xpath('//ul/li')for site in sites:
   title = site.xpath('a/text()').extract()
   link = site.xpath('a/@href').extract()
   desc = site.xpath('text()').extract()
   print title, link, desc

3.4xpath实战

我们用shell做了这么久的实战，最后我们可以把前面学习到的内容应用到dmoz_spider这个爬虫中。

在原爬虫的parse函数中做如下修改：

from scrapy.spider import Spider  
from scrapy.selector import Selector  
  
class DmozSpider(Spider):  
    name = "dmoz"  
    allowed_domains = ["dmoz.org"]  
    start_urls = [  
        "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/",  
        "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/"  
    ]  
  
    def parse(self, response):  
        sel = Selector(response)  
        sites = sel.xpath('//ul/li')  
        for site in sites:  
            title = site.xpath('a/text()').extract()  
            link = site.xpath('a/@href').extract()  
            desc = site.xpath('text()').extract()  
            print title

注意，我们从scrapy.selector中导入了Selector类，并且实例化了一个新的Selector对象。这样我们就可以像Shell中一样操作xpath了。

我们来试着输入一下命令运行爬虫（在tutorial根目录里面）：

scrapy crawl dmoz

运行结果如下：

果然，成功的抓到了所有的标题。但是好像不太对啊，怎么Top，Python这种导航栏也抓取出来了呢？

我们只需要红圈中的内容：

看来是我们的xpath语句有点问题，没有仅仅把我们需要的项目名称抓取出来，也抓了一些无辜的但是xpath语法相同的元素。

审查元素我们发现我们需要的

具有class='directory-url'的属性，

那么只要把xpath语句改成sel.xpath('//ul[@class="directory-url"]/li')即可


将xpath语句做如下调整：

from scrapy.spider import Spider  
from scrapy.selector import Selector  
  
class DmozSpider(Spider):  
    name = "dmoz"  
    allowed_domains = ["dmoz.org"]  
    start_urls = [  
        "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/",  
        "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/"  
    ]  
  
    def parse(self, response):  
        sel = Selector(response)  
        sites = sel.xpath('//ul[@class="directory-url"]/li')  
        for site in sites:  
            title = site.xpath('a/text()').extract()  
            link = site.xpath('a/@href').extract()  
            desc = site.xpath('text()').extract()  
            print title

成功抓出了所有的标题，绝对没有滥杀无辜：



3.5使用Item


接下来我们来看一看如何使用Item。

前面我们说过，Item 对象是自定义的python字典，可以使用标准字典语法获取某个属性的值：

>>> item = DmozItem()  
>>> item['title'] = 'Example title'  
>>> item['title']  
'Example title'

作为一只爬虫，Spiders希望能将其抓取的数据存放到Item对象中。为了返回我们抓取数据，spider的最终代码应当是这样:

from scrapy.spider import Spider  
from scrapy.selector import Selector  
  
from tutorial.items import DmozItem  
  
class DmozSpider(Spider):  
    name = "dmoz"  
    allowed_domains = ["dmoz.org"]  
    start_urls = [  
        "http://www.dmoz.org/Computers/Programming/Languages/Python/Books/",  
        "http://www.dmoz.org/Computers/Programming/Languages/Python/Resources/"  
    ]  
  
    def parse(self, response):  
        sel = Selector(response)  
        sites = sel.xpath('//ul[@class="directory-url"]/li')  
        items = []  
        for site in sites:  
            item = DmozItem()  
            item['title'] = site.xpath('a/text()').extract()  
            item['link'] = site.xpath('a/@href').extract()  
            item['desc'] = site.xpath('text()').extract()  
            items.append(item)  
        return items

4.存储内容（Pipeline）

保存信息的最简单的方法是通过Feed exports，主要有四种：JSON，JSON lines，CSV，XML。

我们将结果用最常用的JSON导出，命令如下：

scrapy crawl dmoz -o items.json -t json

-o 后面是导出文件名，-t 后面是导出类型。

然后来看一下导出的结果，用文本编辑器打开json文件即可（为了方便显示，在item中删去了除了title之外的属性）：



Parce qu'il ne s'agit que d'un petit exemple, un traitement simple suffit.

Si vous souhaitez faire des choses plus complexes avec les éléments capturés, vous pouvez écrire un pipeline d'éléments.

Nous jouerons avec cela lentement à l'avenir^_^

Ce qui précède est le contenu de [Python] Web Crawler (12) : Le premier exemple de robot d'introduction au framework de robot Scrapy, plus connexes Veuillez prêter attention au site Web PHP chinois (www.php.cn) pour le contenu !