Bilder mit Python herunterladensechs skalierbare Methoden

Bilder gehören zu den schwersten und nützlichsten Dateien im Web: Produktfotos für einen Katalog, Diagramme für einen Forschungsdatensatz, Assets für eine Machine-Learning-Pipeline. Wenn Sie mehr als eine Handvoll benötigen, ist "Bild speichern unter" keine Option mehr, und ein kurzes Python-Skript erledigt die Arbeit in Sekunden statt in einem Nachmittag.

Dieser Leitfaden führt Sie durch sechs praktische Möglichkeiten zum Herunterladen von Bildern mit Python, von einer einzelnen Datei mit requests über das Abrufen jedes Bildes von einer Seite mit BeautifulSoup, das Streaming großer Dateien in Chunks, das Organisieren der gespeicherten Dateien bis hin zum Erreichen geschützter Quellen über die Crawlbase Crawling API. Jeder Ausschnitt ist real und läuft so, wie er geschrieben ist, sodass Sie jeden kopieren und an Ihre eigenen Ziele anpassen können.

Was Sie erstellen werden

Am Ende werden Sie über ein kleines Toolkit von Funktionen verfügen, die die häufigen Fälle abdecken, plus ein kurzes Skript, das sie zusammenführt.

• Einzelner Download. Ein Bild per URL abrufen und mit requests auf die Festplatte schreiben.
• Standard-Library-Download. Dasselbe ohne Drittanbieter-Pakete mit urllib.request tun.
• Seiten-Scraping. Alle <img>-Tags auf einer Seite mit BeautifulSoup finden und jede Quelle herunterladen.
• Chunked Streaming. Große Dateien in Stücken speichern, damit der Speicherverbrauch gleichmäßig bleibt.
• Benennung und Ordner. Sichere Dateinamen ableiten und Downloads in Verzeichnisse sortieren.
• Geschützte Quellen. Bilder hinter Rendering oder Bot-Schutz über die Crawling API erreichen.

Warum ein einfacher Download auf manchen Seiten scheitert

Ein Bild herunterzuladen ist im einfachsten Fall ein HTTP GET. Das funktioniert perfekt für statische Dateien, die von einer vorhersehbaren URL bereitgestellt werden. Die Schwierigkeiten beginnen auf echten Seiten. Manche Seiten bauen ihr Bilder-Grid mit JavaScript auf, nachdem das anfängliche HTML geladen wurde, sodass ein einfacher Abruf Markup ohne Bild-Tags zurückgibt. Andere liegen hinter Anti-Bot-Schutzmechanismen, die Anfragen von Datacenter-IPs oder allem, das nicht wie ein echter Browser aussieht, herausfordern oder blockieren, und Sie erhalten eine 403 oder eine HTML-Fehlerseite, wo Sie ein JPEG erwartet haben.

Für unkomplizierte Dateien sind die ersten fünf Methoden unten alles, was Sie brauchen. Für die schwierigen Fälle leitet die letzte Methode die Anfrage durch eine Rendering-Schicht und einen Pool vertrauenswürdiger IPs, sodass die Datei intakt zurückkommt. Wir behandeln zuerst den einfachen Weg, da die meisten Downloads nie mehr als das benötigen.

Voraussetzungen

Sie brauchen nicht viel, um mitzumachen.

Python 3.8 oder höher. Überprüfen Sie Ihre Version mit python --version. Wenn Sie es nicht haben, installieren Sie es von python.org.

Grundlegendes Python. Sie sollten in der Lage sein, ein Skript auszuführen und Pakete mit pip zu installieren. Funktionen, Schleifen und die with-Anweisung sind ausreichend.

Ein Crawlbase-Konto (nur für die letzte Methode). Die ersten fünf Methoden verwenden nur requests, urllib und BeautifulSoup. Für die Methode mit geschützten Quellen benötigen Sie ein kostenloses Crawlbase-Konto und seinen API-Token.

Projekt einrichten

Erstellen Sie eine virtuelle Umgebung, damit die Projektabhängigkeiten isoliert bleiben, und installieren Sie dann die zwei Drittanbieter-Bibliotheken, die in diesem Leitfaden verwendet werden.

