Implementieren Sie eine zeitreihenbasierte Datenaufzeichnung und -analyse mit Scrapy und MongoDB

Mit der rasanten Entwicklung der Big-Data- und Data-Mining-Technologie widmen die Menschen der Aufzeichnung und Analyse von Zeitreihendaten immer mehr Aufmerksamkeit. In Bezug auf Webcrawler ist Scrapy ein sehr gutes Crawler-Framework und MongoDB eine sehr gute NoSQL-Datenbank. In diesem Artikel wird erläutert, wie Sie mit Scrapy und MongoDB eine zeitreihenbasierte Datenaufzeichnung und -analyse implementieren.

1. Installation und Verwendung von Scrapy

Scrapy ist ein in der Python-Sprache implementiertes Webcrawler-Framework. Wir können Scrapy mit dem folgenden Befehl installieren:

pip install scrapy

Nachdem die Installation abgeschlossen ist, können wir Scrapy zum Schreiben unseres Crawlers verwenden. Im Folgenden verwenden wir ein einfaches Crawler-Beispiel, um die Verwendung von Scrapy zu verstehen.

1. Erstellen Sie ein Scrapy-Projekt

Erstellen Sie im Befehlszeilenterminal ein neues Scrapy-Projekt mit dem folgenden Befehl:

scrapy startproject scrapy_example

Nachdem das Projekt erstellt wurde, können wir mit dem folgenden Befehl das Stammverzeichnis des Projekts aufrufen:

cd scrapy_example

2. Einen Crawler schreiben

Mit dem folgenden Befehl können wir einen neuen Crawler erstellen:

scrapy genspider example www.example.com

Das Beispiel hier ist der benutzerdefinierte Crawler-Name und www.example.com ist der Domainname der gecrawlten Website. Scrapy generiert eine Standard-Crawler-Vorlagendatei, und wir können diese Datei bearbeiten, um den Crawler zu schreiben.

In diesem Beispiel crawlen wir eine einfache Webseite und speichern den Textinhalt auf der Webseite in einer Textdatei. Der Crawler-Code lautet wie folgt:

import scrapy

class ExampleSpider(scrapy.Spider):
    name = "example"
    start_urls = ["https://www.example.com/"]

    def parse(self, response):
        filename = "example.txt"
        with open(filename, "w") as f:
            f.write(response.text)
        self.log(f"Saved file {filename}")

3. Führen Sie den Crawler aus

Bevor wir den Crawler ausführen, legen wir zunächst die Scrapy-Konfiguration fest. Suchen Sie im Stammverzeichnis des Projekts die Datei „settings.py“ und setzen Sie ROBOTSTXT_OBEY auf „False“, damit unser Crawler jede Website crawlen kann.

ROBOTSTXT_OBEY = False

Als nächstes können wir den Crawler über den folgenden Befehl ausführen:

scrapy crawl example

Nachdem der Vorgang abgeschlossen ist, können wir im Stammverzeichnis des Projekts eine Datei example.txt sehen, die den von uns gecrawlten Textinhalt enthält .

2. Installation und Verwendung von MongoDB

MongoDB ist eine sehr hervorragende NoSQL-Datenbank. Wir können MongoDB mit dem folgenden Befehl installieren:

sudo apt-get install mongodb

Nachdem die Installation abgeschlossen ist, müssen wir den MongoDB-Dienst starten. Geben Sie im Befehlszeilenterminal den folgenden Befehl ein:

sudo service mongodb start

Nachdem der MongoDB-Dienst erfolgreich gestartet wurde, können wir Daten über die MongoDB-Shell verarbeiten.

1. Erstellen Sie eine Datenbank

Geben Sie den folgenden Befehl in das Befehlszeilenterminal ein, um eine Verbindung zur MongoDB-Datenbank herzustellen:

mongo

Nachdem die Verbindung erfolgreich war, können wir den folgenden Befehl verwenden, um eine neue Datenbank zu erstellen:

use scrapytest

The scrapytest hier ist unser benutzerdefinierter Datenbankname.

2. Erstellen Sie eine Sammlung

In MongoDB verwenden wir Sammlungen zum Speichern von Daten. Wir können den folgenden Befehl verwenden, um eine neue Sammlung zu erstellen:

db.createCollection("example")

Das Beispiel hier ist unser benutzerdefinierter Sammlungsname.

3. Daten einfügen

In Python können wir die Pymongo-Bibliothek verwenden, um auf die MongoDB-Datenbank zuzugreifen. Wir können den folgenden Befehl verwenden, um die Pymongo-Bibliothek zu installieren:

pip install pymongo

Nachdem die Installation abgeschlossen ist, können wir den folgenden Code verwenden, um Daten einzufügen:

import pymongo

client = pymongo.MongoClient(host="localhost", port=27017)
db = client["scrapytest"]
collection = db["example"]
data = {"title": "example", "content": "Hello World!"}
collection.insert_one(data)

Die Daten hier sind die Daten, die wir einfügen möchten, einschließlich der beiden Felder Titel und Inhalt.

4. Daten abfragen

