Wie man Google-Finanzdaten mit Python ausliest

15.10.2024

Bemerkungen: 0

Inhalt des Artikels:

Installation der erforderlichen Bibliotheken

Schritt 1: Verstehen der HTML-Struktur
Schritt 2: Einrichten der Scraper-Funktion

Kompletter Code

Die heutigen Investoren und Analysten nutzen die Informationen von Google Finance, da sie aktuell und genau sind. Google Finance scheint der bevorzugte Ort zu sein, um aktuelle Finanzdaten aller Art zu erhalten, insbesondere für Aktien, Indizes und Markttrends, da es mehr Details über die Finanzkennzahlen von Unternehmen liefert. Python ist die beste Sprache für Web Scraping. In diesem Beitrag erfahren Sie, wie Sie Daten von Google Finance sammeln können, damit Sie über alle notwendigen Finanzanalysetools verfügen.

Installation der erforderlichen Bibliotheken

Bevor Sie beginnen, stellen Sie sicher, dass Sie Python auf Ihrem System installiert haben. Außerdem benötigen Sie die Bibliotheken: requests für HTTP-Anfragen und lxml für das Parsen des HTML-Inhalts von Webseiten. Um die erforderlichen Bibliotheken zu installieren, verwenden Sie die folgenden Befehle in der Befehlszeile:

pip install requests
pip install lxml

Als Nächstes werden wir den schrittweisen Prozess der Datenextraktion aus Google Finance untersuchen:

Schritt 1: Verstehen der HTML-Struktur

Um Daten aus Google Finance zu extrahieren, müssen wir die spezifischen HTML-Elemente identifizieren, die die Informationen enthalten, an denen wir interessiert sind:

Titel: angesiedelt bei //div[@class="zzDege"]/text()
Preis: gefunden bei //div[@class="YMlKec fxKbKc"]/text()
Datum: zu finden unter //div[@class="ygUjEc"]/text()

Diese XPath-Ausdrücke dienen uns als Leitfaden für die Navigation und Extraktion der relevanten Daten aus der HTML-Struktur der Google Finance-Seiten.

Titel:

Preis:

Datum:

Schritt 2: Einrichten der Scraper-Funktion

Bei der Einrichtung eines Scrapers gilt es, einige wichtige Aspekte zu beachten, um eine effiziente und sichere Datenerfassung zu gewährleisten.

HTTP-Anfrage stellen

Um HTML-Inhalte von der Google Finance-Website abzurufen, verwenden wir die Request-Bibliothek. Dieser Schritt leitet den Prozess ein, indem er die Webseite lädt, aus der wir Daten extrahieren wollen.

Wichtigkeit der Verwendung korrekter Header beim Scraping

Es ist sehr wichtig, beim Web Scraping die richtigen Header zu verwenden, vor allem den User-Agent-Header. Die Verwendung von Headern ist wichtig, um eine echte Browser-Anfrage zu simulieren, die verhindert, dass die Website Ihr automatisches Skript identifiziert und stoppt. Sie sorgen dafür, dass der Server korrekt antwortet, indem sie relevante Informationen über die Anfrage liefern. Ohne die richtigen Header könnte die Anfrage abgelehnt werden, oder der Server könnte völlig andere Inhalte zurückgeben oder Inhalte in Teilen liefern, die die Web-Scraping-Aktivität einschränken könnten. Die richtige Einstellung der Kopfzeilen trägt also dazu bei, den Zugriff auf die Website aufrechtzuerhalten, und gewährleistet, dass der Scraper die richtigen Daten abruft.

import requests

# Definieren Sie die Kopfzeilen, um einen Browser-Besuch zu imitieren und zu vermeiden, dass sie vom Server blockiert werden
headers = {
    'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
    'accept-language': 'en-IN,en;q=0.9',
    'cache-control': 'no-cache',
    'dnt': '1',  # Do Not Track-Anfrage-Header
    'pragma': 'no-cache',
    'priority': 'u=0, i',
    'sec-ch-ua': '"Not/A)Brand";v="8", "Chromium";v="126", "Google Chrome";v="126"',
    'sec-ch-ua-arch': '"x86"',
    'sec-ch-ua-bitness': '"64"',
    'sec-ch-ua-full-version-list': '"Not/A)Brand";v="8.0.0.0", "Chromium";v="126.0.6478.114", "Google Chrome";v="126.0.6478.114"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-model': '""',
    'sec-ch-ua-platform': '"Linux"',
    'sec-ch-ua-platform-version': '"6.5.0"',
    'sec-ch-ua-wow64': '?0',
    'sec-fetch-dest': 'document',
    'sec-fetch-mode': 'navigate',
    'sec-fetch-site': 'none',
    'sec-fetch-user': '?1',
    'upgrade-insecure-requests': '1',
    'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36',
}