python --version

python -m venv image_env
source image_env/bin/activate

pip install requests beautifulsoup4

Aktivieren Sie unter Windows die Umgebung mit image_env\Scripts\activate anstelle der source-Zeile. requests ist der HTTP-Client, der jede Datei abruft, und beautifulsoup4 parst Seiten-HTML, sodass Sie Bild-Tags finden können. urllib, os und hashlib sind Teil der Standardbibliothek und müssen nicht installiert werden.

Tipp 1: Ein einzelnes Bild mit requests herunterladen

Der häufigste Fall ist ein Bild an einer gegebenen URL. Senden Sie ein GET, bestätigen Sie, dass die Antwort als Bild zurückgekommen ist, und schreiben Sie die Bytes in eine Datei im Binärmodus. Die Überprüfung des Statuscodes und des Content-Type vor dem Schreiben schützt davor, eine HTML-Fehlerseite unter einem .jpg-Namen zu speichern.

import requests

url = "https://www.python.org/static/img/python-logo.png"
headers = {"User-Agent": "Mozilla/5.0 (image downloader)"}

response = requests.get(url, headers=headers, timeout=10)
if response.status_code == 200 and "image" in response.headers.get("Content-Type", ""):
    with open("python-logo.png", "wb") as f:
        f.write(response.content)
    print("Saved python-logo.png")
else:
    print(f"Skipped: {response.status_code} {response.headers.get('Content-Type')}")

Drei Details sind hier wichtig. Die Datei wird mit "wb" (write binary) geöffnet, weil Bilddaten Bytes sind, kein Text, und das Schreiben als Text würde die Datei beschädigen. Die Content-Type-Prüfung bestätigt, dass der Server tatsächlich ein Bild zurückgegeben hat und keine Fehlerseite, die zufällig einen 200-Status trägt. Das timeout verhindert, dass das Skript bei einem blockierten Server ewig hängt. Führen Sie dies aus und Sie sollten Saved python-logo.png mit einem echten PNG neben Ihrem Skript sehen. Das ist ein funktionierender Download.

Tipp 2: Mit urllib aus der Standardbibliothek herunterladen

Wenn Sie lieber keine Abhängigkeit hinzufügen möchten, kann die Standardbibliothek dieselbe Aufgabe erledigen. urllib.request wird mit Python mitgeliefert, sodass dieser Ansatz überhaupt nichts installiert werden muss. Das Setzen eines User-Agent über ein Request-Objekt hilft bei Servern, die den Standard-urllib-Agent ablehnen.

import urllib.request

url = "https://www.python.org/static/img/python-logo.png"
req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0 (image downloader)"})

with urllib.request.urlopen(req, timeout=10) as resp, open("logo_urllib.png", "wb") as f:
    f.write(resp.read())

print("Saved logo_urllib.png")

Die with-Anweisung öffnet sowohl die Verbindung als auch die Ausgabedatei zusammen und schließt sie sauber, wenn der Block endet, auch wenn ein Fehler während des Schreibens auftritt. Es gibt auch eine einzeilige Abkürzung, urllib.request.urlretrieve(url, "logo.png"), die für schnelle Skripte praktisch ist, Ihnen jedoch keine Kontrolle über Header oder Fehlerbehandlung gibt, sodass die obige explizite Form die sicherere Standardmethode ist. Sowohl requests als auch urllib bringen dieselben Bytes auf die Festplatte; requests hat einfach eine benutzerfreundlichere API, weshalb der Rest dieses Leitfadens hauptsächlich es verwendet.

Tipp 3: Alle Bilder einer Seite mit BeautifulSoup herunterladen

Eine Datei herunterzuladen ist einfach. Die eigentliche Arbeit besteht darin, alle Bilder einer Seite automatisch abzurufen. Das Muster besteht aus zwei Schritten: das Seiten-HTML abrufen, es dann mit BeautifulSoup parsen, um das src jedes <img>-Tags zu sammeln, und schließlich über diese URLs schleifen und die Einzelbild-Logik aus Tipp 1 wiederverwenden.

