Rottentomatoes.com ist eine beliebte Website für Filmbewertungen und -rezensionen. Die Plattform bietet wertvolle Informationen zu Filmen, Fernsehsendungen und sogar zu den Meinungen des Publikums. Rotten Tomatoes verfügt über Daten für Filmliebhaber, Forscher und Entwickler.

In diesem Blog erfahren Sie, wie Sie mit Python Filmbewertungen von Rotten Tomatoes abrufen können. Da Rotten Tomatoes JavaScript-Rendering verwendet, verwenden wir die Crawlbase Crawling API um das dynamische Laden von Inhalten zu handhaben. Am Ende dieses Blogs wissen Sie, wie Sie wichtige Filmdaten wie Bewertungen, Veröffentlichungsdaten und Rezensionen extrahieren und in einem strukturierten Format wie JSON speichern.

Hier ist eine ausführliche Anleitung zum Scrapen von Rotten Tomatoes:

Inhaltsverzeichnis

  1. Warum die Bewertung von Filmen bei Rotten Tomatoes durchforsten?
  2. Wichtige Datenpunkte zum Extrahieren aus Rotten Tomatoes
  3. Crawlbase Crawling API für Rotten Tomatoes Scraping
  4. Einrichten Ihrer Python-Umgebung
  • Installieren von Python und erforderlichen Bibliotheken
  • Einrichten einer virtuellen Umgebung
  • Auswahl einer IDE
  1. Auszug aus den Filmlisten von Rotten Tomatoes
  • Überprüfen der HTML-Struktur
  • Schreiben des Rotten Tomatoes Movie Listings Scrapers
  • Umgang mit Paginierung
  • Speichern von Daten in einer JSON-Datei
  • Vollständiges Codebeispiel
  1. Details zum Film „Rotten Tomatoes“
  • Überprüfen der HTML-Struktur
  • Schreiben des Rotten Tomatoes Movie Details Scrapers
  • Speichern von Daten in einer JSON-Datei
  • Vollständiges Codebeispiel
  1. Abschließende Überlegungen
  2. Häufig gestellte Fragen

Warum die Bewertung von Filmen bei Rotten Tomatoes durchforsten?

Rotten Tomatoes ist eine zuverlässige Quelle für Filmbewertungen und -rezensionen und daher eine gute Website zum Scrapen von Filmdaten. Egal, ob Sie Filmliebhaber, Datenanalyst oder Entwickler sind, Sie können Rotten Tomatoes scrapen, um Einblicke in Filmtrends, Publikumspräferenzen und Kritikerbewertungen zu erhalten.

Hier sind einige Gründe, warum Sie bei Rotten Tomatoes nach Filmbewertungen suchen sollten.

  1. Zugriff auf Kritikerrezensionen: Rotten Tomatoes bietet Kritiken und ermöglicht Ihnen, zu sehen, wie einzelne Fachleute den Film wahrnehmen.
  2. Zuschauerbewertungen: Erhalten Sie Einschaltquoten, die zeigen, wie ein Film beim allgemeinen Publikum ankommt.
  3. Filmdetails: Rotten Tomatoes bietet Daten wie Titel, Genres, Veröffentlichungsdaten und mehr.
  4. Popularitätsverfolgung: Durch das Scraping von Bewertungen im Zeitverlauf können Sie Trends bei Genres, Regisseuren oder der Popularität von Schauspielern überwachen.
  5. Erstellen Sie eine persönliche Filmdatenbank: Sammeln Sie Bewertungen und Rezensionen, um eine benutzerdefinierte Datenbank für Recherchen, Empfehlungen oder persönliche Projekte aufzubauen.

Wichtige Datenpunkte zum Extrahieren aus Rotten Tomatoes

Wenn Sie Filmbewertungen von Rotten Tomatoes abrufen, sollten Sie sich darauf konzentrieren, die wichtigsten Datenpunkte zu erhalten. Diese Datenpunkte liefern Ihnen wichtige Informationen über die Rezeption, Popularität und Leistung des Films. Hier sind die Datenpunkte, die Sie extrahieren sollten:

Wichtige Datenpunkte von Rotten Tomatoes
  1. Filmtitel: Der Titel des Films ist die erste Information, die sie haben. Dies hilft Ihnen dabei, Ihre Scraped-Daten nach bestimmten Filmen zu kategorisieren.
  2. Kritikerwertung (Tomatometer): Rotten Tomatoes hat eine Kritikerwertung, die als „Tomatometer“ bezeichnet wird. Diese Wertung wird anhand von Rezensionen anerkannter Kritiker berechnet und liefert ein Gesamtbild der kritischen Zustimmung zu einem Film.
  3. Publikums-Score: Die Zuschauerwertung spiegelt wider, wie das allgemeine Publikum den jeweiligen Film mag. Sie ist daher nützlich, wenn man die Meinungen von Fachleuten und der Öffentlichkeit zu verschiedenen Filmen vergleicht.
  4. Anzahl der Bewertungen: Kritiker- und Zuschauerbewertungen werden anhand der Anzahl der verfügbaren Rezensionen berechnet. Um die Zuverlässigkeit der Bewertungen zu ermitteln, müssen Sie auch diese Daten extrahieren. Eine Möglichkeit, dieses Wissen zu nutzen, besteht darin, Filme aus verschiedenen Jahren zu vergleichen und Änderungen im Laufe der Zeit zu analysieren, wenn Sie das Erscheinungsdatum eines bestimmten Films kennen.
  5. Release Date: Das Erscheinungsdatum kann verwendet werden, um Filme aus verschiedenen Jahren zu vergleichen und Veränderungen im Laufe der Zeit zu analysieren.
  6. Genre: Die Filme in der Datenbank von Rotten Tomatoes sind nach Genre wie Drama, Action oder Komödie klassifiziert. Daher sind Genres relevant, um die Filmbewertungen nach den Interessen der Zuschauer zu kategorisieren.
  7. Film Synopse: Durch das Extrahieren der Kurzbeschreibung/Zusammenfassung des Films erhalten Sie Hintergrundinformationen zur Handlung und den Themen des Films.
  8. Besetzung und Crew: Rotten Tomatoes hat die Besetzungs- und Crewliste der Filme. Diese Daten sind nützlich, um Filme eines bestimmten Regisseurs, Schauspielers oder Autors zu verfolgen.

Crawlbase Crawling API für Rotten Tomatoes Scraping

Wir werden die Crawlbase Crawling API um Filmbewertungen und andere Daten von Rotten Tomatoes zu erhalten. Das Scrapen von Rotten Tomatoes mit einfachen Ansätzen ist schwierig, da die Website ihren Inhalt dynamisch mit JavaScript lädt. Crawlbase Crawling API ist für die Verarbeitung dynamischer Websites mit viel JavaScript konzipiert und stellt daher die beste Möglichkeit dar, Rotten Tomatoes schnell und einfach zu scrapen.

Warum Rotten Tomatoes mit Crawlbase scrapen?

JavaScript wird verwendet, um dynamische Inhalte von Rotten Tomatoes-Seiten zu laden, einschließlich Zuschauerbewertungen, Rezensionen und Bewertungen. Solche Websites sind für Standard-Web-Scraping-Bibliotheken wie requests zu handhaben, da sie JavaScript-Rendering nicht verwalten können. Die Crawlbase Crawling API löst dieses Problem, indem sichergestellt wird, dass Sie durch serverseitiges JavaScript-Rendering vollständig geladenes HTML mit allen erforderlichen Daten erhalten.

Aus diesem Grund ist Crawlbase eine gute Wahl zum Scrapen von Rotten Tomatoes:

  1. JavaScript-Rendering: Es verarbeitet automatisch Seiten, die zum Laden von Inhalten wie Bewertungen oder Rezensionen auf JavaScript angewiesen sind.
  2. Integrierte Proxys: Crawlbase enthält rotierende Proxys, um IP-Sperren und Captchas zu vermeiden und so für reibungsloses Scraping zu sorgen.
  3. Anpassbare Parameter: Sie können API-Parameter anpassen wie ajax_wait und page_wait um sicherzustellen, dass alle Inhalte vollständig geladen sind, bevor Sie mit dem Scraping beginnen.
  4. Zuverlässig und schnell: Crawlbase ist auf Effizienz ausgelegt und ermöglicht Ihnen das schnelle und einfache Scrapen großer Datensätze von Rotten Tomatoes mit minimalen Unterbrechungen.

Crawlbase Python-Bibliothek

Crawlbase bietet sein eigenes Python Bibliothek der Einfachheit halber. Um es zu verwenden, benötigen Sie einen Zugriffstoken von Crawlbase, den Sie erhalten, indem Sie sich registrieren Konto.

Hier ist eine Beispielfunktion zum Senden von Anfragen mit der Crawlbase Crawling API:

1
2
3
4
5
6
7
8
9
10
11
12
13
für Crawlbase importieren CrawlingAPI

