Scrapy implementiert das Crawlen und Analysieren von Artikeln über öffentliche WeChat-Konten

Scrapy ermöglicht das Crawlen von Artikeln und die Analyse öffentlicher WeChat-Konten.

WeChat ist in den letzten Jahren eine sehr beliebte Social-Media-Anwendung, und die darin betriebenen öffentlichen Konten spielen ebenfalls eine sehr wichtige Rolle. Wie wir alle wissen, sind öffentliche WeChat-Konten ein Ozean an Informationen und Wissen, da jedes öffentliche Konto Artikel, grafische Nachrichten und andere Informationen veröffentlichen kann. Diese Informationen können in vielen Bereichen umfassend genutzt werden, beispielsweise in Medienberichten, in der akademischen Forschung usw.

In diesem Artikel erfahren Sie, wie Sie das Scrapy-Framework zum Crawlen und Analysieren von WeChat-Artikeln zu öffentlichen Konten verwenden. Scrapy ist ein Python-Webcrawler-Framework, dessen Hauptfunktion das Data Mining und die Informationssuche ist. Daher ist Scrapy sehr anpassbar und effizient.

1. Installieren Sie Scrapy und erstellen Sie das Projekt

Um das Scrapy-Framework zum Crawlen zu verwenden, müssen Sie zunächst Scrapy und andere Abhängigkeiten installieren. Sie können zum Installieren den Befehl pip verwenden. Der Installationsprozess ist wie folgt:

pip install scrapy
pip install pymongo
pip install mysql-connector-python

Nach der Installation von Scrapy müssen wir das Scrapy-Befehlszeilentool verwenden, um das Projekt zu erstellen. Der Befehl lautet wie folgt:

scrapy startproject wechat

Nach der Ausführung dieses Befehls erstellt Scrapy ein Projekt mit dem Namen „wechat“ und erstellt viele Dateien und Verzeichnisse im Projektverzeichnis.

2. Implementieren Sie das Crawlen von Artikeln zu öffentlichen WeChat-Konten

Bevor wir mit dem Crawlen beginnen, müssen wir zunächst das URL-Format der Artikelseiten zu öffentlichen WeChat-Konten verstehen. Die URL einer typischen Artikelseite eines öffentlichen WeChat-Kontos sieht wie folgt aus:

https://mp.weixin.qq.com/s?__biz=XXX&mid=XXX&idx=1&sn=XXX&chksm=XXX#wechat_redirect

Unter diesen steht __biz für die ID des öffentlichen WeChat-Kontos, mid für die ID des Artikels, idx für die Seriennummer des Artikels und sn für die Signatur des Artikels und chksm steht für die Inhaltsüberprüfung. Wenn wir daher alle Artikel eines bestimmten offiziellen Kontos crawlen möchten, müssen wir die ID des offiziellen Kontos finden und diese zum Erstellen der URL verwenden. Unter anderem ist biz_id die eindeutige Kennung des offiziellen Kontos.

Zuerst müssen wir eine Liste mit vielen offiziellen Konto-IDs vorbereiten, da wir die Artikel dieser offiziellen Konten crawlen möchten. Die Sammlung von IDs kann auf verschiedene Weise erfolgen. Hier verwenden wir als Beispiel eine Liste mit mehreren Test-IDs:

biz_ids = ['MzU5MjcwMzA4MA==', 'MzI4MzMwNDgwMQ==', 'MzAxMTcyMzg2MA==']

Als nächstes müssen wir einen Spider schreiben, um alle Artikel eines bestimmten öffentlichen Kontos zu crawlen. Hier übergeben wir den Namen und die ID des offiziellen Kontos an Spider, damit wir mit verschiedenen offiziellen Konto-IDs umgehen können.

import scrapy
import re

class WeChatSpider(scrapy.Spider):
    name = "wechat"
    allowed_domains = ["mp.weixin.qq.com"]
    
    def __init__(self, name=None, biz_id=None):
        super().__init__(name=name)
        self.start_urls = ['https://mp.weixin.qq.com/mp/profile_ext?action=home&__biz={}==#wechat_redirect'.format(biz_id)]

    def parse(self, response):
        article_urls = response.xpath('//h4[1]/a/@href')
        for url in article_urls.extract():
            yield scrapy.Request(url, callback=self.parse_article)
        
        next_page = response.xpath('//a[@id="js_next"]/@href')
        if next_page:
            yield scrapy.Request(response.urljoin(next_page[0].extract()), callback=self.parse)
    
    def parse_article(self, response):
        url = response.url
        title = response.xpath('//h2[@class="rich_media_title"]/text()')
        yield {'url': url, 'title': title.extract_first().strip()}

Spiders Hauptfunktion besteht darin, mit einer bestimmten offiziellen Konto-ID auf die offizielle Konto-Homepage zuzugreifen und dann jede Seite rekursiv zu durchsuchen, um die URLs aller Artikel zu extrahieren. Darüber hinaus wird die Methode parse_article verwendet, um die URL und den Titel des Artikels für die spätere Verarbeitung zu extrahieren. Insgesamt ist diese Spinne nicht sehr komplex, aber die Extraktionsgeschwindigkeit ist langsam.