import requests
from bs4 import BeautifulSoup
from urllib.parse import urljoin

page_url = "https://en.wikipedia.org/wiki/Python_(programming_language)"
headers = {"User-Agent": "Mozilla/5.0 (image downloader)"}

page = requests.get(page_url, headers=headers, timeout=10)
soup = BeautifulSoup(page.text, "html.parser")

image_urls = []
for img in soup.select("img"):
    src = img.get("src")
    if src:
        image_urls.append(urljoin(page_url, src))

print(f"Found {len(image_urls)} images")

Zwei Teile davon verdienen besondere Aufmerksamkeit. Der Selektor img greift jedes Bild-Tag auf der Seite ab, und das Lesen von img.get("src") anstelle von img["src"] gibt für ein Tag ohne das Attribut None zurück, anstatt einen Fehler auszulösen. Das andere Schlüsselelement ist urljoin: Bildquellen sind oft relative Pfade wie /images/photo.jpg, und das Verbinden jedes Pfads mit der Seiten-URL macht daraus eine vollständige, herunterladbare Adresse. Für einen tieferen Einblick in die Auswahl von Elementen auf diese Weise lesen Sie wie man BeautifulSoup in Python verwendet.

Mit der Liste absoluter URLs in der Hand verwendet die Download-Schleife das Binärschreib-Muster aus Tipp 1 und gibt jeder Datei einen eigenen Namen.

import os

os.makedirs("downloads", exist_ok=True)

for i, img_url in enumerate(image_urls):
    try:
        r = requests.get(img_url, headers=headers, timeout=10)
        if r.status_code == 200 and "image" in r.headers.get("Content-Type", ""):
            path = os.path.join("downloads", f"image_{i}.jpg")
            with open(path, "wb") as f:
                f.write(r.content)
    except requests.RequestException as e:
        print(f"Failed {img_url}: {e}")

Das try/except um jede Anfrage ist nicht optional, sobald Sie viele Dateien herunterladen. Von Dutzenden von Bildern wird eines irgendwann ein Timeout haben, eine Umleitungsschleife zurückgeben oder verschwinden, und das Abfangen von requests.RequestException lässt die Schleife das schlechte Bild überspringen und weitermachen, anstatt bei Bild dreißig abzustürzen. Der Aufruf os.makedirs(..., exist_ok=True) erstellt den Ausgabeordner einmalig und tut nichts, wenn er bereits vorhanden ist.

Tipp 4: Große Dateien in Chunks streamen

Das Lesen von response.content lädt die gesamte Datei in den Speicher, bevor sie geschrieben wird. Das ist für ein Logo in Ordnung, aber verschwenderisch für ein hochauflösendes Foto oder ein mehrmegabyte-großes Asset, und es kann den Speicher erschöpfen, wenn Sie viele große Dateien hintereinander herunterladen. Das Streamen der Antwort und das Schreiben in festen Stückgrößen hält den Speicherverbrauch unabhängig von der Dateigröße konstant.

def download_stream(url, path, chunk_size=8192):
    with requests.get(url, headers=headers, stream=True, timeout=30) as r:
        r.raise_for_status()
        with open(path, "wb") as f:
            for chunk in r.iter_content(chunk_size=chunk_size):
                f.write(chunk)
    return path

download_stream(
    "https://upload.wikimedia.org/wikipedia/commons/c/c3/Python-logo-notext.svg",
    "downloads/large_logo.svg",
)

Das Übergeben von stream=True teilt requests mit, den Body nicht im Voraus herunterzuladen; stattdessen zieht iter_content ihn in Stücken von chunk_size Bytes und schreibt jedes Stück direkt auf die Festplatte. Der Spitzenspeicher bleibt in der Größe eines Chunks, hier acht Kilobyte, unabhängig von der Dateigröße. raise_for_status() wandelt eine 4xx- oder 5xx-Antwort in eine Ausnahme um, damit Sie keinen Fehlerbody stillschweigend speichern, und das äußere with bei der Anfrage stellt sicher, dass die Verbindung freigegeben wird, sobald die Datei geschrieben wurde.

Tipp 5: Dateien benennen und organisieren