# Initialisieren Sie die Crawlbase-API mit Ihrem Token
crawling_api = CrawlingAPI({'Zeichen': 'IHR_CRAWLBASE_TOKEN'})

def Crawlbase-Anfrage erstellen(URL):
    Antwort = crawling_api.get(URL)

    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Seite konnte nicht abgerufen werden. Crawlbase-Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

Note: Für statische Websites verwenden Sie das normale Token. Für dynamische Websites wie Rotten Tomatoes verwenden Sie das JS-Token. Crawlbase bietet 1,000 kostenlose Anfragen zum Einstieg, ohne dass eine Kreditkarte erforderlich ist. Weitere Einzelheiten finden Sie in der Crawlbase Crawling API Dokumentation.

In den nächsten Abschnitten werden wir erklären, wie Sie Ihre Python-Umgebung einrichten und den Code zum Scrapen von Filmdaten mit Crawlbase verwenden. Crawling API.

Einrichten Ihrer Python-Umgebung

Um Daten von Rotten Tomatoes zu scrapen, müssen Sie zunächst Ihre Python-Umgebung einrichten. Dazu gehört die Installation von Python, das Erstellen einer virtuellen Umgebung und das Sicherstellen, dass alle benötigten Bibliotheken vorhanden sind.

Python installieren

Der erste Schritt besteht darin, sicherzustellen, dass Python auf Ihrem System installiert ist. Gehen Sie zu offizielle Python-Website um die neueste Version herunterzuladen. Denken Sie daran, die Version auszuwählen, die zu Ihrem Betriebssystem passt (Windows, macOS oder Linux).

Einrichten einer virtuellen Umgebung

Die Verwendung einer virtuellen Umgebung ist eine intelligente Möglichkeit, Ihre Projektabhängigkeiten zu verwalten. Sie hilft Ihnen, Übersichtlichkeit zu bewahren und Konflikte mit anderen Projekten zu vermeiden. So können Sie es tun:

  1. Öffnen Sie Ihr Terminal oder Ihre Eingabeaufforderung.

  2. Gehen Sie zu Ihrem Projektordner.

  3. Führen Sie den folgenden Befehl aus, um eine virtuelle Umgebung zu erstellen:

    1
    python -m venv meine Umgebung

  4. Aktivieren Sie die virtuelle Umgebung:

  • Unter Windows:

    1
    myenv\Scripts\activate

  • Unter macOS/Linux:

    1
    Quelle myenv/bin/activate

Extrahieren von Daten mit BeautifulSoup und Crawlbase

Als Nächstes müssen Sie die erforderlichen Bibliotheken installieren, darunter Crawlbase und BeautifulSoup zur Datenverarbeitung. Führen Sie den folgenden Befehl in Ihrem Terminal aus:

1
pip installieren crawlbase beautifulsoup4
  • Crawlbase: Wird zur Interaktion mit den Crawlbase-Produkten verwendet, einschließlich Crawling API.
  • BeautifulSuppe: Zum Parsen von HTML und Extrahieren der erforderlichen Daten.

Auswahl einer IDE

Um Ihre Python-Skripte reibungslos schreiben und ausführen zu können, verwenden Sie eine gute IDE (Integrated Development Environment). Hier sind einige:

Nachdem Sie Ihre Umgebung eingerichtet haben, können wir mit Python damit beginnen, Filmbewertungen von Rotten Tomatoes zu durchsuchen. Im nächsten Abschnitt werden wir uns mit dem Code befassen, der Filmbewertungen und andere Informationen von Rotten Tomatoes extrahiert.

Auszug aus den Filmlisten von Rotten Tomatoes

Hier werden wir Filmlisten von Rotten Tomatoes scrapen. Wir werden uns das HTML ansehen, den Scraper schreiben, die Paginierung handhaben und die Daten organisieren. Wir werden die Crawlbase verwenden Crawling API für JavaScript und dynamische Inhalte.

Überprüfen der HTML-Struktur

Bevor wir den Scraper schreiben, müssen wir uns die Rotten-Tomatoes-Seite ansehen, um zu sehen, wie die Struktur aussieht. So wissen wir, worauf wir abzielen müssen.

  1. Öffnen Sie die Rotten Tomatoes-Seite: Gehen Sie zu der Seite, die Sie scrapen möchten. Wir scrapen beispielsweise Liste der erfolgreichsten Filme an den Kinokassen.
  2. Öffnen Sie die Entwicklertools: Klicken Sie mit der rechten Maustaste auf die Seite und wählen Sie „Untersuchen“ oder drücken Sie Ctrl+Shift+I (Windows) oder Cmd+Option+I (Mac).
