Scrapen von GitHub-Repositorys in Python

Dieses Tutorial behandelt:

Warum GitHub-Repositorys scrapen?
GitHub-Scraping-Bibliotheken und -Tools
Erstellen Sie einen GitHub-Repo-Scraper mit Beautiful Soup

Warum GitHub-Repositorys scrapen?

Es gibt verschiedene Gründe, GitHub-Repositorys zu scrapen. Die beliebtesten davon sind folgende:

Verfolgung von Technologietrends: Indem Sie die Repository-Sterne und -Veröffentlichungen verfolgen, können Sie sich über aktuelle Trends in Programmiersprachen, Frameworks und Bibliotheken informieren. Durch Scraping von GitHub können Sie die Technologien analysieren, die an Popularität gewinnen, um deren Entwicklung zu verfolgen und neue Trends zu erkennen. Anhand dieser Daten können Entscheidungen über die Einführung von Technologien, die Entwicklung von Fähigkeiten und die Zuweisung von Ressourcen abgeleitet werden.
Zugriff auf eine umfangreiche Wissensdatenbank zum Thema Programmierung: GitHub ist eine wahre Schatzkammer von Open-Source-Projekten, Codebeispielen und Lösungen. Das bedeutet, dass Sie auf der Plattform eine riesige Menge an Programmierwissen und bewährten Verfahren sammeln können. Das ist für Bildungszwecke, zur Verbesserung der Programmierkenntnisse und zum Verständnis der Implementierung verschiedener Technologien sinnvoll.
Einblicke in die kollaborative Entwicklung erhalten: Repositorys bieten Einblicke in die Art und Weise, wie Entwickler durch Pull Requests, Probleme und Diskussionen zusammenarbeiten. Durch das Sammeln dieser Daten können Sie Muster der Kollaboration studieren, die Ihnen bei der Ausarbeitung von Strategien für die Teamarbeit, der Verbesserung des Projektmanagements sowie der Optimierung von Softwareentwicklungsprozessen nützlich sind.

GitHub ist nicht die einzige Cloud-basierte Plattform für das Hosting von Git-Repositorys, und es gibt viele Alternativen. Dennoch bleibt es die bevorzugte Wahl für Data-Scraping aufgrund folgender Faktoren:

Große Nutzerbasis
Hohe Nutzeraktivität
Etablierter Ruf

Die Daten von GitHub sind insbesondere zur Überwachung von Tech-Trends, zur Erkennung von Bibliotheken und Frameworks und zur Verbesserung des Softwareentwicklungsprozesses wertvoll. Diese Informationen tragen entscheidend dazu bei, der Konkurrenz in der IT-Welt immer einen Schritt voraus zu sein.

GitHub-Scraping-Bibliotheken und -Tools

Python gilt dank seiner einfachen Syntax, seiner entwicklerfreundlichen Natur und seiner umfangreichen Bibliotheken weithin als ausgezeichnete Sprache für Web-Scraping. Daher ist Python die empfohlene Programmiersprache für das Scraping von GitHub. Erfahren Sie mehr in unserer ausführlichen Anleitung zum Web-Scraping mit Python.

Im nächsten Schritt müssen Sie aus der Vielzahl der verfügbaren Optionen die geeigneten Scraping-Bibliotheken auswählen. Um eine sachkundige Entscheidung treffen zu können, sollten Sie die Plattform zunächst in Ihrem Browser erkunden. Öffnen Sie die DevTools und prüfen Sie die AJAX-Aufrufe, die von den Repository-Seiten auf GitHub getätigt werden. Ihnen wird auffallen, dass die meisten dieser Aufrufe ignoriert werden können. Tatsächlich sind die meisten Seitendaten nämlich in die vom Server zurückgegebenen HTML-Dokumente eingebettet.

Das bedeutet, dass eine Bibliothek für HTTP-Anfragen an den Server in Ergänzung mit einem HTML-Parser für diese Aufgabe völlig ausreicht. Sie sollten sich also für Folgendes entscheiden:

Requests: Die beliebteste HTTP-Client-Bibliothek im Ökosystem von Python. Sie rationalisiert den Prozess der Übermittlung von HTTP-Anfragen und der Verarbeitung entsprechender Antworten.
Beautiful Soup: Eine umfassende HTML- und XML-Parsing-Bibliothek. Diese Bibliothek bietet eine robuste DOM-Navigation und eine API zur Datenextraktion beim Web-Scraping.

Dank Requests und Beautiful Soup lassen sich GitHub-Scrapings mit Python effektiv durchführen. Schauen wir uns nun das Ganze etwas genauer an!

Erstellung eines GitHub-Repo-Scrapers mit Beautiful Soup

Folgen Sie dieser Schritt-für-Schritt-Anleitung und lernen Sie, wie man GitHub in Python scrapt. Sie möchten den ganzen Programmier- und Scraping-Prozess überspringen? Erwerben Sie stattdessen einen GitHub-Datensatz.

Schritt 1: Einrichtung des Python-Projekts

Bevor Sie loslegen, sollten Sie sicherstellen, dass Sie die unten aufgeführten Voraussetzungen erfüllen:

Auf Ihrem Computer ist Python 3+ installiert: Laden Sie das Installationsprogramm herunter, führen Sie es aus und folgen Sie den Anweisungen.
Eine Python-IDE Ihrer Wahl: Visual Studio Code mit der Python- Erweiterung und PyCharm Community Edition sind die zwei empfohlenen IDEs.

Jetzt verfügen Sie über alle notwendigen Elemente, um ein Projekt in Python einzurichten!

Führen Sie die folgenden Befehle im Terminal aus, um einen github-scraper-Ordner anzulegen und diesen mit einer virtuellen Python-Umgebung zu initialisieren:


mkdir github-scraper
cd github-scraper
python -m venv env

Unter Windows führen Sie den unten stehenden Befehl aus, um die Umgebung zu aktivieren:

env\Scripts\activate.ps1

Führen Sie ihn unter Linux oder macOS wie folgt aus:

./env/bin/activate

Fügen Sie anschließend eine Datei scraper.py mit der unten stehenden Zeile in den Projektordner ein:

print('Hello, World!')

Momentan gibt Ihr GitHub-Scraper nur „Hello, World!“ aus, doch bald wird er die entsprechenden Logiken enthalten, um Daten aus öffentlichen Repositorys zu extrahieren.

Sie können das Skript wie folgt starten:

python scraper.py

Sofern alles wie geplant verläuft, sollte im Terminal diese Meldung ausgegeben werden:

Hello, World!

Nachdem Sie nun wissen, dass alles funktioniert, öffnen Sie den Projektordner in Ihrer bevorzugten Python-IDE.

Ausgezeichnet! Bereiten Sie sich darauf vor, ein wenig Python-Code zu schreiben.

Schritt 2: Installation der Scraping-Bibliotheken

Wie bereits erwähnt, unterstützen Beautiful Soup und Requests Sie bei der Durchführung von Web-Scraping auf GitHub. Führen Sie in der bereits aktivierten virtuellen Umgebung den folgenden Befehl aus, um sie den Projektabhängigkeiten beizufügen:

pip install beautifulsoup4 requests

Löschen Sie scraper.py und importieren Sie dann die beiden Pakete mit folgenden Zeilen:

import requestsfrom bs4 import BeautifulSoup
# scraping logic...

Stellen Sie sicher, dass Ihre Python-IDE keine Fehler meldet. Sie erhalten möglicherweise einige Warnungen aufgrund von nicht verwendeten Importen. Diese können Sie jedoch ignorieren, da Sie diese Scraping-Bibliotheken verwenden werden, um Repository-Daten aus GitHub zu extrahieren!

Schritt 3: Herunterladen der Zielseite.

Wählen Sie ein GitHub-Repository aus, von dem Sie Daten abrufen möchten. In diesem Leitfaden lernen Sie, wie man das luminati-proxy-Repository scrapen kann. Bedenken Sie allerdings, dass jedes andere Repository ebenfalls funktioniert, da die Scraping-Logik identisch ist.