Alles als image_0.jpg, image_1.jpg zu speichern funktioniert, wirft aber die ursprünglichen Dateinamen weg und verliert die Dateierweiterung, was wichtig ist, wenn Sie PNGs, JPEGs und SVGs mischen. Ein kleines Hilfsprogramm leitet einen sauberen Namen aus der URL ab und greift auf einen Content-Hash zurück, wenn die URL keinen nutzbaren Namen hat, was Eindeutigkeit garantiert und verhindert, dass zwei Dateien, die denselben Namen teilen, überschrieben werden.

import os
import hashlib
from urllib.parse import urlparse

def filename_for(url, content, folder="downloads"):
    name = os.path.basename(urlparse(url).path)
    if not name or "." not in name:
        digest = hashlib.md5(content).hexdigest()[:12]
        name = f"{digest}.jpg"
    return os.path.join(folder, name)

# Example: turn a messy URL into a tidy path
r = requests.get(image_urls[0], headers=headers, timeout=10)
print(filename_for(image_urls[0], r.content))

urlparse(...).path entfernt Query-Strings und Fragmente von der URL, und os.path.basename nimmt nur das letzte Segment, sodass aus .../photo.jpg?size=large photo.jpg wird. Wenn die URL keinen richtigen Dateinamen hat, gibt der MD5-Hash der Dateibytes einen kurzen, stabilen, kollisionsresistenten Namen. Derselbe Hash ist auch der einfachste Weg, Duplikate zu erkennen: Zwei identische Bilder erzeugen denselben Digest, sodass Sie eine Datei überspringen können, die Sie bereits gespeichert haben, bevor Sie sie schreiben.

Tipp 6: Von geschützten Quellen mit der Crawling API herunterladen

Die fünf obigen Methoden decken jedes Bild ab, das Sie mit einer einfachen Anfrage erreichen können. Manche Seiten sind nicht so kooperativ. Die Seite kann ihr Bilder-Grid mit JavaScript rendern, sodass ein Abruf keine <img>-Tags zurückgibt, oder der Bild-Host kann Datacenter-IPs blockieren und statt der Datei eine 403 liefern. Sie können beides selbst lösen, indem Sie einen Headless-Browser betreiben und einen Pool rotierender Residential-Proxys pflegen, aber das Aufbauen und Gesundhalten dessen ist der größte Teil des Engineering-Aufwands und hat nichts mit den gewünschten Bildern zu tun.

Die Crawling API kombiniert Rendering und IP-Rotation in einer einzigen Anfrage. Sie installieren den offiziellen Client und leiten dann den Seitenabruf darüber; das zurückgegebene HTML ist vollständig gerendert, sodass das BeautifulSoup-Parsen aus Tipp 3 unverändert funktioniert.

pip install crawlbase

from crawlbase import CrawlingAPI
from bs4 import BeautifulSoup
from urllib.parse import urljoin

api = CrawlingAPI({"token": "YOUR_CRAWLBASE_JS_TOKEN"})
page_url = "https://example.com/gallery"

result = api.get(page_url, {"ajax_wait": "true", "page_wait": 5000})
html = result["body"].decode("utf-8") if result["status_code"] == 200 else None

# Same parsing as Tip 3, now against rendered HTML
soup = BeautifulSoup(html, "html.parser")
image_urls = [urljoin(page_url, img["src"]) for img in soup.select("img[src]")]
print(f"Found {len(image_urls)} images on the rendered page")

Die zwei Wartoptionen sind bei einer clientseitig gerenderten Galerie wichtig. ajax_wait teilt der API mit, auf das Laden asynchroner Inhalte zu warten, und page_wait hält für eine feste Anzahl von Millisekunden nach dem Laden an, damit spät erscheinende Bilder vor der Erfassung erscheinen. Verwenden Sie den JavaScript-Token für Seiten, die ihr Grid im Browser aufbauen; für statische Bild-Hosts ist der normale Token schneller. Sobald image_urls befüllt ist, speisen Sie es direkt in den Chunk-basierten download_stream-Helper aus Tipp 4 ein. Wenn Sie nur die IP-Rotation und nicht das Rendering benötigen, zum Beispiel wenn das Seiten-HTML in Ordnung ist, aber der Bild-Host Sie blockiert, leitet der Smart AI Proxy normalen requests-Traffic durch denselben vertrauenswürdigen Pool mit einer einzeiligen Änderung Ihrer Proxy-Einstellungen.

