Wie man Spotify-Daten mit Python abgreift

Spotify-Wiedergabelistendaten können nützlich sein, um Informationen zu Songs, Interpreten und anderen Titeldetails zu sammeln. Spotify bietet ohne einen API-Schlüssel keinen detaillierten Zugriff auf einige Daten, aber mit Playwright für Python können wir auf dynamische Inhalte zugreifen und Wiedergabelistendaten direkt von der Spotify-Website extrahieren. Dieser Artikel veranschaulicht, wie Playwright implementiert wird, um Informationen wie Titelnamen, Bandnamen, Links und Längen von Titeln aus Spotify-Wiedergabelisten zu extrahieren.

Anforderungen und Installation

Installieren Sie zunächst Playwright und lxml, um den dynamischen Seiteninhalt und das HTML-Parsing zu verwalten:

pip install playwright
pip install lxml

Um die Playwright-Browser zu aktivieren, verwenden Sie den folgenden Befehl, um die erforderlichen Browser-Binärdateien herunterzuladen:

playwright install

Damit sind wir bereit, Spotify zu scrapen.

Spotify Scraping-Prozess: Schritt-für-Schritt-Anleitung

Die Inhalte von Spotify werden dynamisch geladen, sodass die Verwendung von Anfragen oder anderen einfachen HTTP-Bibliotheken nicht alle von JavaScript gerenderten Informationen erfassen kann. Playwright ist eine Bibliothek zur Browser-Automatisierung, mit der wir mit dynamischen Websites interagieren können, als ob wir sie selbst durchsuchen würden, was bedeutet, dass wir warten können, bis JavaScript geladen ist, bevor wir scrapen.

Playwright unterstützt auch die Proxy-Konfiguration, so dass wir bei Bedarf andere IPs verwenden können, um Ratenbegrenzungen oder geografische Beschränkungen auf Spotify zu umgehen.

Im Folgenden finden Sie eine ausführliche, schrittweise Anleitung zum Scraping mit Code-Beispielen, um den Prozess besser zu verstehen.

Schritt 1. Einrichten der Funktion zum Abrufen von HTML-Inhalten

Die Funktion fetch_html_content initialisiert die Playwright-Umgebung, startet einen Browser und navigiert zur URL der Spotify-Playlist. Hier wird headless=False gesetzt, sodass die Benutzeroberfläche des Browsers sichtbar bleibt (nützlich zum Debuggen); für automatisierte Aufgaben empfiehlt es sich, den Wert auf True zu setzen, um die Ausführung zu beschleunigen.

Die Option wait_until='networkidle' wartet, bis die Netzwerkaktivität stabil ist, bevor der Seiteninhalt erfasst wird, um sicherzustellen, dass alle Elemente korrekt geladen sind.

from playwright.async_api import async_playwright

async def fetch_html_content(playlist_url):
    async with async_playwright() as p:
        # Browser mit Proxy-Einrichtung starten, falls erforderlich
        browser = await p.chromium.launch(headless=False)
        page = await browser.new_page()

        # Rufen Sie die URL auf
        await page.goto(playlist_url, wait_until='networkidle')

        # Warten Sie, bis sich die Netzwerkaktivität beruhigt hat.
        await page.wait_for_timeout(3000)

        # Erfassen von Seiteninhalten
        page_content = await page.content()

        # Schließen Sie den Browser
        await browser.close()

        return page_content

Um einen Proxy mit IP-Adressauthentifizierung in Playwright zu verwenden, konfigurieren Sie die Startfunktion wie folgt:

browser = await p.chromium.launch(headless=True, proxy={"server": "http://your-proxy-server:port"})

Dadurch werden Anfragen über den angegebenen Proxyserver geleitet, wodurch Ihre ursprüngliche IP-Adresse maskiert und mögliche Einschränkungen beim Scraping vermieden werden.

Schritt 2. Parsen des HTML-Inhalts

Mit der fromstring-Funktion von lxml erstellen wir einen Parser für den abgerufenen HTML-Inhalt. Dies ermöglicht es uns, bestimmte Daten mit XPath-Ausdrücken zu finden und zu extrahieren.

from lxml.html import fromstring

page_content = await fetch_html_content('https link')
parser = fromstring(page_content)

Schritt 3. Extrahieren von Spurinformationen

Mit XPath-Selektoren erfassen wir die folgenden Details für jeden Titel in der Wiedergabeliste:

1. Namen der Spur;
2. Spur-URLs;
3. Namen der Interpreten;
4. Interpreten-URLs;
5. Laufzeiten der Tracks.