Rotten Tomatoes-Listing-Seite

  1. Identifizieren des Filmcontainers: Filme auf Rotten Tomatoes sind in der Regel innerhalb

    Elemente mit der Klasse Flex-Container, die sich innerhalb eines übergeordneten Elements befinden
    mit dem Attribut data-qa=”discovery-media-list”.

  2. Wichtige Daten finden:

    • Titel : Normalerweise innerhalb eines <span> mit Attribut wie data-qa="discovery-media-list-item-title". Das ist der Filmtitel.
    • Kritikerwertung: Innerhalb eines rt-text Element mit slot="criticsScore". Dies ist die Kritikerwertung des Films.
    • Publikums-Score: Auch innerhalb einer rt-text Element, aber mit slot="audienceScore". Dies ist die Zuschauerbewertung des Films.
    • Link: Der Filmlink befindet sich normalerweise in einem <a> tag mit data-qa Attribut, das beginnt mit discovery-media-list-itemSie können die href Attribut von diesem Element, um den Link zur Seite des Films zu erhalten.

Schreiben des Rotten Tomatoes Movie Listings Scrapers

Jetzt, da wir die Struktur kennen, schreiben wir den Scraper. Wir verwenden Crawlbase Crawling API um das HTML abzurufen, und BeautifulSoup, um die Seite zu analysieren und Titel, Bewertungen und Links zu extrahieren.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe

# Initialisieren Sie die Crawlbase-API mit Ihrem Token
crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

def fetch_html(URL):
    Optionen = {
        'ajax_wait': "wahr",
        'Seite_warten': '5000'
    }
    Antwort = crawling_api.get(URL, Optionen)
    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Daten konnten nicht abgerufen werden. Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

def Filme parsen(html):
    Suppe = Schöne Suppe (html, 'html.parser')
    Filme = Suppe.Auswahl('div[data-qa="Entdeckungsmedienliste"] > div.flex-container')

    Filmdaten = []
    
für Film in Filme:
        Titel = Film.Wählen Sie einen aus('span[data-qa="discovery-media-list-item-title"]').text.strip() if Film.Wähle einen aus('span[data-qa="discovery-media-list-item-title"]') sonst ''
        Kritikerwertung = Film.Wählen Sie einen aus('rt-text[slot="criticsScore"]').text.strip() if Film.Wähle einen aus('rt-text[slot="criticsScore"]') sonst ''
        Publikumswertung = Film.Wählen Sie einen aus('rt-text[slot="audienceScore"]').text.strip() if Film.Wähle einen aus('rt-text[slot="audienceScore"]') sonst ''
        Link = Film.Wählen Sie einen aus('a[data-qa^="Entdeckungsmedien-Listenelement"]')['href'] if Film.Wähle einen aus('a[data-qa^="Entdeckungsmedien-Listenelement"]') sonst ''

        movie_data.anhängen({
            ‚Titel‘: Titel,
            'Kritikerwertung': KritikerScore,
            'Publikumsscore': Publikumswertung,
            'Link': „https://www.rottentomatoes.com“ + Links
        })

    Rückkehr Filmdaten

Umgang mit Paginierung

Rotten Tomatoes verwendet für seine Filmlisten eine schaltflächenbasierte Seitennummerierung. Wir müssen die Seitennummerierung durch Klicken auf die Schaltfläche „Mehr laden“ verwalten. Crawlbase Crawling API ermöglicht uns die Paginierung mit dem css_click_selector Parameters.

1
2
3
4
5
6
7
8
9
10
11
12
def fetch_html_with_pagination(URL):
    Optionen = {
        'ajax_wait': "wahr",
        'Seite_warten': '5000',
        'css_click_selector': 'Schaltfläche[data-qa="dlp-load-more-button"]'  # CSS-Selektor für die Schaltfläche „Mehr laden“
    }
    Antwort = crawling_api.get(URL, Optionen)
    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Daten konnten nicht abgerufen werden. Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

Dieser Code klickt auf die Schaltfläche „Mehr laden“, um weitere Filmlisten zu laden, bevor die Daten ausgelesen werden.

Speichern von Daten in einer JSON-Datei

Nachdem wir die Filmdaten extrahiert haben, können wir sie in einer Datei in einem strukturierten Format wie JSON speichern.