Wie die Ausgabe aussieht

Nach einem Seiten-Scraping ist ein kleines Manifest darüber, was Sie gespeichert haben, nützlich für Audits und zum Überspringen von Duplikaten beim nächsten Lauf. Das Schreiben eines Datensatzes pro Datei gibt Ihnen ein strukturiertes Protokoll neben den Bildern selbst.

[
  {
    "source_url": "https://example.com/img/photo-01.jpg",
    "saved_as": "downloads/photo-01.jpg",
    "content_type": "image/jpeg",
    "bytes": 184213
  },
  {
    "source_url": "https://example.com/img/diagram.svg",
    "saved_as": "downloads/diagram.svg",
    "content_type": "image/svg+xml",
    "bytes": 9042
  }
]

Jeder Datensatz verknüpft die ursprüngliche URL mit der lokalen Datei, vermerkt den Content-Type, damit Sie das echte Format kennen, und erfasst die Bytegröße. Das Beibehalten der source_url bedeutet, dass ein späterer Lauf überprüfen kann, was Sie bereits haben, bevor er es erneut herunterlädt.

Skalierung auf viele Bilder

Für ein paar Dutzend Dateien ist die sequentielle Schleife in Tipp 3 in Ordnung. Wenn Sie Tausende abrufen, ist das einzelne sequentielle Herunterladen der Engpass, da die meiste Zeit auf das Netzwerk gewartet wird, nicht auf Ihre CPU. Ein Thread-Pool lässt mehrere Downloads gleichzeitig laufen und ist dabei weitaus einfacher als vollständiger asynchroner Code.

from concurrent.futures import ThreadPoolExecutor

def save_one(url):
    try:
        r = requests.get(url, headers=headers, timeout=15)
        if r.status_code == 200 and "image" in r.headers.get("Content-Type", ""):
            path = filename_for(url, r.content)
            with open(path, "wb") as f:
                f.write(r.content)
            return path
    except requests.RequestException:
        return None

with ThreadPoolExecutor(max_workers=8) as pool:
    saved = list(pool.map(save_one, image_urls))

print(f"Saved {len([p for p in saved if p])} of {len(image_urls)} images")

Acht Worker sind ein vernünftiger Ausgangspunkt; zu hoch zu gehen riskiert, den Host zu überlasten, was sowohl unhöflich als auch ein schneller Weg ist, eine Ratenbeschränkung zu erhalten. Jeder save_one-Aufruf ist in sich geschlossen und schluckt seine eigenen Fehler, sodass ein Fehlschlag nie den ganzen Batch versenkt. Wenn Sie bei diesem Volumen von einer geschützten Quelle herunterladen, leiten Sie save_one über die Crawling API oder den Smart AI Proxy, damit die rotierenden IPs die Last absorbieren, anstatt Ihrer einzelnen Adresse. Für mehr darüber, wie man große Läufe am Leben erhält, lesen Sie wie man Websites ohne Blockierung scrapt.

Bilder verantwortungsvoll herunterladen

Bilder sind keine frei schwebenden Daten; sie sind kreative Werke, und fast jedes Bild, das Sie online finden, ist urheberrechtlich geschützt durch denjenigen, der es erstellt hat. In der Lage zu sein, eine Datei herunterzuladen, ist nicht dasselbe wie erlaubt zu sein, sie zu verwenden. Bevor Sie ein Skript auf eine Seite richten, lesen Sie deren Nutzungsbedingungen und überprüfen Sie die robots.txt, halten Sie Ihr Anfragevolumen so niedrig, dass Sie den Server nicht belasten, und laden Sie nur das herunter, wozu Sie tatsächlich das Recht haben. Fotos hinter einem Login, persönliche Bilder und nicht lizenzierte Stockbilder sind tabu.

