Collectez des données à l'aide de scrapy et remplissez mongoDB

Google collecte des informations auprès des moteurs de recherche [Googlebot](https://ja.wikipedia.org/wiki/%E3%82%B0%E3%83%BC%E3%82%B0%E3%83%AB%E3 % 83% 9C% E3% 83% 83% E3% 83% 88) est utilisé. À partir d'un certain site Web, il suit automatiquement les liens de ce site et collecte des informations.

Vous pouvez faire la même chose avec le module Scrapy de python. Utilisons Scrapy pour collecter des informations sur le site.

Préparation

Installez Scrapy avec pip. `$ pip install scrapy

Comment utiliser

Scrapy est géré projet par projet. Après avoir généré le projet, modifiez les fichiers suivants qui y sont automatiquement générés.

1. items.py: définir les données extraites
2. spiders / Les fichiers spider (crawler) suivants: patrouille, conditions d'extraction de données
3. pipelines.py: destination de sortie des données extraites. Cette fois mongoDB
4. settings.py: conditions de patrouille de données (fréquence, hiérarchie, etc.)

Créer un projet

Commencez par créer un projet. $ scrapy startproject tutorial Ensuite, un tel dossier sera créé.

tutorial/

tutorial/
    scrapy.cfg            # deploy configuration file

    tutorial/             # project's Python module, you'll import your code from here
        __init__.py

        items.py          # project items file

        pipelines.py      # project pipelines file

        settings.py       # project settings file

        spiders/          # a directory where you'll later put your spiders
            __init__.py
            ...

Définition des données extraites

Définissez ce que vous obtenez. C'est la définition du champ dans la base de données.

items.py

import scrapy

class WebItem(scrapy.Item):
    title = scrapy.Field()
    link = scrapy.Field()
    date = scrapy.Field()

Créer une araignée

Il s'agit d'un fichier en forme de fleur qui explore le Web et extrait les données. Spécifiez l'adresse de début de la patrouille, les conditions de la patrouille et les conditions d'extraction des données.

Génération d'araignées

Faites une araignée. La syntaxe est $ scrapy genspider [options] <nom> <domaine>.

commandline

$ scrapy genspider webspider exsample.com
  Created spider 'webspider' using template 'basic' in module:
  tutorial.spiders.webspider

Le fichier généré est

tutorial/spiders/webspider.py

# -*- coding: utf-8 -*-
import scrapy

class WebspiderSpider(scrapy.Spider):
    name = "webspider"   #Le nom dans le projet. Utilisé pour spécifier une araignée lors du déplacement
    allowed_domains = ["exsample.com"] #Spécification de domaine pour la patrouille OK
    start_urls = (
        'http://www.exsample.com/', #Commencer ici. Vous pouvez en spécifier plusieurs dans la liste.
    )

    def parse(self, response):  #Voici les conditions d'extraction
        pass

Un fichier comme celui-ci sera généré. Changez cela à votre goût.

tutorial/spiders/webspider.py

# -*- coding: utf-8 -*-
import scrapy
from tutorial.items import WebItem
import re
import datetime
from scrapy.spiders import CrawlSpider, Rule
from scrapy.linkextractors import LinkExtractor

class WebspiderSpider(CrawlSpider):  #Le nom de la classe n'a aucune signification
    name = 'WebspiderSpider'  #C'est important. Araignée avec ce nom(Crawler)Bouge toi
    allowed_domains = ['example.com']
    start_urls = ['http://www.example.com']

    xpath = {
        'title' : "//title/text()",
    }

    list_allow = [r'(Expressions régulières)'] #Les liens qui remplissent cette condition sont patrouillés
    list_deny = [
                r'/exsample/hogehoge/hoge/', #Ceci est un exemple de spécification d'un lien qui ne circule pas. La notation de liste est également possible
            ]
    list_allow_parse = [r'(Expressions régulières)']  #Lier la spécification pour extraire les données
    list_deny_parse = [                #Spécification de lien sans extraction de données
                r'(Expressions régulières)',
                r'(Expressions régulières)',
                ]

    rules = (
        #Règles de patrouille.
        Rule(LinkExtractor(
            allow=list_allow,
            deny=list_deny,
            ),
            follow=True #Allez dans ce lien
        ),
        #Règles d'extraction de données
        Rule(LinkExtractor(
            allow=list_allow_parse,
            deny=list_deny_parse,
            unique=True #Ne pas extraire les données à la même destination de lien
            ),
            callback='parse_items' #Si les conditions sont remplies, la fonction d'exécution d'extraction de données spécifiée ici est exécutée.
        ),
    )

   #Définition de la fonction d'extraction de données
   def parse_items(self, response): #La réponse contient des informations sur le site Web
        item = WebItem()  # items.Classe spécifiée par py
        item['title'] = response.xpath(self.xpath['title']).extract()[0]
        item['link'] = response.url
        item['date'] = datetime.datetime.utcnow() + datetime.timedelta(hours=9) #Heure actuelle. Ce sera au Japon.

        yield item

Veuillez vous référer aux commentaires pour ce que vous écrivez.

Modification de pipeline.py

Insérez l'élément de rendement de l'araignée créée ci-dessus dans mongoDB.

pipelines.py

from pymongo import MongoClient  #Connexion avec mongoDB
import datetime

class TutorialPipeline(object):

    def __init__(self, mongo_uri, mongo_db, mongolab_user, mongolab_pass):
        #Initialisation de la variable avec les arguments passés lors de la création de l'instance
        self.mongo_uri = mongo_uri
        self.mongo_db = mongo_db
        self.mongolab_user = mongolab_user
        self.mongolab_pass = mongolab_pass

    @classmethod  #Vous pouvez accéder aux variables de classe car il y a une classe dans l'argument
    def from_crawler(cls, crawler):
        return cls(
            mongo_uri=crawler.settings.get('MONGO_URI'), # settings.Accéder aux variables définies par py
            mongo_db=crawler.settings.get('MONGO_DATABASE', 'items'),
            mongolab_user=crawler.settings.get('MONGOLAB_USER'),
            mongolab_pass=crawler.settings.get('MONGOLAB_PASS')
        ) # def __init__Devenez un argument de

    def open_spider(self, spider): #Exécuté lorsque l'araignée démarre. Connexion à la base de données
        self.client = MongoClient(self.mongo_uri)
        self.db = self.client[self.mongo_db]
        self.db.authenticate(self.mongolab_user, self.mongolab_pass)

    def close_spider(self, spider): #Exécuté à la fin de l'araignée. Fermer la connexion à la base de données
        self.client.close()

    def process_item(self, item, spider):
        self.db[self.collection_name].update(
            {u'link': item['link']},
            {"$set": dict(item)},
            upsert = True
        ) #Lien de recherche, créer un nouveau sinon, mettre à jour si

        return item

J'ai beaucoup écrit, mais le fait est que je viens d'ouvrir la base de données, de piquer les données et de la fermer lorsque j'ai terminé.

settings.py Tout d'abord, définissez les différentes variables que vous appelez dans pipelines.py.

settings.py

MONGO_URI = 'hogehoge.mongolab.com:(numéro de port)'
MONGO_DATABASE = 'database_name'
MONGOLAB_USER = 'user_name'
MONGOLAB_PASS = 'password'

Ceci est un exemple de mongolab. Dans settings.py, spécifiez le comportement en plus.

settings.py

REDIRECT_MAX_TIMES = 6
RETRY_ENABLED = False
DOWNLOAD_DELAY=10
COOKIES_ENABLED=False

Ici, le nombre maximum de redirections est défini sur 6, de sorte que les tentatives ne sont pas exécutées, l'accès au site Web est défini toutes les 10 secondes et les cookies ne sont pas enregistrés. Si vous ne spécifiez pas DOWNLOAD_DELAY, vous accéderez à pleine puissance, ce qui mettra une lourde charge sur le site de destination. arrêtons-nous.

Courir

Lançons-le.

commandline

$ scrapy crawl WebspiderSpider

Nous suivrons les liens les uns après les autres, et les données seront extraites des liens qui remplissent les conditions.