track_names = parser.xpath('//div[@data-testid="tracklist-row"]//a[@data-testid="internal-track-link"]/div/text()')
track_urls = parser.xpath('//div[@data-testid="tracklist-row"]//a[@data-testid="internal-track-link"]/@href')
track_urls_with_domain = [f"https://open.spotify.com/{url}" for url in track_urls]
artist_names = parser.xpath('//div[@data-testid="tracklist-row"]//div[@data-encore-id="text"]/a/text()')
artist_urls = parser.xpath('//div[@data-testid="tracklist-row"]//div[@data-encore-id="text"]/a/@href')
artist_urls_with_domain = [f"https://open.spotify.com/{url}" for url in artist_urls]
track_durations = parser.xpath('//div[@data-testid="tracklist-row"]//div[@class="PAqIqZXvse_3h6sDVxU0"]/div/text()')

Die URL-Listen werden mit der Spotify-Domäne ergänzt, um vollständig qualifizierte Links zu erstellen.

Schritt 4. Speichern der Daten in einer CSV-Datei

Nachdem wir die Daten gesammelt haben, schreiben wir sie in eine CSV-Datei. Jede Zeile in der Datei enthält den Titelnamen, die Titel-URL, den Künstlernamen, die Künstler-URL und die Titeldauer.

import csv

rows = zip(track_names, track_urls_with_domain, artist_names, artist_urls_with_domain, track_durations)
csv_filename = "spotify_playlist.csv"

with open(csv_filename, mode='w', newline='') as file:
    writer = csv.writer(file)
    # Kopfzeile schreiben
    writer.writerow(["track_names", "track_urls", "artist_names", "artist_urls", "track_durations"])
    # Zeilen schreiben
    writer.writerows(rows)

print(f"Data successfully written to {csv_filename}")

So entsteht eine gut strukturierte CSV-Datei, die sich leicht analysieren und in weiteren Anwendungen verwenden lässt.

Vollständiges Codebeispiel mit Proxy-Unterstützung

Hier ist der vollständige Code, der alle Schritte für einen optimierten Spotify-Scraping-Prozess kombiniert:

from playwright.async_api import async_playwright
from lxml.html import fromstring
import csv

async def fetch_html_content(playlist_url):
    async with async_playwright() as p:
        # Browser starten, bei Bedarf mit Proxy-Option
        browser = await p.chromium.launch(headless=False, proxy={"server": "http://your-proxy-server:port", "username": "username", "password": "password"})
        page = await browser.new_page()

        # Rufen Sie die URL auf
        await page.goto(playlist_url, wait_until='networkidle')
        
        # Warten Sie, bis sich die Netzwerkaktivitäten beruhigt haben.
        await page.wait_for_timeout(3000)
        
        # Erfassen von Seiteninhalten
        page_content = await page.content()

        # Schließen Sie den Browser
        await browser.close()
        
        return page_content

page_content = asyncio.run(fetch_html_content('https link'))
parser = fromstring(page_content)


# Auszug Details
track_names = parser.xpath('//div[@data-testid="tracklist-row"]//a[@data-testid="internal-track-link"]/div/text()')
track_urls = parser.xpath('//div[@data-testid="tracklist-row"]//a[@data-testid="internal-track-link"]/@href')
track_urls_with_domain = [f"https://open.spotify.com/{url}" for url in track_urls]
artist_names = parser.xpath('//div[@data-testid="tracklist-row"]//div[@data-encore-id="text"]/a/text()')
artist_urls = parser.xpath('//div[@data-testid="tracklist-row"]//div[@data-encore-id="text"]/a/@href')
artist_urls_with_domain = [f"https://open.spotify.com/{url}" for url in artist_urls]
track_durations = parser.xpath('//div[@data-testid="tracklist-row"]//div[@class="PAqIqZXvse_3h6sDVxU0"]/div/text()')

# Schreiben in CSV
rows = zip(track_names, track_urls_with_domain, artist_names, artist_urls_with_domain, track_durations)
csv_filename = "spotify_playlist.csv"

with open(csv_filename, mode='w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(["track_names", "track_urls", "artist_names", "artist_urls", "track_durations"])
    writer.writerows(rows)

print(f"Data successfully written to {csv_filename}")

Das Sammeln von Spotify-Wiedergabelistendaten mit Python und Playwright ermöglicht den Zugriff auf dynamische Inhalte zum Extrahieren und Analysieren von Titelinformationen. Durch die Konfiguration von Playwright mit Proxies können wir die Ratenbegrenzung handhaben und so eine zuverlässige Methode zur Erfassung von Wiedergabelistendaten schaffen. Dieses Setup eröffnet Möglichkeiten für detaillierte Analysen und kann leicht für andere Spotify-Inhaltstypen angepasst werden.