Dieselbe Sorgfalt gilt für das, was Sie danach tun. Verbreiten Sie die Bilder anderer nicht als Ihre eigenen, und speisen Sie kein urheberrechtlich geschütztes Material ohne Erlaubnis des Rechteinhabers in ein Modell oder einen Datensatz ein. Wenn eine Seite eine offizielle API oder einen Lizenzierungsweg für ihre Medien anbietet, nutzen Sie diese: Es ist der sauberste Weg, Bilder zu erhalten, auf die Sie sich rechtlich verlassen können, und in der Regel kommt es mit Bedingungen, die genau festlegen, was Sie damit tun dürfen.

Häufig gestellte Fragen

Was ist der einfachste Weg, ein Bild in Python herunterzuladen?

Senden Sie ein GET mit requests und schreiben Sie dann response.content in eine im Binärmodus geöffnete Datei ("wb"). Das sind drei Zeilen für eine einzelne Datei. Überprüfen Sie zuerst den Statuscode und den Content-Type-Header, damit Sie nur echte Bilddaten speichern und keine HTML-Fehlerseite, die zufällig einen 200-Status zurückgegeben hat.

Soll ich requests oder urllib verwenden?

Beide laden dieselben Bytes herunter. requests hat eine sauberere API, einfachere Header-Handhabung und eingebautes Streaming, weshalb die meisten Codes es verwenden. Greifen Sie auf urllib.request zurück, wenn Sie keine Drittanbieter-Abhängigkeiten möchten, da es mit Python mitgeliefert wird. Die Download-Logik ist ansonsten identisch.

Wie lade ich alle Bilder von einer Webseite herunter?

Das Seiten-HTML abrufen, es mit BeautifulSoup parsen und das src jedes <img>-Tags sammeln. Relative Pfade mit urljoin zu absoluten URLs auflösen und dann über die Liste schleifen und jede Datei mit dem Einzelbild-Muster herunterladen. Jede Anfrage in try/except einwickeln, damit eine schlechte URL nicht den ganzen Batch stoppt, wie in Tipp 3 gezeigt.

Warum öffnet meine heruntergeladene Datei als beschädigtes Bild?

Normalerweise einer von zwei Gründen. Entweder wurde die Datei im Textmodus statt im Binärmodus geöffnet, was die Bytes beschädigt, also stellen Sie sicher, dass Sie "wb" verwenden. Oder der Server hat eine HTML-Fehlerseite anstelle des Bildes zurückgegeben, weshalb das Überprüfen des Statuscodes und des Content-Type vor dem Schreiben wichtig ist. Auf JavaScript-schweren Seiten existiert das Bild möglicherweise gar nicht im anfänglichen HTML, in diesem Fall benötigen Sie einen Rendering-Schritt.

Wie lade ich Bilder herunter, ohne blockiert zu werden?

Senden Sie einen realistischen User-Agent, paced Ihre Anfragen mit einer kurzen Verzögerung und vermeiden Sie es, einen Host mit vielen gleichzeitigen Threads zu überlasten. Bei höherem Volumen benötigen Sie auch IPs, die als echte Besucher erkannt werden, was ein einzelner Rechner nicht bieten kann. Das Routing durch rotierende Residential-IPs, über die Crawling API oder den Smart AI Proxy, hält große Bild-Läufe davon ab, Ratenbeschränkungen auszulösen.

Wie kann ich verhindern, dasselbe Bild zweimal herunterzuladen?

Berechnen Sie einen Hash der Bytes jeder Datei mit hashlib und halten Sie die bereits gesehenen Digests in einer Menge. Bevor Sie eine neue Datei schreiben, überprüfen Sie, ob ihr Hash bereits in der Menge ist; wenn ja, überspringen Sie sie. Derselbe Digest liefert auch einen zuverlässigen, kollisionsresistenten Dateinamen, wenn die URL keinen nutzbaren Namen hat.

BA

Bilal Ahmed

Softwareentwickler · Crawlbase

Softwareentwickler, der einige der meistgelesenen Beiträge im Crawlbase-Blog verfasst hat, über Web Scraping, Proxys und Daten-Tooling.