1
2
3
4
5
6
importieren JSON

def in JSON speichern(Daten, Dateiname='Filme.json'):
    mit XNUMXh geöffnet(Dateiname, 'w') as Datei:
        json.dump(Daten, Datei, Einzug=4)
    drucken(f"Daten gespeichert in {Dateiname}")

Vollständiges Codebeispiel

Hier ist der vollständige Code, der alles zusammenführt, das HTML abruft, die Filmdaten analysiert, die Seitennummerierung handhabt und die Ergebnisse in einer JSON-Datei speichert.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
importieren JSON

# Initialisieren Sie die Crawlbase-API mit Ihrem Token
crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

def fetch_html_with_pagination(URL):
    Optionen = {
        'ajax_wait': "wahr",
        'Seite_warten': '5000',
        'css_click_selector': 'Schaltfläche[data-qa="dlp-load-more-button"]'  # CSS-Selektor für die Schaltfläche „Mehr laden“
    }
    Antwort = crawling_api.get(URL, Optionen)
    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Daten konnten nicht abgerufen werden. Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

def Filme parsen(html):
    Suppe = Schöne Suppe (html, 'html.parser')
    Filme = Suppe.Auswahl('div[data-qa="Entdeckungsmedienliste"] > div.flex-container')

    Filmdaten = []
    
für Film in Filme:
        Titel = Film.Wählen Sie einen aus('span[data-qa="discovery-media-list-item-title"]').text.strip() if Film.Wähle einen aus('span[data-qa="discovery-media-list-item-title"]') sonst ''
        Kritikerwertung = Film.Wählen Sie einen aus('rt-text[slot="criticsScore"]').text.strip() if Film.Wähle einen aus('rt-text[slot="criticsScore"]') sonst ''
        Publikumswertung = Film.Wählen Sie einen aus('rt-text[slot="audienceScore"]').text.strip() if Film.Wähle einen aus('rt-text[slot="audienceScore"]') sonst ''
        Link = Film.Wählen Sie einen aus('a[data-qa^="Entdeckungsmedien-Listenelement"]')['href'] if Film.Wähle einen aus('a[data-qa^="Entdeckungsmedien-Listenelement"]') sonst ''

        movie_data.anhängen({
            ‚Titel‘: Titel,
            'Kritikerwertung': KritikerScore,
            'Publikumsscore': Publikumswertung,
            'Link': „https://www.rottentomatoes.com“ + Links
        })

    Rückkehr Filmdaten

def in JSON speichern(Daten, Dateiname='Filme.json'):
    mit XNUMXh geöffnet(Dateiname, 'w') as Datei:
        json.dump(Daten, Datei, Einzug=4)
    drucken(f"Daten gespeichert in {Dateiname}")

if __name__ == "__hauptsächlich__":
    URL = „https://www.rottentomatoes.com/browse/movies_in_theaters/sort:top_box_office“
    html_content = fetch_html_with_pagination(url)
    if HTML-Inhalt:
        Filmdaten = Filme analysieren (HTML-Inhalt)
        save_to_json(Filmdaten)

Beispielausgabe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
[
    {
        „Titel“: "Käfersaft Käfersaft",
        "Kritikerwertung": "77%",
        "Publikumsscore": "81%",
        "Verknüpfung": „https://www.rottentomatoes.com/m/beetlejuice_beetlejuice“
    },
    {
        „Titel“: "Deadpool und Wolverine",
        "Kritikerwertung": "79%",
        "Publikumsscore": "95%",
        "Verknüpfung": „https://www.rottentomatoes.com/m/deadpool_and_wolverine“
    },
    {
        „Titel“: "Alien: Romulus",
        "Kritikerwertung": "80%",
        "Publikumsscore": "85%",
        "Verknüpfung": „https://www.rottentomatoes.com/m/alien_romulus“
    },
    {
        „Titel“: „Es endet mit uns“,
        "Kritikerwertung": "57%",
        "Publikumsscore": "91%",
        "Verknüpfung": „https://www.rottentomatoes.com/m/it_ends_with_us“
    },
    {
        „Titel“: "Die Schmiede",
        "Kritikerwertung": "73%",
        "Publikumsscore": "99%",
        "Verknüpfung": „https://www.rottentomatoes.com/m/the_forge“
    },
    {
        „Titel“: "Twister",
        "Kritikerwertung": "75%",
        "Publikumsscore": "91%",
        "Verknüpfung": „https://www.rottentomatoes.com/m/twisters“
    },
    {
        „Titel“: „Zweimal blinzeln“,
        "Kritikerwertung": "74%",
        "Publikumsscore": "69%",
        "Verknüpfung": „https://www.rottentomatoes.com/m/blink_twice“
    },
    ... mehr
]