Abschließend müssen wir im Terminal den folgenden Befehl eingeben, um Spider zu starten:

scrapy crawl wechat -a biz_id=XXXXXXXX

Ebenso können wir auch mehrere offizielle Konten crawlen, geben Sie einfach die IDs aller offiziellen Konten im Befehl an:

scrapy crawl wechat -a biz_id=ID1,ID2,ID3

3. Artikeldaten speichern

Nachdem wir den Artikel gecrawlt haben, müssen wir den Titel und die URL des Artikels in einer Datenbank (wie MongoDB, MySQL usw.) speichern. Hier verwenden wir die Pymongo-Bibliothek, um die gecrawlten Daten zu speichern.

import pymongo

class MongoPipeline(object):
    collection_name = 'wechat'

    def __init__(self, mongo_uri, mongo_db):
        self.mongo_uri = mongo_uri
        self.mongo_db = mongo_db

    @classmethod
    def from_crawler(cls, crawler):
        return cls(
            mongo_uri=crawler.settings.get('MONGO_URI'),
            mongo_db=crawler.settings.get('MONGO_DATABASE', 'items')
        )

    def open_spider(self, spider):
        self.client = pymongo.MongoClient(self.mongo_uri)
        self.db = self.client[self.mongo_db]

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

    def process_item(self, item, spider):
        self.db[self.collection_name].insert_one(dict(item))
        return item

In dieser Pipeline verwenden wir MongoDB als Backend zum Speichern von Daten. Diese Klasse kann bei Bedarf geändert werden, um andere Datenbanksysteme zu verwenden.

Als nächstes müssen wir datenbankbezogene Parameter in der Datei „settings.py“ konfigurieren:

MONGO_URI = 'mongodb://localhost:27017/'
MONGO_DATABASE = 'wechat'
ITEM_PIPELINES = {'myproject.pipelines.MongoPipeline': 300}

Abschließend rufen wir Pipeline in Spider auf, um Daten in MongoDB zu speichern:

class WeChatSpider(scrapy.Spider):
    name = "wechat"
    allowed_domains = ["mp.weixin.qq.com"]
    
    def __init__(self, name=None, biz_id=None):
        super().__init__(name=name)
        self.start_urls = ['https://mp.weixin.qq.com/mp/profile_ext?action=home&__biz={}==#wechat_redirect'.format(biz_id)]

    def parse(self, response):
        article_urls = response.xpath('//h4[1]/a/@href')
        for url in article_urls.extract():
            yield scrapy.Request(url, callback=self.parse_article)
        
        next_page = response.xpath('//a[@id="js_next"]/@href')
        if next_page:
            yield scrapy.Request(response.urljoin(next_page[0].extract()), callback=self.parse)
            
    def parse_article(self, response):
        url = response.url
        title = response.xpath('//h2[@class="rich_media_title"]/text()')
        yield {'url': url, 'title': title.extract_first().strip()}

        pipeline = response.meta.get('pipeline')
        if pipeline:
            item = dict()
            item['url'] = url
            item['title'] = title.extract_first().strip()
            yield item

Im obigen Code ist die Antwort meta.get(' Pipeline‘) wird verwendet, um das Pipeline-Objekt zu erhalten, das wir in Spider festgelegt haben. Fügen Sie daher einfach den folgenden Code zum Spider-Code hinzu, um Pipeline zu unterstützen:

yield scrapy.Request(url, callback=self.parse_article, meta={'pipeline': 1})

4. Datenanalyse

Abschließend werden wir Bibliotheken wie Scrapy und Pandas verwenden, um Daten zu analysieren und zu visualisieren.

Hier extrahieren wir die Daten, die wir aus MongoDB gecrawlt haben, und speichern sie in einer CSV-Datei. Anschließend können wir Pandas verwenden, um die CSV-Datei zu verarbeiten und zu visualisieren.

Das Folgende ist der Implementierungsprozess:

import pandas as pd
from pymongo import MongoClient

client = MongoClient('mongodb://localhost:27017/')
db = client['wechat']
articles = db['wechat']

cursor = articles.find()
doc = list(cursor)

df = pd.DataFrame(doc)
df.to_csv('wechat.csv', encoding='utf-8')

df.groupby('biz_id')['title'].count().plot(kind='bar')

Im obigen Code verwenden wir die Bibliotheken MongoDB und Pandas, um die gecrawlten Daten im Datenordner der CSV-Datei zu speichern. Anschließend nutzten wir die leistungsstarke Datenanalysefunktion von Pandas, um die Anzahl der Artikel jedes öffentlichen Kontos visuell darzustellen.

Das obige ist der detaillierte Inhalt vonScrapy implementiert das Crawlen und Analysieren von Artikeln über öffentliche WeChat-Konten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!