Wir können den folgenden Code verwenden, um Daten abzufragen:

import pymongo

client = pymongo.MongoClient(host="localhost", port=27017)
db = client["scrapytest"]
collection = db["example"]
result = collection.find_one({"title": "example"})
print(result["content"])

Die Abfragebedingung hier ist „Titel“: „Beispiel“, was bedeutet, dass die Daten abgefragt werden, deren Titelfeld dem Beispiel entspricht. Die Abfrageergebnisse umfassen das gesamte Datendokument, und wir können den Wert des Inhaltsfelds über result["content"] abrufen.

3. Kombinierte Verwendung von Scrapy und MongoDB

In tatsächlichen Crawler-Anwendungen müssen wir häufig die gecrawlten Daten in der Datenbank speichern und die Daten in Zeitreihen aufzeichnen und analysieren. Die Kombination aus Scrapy und MongoDB kann diese Anforderung gut erfüllen.

In Scrapy können wir Pipelines verwenden, um die gecrawlten Daten zu verarbeiten und die Daten in MongoDB zu speichern.

1. Pipeline erstellen

Wir können eine Datei mit dem Namen „pipelines.py“ im Stammverzeichnis des Scrapy-Projekts erstellen und unsere Pipeline in dieser Datei definieren. In diesem Beispiel speichern wir die gecrawlten Daten in MongoDB und fügen ein Zeitstempelfeld hinzu, um den Zeitstempel des Datensatzes darzustellen. Der Code lautet wie folgt:

import pymongo
from datetime import datetime

class ScrapyExamplePipeline:
    def open_spider(self, spider):
        self.client = pymongo.MongoClient("localhost", 27017)
        self.db = self.client["scrapytest"]

    def close_spider(self, spider):
        self.client.close()

    def process_item(self, item, spider):
        collection = self.db[spider.name]
        item["timestamp"] = datetime.now()
        collection.insert_one(dict(item))
        return item

Diese Pipeline wird jedes Mal aufgerufen, wenn der Crawler ein Element crawlt. Wir konvertieren die gecrawlten Elemente in ein Wörterbuch, fügen ein Zeitstempelfeld hinzu und speichern dann das gesamte Wörterbuch in MongoDB.

2. Pipeline konfigurieren

Suchen Sie die Datei „settings.py“ im Stammverzeichnis des Scrapy-Projekts und setzen Sie ITEM_PIPELINES auf die Pipeline, die wir gerade definiert haben:

ITEM_PIPELINES = {
   "scrapy_example.pipelines.ScrapyExamplePipeline": 300,
}

Die 300 hier ist die Priorität der Pipeline, was darauf hinweist, dass die Pipeline ist in allen Pipelines Ausführungsreihenfolge in .

3. Ändern Sie den Crawler-Code

Ändern Sie den Crawler-Code, den wir gerade geschrieben haben, und übergeben Sie das Element an die Pipeline.

import scrapy

class ExampleSpider(scrapy.Spider):
    name = "example"
    start_urls = ["https://www.example.com/"]

    def parse(self, response):
        for text in response.css("p::text"):
            yield {"text": text.extract()}

Hier haben wir einfach den Textinhalt auf der Webseite gecrawlt und den Inhalt in einem Textfeld gespeichert. Scrapy übergibt dieses Element zur Verarbeitung an die definierte Pipeline.

4. Daten abfragen

Jetzt können wir die gecrawlten Daten in MongoDB speichern. Wir müssen auch die Aufzeichnung und Analyse von Zeitreihen implementieren. Wir können dies mithilfe der Abfrage- und Aggregationsoperationen von MongoDB tun.

Daten für einen bestimmten Zeitraum finden:

import pymongo
from datetime import datetime

client = pymongo.MongoClient("localhost", 27017)
db = client["scrapytest"]
collection = db["example"]
start_time = datetime(2021, 1, 1)
end_time = datetime(2021, 12, 31)
result = collection.find({"timestamp": {"$gte": start_time, "$lte": end_time}})
for item in result:
    print(item["text"])

Hier finden wir alle Daten für 2021.

统计每个小时内的记录数：

import pymongo

client = pymongo.MongoClient("localhost", 27017)
db = client["scrapytest"]
collection = db["example"]
pipeline = [
    {"$group": {"_id": {"$hour": "$timestamp"}, "count": {"$sum": 1}}},
    {"$sort": {"_id": 1}},
]
result = collection.aggregate(pipeline)
for item in result:
    print(f"{item['_id']}: {item['count']}")

这里我们使用MongoDB的聚合操作来统计每个小时内的记录数。

通过Scrapy和MongoDB的结合使用，我们可以方便地实现时间序列的数据记录和分析。这种方案的优点是具有较强的扩展性和灵活性，可以适用于各种不同的应用场景。不过，由于本方案的实现可能涉及到一些较为复杂的数据结构和算法，所以在实际应用中需要进行一定程度的优化和调整。

Das obige ist der detaillierte Inhalt vonImplementieren Sie eine zeitreihenbasierte Datenaufzeichnung und -analyse mit Scrapy und MongoDB. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!