Im nächsten Abschnitt besprechen wir das Scraping einzelner Filmdetails.

Details zum Film „Rotten Tomatoes“

Nun fahren wir mit dem Scrapen einzelner Filmdetails von Rotten Tomatoes fort. Sobald Sie die Filmlisten haben, müssen Sie detaillierte Informationen zu jedem Film extrahieren, wie z. B. Veröffentlichungsdatum, Regisseur, Genre usw. Dieser Teil führt Sie durch die Überprüfung des HTML einer Filmseite, das Schreiben des Scrapers und das Speichern der Daten in einer JSON-Datei.

Überprüfen der HTML-Struktur

Bevor wir mit dem Schreiben des Scrapers beginnen, müssen wir die HTML-Struktur einer bestimmten Filmseite überprüfen.

  1. Filmseite öffnen: Gehen Sie von der Liste, die Sie zuvor durchsucht haben, zu einer Filmseite.

  2. Öffnen Sie die Entwicklertools: Klicken Sie mit der rechten Maustaste auf die Seite und wählen Sie „Untersuchen“ oder drücken Sie Ctrl+Shift+I (Windows) oder Cmd+Option+I (Mac).

  3. Wichtige Daten finden:

  • Titel : Normalerweise in einem

    mit slot="titleIntro" Attribut.
  • Zusammenfassung: In einem
    mit einer klasse von synopsis-wrap und ein rt-text Element ohne die .key-Klasse.
  • Filmdetails: Diese liegen in einem Listenformat vor mit <dt> Elemente (Schlüssel) und <dd> Elemente (Werte). Die Daten sind in der Regel in rt-link und rt-text Stichworte.

Schreiben des Rotten Tomatoes Movie Details Scrapers

Da wir nun die HTML-Struktur haben, können wir den Scraper schreiben, um die Details von jeder Filmseite abzurufen. Schreiben wir den Scraper-Code.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe

# Initialisieren Sie die Crawlbase-API mit Ihrem Token
crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

def fetch_html(URL):
    Optionen = {
        'ajax_wait': "wahr",
        'Seite_warten': '5000'
    }
    Antwort = crawling_api.get(URL, Optionen)
    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Daten konnten nicht abgerufen werden. Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

def Filmdetails abrufen(Film-URL):
    html = fetch_html(Film-URL)
    if html:
        Suppe = Schöne Suppe (html, 'html.parser')

        # Filmtitel extrahieren
        Titel = Suppe.select_one('h1[slot="TitelIntro"]').text.strip()

        # Inhaltsangabe extrahieren
        Zusammenfassung = Suppe.Wählen Sie eine(„div.synopsis-wrap rt-text:nicht(.key)“).text.strip() if Suppe.Wähle eine(„div.synopsis-wrap rt-text:nicht(.key)“) sonst 'N / A'

        # Alle Filmdetails abrufen
        Filmdetails = {dt.text.strip(): ','.beitreten([Element.Text.Streifen() 
für Artikel in dd.find_all([„RT-Link“, „rt-text“]) if Artikelname != „rt-text“ or 'Trennzeichen' nicht in Artikel.get('Klasse', [])]) 
für dt, dd in Reißverschluss(Suppe.Auswahl('dt.key rt-text'), Suppe.Auswahl('tt'))}

        # Gibt die gesammelten Details als Wörterbuch zurück
        Rückkehr {
            ‚Titel‘: Titel,
            'Zusammenfassung': Zusammenfassung,
            'Filmdetails': Filmdetails
        }
    sonst:
        drucken(„Filmdetails konnten nicht abgerufen werden.“)
        Rückkehr Keine

fetch_movie_details Die Funktion ruft den Filmtitel, das Veröffentlichungsdatum, den Regisseur und die Genres aus der Film-URL ab. Sie verwendet BeautifulSoup zur HTML-Analyse und strukturiert die Daten in einem Wörterbuch.

Speichern von Filmdetails in einer JSON-Datei

Nachdem Sie die Filmdetails extrahiert haben, möchten Sie die Daten in einem strukturierten Format wie JSON speichern. Hier ist der Code zum Speichern der Filmdetails in einer JSON-Datei.

1
2
3
4
5
6
importieren JSON