Hier wird gezeigt, wie die Zielseite im Browser aussieht:

Speichern Sie die URL der Zielseite in einer Variablen:

url = 'https://github.com/luminati-io/luminati-proxy'

Laden Sie anschließend die Seite mit requests.get() herunter:

page = requests.get(url)

Im Verborgenen stellt requests eine HTTP-GET-Anfrage an diese URL und speichert die vom Server erzeugte Antwort in der Variablen page. Ihre Aufmerksamkeit sollte auf das Attribut text gerichtet sein. Dieses enthält das mit der Ziel-Webseite verknüpfte HTML-Dokument. Überprüfen Sie dies mit einer simplen Druckanweisung:

print(page.text)

Führen Sie den Scraper aus, woraufhin Sie im Terminal folgendes sehen sollten:


<!DOCTYPE html>
<html lang="en" data-color-mode="dark" data-light-theme="light" data-dark-theme="dark"  data-a11y-animated-images="system" data-a11y-link-underlines="false">
      <head>
        <meta charset="utf-8">
      <link rel="dns-prefetch" href="https://github.githubassets.com">
      <link rel="dns-prefetch" href="https://avatars.githubusercontent.com">
      <link rel="dns-prefetch" href="https://github-cloud.s3.amazonaws.com">
      <link rel="dns-prefetch" href="https://user-images.githubusercontent.com/">
      <link rel="preconnect" href="https://github.githubassets.com" crossorigin>
      <link rel="preconnect" href="https://avatars.githubusercontent.com">
<!-- Omitted for brevity... -->
Awesome! Let’s now learn how to parse this

Schritt 4: Parsen des HTML-Dokuments

Um das oben abgerufene HTML-Dokument zu parsen, übermitteln Sie es an Beautiful Soup:

soup = BeautifulSoup(page.text, 'html.parser')

Der BeautifulSoup()-Konstruktor benötigt zwei Argumente:

Die Zeichenkette, die den HTML-Inhalt beinhaltet: In diesem Fall in der Variable page.text gespeichert.
Der von Beautiful Soup zu verwendende Parser: „html.parser“ ist der Name des in Python eingebauten HTML-Parsers.

BeautifulSoup() parst das HTML und gibt eine erkundbare Baumstruktur zurück. Konkret bietet die Variable soup effektive Methoden zur Auswahl von Elementen aus dem DOM-Baum, wie z. B.:

find(): Gibt das erste HTML-Element zurück, das der als Parameter übergebenen Selektor-Strategie entspricht.
find_all(): Gibt die Liste der HTML-Elemente zurück, die der eingegebenen Selektor-Strategie entsprechen.
select_one(): Gibt das erste HTML-Element zurück, das dem als Parameter übergebenen CSS-Selektor entspricht.
select(): Gibt die Liste der HTML-Elemente zurück, die dem eingegebenen CSS-Selektor entsprechen.

Beachten Sie, dass diese Methoden auch für einen einzelnen Knoten in der Baumstruktur aufgerufen werden können. Neben diesen Methoden verfügt ein Beautiful-Soup-Knotenobjekt auch über:

find_next_sibling(): Gibt den ersten HTML-Knoten innerhalb der gegGeschwister des Elements zurück, der dem angegebenen CSS-Selektor entspricht.
find_next_siblings(): Gibt alle HTML-Knoten innerhalb des gleichgeordneten Elements zurück, die mit dem als Parameter übergebenen CSS-Selektor übereinstimmen.

Mit diesen Funktionen sind Sie bereit, GitHub zu scrapen. Schauen wir uns an, wie!

Schritt 5: Einarbeitung in die Zielseite

Bevor Sie mit der Programmierung loslegen, müssen Sie einen weiteren wichtigen Schritt ausführen. Beim Scraping von Daten aus einer Website gilt es, die relevanten HTML-Elemente auszuwählen und daraus Daten zu extrahieren. Eine wirkungsvolle Selektionsstrategie festzulegen ist nicht immer einfach, weshalb Sie einige Zeit zur Analyse der Struktur Ihrer Ziel-Webseite aufwenden müssen.