# Definieren Sie die URL der Google Finance-Seite für BNP Paribas (Ticker BNP) an der Börse Euronext Paris (EPA)
url = "https://www.google.com/finance/quote/BNP:EPA?hl=en"

# Führen Sie die HTTP-GET-Anforderung an die URL mit den angegebenen Kopfzeilen aus
response = requests.get(url, headers=headers)

Bedeutung der Verwendung von Proxys

Beim Scrapen von Google Finance oder anderen Websites in großem Umfang ist die Verwendung von Proxys unerlässlich. Hier ist der Grund dafür:

Vermeiden Sie IP-Sperren: Websites wie Google Finance blockieren oder beschränken oft den Zugriff von IP-Adressen, die in einem kurzen Zeitraum zu viele Anfragen stellen. Proxys helfen dabei, die Anfragen auf mehrere IP-Adressen zu verteilen, wodurch die Wahrscheinlichkeit einer Erkennung und Sperrung verringert wird.
Verbesserter Datenschutz: Die Verwendung von Proxys bietet eine zusätzliche Ebene der Anonymität, die Ihre Identität und Ihre Absichten beim Scrapen von Daten schützt.

# Definieren Sie die Proxy-Einstellungen
proxies = {
    'http': 'http://your_proxy_address:port',
    'https': 'https://your_proxy_address:port',
}

# Führen Sie die HTTP-GET-Anfrage an die URL mit den angegebenen Kopfzeilen und Proxys aus
response = requests.get(url, headers=headers, proxies=proxies)

HTML mit lxml zerlegen

Sobald wir den HTML-Inhalt abgerufen haben, müssen wir ihn mit der lxml-Bibliothek analysieren. Dies ermöglicht es uns, durch die HTML-Struktur zu navigieren und die benötigten Daten zu extrahieren:

Die Funktion fromstring aus lxml.html wird importiert, um den HTML-Inhalt in ein Element-Objekt zu parsen. Die fromstring-Methode parst response.text, den rohen HTML-Inhalt der zuvor abgerufenen Webseite, und gibt ein Element-Objekt zurück, das in der Parser-Variable gespeichert ist und die Wurzel des geparsten HTML-Baums darstellt.

from lxml.html import fromstring

# Parsen des HTML-Inhalts der Antwort mit der fromstring-Methode von lxml
parser = fromstring(response.text)

Extracting data with XPath

Now, let's extract specific data using XPath expressions from the parsed HTML tree:

The title retrieves the financial instrument's title from the parsed HTML. The price retrieves the current stock price. The date retrieves the date. The finance_data dictionary contains the extracted title, price, and date. This dictionary is appended to a list.

# Liste zum Speichern von Ausgabedaten
finance_data_list = []

# Extraktion des Titels des Finanzinstruments
title = parser.xpath('//div[@class="zzDege"]/text()')[0]

# Extrahieren des aktuellen Kurses der Aktie
price = parser.xpath('//div[@class="YMlKec fxKbKc"]/text()')[0]

# Extrahieren des Datums
date = parser.xpath('//div[@class="ygUjEc"]/text()')[0]

# Erstellung eines Wörterbuchs zur Speicherung der extrahierten Daten
finance_data = {
    'title': title,
    'price': price,
    'date': date
}
# Anhängen von Daten an finance_data_list
finance_data_list.append(finance_data)

Datenverarbeitung und -speicherung

Um die gescrapten Daten zu verarbeiten, kann es sinnvoll sein, sie weiter zu verarbeiten oder in einem strukturierten Format wie JSON zu speichern:

Die Variable output_file gibt den Namen der JSON-Datei an, in der die Daten gespeichert werden sollen (finance_data.json). Mit open(output_file, 'w') wird die Datei im Schreibmodus geöffnet, und json.dump(finance_data_list, f, indent=4) schreibt die finance_data_list in die Datei mit einer Einrückung von 4 Leerzeichen zur besseren Lesbarkeit.

# finance_data_list in einer JSON-Datei speichern
output_file = 'finance_data.json'
with open(output_file, 'w') as f:
    json.dump(finance_data_list, f, indent=4)

Handling request exceptions

While scraping data from websites, it is important to handle request exceptions in order to ensure the reliability and robustness of your scraping script. These requests can fail for various reasons such as network issues, server errors or timeouts. The requests library in Python provides a way to effectively handle these types of exceptions as shown below:

try:
    # Senden einer GET-Anfrage an die URL
    response = requests.get(url)

    # HTTPError für schlechte Antworten (4xx oder 5xx Statuscodes) auslösen
    response.raise_for_status()

except requests.exceptions.HTTPError as e:
    # Behandlung von HTTP-Fehlern (wie 404, 500, usw.)
    print(f"HTTP error occurred: {e}")

except requests.exceptions.RequestException as e:
    # Behandeln Sie alle anderen Ausnahmen, die während der Anfrage auftreten können
    print(f"An error occurred: {e}")