def Filmdetails in JSON speichern(Filmdaten, Dateiname='Filmdetails.json'):
    mit XNUMXh geöffnet(Dateiname, 'w') as Datei:
        json.dump(Filmdaten, Datei, Einzug=4)
    drucken(f"Filmdetails gespeichert in {Dateiname}")

Vollständiges Codebeispiel

Hier ist der vollständige Code zum Scrapen von Filmdetails von Rotten Tomatoes und zum Speichern in einer JSON-Datei.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
für Crawlbase importieren CrawlingAPI
für bs4 importieren BeautifulSuppe
importieren JSON

# Initialisieren Sie die Crawlbase-API mit Ihrem Token
crawling_api = CrawlingAPI({'Zeichen': 'CRAWLBASE_JS_TOKEN'})

def fetch_html(URL):
    Optionen = {
        'ajax_wait': "wahr",
        'Seite_warten': '5000'
    }
    Antwort = crawling_api.get(URL, Optionen)
    if Antwort['Kopfzeilen']['pc_status'] == '200':
        Rückkehr Antwort['Körper'].dekodieren('utf-8')
    sonst:
        drucken(f"Daten konnten nicht abgerufen werden. Statuscode: {Antwort['Kopfzeilen']['pc_status']}")
        Rückkehr Keine

def Filmdetails abrufen(Film-URL):
    html = fetch_html(Film-URL)
    if html:
        Suppe = Schöne Suppe (html, 'html.parser')

        # Filmtitel extrahieren
        Titel = Suppe.select_one('h1[slot="TitelIntro"]').text.strip()

        # Inhaltsangabe extrahieren
        Zusammenfassung = Suppe.Wählen Sie eine(„div.synopsis-wrap rt-text:nicht(.key)“).text.strip() if Suppe.Wähle eine(„div.synopsis-wrap rt-text:nicht(.key)“) sonst 'N / A'

        # Alle Filmdetails abrufen
        Filmdetails = {dt.text.strip(): ','.beitreten([Element.Text.Streifen() 
für Artikel in dd.find_all([„RT-Link“, „rt-text“]) if Artikelname != „rt-text“ or 'Trennzeichen' nicht in Artikel.get('Klasse', [])]) 
für dt, dd in Reißverschluss(Suppe.Auswahl('dt.key rt-text'), Suppe.Auswahl('tt'))}

        # Gibt die gesammelten Details als Wörterbuch zurück
        Rückkehr {
            ‚Titel‘: Titel,
            'Zusammenfassung': Zusammenfassung,
            'Filmdetails': Filmdetails
        }
    sonst:
        drucken(„Filmdetails konnten nicht abgerufen werden.“)
        Rückkehr Keine

def Filmdetails in JSON speichern(Filmdaten, Dateiname='Filmdetails.json'):
    mit XNUMXh geöffnet(Dateiname, 'w') as Datei:
        json.dump(Filmdaten, Datei, Einzug=4)
    drucken(f"Filmdetails gespeichert in {Dateiname}")

if __name__ == "__hauptsächlich__":
    Film-URL = 'https://www.rottentomatoes.com/m/beetlejuice_beetlejuice'
    Filmdetails = Filmdetails abrufen(Film-URL)
    if Filmdetails:
        save_movie_details_to_json(Filmdetails)

Beispielausgabe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
{
  „Titel“: "Käfersaft Käfersaft",
  "Zusammenfassung": "Beetlejuice ist zurück! Nach einer unerwarteten Familientragödie kehren drei Generationen der Familie Deetz nach Winter River zurück. Lydias Leben wird immer noch von Beetlejuice heimgesucht und wird völlig auf den Kopf gestellt, als ihre rebellische Teenager-Tochter Astrid das mysteriöse Modell der Stadt auf dem Dachboden entdeckt und das Portal zum Jenseits versehentlich geöffnet wird. Da sich in beiden Reichen Ärger zusammenbraut, ist es nur eine Frage der Zeit, bis jemand Beetlejuices Namen dreimal ausspricht und der schelmische Dämon zurückkehrt, um seine ganz eigene Art von Chaos zu entfesseln.",
  "Filmdetails": {
    "Direktor": „Tim Burton“,
    "Hersteller": „Marc Toberoff, Dede Gardner, Jeremy Kleiner, Tommy Harper, Tim Burton“,
    "Drehbuchautor": „Alfred Gough, Meilen Millar“,
    "Verteiler": "Warner Bros. Bilder",
    „Produktionsfirma“: „Tommy Harper, Plan B Entertainment, Marc Toberoff, Tim Burton Productions“,
    "Bewertung": „PG-13 (Makabre und blutige Bilder|Kurzzeitiger Drogenkonsum|Teilweise anzügliches Material|Starke Sprache|Gewalttätiger Inhalt)“,
    "Genre": "Komödie, Fantasie",
    "Originalsprache": "Englisch",
    „Erscheinungsdatum (Kinos)“: „6. September 2024, Weit“,
    „Einspielergebnisse (Brutto USA)“: „111.0 Mio. USD“,
    "Laufzeit": „1 Stunde 44 Min.“,
    "Seitenverhältnis": „Flach (1.85:1)“
  }
}