Öffnen Sie dazu die Zielseite von GitHub im Browser und machen Sie sich mit ihr vertraut. Klicken Sie mit der rechten Maustaste darauf und wählen Sie „Inspizieren“, um die DevTools zu öffnen:

Inspizieren der GitHub-Seite mit DevTools

Wenn Sie sich den HTML-Code genauer ansehen, werden Sie bemerken, dass die Seite viele ihrer Elemente nicht mit eindeutigen Klassen oder Attributen kennzeichnet. Aus diesem Grund ist es meist schwierig, zum gewünschten Element zu navigieren, sodass Sie sich auf komplizierte Weise durch die einzelnen Elemente durcharbeiten müssen.

Aber nur keine Sorge. Die Entwicklung effektiver Selektionsstrategien für GitHub ist zwar nicht einfach, allerdings auch nicht unmöglich. Untersuchen Sie die Seite in den DevTools solange, bis Sie sich bereit fühlen, sie zu scrapen!

Schritt 6: Extrahieren der Repo-Daten

Das Ziel besteht darin, nützliche Daten aus dem GitHub-Repository zu extrahieren, z.B. Sterne, Beschreibung, letzter Commit und ähnliches. Dafür müssen Sie ein Python-Wörterbuch initialisieren, um diese Daten zu speichern. Ergänzen Sie Ihren Code:

repo = {}

Überprüfen Sie zunächst das Element „name“:

Initialisierung des Python-Wörterbuchs für die Extraktion von Repo-Daten

Beachten Sie, dass es ein eindeutiges itemprop=”name”- Attribut besitzt. Wählen Sie dieses aus und extrahieren Sie dessen Textinhalt mit:

name_html_element = soup.select_one('[itemprop="name"]')name = name_html_element.text.strip()

Verwenden Sie bei einem Beautiful-Soup-Knoten die get_text()- Methode, um auf dessen Textinhalt zuzugreifen.

Bei der Überprüfung von name_html_element.text im Debugger sehen Sie:

\nluminati-proxy\n

GitHub-Textfelder enthalten meist Leerzeichen und Zeilenumbrüche. Entfernen Sie diese mit der Python-Funktion strip().

Unmittelbar unter dem Repo-Namen befindet sich der Verzweigungsselektor:

Extrahieren des Repository-Namens mit Beautiful Soup

Hierbei ist zu beachten, dass es keine einfache Möglichkeit gibt, das HTML-Element auszuwählen, in dem der Name des Hauptzweigs gespeichert ist. Allerdings können Sie den Knoten .octicon-git-branch auswählen und dann unter den gleichgeordneten Elementen nach der Zielspanne suchen:

git_branch_icon_html_element = soup.select_one('.octicon-git-branch')
main_branch_html_element = git_branch_icon_html_element.find_next_sibling('span')
main_branch = main_branch_html_element.get_text().strip()

Die Methode zur Erkennung eines bestimmten Elements über die gleichgeordneten Elemente eines Symbols ist auf GitHub äußerst effektiv. In diesem Abschnitt werden Sie dies mehrmals angewendet sehen.

Richten Sie Ihre Aufmerksamkeit nun auf den Header des Zweigs:

Auswahl des Hauptzweignamens über ein gleichgeordnetes Element in GitHub

Extrahieren Sie die letzte Commit-Zeit mit:

relative_time_html_element = boxheader_html_element.select_one('relative-time')
latest_commit = relative_time_html_element['datetime']

Bei einem Knoten können Sie auf seine HTML-Attribute wie in einem Python-Wörterbuch zugreifen.

Eine weitere wichtige Angabe in diesem Abschnitt ist die Anzahl der Commits:

Diese wird mit dem zuvor beschriebenen Symbolmuster erfasst:

history_icon_html_element = boxheader_html_element.select_one('.octicon-history')
commits_span_html_element = history_icon_html_element.find_next_sibling('span')
commits_html_element = commits_span_html_element.select_one('strong')
commits = commits_html_element.get_text().strip().replace(',', '')

Beachten Sie, dass find_next_sibling() nur Zugriff auf gleichgeordnete Elemente der obersten Ebenebietet. Um eines ihrer untergeordneten Elemente auszuwählen, müssen Sie zuerst das gleichgeordnete Element abrufen und dann select_one() aufrufen,wie zuvor beschrieben.

Da Zahlen über 1000 in GitHub ein Komma enthalten, können Sie dieses mit der Python-Methode replace() entfernen.

Schauen Sie sich als Nächstes die Infobox auf der rechten Seite an:

Wählen Sie diese mit:

bordergrid_html_element = soup.select_one('.BorderGrid')

Inspizieren Sie das Beschreibungselement:

Auswahl und Inspektion des Beschreibungselements auf GitHu

Auch hier können Sie es über ein gleichgeordnetes Element auswählen:

about_html_element = bordergrid_html_element.select_one('h2')
description_html_element = about_html_element.find_next_sibling('p')
description = description_html_element.get_text().strip()

Wenden Sie anschließend das Symbolmuster an, um die Repository-Sterne, -Uhren und -Gabeln abzurufen.

Achten Sie auf die Symbole und dann auf ihre zugehörigen Textelemente:

star_icon_html_element = bordergrid_html_element.select_one('.octicon-star')
stars_html_element = star_icon_html_element.find_next_sibling('strong')
stars = stars_html_element.get_text().strip().replace(',', '')

eye_icon_html_element = bordergrid_html_element.select_one('.octicon-eye')
watchers_html_element = eye_icon_html_element.find_next_sibling('strong')
watchers = watchers_html_element.get_text().strip().replace(',', '')

fork_icon_html_element = bordergrid_html_element.select_one('.octicon-repo-forked')
forks_html_element = fork_icon_html_element.find_next_sibling('strong')
forks = forks_html_element.get_text().strip().replace(',', '')

Gut gemacht! Sie haben gerade ein GitHub-Repository gescrapt.

Schritt 7: Scraping von Readme

Eine weitere wichtige abzurufende Information ist die Datei README.md . Es handelt sich hierbei um eine optionale Textdatei, die das GitHub-Repository beschreibt und die Verwendung des Codes erläutert.

Wenn Sie auf dieDatei README.md und daraufhin auf die Schaltfläche „Raw“ (Rohdaten) klicken, werden Sie zur folgenden URL weitergeleitet:

https://raw.githubusercontent.com/luminati-io/luminati-proxy/master/README.md

Extrahieren von Stern-, Watcher- und Fork-Zählungen und Zugriff auf README.md auf

GitHub Daraus lässt sich ableiten, dass die URL der Readme-Datei eines GitHub-Repos dem nachstehenden Format folgt:

https://raw.githubusercontent.com/<repo_id>/<repo_main_branch>/README.md

Da Sie die repo_main_branch > info in der main_branch- Variable abgelegt haben, können Sie diese URL programmgesteuert mit einem Python-f-string erstellen:

readme_url = f'https://raw.githubusercontent.com/luminati-io/luminati-proxy/{main_branch}/README.md'

Verwenden Sie nun Anfragen , um den Markdown-Rohinhalt der Readme-Datei abzurufen:

readme_url = f'https://raw.githubusercontent.com/luminati-io/luminati-proxy/{main_branch}/README.md'
readme_page = requests.get(readme_url)

readme = None
# if there is a README.md file
if readme_page.status_code != 404:
    readme = readme_page.text

Berücksichtigen Sie die 404-Prüfung, um zu vermeiden, dass der Inhalt der GitHub-404-Seite gespeichert wird, wenn das Repo keine Readme-Datei enthält.

Schritt 8: Speichern der gescrapten Daten

Denken Sie daran, die Variablen der gescrapten Daten zum repo-Wörterbuch hinzuzufügen:

repo['name'] = name
repo['latest_commit'] = latest_commit
repo['commits'] = commits
repo['main_branch'] = main_branch
repo['description'] = description
repo['stars'] = stars
repo['watchers'] = watchers
repo['forks'] = forks
repo['readme'] = readme

Verwenden Sie print(repo), um sicherzustellen, dass der Datenextraktionsprozess wie gewünscht funktioniert. Nach dem Ausführen des Python-GitHub-Scrapers erhalten Sie:

{'name': 'luminati-proxy', 'latest_commit': '2023-08-09T08:25:15Z', 'commits': '1079', 'main_branch': 'master', 'description': 'Luminati HTTP/HTTPS Proxy manager', 'stars': '645', 'watchers': '55', 'forks': '196', 'readme': '# Proxy manager\n\n (omitted for brevity...)'}

Ausgezeichnet! Nun wissen Sie, wie man GitHub scrapt!

Schritt 9: Export der gescrapten Daten nach JSON.

Im letzten Schritt geht es darum, die Weitergabe, das Lesen und die Analyse der erfassten Daten zu erleichtern. Dies lässt sich am besten durch den Export der Daten in ein für Menschen lesbares Format wie JSON erreichen:

import json

# ...

with open('repo.json', 'w') as file:
    json.dump(repo, file, indent=4)

Importieren Sie json aus der Python-Standardbibliothek, initialisieren Sie arepo.jsonfile mit open() und verwenden Sie schließlich json.ump() , um es zu füllen. In unserem Leitfaden erfahren Sie mehr darüber, wie man JSON in Python parst.

Perfekt! Zeit, sich einmal den gesamten GitHub-Python-Scraper näher anzusehen.

Schritt 9: Das Ganze zusammenfügen

So sieht die vollständige scraper.py- Datei aus:

import requests
from bs4 import BeautifulSoup
import json

# the URL of the target repo to scrape
url = 'https://github.com/luminati-io/luminati-proxy'

# download the target page
page = requests.get(url)
# parse the HTML document returned by the server
soup = BeautifulSoup(page.text, 'html.parser')

# initialize the object that will contain
# the scraped data
repo = {}

# repo scraping logic
name_html_element = soup.select_one('[itemprop="name"]')
name = name_html_element.get_text().strip()

git_branch_icon_html_element = soup.select_one('.octicon-git-branch')
main_branch_html_element = git_branch_icon_html_element.find_next_sibling('span')
main_branch = main_branch_html_element.get_text().strip()

# scrape the repo history data
boxheader_html_element = soup.select_one('.Box .Box-header')

relative_time_html_element = boxheader_html_element.select_one('relative-time')
latest_commit = relative_time_html_element['datetime']

history_icon_html_element = boxheader_html_element.select_one('.octicon-history')
commits_span_html_element = history_icon_html_element.find_next_sibling('span')
commits_html_element = commits_span_html_element.select_one('strong')
commits = commits_html_element.get_text().strip().replace(',', '')

# scrape the repo details in the right box
bordergrid_html_element = soup.select_one('.BorderGrid')

about_html_element = bordergrid_html_element.select_one('h2')
description_html_element = about_html_element.find_next_sibling('p')
description = description_html_element.get_text().strip()

star_icon_html_element = bordergrid_html_element.select_one('.octicon-star')
stars_html_element = star_icon_html_element.find_next_sibling('strong')
stars = stars_html_element.get_text().strip().replace(',', '')

eye_icon_html_element = bordergrid_html_element.select_one('.octicon-eye')
watchers_html_element = eye_icon_html_element.find_next_sibling('strong')
watchers = watchers_html_element.get_text().strip().replace(',', '')

fork_icon_html_element = bordergrid_html_element.select_one('.octicon-repo-forked')
forks_html_element = fork_icon_html_element.find_next_sibling('strong')
forks = forks_html_element.get_text().strip().replace(',', '')