Der try-Block umschließt den Code, der Ausnahmen auslösen kann. Mit requests.get(url) wird eine GET-Anfrage gesendet. response.raise_for_status() prüft den Statuscode der Antwort und löst bei erfolglosen Codes einen HTTPError aus. Die except requests.exceptions.HTTPError as e: fängt HTTPError-Ausnahmen ab und gibt die Fehlermeldung aus. Die except requests.exceptions.RequestException as e: fängt andere Ausnahmen ab (z.B. Netzwerkfehler, Timeouts) und gibt die Fehlermeldung aus.

Kompletter Code

Integrieren wir nun alles, um unsere Scraper-Funktion zu erstellen, die Daten von mehreren Google Finance-URLs abruft, analysiert und extrahiert:

import requests
from lxml.html import fromstring
import json
import urllib3
import ssl

ssl._create_default_https_context = ssl._create_stdlib_context
urllib3.disable_warnings()


# Liste der zu scrapender URLs
urls = [
    "https://www.google.com/finance/quote/BNP:EPA?hl=en",
    "https://www.google.com/finance/quote/SPY:NYSEARCA?hl=en",
    "https://www.google.com/finance/quote/SENSEX:INDEXBOM?hl=en"
]

# Definieren Sie Kopfzeilen, um einen Browserbesuch zu imitieren
headers = {
    'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
    'accept-language': 'en-IN,en;q=0.9',
    'cache-control': 'no-cache',
    'dnt': '1',
    'pragma': 'no-cache',
    'priority': 'u=0, i',
    'sec-ch-ua': '"Not/A)Brand";v="8", "Chromium";v="126", "Google Chrome";v="126"',
    'sec-ch-ua-arch': '"x86"',
    'sec-ch-ua-bitness': '"64"',
    'sec-ch-ua-full-version-list': '"Not/A)Brand";v="8.0.0.0", "Chromium";v="126.0.6478.114", "Google Chrome";v="126.0.6478.114"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-model': '""',
    'sec-ch-ua-platform': '"Linux"',
    'sec-ch-ua-platform-version': '"6.5.0"',
    'sec-ch-ua-wow64': '?0',
    'sec-fetch-dest': 'document',
    'sec-fetch-mode': 'navigate',
    'sec-fetch-site': 'none',
    'sec-fetch-user': '?1',
    'upgrade-insecure-requests': '1',
    'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36',
}

# Proxy-Endpunkt definieren
proxies = {
    'http': 'http://your_proxy_address:port',
    'https': 'https://your_proxy_address:port',
}

# Liste zum Speichern der ausgewerteten Daten
finance_data_list = []

# Iterieren Sie durch jede URL und scrapen Sie Daten
for url in urls:
    try:
        # Senden einer GET-Anfrage an die URL
        response = requests.get(url, headers=headers, proxies=proxies, verify=False)
        
        # HTTPError für schlechte Antworten (4xx oder 5xx Statuscodes) auslösen
        response.raise_for_status()
        
        # Parsen des HTML-Inhalts der Antwort mit der fromstring-Methode von lxml
        parser = fromstring(response.text)
        
        # Extrahieren des Titels, des Preises und des Datums
        title = parser.xpath('//div[@class="zzDege"]/text()')[0]
        price = parser.xpath('//div[@class="YMlKec fxKbKc"]/text()')[0]
        date = parser.xpath('//div[@class="ygUjEc"]/text()')[0]
        
        # Extrahierte Daten in einem Wörterbuch speichern
        finance_data = {
            'title': title,
            'price': price,
            'date': date
        }
        
        # Das Wörterbuch an die Liste anhängen
        finance_data_list.append(finance_data)
    
    except requests.exceptions.HTTPError as e:
        # Behandlung von HTTP-Fehlern (wie 404, 500, usw.)
        print(f"HTTP error occurred for URL {url}: {e}")
    except requests.exceptions.RequestException as e:
        # Behandeln Sie alle anderen Ausnahmen, die während der Anfrage auftreten können
        print(f"An error occurred for URL {url}: {e}")

# finance_data_list in einer JSON-Datei speichern
output_file = 'finance_data.json'
with open(output_file, 'w') as f:
    json.dump(finance_data_list, f, indent=4)

print(f"Scraped data saved to {output_file}")

Ausgabe:

Dieser Leitfaden bietet ein umfassendes Tutorial zum Scraping von Daten aus Google Finance mit Python und leistungsstarken Bibliotheken wie `lxml` und `requests`. Es legt den Grundstein für die Erstellung anspruchsvoller Tools für das Scraping von Finanzdaten, die zur Durchführung eingehender Marktanalysen, zur Überwachung der Aktivitäten von Wettbewerbern oder zur Unterstützung fundierter Investitionsentscheidungen genutzt werden können.

Bemerkungen:

0 Bemerkungen

Vorheriger Artikel

Nächster Artikel