--- title: "Scrapen von GitHub-Repositorys in Python" slug: how-to-scrape-github-repositories-in-python date: 2023-08-21T12:55:31+00:00 modified: 2026-04-20T11:25:44+00:00 permalink: https://brightdata.de/blog/wie/how-to-scrape-github-repositories-in-python type: blog --- [ Blog ](https://brightdata.de/blog "Blog") / [How Tos](https://brightdata.de/blog/wie) [How Tos](https://brightdata.de/blog/wie) # Scrapen von GitHub-Repositorys in Python Wollten Sie schon immer mal wissen, wie man GitHub scrapen kann? Finden Sie es hier heraus! 17 min lesen ![Github scraping guide](https://media.brightdata.de/2023/08/Github-scraping-guide-V2-1.svg) 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: 1. Große Nutzerbasis 2. Hohe Nutzeraktivität 3. 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](https://brightdata.de/blog/wie/web-scraping-with-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**](https://requests.readthedocs.io/en/latest/): 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**](https://www.crummy.com/software/BeautifulSoup/bs4/doc/): 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 ](https://brightdata.de/products/datasets/github)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](https://www.python.org/downloads/), führen Sie es aus und folgen Sie den Anweisungen. - **Eine Python-IDE Ihrer Wahl**: Visual Studio Code mit der [Python-](https://marketplace.visualstudio.com/items?itemName=ms-python.python) Erweiterung und [PyCharm Community Edition](https://www.jetbrains.com/pycharm/download/#section=windows) 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](https://docs.python.org/3/library/venv.html) zu initialisieren: ```none 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: ```none envScriptsactivate.ps1 ``` Führen Sie ihn unter Linux oder macOS wie folgt aus: ```none `./env/bin/activate` ``` Fügen Sie anschließend eine Datei `scraper.py` mit der unten stehenden Zeile in den Projektordner ein: ```none `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: ```none `python scraper.py` ``` Sofern alles wie geplant verläuft, sollte im Terminal diese Meldung ausgegeben werden: ```none `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](https://pypi.org/project/beautifulsoup4/) und [Requests](https://pypi.org/project/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: ```none `pip install beautifulsoup4 requests` ``` Löschen Sie `scraper.py` und importieren Sie dann die beiden Pakete mit folgenden Zeilen: ```none `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](https://github.com/luminati-io/luminati-proxy) 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: ![Auswahlhilfe für GitHub-Repository](https://media.brightdata.de/2023/08/GitHub-Repository-Selection-Guide.png)Speichern Sie die URL der Zielseite in einer Variablen: ```none `url = 'https://github.com/luminati-io/luminati-proxy'` ``` Laden Sie anschließend die Seite mit `requests.get() herunter:` ```none `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`: ```none `print(page.text)` ``` Führen Sie den Scraper aus, woraufhin Sie im Terminal folgendes sehen sollten: ```none 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: ```none `soup = BeautifulSoup(page.text, 'html.parser')` ``` Der `BeautifulSoup()`-Konstruktor benötigt zwei Argumente: 1. Die Zeichenkette, die den HTML-Inhalt beinhaltet: In diesem Fall in der Variable `page.text` gespeichert. 2. Der von Beautiful Soup zu verwendende Parser: „[`html.parser`](https://docs.python.org/3/library/html.parser.html)“ 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()`](https://www.crummy.com/software/BeautifulSoup/bs4/doc/#find): Gibt das erste HTML-Element zurück, das der als Parameter übergebenen Selektor-Strategie entspricht. - [`find_all()`](https://www.crummy.com/software/BeautifulSoup/bs4/doc/#find-all): Gibt die Liste der HTML-Elemente zurück, die der eingegebenen Selektor-Strategie entsprechen. - [`select_one()`](https://www.crummy.com/software/BeautifulSoup/bs4/doc/#css-selectors-through-the-css-property): Gibt das erste HTML-Element zurück, das dem als Parameter übergebenen CSS-Selektor entspricht. - [`select()`](https://www.crummy.com/software/BeautifulSoup/bs4/doc/#css-selectors-through-the-css-property): 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()`](https://www.crummy.com/software/BeautifulSoup/bs4/doc/#find-next-siblings-and-find-next-sibling): Gibt den ersten HTML-Knoten innerhalb der gegGeschwister des Elements zurück, der dem angegebenen CSS-Selektor entspricht. - [`find_next_siblings()`](https://www.crummy.com/software/BeautifulSoup/bs4/doc/#find-next-siblings-and-find-next-sibling): 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](https://github.com/luminati-io/luminati-proxy) 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](https://media.brightdata.de/2023/08/Inspecting-GitHub-Page-with-DevTools.png)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: ```none `repo = {}` ``` Überprüfen Sie zunächst das Element „name“: ![Initialisierung des Python-Wörterbuchs für die Extraktion von Repo-Daten](https://media.brightdata.de/2023/08/Initializing-Python-Dictionary-for-Repo-Data-Extraction.png)Beachten Sie, dass es ein eindeutiges `itemprop=”name”-` Attribut besitzt. Wählen Sie dieses aus und extrahieren Sie dessen Textinhalt mit: ```none `name_html_element = soup.select_one('[itemprop="name"]')name = name_html_element.text.strip()` ``` Verwenden Sie bei einem Beautiful-Soup-Knoten die [`get_text()-`](https://www.crummy.com/software/BeautifulSoup/bs4/doc/#get-text) Methode, um auf dessen Textinhalt zuzugreifen. Bei der Überprüfung von `name_html_element.text` im Debugger sehen Sie: ```none `nluminati-proxyn` ``` GitHub-Textfelder enthalten meist Leerzeichen und Zeilenumbrüche. Entfernen Sie diese mit der Python-Funktion [`strip().`](https://docs.python.org/3/library/stdtypes.html#str.strip) Unmittelbar unter dem Repo-Namen befindet sich der Verzweigungsselektor: ![Extrahieren des Repository-Namens mit Beautiful Soup](https://media.brightdata.de/2023/08/Extracting-Repository-Name-Using-Beautiful-Soup.png)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: ```none 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](https://media.brightdata.de/2023/08/Selecting-Main-Branch-Name-via-Sibling-Element-in-GitHub.png)Extrahieren Sie die letzte Commit-Zeit mit: ```none 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: ![](https://media.brightdata.de/2023/08/Extracting-Latest-Commit-Time-and-Commit-Count-from-GitHub-1.png)Diese wird mit dem zuvor beschriebenen Symbolmuster erfasst: ```none 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: ![](https://media.brightdata.de/2023/08/Extracting-Commit-Count-Using-Icon-Pattern-on-GitHub.png)Wählen Sie diese mit: ```none bordergrid_html_element = soup.select_one('.BorderGrid') ``` Inspizieren Sie das Beschreibungselement: ![Auswahl und Inspektion des Beschreibungselements auf GitHu](https://media.brightdata.de/2023/08/Selecting-and-Inspecting-the-Description-Element-on-GitHub.png)Auch hier können Sie es über ein gleichgeordnetes Element auswählen: ```none 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. ![](https://media.brightdata.de/2023/08/Extracting-Repository-Description-and-Applying-Icon-Pattern-for-Stats-on-GitHub.png)Achten Sie auf die Symbole und dann auf ihre zugehörigen Textelemente: ```none 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: ```none 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](https://media.brightdata.de/2023/08/Extracting-Star-Watcher-and-Fork-Counts-and-Accessing-README.md-on-GitHub.png)GitHub Daraus lässt sich ableiten, dass die URL der Readme-Datei eines GitHub-Repos dem nachstehenden Format folgt: ```none https://raw.githubusercontent.com///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:` ```none 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: ```none 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:` ```none 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: ```none {'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 managernn (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: ```none 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: ```none 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: ```none 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:` ```none { "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 managernn[![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](/products/web-scraper/github) 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](https://brightdata.de/proxy-types) von Bright Data und die [dedizierten GitHub-Proxys](https://brightdata.de/solutions/github-proxy). Bright Data betreibt die besten Proxys für Web-Scraping und betreut Fortune-500-Unternehmen sowie mehr als 20.000 Kunden. - [Datacenter-Proxys](https://brightdata.de/proxy-types/datacenter-proxies) – Über 770.000 Rechenzentrum-IPs. - Privatanwender-Proxys – Über 400M+ monthly Privatanwender-IPs in mehr als 195 Ländern.[](https://brightdata.de/proxy-types/residential-proxies) - IDA-Proxys – Über 700.000 IDA-IPs.[](https://brightdata.de/proxy-types/isp-proxies) 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. **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.** Vertrieb kontaktierenGratis testen![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Inhaltsverzeichnis Dedicated Scraper APIs & No-Code Scrapers Over 1000 scrapers for all popular domains. Simplify your web scraping. [See pricing](/pricing/web-scraper "See pricing") Just want data? Skip scraping. Hundreds of ready-to-use datasets from all popular domains. [See pricing](/pricing/datasets "See pricing") [ ](https://news.ycombinator.com/submitlink?t=Scrapen+von+GitHub-Repositorys+in+Python&u=https://brightdata.de/blog/wie/how-to-scrape-github-repositories-in-python) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Scrapen+von+GitHub-Repositorys+in+Python&url=https://brightdata.de/blog/wie/how-to-scrape-github-repositories-in-python) [ ](http://www.reddit.com/submit?title=Scrapen+von+GitHub-Repositorys+in+Python&url=https://brightdata.de/blog/wie/how-to-scrape-github-repositories-in-python) ## Das könnte Sie auch interessieren [ ![Best scraping proxies](https://media.brightdata.de/2023/07/Best-web-scraping-proxies.svg) ](https://brightdata.de/blog/proxys-101/best-scraping-proxies-guide "Beste Proxys für Web-Scraping: Top-Anbieter und Typen im Vergleich") [Proxy 101 ![Antonello Zanini](https://media.brightdata.de/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Beste Proxys für Web-Scraping: Top-Anbieter und Typen im Vergleich Was sind die besten Proxys für Scraping? Erfahren Sie mehr über die verschiedenen Proxy-Typen und welcher Proxy-Typ am besten für Ihre Web-Scraping-Anforderungen geeignet ist. 25-Jul-2023 10 min lesen ](https://brightdata.de/blog/proxys-101/best-scraping-proxies-guide) [ ![How to scrape ecommerce websites](https://media.brightdata.de/2023/07/blog-image-for-how-to-scrape-ecommerce-sites-1.svg) ](https://brightdata.de/blog/wie/ecommerce-web-scraping-guide "Anleitung zum Scrapen von E-Commerce-Webseiten") [How Tos ### Anleitung zum Scrapen von E-Commerce-Webseiten In dieser Schritt-für-Schritt-Anleitung erfahren Sie, wie Sie E-Commerce-Webseiten mit Playwright und dem Scraping-Browser von Bright Data scrapen können. 17-Jul-2023 10 min lesen ](https://brightdata.de/blog/wie/ecommerce-web-scraping-guide) [ ![OpenHuman with Bright Data](https://media.brightdata.de/2026/09/OpenHuman-with-Bright-Data.png) ](https://brightdata.de/blog/ai/openhuman-with-bright-data "Produktionsreifer Web-Zugriff in OpenHuman über die Bright Data CLI") [AI ![Antonello Zanini](https://media.brightdata.de/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Produktionsreifer Web-Zugriff in OpenHuman über die Bright Data CLI Integrieren Sie die Bright Data CLI mit OpenHuman, um produktionsreifen Web-Zugriff und Datenerhebung für KI-Agenten zu ermöglichen. 09-Sep-2026 12 min lesen ](https://brightdata.de/blog/ai/openhuman-with-bright-data)