# build the URL for README.md and download it
readme_url = f'https://raw.githubusercontent.com/luminati-io/luminati-proxy/{main_branch}/README.md'
readme_page = requests.get(readme_url)

readme = None
# if there is a README.md file
if readme_page.status_code != 404:
    readme = readme_page.text

# store the scraped data 
repo['name'] = name
repo['latest_commit'] = latest_commit
repo['commits'] = commits
repo['main_branch'] = main_branch
repo['description'] = description
repo['stars'] = stars
repo['watchers'] = watchers
repo['forks'] = forks
repo['readme'] = readme

# export the scraped data to a repo.json output file
with open('repo.json', 'w') as file:
    json.dump(repo, file, indent=4)

Mit weniger als 100 Codezeilen können Sie einen Web-Spider zur Erfassung von Repo-Daten erstellen.

Führen Sie das Skript wie folgt aus:

python scraper.py

Warten Sie den Abschluss des Scraping-Vorgangs ab, woraufhin Sie im Stammordner Ihres Projekts die Datei repo.json finden. Beim Öffnen dieser Datei werden Sie Folgendes sehen:

{
    "name": "luminati-proxy",
    "latest_commit": "2023-08-09T08:25:15Z",
    "commits": "1079",
    "main_branch": "master",
    "description": "Luminati HTTP/HTTPS Proxy manager",
    "stars": "645",
    "watchers": "55",
    "forks": "196",
    "readme": "# Proxy manager\n\n[![dependencies Status](https://david-dm.org/luminati-io/luminati-proxy/status.svg)](https://david-dm.org/luminati-io/luminati-proxy)\n[![devDependencies Status](https://david-dm.org/luminati-io/luminati-proxy/dev-status.svg)](https://david-dm..."
}

Herzlichen Glückwunsch! Sie haben mit Rohdaten begonnen, die in einer Webseite enthalten sind und verfügen nun über halbstrukturierte Daten in einer JSON-Datei. Sie haben soeben gelernt, wie man einen GitHub-Repo-Scraper in Python erstellt!

Fazit

Diese Schritt-für-Schritt-Anleitung hat Ihnen die Gründe für die Erstellung eines GitHub-Repo-Scrapers nähergebracht. Konkret haben Sie in einer geführten Anleitung gelernt, wie man GitHub scrapt. Wie hier gezeigt, sind dafür nur wenige Codezeilen vonnöten.

Jedoch setzen immer mehr Websites Anti-Scraping-Technologien ein. Mit diesen Technologien können Anfragen durch IP-Sperren und Ratenbegrenzung identifiziert und blockiert werden, wodurch verhindert wird, dass Ihr Scraper auf die Website zugreifen kann. Die beste Art, diese zu umgehen, ist ein Proxy. Erkunden Sie das breitgefächerte Angebot an erstklassigen Proxy-Diensten von Bright Data und die dedizierten GitHub-Proxys.

Bright Data betreibt die besten Proxys für Web-Scraping und betreut Fortune-500-Unternehmen sowie mehr als 20.000 Kunden.

Datacenter-Proxys – Über 770.000 Rechenzentrum-IPs.
Privatanwender-Proxys – Über 72 Millionen Privatanwender-IPs in mehr als 195 Ländern.
IDA-Proxys – Über 700.000 IDA-IPs.
Mobile Proxys – Über 7 Millionen mobile IPs.

Zusammengefasst ist Bright Data eines der größten und zuverlässigsten auf Scraping ausgerichteten Proxy-Netzwerke auf dem Markt. Wenden Sie sich an einen unserer Vertriebsmitarbeiter und finden Sie heraus, welches der Produkte von Bright Data Ihren Anforderungen am besten entspricht.

Kostenlose Testversion starten

Kostenlos mit Google loslegen

Keine Kreditkarte erforderlich

Hinweis: Dieser Leitfaden wurde von unserem Team bei der Erstellung gründlich getestet. Da Websites jedoch häufig ihren Code und ihre Struktur aktualisieren, funktionieren manche Schritte eventuell nicht mehr wie erwartet.