Scrapen Sie Filmbewertungen auf Rotten Tomatoes mit Crawlbase

Das Scraping von Filmbewertungen von Rotten Tomatoes hat viele Verwendungsmöglichkeiten. Sie können Daten sammeln, um sie zu analysieren, zu recherchieren oder einfach nur Spaß zu haben. Es hilft Ihnen zu sehen, was beliebt ist. Die Crawlbase Crawling API kann mit dynamischen Inhalten umgehen, sodass Sie die Daten erhalten, die Sie benötigen. Wenn Sie Rotten Tomatoes durchsuchen, können Sie öffentliche Meinungen, Kassenstatistiken oder Filmdetails abrufen, die Sie in jedem beliebigen Projekt verwenden können.

In diesem Blog wurde Ihnen gezeigt, wie Sie Filmlisten und Bewertungen durchsuchen und Details wie Veröffentlichungsdaten, Regisseure und Genres abrufen können. Wir haben Python, Crawlbase BeautifulSoup und JSON verwendet, um die Daten zu sammeln und zu sortieren, damit Sie sie verwenden und untersuchen können. In diesem Blog wurde Ihnen gezeigt, wie Sie Filmlisten und Bewertungen durchsuchen und Details wie Veröffentlichungsdaten, Regisseure und Genres abrufen können.

Wenn Sie mehr Web Scraping betreiben möchten, sehen Sie sich unsere Anleitungen zum Scraping anderer wichtiger Websites an.

📜 So scrapen Sie Monster.com
📜 Wie man Groupon scrapt
📜 So scrapen Sie TechCrunch
📜 Wie man Clutch.co scrapt

Bei Fragen oder Anregungen steht Ihnen unser Support-Team kann Ihnen beim Web Scraping helfen. Viel Spaß beim Scraping!

Häufig gestellte Fragen

F: Wie kann ich Rotten Tomatoes durchsuchen, wenn die Site ihr Layout ändert?

Wenn Rotten Tomatoes sein Layout oder HTML ändert, funktioniert Ihr Scraper nicht mehr. So beheben Sie das Problem:

  • Behalten Sie die Site im Auge, um eventuelle Änderungen zu erfahren.
  • Untersuchen Sie das neue HTML und überarbeiten Sie Ihre CSS-Selektoren.
  • Nehmen Sie Änderungen am Code Ihres Scrapers vor.

F: Was muss ich beim Scrapen von Rotten Tomatoes beachten?

Wenn Sie Rotten Tomatoes oder ähnliche Websites scrapen:

  • Schauen Sie sich die Robots.txt an: Stellen Sie sicher, dass die Site Scraping zulässt, indem Sie deren robots.txt Datei.
  • Drosselung nutzen: Fügen Sie zwischen den Anfragen etwas Zeit hinzu, um eine Überlastung des Servers zu vermeiden und die Wahrscheinlichkeit einer Blockierung zu verringern.
  • Mit Fehlern umgehen: Fügen Sie Möglichkeiten zum Umgang mit Anforderungsfehlern oder Änderungen beim Aufbau der Site hinzu.

F. Wie verwalte ich die Paginierung mit Crawlbase Crawling API beim Durchsehen von Rotten Tomatoes?

Rotten Tomatoes nutzt möglicherweise andere Möglichkeiten, um mehr Inhalt anzuzeigen, etwa „Mehr laden“-Schaltflächen oder endloses Scrollen.

  • Für Schaltflächen: Verwenden Sie die css_click_selector Parameter in der Crawlbase Crawling API um auf die Schaltfläche „Mehr laden“ zu klicken.
  • Für unendliches Scrollen: Benutzen page_wait or ajax_wait Parameter in der Crawlbase Crawling API um zu warten, bis der gesamte Inhalt geladen ist, bevor Sie mit der Aufnahme beginnen.