Python Grundkurs 004: Dateien automatisch nach Dateityp sortieren

Worum geht es in diesem Teil?

In diesem vierten Teil des Python-Grundkurses sortieren wir Dateien automatisch nach ihrer Dateiendung in passende Unterordner.

Aus Dateien wie:

urlaub.jpg
intro.mp4
rechnung.pdf
umsatz.xlsx
projekt.zip

entsteht zum Beispiel diese übersichtliche Ordnerstruktur:

01_Bilder
02_Videos
03_Dokumente
04_Tabellen
05_Archive

Vorher

Python: NachherDie Dateiendungen und Zielordner werden in einem Python-Dictionary festgelegt. Dadurch kann die Sortierung später leicht erweitert oder angepasst werden.

Es gibt wieder zwei Varianten:

01_Einfach
02_SendTo_Dateien_nach_Typ_sortieren

Die einfache Variante wird direkt in den Ordner kopiert, dessen Dateien sortiert werden sollen.

Die zweite Variante ist eine SendTo-Version. Damit können ein oder mehrere Ordner im Windows-Explorer markiert und über Senden an an das Python-Skript übergeben werden.

Was ist das Ziel?

Das Ziel ist ein verständliches Python-Skript, das bekannte Dateitypen erkennt und die Dateien in vorbereitete Kategorien einsortiert.

Dabei gelten wichtige Sicherheitsregeln:

Zuerst wird nur getestet.
Im Testmodus werden keine Dateien verschoben.
Im Testmodus werden keine Ordner erstellt.
Vorhandene Zieldateien werden nicht überschrieben.
Unbekannte Dateitypen bleiben liegen.
Dateien werden nicht automatisch umbenannt.
Vor dem echten Sortieren muss JA eingegeben werden.

Bei der Sicherheitsabfrage spielt die Groß- und Kleinschreibung keine Rolle. Damit werden zum Beispiel JA, Ja und ja akzeptiert.

Im Echtmodus werden immer alle fünf Kategorieordner erstellt. Das gilt auch dann, wenn für eine Kategorie momentan keine passende Datei vorhanden ist.

Das Skript kann die Meldungen außerdem wahlweise nur im Fenster anzeigen, als Logdatei speichern, in die Zwischenablage kopieren oder beide zusätzlichen Ausgaben verwenden.

Warum ist dieser Teil wichtig?

In diesem Teil lernen wir mehrere zentrale Python-Grundlagen kennen:

Module importieren
Startargumente mit sys.argv auslesen
Variablen und Listen
Python-Dictionaries
for-Schleifen
if-Abfragen
Dateiendungen mit suffix auswerten
Pfade mit pathlib zusammensetzen
Dateien und Ordner prüfen
Ordner mit mkdir() erstellen
Dateien mit shutil.move() verschieben
Fehler mit try und except behandeln
Protokolle als Textdatei speichern
Text in die Windows-Zwischenablage kopieren

Besonders wichtig ist der Unterschied zwischen einem normalen Programmlauf und einem Testlauf. Das Skript zeigt im Testmodus möglichst genau, was bei der echten Ausführung passieren würde, verändert den Ordner aber nicht.

Hinweis zur Kursreihe

Diese Python-Reihe ist Teil einer größeren Windows-Automatisierungsreihe.

Viele Aufgaben werden in mehreren Sprachen umgesetzt:

Batch
PowerShell 7
Python

Dadurch kann man gut vergleichen, wie dieselbe Aufgabe in unterschiedlichen Sprachen gelöst wird.

Der Python-Code ist bewusst ausführlich aufgebaut. Funktionen oder Klassen wären möglich, würden diesen Grundkurs aber unnötig komplizierter machen. Deshalb verwenden wir gut sichtbare Variablen, Schleifen, Abfragen, Zähler und Meldungen.

Downloads zu diesem Teil

Für diesen Teil gibt es zwei Python-Skripte und die dazugehörigen Starter-Batchdateien.

C:\TOPTORIALS_CODE\020_Python_Grundkurs

C:\TOPTORIALS_CODE\020_Python_Grundkurs\004_Dateien_nach_Typ_sortieren

01_Einfach
02_SendTo_Dateien_nach_Typ_sortieren

Testumgebung zum Mitmachen

Für diese Tutorialreihe gibt es zusätzlich eine vorbereitete Testumgebung.

Die Testumgebung enthält vorbereitete Ordner und Beispieldateien, mit denen die Skripte gefahrlos ausprobiert werden können.

C:\TOPTORIALS_CODE\1000_TESTBEREICH

TOPTORIALS_Testdaten_Windows_Automatisierung_Python_V001

Ein möglicher Testpfad wäre dann:

C:\TOPTORIALS_CODE\1000_TESTBEREICH\TOPTORIALS_Testdaten_Windows_Automatisierung_Python_V001\004_Dateien_nach_Typ_sortieren

Sicherheitshinweis

Enthaltene Dateien

Zu diesem Teil gehören zwei Varianten.

Variante 1: Einfach

01_Einfach
├── 004_dateien_nach_typ_sortieren.py
└── 004_dateien_nach_typ_sortieren_starter_batch_test.bat

Variante 2: SendTo-Dateien nach Typ sortieren

02_SendTo_Dateien_nach_Typ_sortieren
├── 004_sendto_dateien_nach_typ_sortieren.py
└── 004_sendto_dateien_nach_typ_sortieren_starter_batch_test.bat

Variante 1: Dateien im aktuellen Ordner sortieren

Die einfache Variante wird direkt in den Ordner kopiert, dessen Dateien sortiert werden sollen.

Danach wird diese Datei per Doppelklick gestartet:

004_dateien_nach_typ_sortieren_starter_batch_test.bat

Solange _test im Dateinamen steht, läuft nur die Vorschau. Das Skript meldet dann zum Beispiel:

WÜRDE VERSCHIEBEN: "urlaub.jpg" nach "C:\Test\01_Bilder\urlaub.jpg"
ÜBERSPRUNGEN: "projekt.xyz" - unbekannter Dateityp (.xyz)

Wenn alles richtig aussieht, wird ausschließlich _test aus dem Namen der Starter-Batchdatei entfernt:

004_dateien_nach_typ_sortieren_starter_batch.bat

Die Python-Datei selbst wird nicht umbenannt.

Der komplette Code der einfachen Python-Datei

Die Datei heißt:

004_dateien_nach_typ_sortieren.py

# ============================================================
# TOPTORIALS OFFICE - Python Grundkurs
# Script: 004_dateien_nach_typ_sortieren.py
# Beschreibung: Sortiert Dateien nach Dateityp in Unterordner.
# Autor: Chris
# YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
# Webseite: https://www.toptorials.com
# Version: 1.0
# Stand: 2026-08-05
# ============================================================

from datetime import datetime
from pathlib import Path
import shutil
import subprocess
import sys


print()
print("Dateien werden nach Typ sortiert...")
print()

basis_ordner = Path.cwd()
testmodus = "--test" in sys.argv


# ------------------------------------------------------------
# Welche zusätzliche Ausgabe soll erstellt werden?
# Wichtig: Immer nur EINE der folgenden Varianten aktiv lassen.
# ------------------------------------------------------------

# Variante 1: Nur Bildschirmausgabe
logdatei_erstellen = False
zwischenablage_verwenden = False

# Variante 2: Logdatei erstellen
# logdatei_erstellen = True
# zwischenablage_verwenden = False

# Variante 3: Nur in die Zwischenablage kopieren
# logdatei_erstellen = False
# zwischenablage_verwenden = True

# Variante 4: Logdatei erstellen und in die Zwischenablage kopieren
# logdatei_erstellen = True
# zwischenablage_verwenden = True


# ------------------------------------------------------------
# Dateitypen und Zielordner festlegen
# ------------------------------------------------------------

kategorien = {
    "01_Bilder": [".jpg", ".jpeg", ".png", ".gif", ".webp"],
    "02_Videos": [".mp4", ".mov", ".mkv", ".avi"],
    "03_Dokumente": [".pdf", ".docx", ".txt"],
    "04_Tabellen": [".xlsx", ".xls", ".csv"],
    "05_Archive": [".zip", ".rar", ".7z"],
}

bekannte_erweiterungen = []

for erweiterungen in kategorien.values():
    bekannte_erweiterungen.extend(erweiterungen)

anzahl_verschoben = 0
anzahl_uebersprungen = 0
anzahl_fehler = 0
protokoll = []

if testmodus:
    modus_text = "TESTMODUS"
else:
    modus_text = "ECHTMODUS"

protokoll.append("Dateien werden nach Typ sortiert.")
protokoll.append(f"Modus: {modus_text}")
protokoll.append(f"Verarbeiteter Ordner: {basis_ordner}")
protokoll.append("")

print(f"Modus: {modus_text}")
print(f"Verarbeiteter Ordner: {basis_ordner}")
print()


# ------------------------------------------------------------
# Sicherheitsabfrage bei der echten Ausführung
# ------------------------------------------------------------

if not testmodus:
    print("ACHTUNG: Dieses Skript wird Dateien wirklich verschieben.")
    print()

    antwort = input("Zum Fortfahren JA eingeben: ")

    if antwort.upper() != "JA":
        print()
        print("Abgebrochen.")
        print()
        input("Drücke Enter zum Beenden")
        sys.exit()


# ------------------------------------------------------------
# Dateien erfassen
# Es werden nur Dateien direkt im Basisordner verarbeitet.
# Unterordner werden nicht durchsucht.
# ------------------------------------------------------------

dateien = []

for pfad in basis_ordner.iterdir():
    if pfad.is_file():
        dateien.append(pfad)


# ------------------------------------------------------------
# Bekannte Dateitypen sortieren
# ------------------------------------------------------------

for kategorie, erweiterungen in kategorien.items():
    ziel_ordner = basis_ordner / kategorie
    passende_dateien = []

    for datei in dateien:
        if datei.suffix.lower() in erweiterungen:
            passende_dateien.append(datei)

    # Im Echtmodus werden alle Kategorieordner erstellt.
    # Das gilt auch dann, wenn momentan keine passende Datei vorhanden ist.
    if not testmodus:
        try:
            ziel_ordner.mkdir(parents=True, exist_ok=True)
        except OSError as fehler:
            if passende_dateien:
                for datei in passende_dateien:
                    meldung = (
                        f'FEHLER: "{datei.name}" konnte nicht verschoben werden. '
                        f'Zielordner "{kategorie}" konnte nicht erstellt werden. '
                        f"Grund: {fehler}"
                    )
                    print(meldung)
                    protokoll.append(meldung)
                    anzahl_fehler += 1
            else:
                meldung = (
                    f'FEHLER: Zielordner "{kategorie}" konnte nicht erstellt werden. '
                    f"Grund: {fehler}"
                )
                print(meldung)
                protokoll.append(meldung)
                anzahl_fehler += 1

            continue

    for datei in passende_dateien:
        ziel_datei = ziel_ordner / datei.name

        if ziel_datei.exists():
            if testmodus:
                meldung = (
                    f'WÜRDE ÜBERSPRINGEN: "{datei.name}" - '
                    f'Zieldatei existiert bereits: "{ziel_datei}"'
                )
            else:
                meldung = (
                    f'ÜBERSPRUNGEN: "{datei.name}" - '
                    f'Zieldatei existiert bereits: "{ziel_datei}"'
                )

            print(meldung)
            protokoll.append(meldung)
            anzahl_uebersprungen += 1
            continue

        if testmodus:
            meldung = f'WÜRDE VERSCHIEBEN: "{datei.name}" nach "{ziel_datei}"'
            print(meldung)
            protokoll.append(meldung)
            anzahl_verschoben += 1
            continue

        try:
            shutil.move(str(datei), str(ziel_datei))
            meldung = f'VERSCHOBEN: "{datei.name}" nach "{ziel_datei}"'
            print(meldung)
            protokoll.append(meldung)
            anzahl_verschoben += 1
        except OSError as fehler:
            meldung = (
                f'FEHLER: "{datei.name}" konnte nicht verschoben werden. '
                f"Grund: {fehler}"
            )
            print(meldung)
            protokoll.append(meldung)
            anzahl_fehler += 1


# ------------------------------------------------------------
# Unbekannte Dateitypen überspringen
# Diese Dateien bleiben unverändert im Basisordner liegen.
# ------------------------------------------------------------

for datei in dateien:
    if datei.suffix.lower() not in bekannte_erweiterungen:
        if datei.suffix:
            endung_text = datei.suffix
        else:
            endung_text = "keine Dateiendung"

        meldung = (
            f'ÜBERSPRUNGEN: "{datei.name}" - '
            f"unbekannter Dateityp ({endung_text})"
        )
        print(meldung)
        protokoll.append(meldung)
        anzahl_uebersprungen += 1


# ------------------------------------------------------------
# Zusammenfassung
# ------------------------------------------------------------

protokoll.append("")
protokoll.append("Fertig.")

print()
print("Fertig.")
print()

if testmodus:
    meldung_1 = f"Anzahl Dateien, die verschoben würden: {anzahl_verschoben}"
    meldung_2 = f"Anzahl übersprungen: {anzahl_uebersprungen}"
    meldung_3 = f"Anzahl Fehler: {anzahl_fehler}"

    print(meldung_1)
    print(meldung_2)
    print(meldung_3)
    print()
    print("Es wurden keine Dateien verschoben und keine Ordner erstellt.")
    print("Wenn alles richtig aussieht, entferne _test aus dem Namen der Starter-Batchdatei.")

    protokoll.append(meldung_1)
    protokoll.append(meldung_2)
    protokoll.append(meldung_3)
    protokoll.append("Es wurden keine Dateien verschoben und keine Ordner erstellt.")
else:
    meldung_1 = f"Anzahl verschoben: {anzahl_verschoben}"
    meldung_2 = f"Anzahl übersprungen: {anzahl_uebersprungen}"
    meldung_3 = f"Anzahl Fehler: {anzahl_fehler}"

    print(meldung_1)
    print(meldung_2)
    print(meldung_3)

    protokoll.append(meldung_1)
    protokoll.append(meldung_2)
    protokoll.append(meldung_3)


# ------------------------------------------------------------
# Optionale Ausgabe als Logdatei und in die Zwischenablage
# ------------------------------------------------------------

protokoll_text = "\n".join(protokoll)
zeitstempel = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
logdatei = basis_ordner / f"sortierprotokoll_{zeitstempel}.log"

if logdatei_erstellen:
    try:
        logdatei.write_text(protokoll_text, encoding="utf-8")
        print()
        print("Das Protokoll wurde erstellt:")
        print(logdatei)
    except OSError as fehler:
        print()
        print(f"FEHLER: Das Protokoll konnte nicht erstellt werden. Grund: {fehler}")

if zwischenablage_verwenden:
    try:
        subprocess.run(
            "clip",
            input=protokoll_text,
            text=True,
            encoding="utf-8",
            check=True,
        )
        print()
        print("Das Protokoll wurde zusätzlich in die Zwischenablage kopiert.")
    except (OSError, subprocess.CalledProcessError) as fehler:
        print()
        print(f"FEHLER: Das Protokoll konnte nicht kopiert werden. Grund: {fehler}")

print()
input("Drücke Enter zum Beenden")

Code der einfachen Python-Datei erklärt

Benötigte Module importieren

from datetime import datetime
from pathlib import Path
import shutil
import subprocess
import sys

datetime liefert Datum und Uhrzeit für den Namen der optionalen Logdatei.

Path aus pathlib erleichtert die Arbeit mit Datei- und Ordnerpfaden.

shutil wird zum Verschieben der Dateien verwendet. subprocess startet das Windows-Programm clip für die Zwischenablage. sys liefert die Startargumente und kann das Skript mit sys.exit() beenden.

Arbeitsordner und Testmodus bestimmen

basis_ordner = Path.cwd()
testmodus = "--test" in sys.argv

Path.cwd() liefert den aktuellen Arbeitsordner. Die Starter-Batchdatei wechselt vorher mit cd /d "%~dp0" in ihren eigenen Ordner.

Mit "--test" in sys.argv wird geprüft, ob das Startargument --test vorhanden ist. Das Ergebnis ist entweder True oder False.

Zusätzliche Ausgaben auswählen

# Variante 1: Nur Bildschirmausgabe
logdatei_erstellen = False
zwischenablage_verwenden = False

Die beiden booleschen Variablen steuern die optionalen Ausgaben. Im Skript sind vier fertige Kombinationen vorbereitet:

Nur Bildschirmausgabe
Bildschirmausgabe und Logdatei
Bildschirmausgabe und Zwischenablage
Bildschirmausgabe, Logdatei und Zwischenablage

Immer nur eine der vier vorbereiteten Varianten sollte aktiv sein.

Kategorien in einem Dictionary speichern

kategorien = {
    "01_Bilder": [".jpg", ".jpeg", ".png", ".gif", ".webp"],
    "02_Videos": [".mp4", ".mov", ".mkv", ".avi"],
    "03_Dokumente": [".pdf", ".docx", ".txt"],
    "04_Tabellen": [".xlsx", ".xls", ".csv"],
    "05_Archive": [".zip", ".rar", ".7z"],
}

Ein Dictionary speichert zusammengehörige Schlüssel und Werte. Der Schlüssel ist hier der Name des Zielordners. Der Wert ist jeweils eine Liste mit den dazugehörigen Dateiendungen.

Seit Python 3.7 bleibt die Einfügereihenfolge von Dictionaries garantiert erhalten. Die Kategorien werden daher in der eingetragenen Reihenfolge verarbeitet.

Alle bekannten Erweiterungen sammeln

bekannte_erweiterungen = []

for erweiterungen in kategorien.values():
    bekannte_erweiterungen.extend(erweiterungen)

kategorien.values() liefert alle Listen mit Dateiendungen. extend() hängt die enthaltenen Werte einzeln an die Liste bekannte_erweiterungen an. Diese Gesamtliste wird später benötigt, um unbekannte Dateitypen zu erkennen.

Zähler und Protokoll vorbereiten

anzahl_verschoben = 0
anzahl_uebersprungen = 0
anzahl_fehler = 0
protokoll = []

Die drei Zähler erfassen verschobene beziehungsweise im Testmodus vorgesehene, übersprungene und fehlerhafte Dateien. protokoll beginnt als leere Liste und sammelt die Meldungen des Skripts.

Sicherheitsabfrage im Echtmodus

if not testmodus:
    antwort = input("Zum Fortfahren JA eingeben: ")

    if antwort.upper() != "JA":
        sys.exit()

Die Sicherheitsabfrage wird nur ausgeführt, wenn der Testmodus nicht aktiv ist. upper() wandelt die Eingabe in Großbuchstaben um. Deshalb werden ja, Ja, jA und JA akzeptiert.

Dateien im Basisordner erfassen

dateien = []

for pfad in basis_ordner.iterdir():
    if pfad.is_file():
        dateien.append(pfad)

iterdir() liefert die direkten Inhalte des Basisordners. is_file() prüft, ob das aktuelle Element eine Datei ist. Unterordner werden nicht durchsucht, weil kein rglob() verwendet wird.

Dictionary mit items() durchlaufen

for kategorie, erweiterungen in kategorien.items():

items() liefert bei jedem Schleifendurchlauf den Kategorienamen und die zugehörige Liste der Dateiendungen. Beide Werte werden direkt in kategorie und erweiterungen gespeichert.

Passende Dateien auswählen

passende_dateien = []

for datei in dateien:
    if datei.suffix.lower() in erweiterungen:
        passende_dateien.append(datei)

suffix liefert die Dateiendung einschließlich Punkt. lower() wandelt sie in Kleinbuchstaben um. Dadurch werden auch Endungen wie .JPG oder .Mp4 erkannt.

Der Operator in prüft, ob die Endung in der Liste der aktuellen Kategorie vorkommt.

Alle Kategorieordner im Echtmodus erstellen

if not testmodus:
    ziel_ordner.mkdir(parents=True, exist_ok=True)

mkdir() erstellt einen Ordner. parents=True erlaubt bei Bedarf auch das Erstellen fehlender übergeordneter Ordner. exist_ok=True verhindert einen Fehler, wenn der Zielordner bereits vorhanden ist.

Dieser Block wird für jede Kategorie ausgeführt. Deshalb entstehen im Echtmodus immer alle fünf Kategorieordner, auch wenn in einer Kategorie gerade keine passende Datei vorhanden ist. Im Testmodus wird mkdir() überhaupt nicht ausgeführt.

Zielpfad mit dem Schrägstrich-Operator bilden

ziel_datei = ziel_ordner / datei.name

Bei Path-Objekten verbindet der Operator / Pfadbestandteile. Aus dem Zielordner und dem Dateinamen entsteht der vollständige Zielpfad.

Vorhandene Zieldateien schützen

if ziel_datei.exists():
    anzahl_uebersprungen += 1
    continue

exists() prüft, ob die Zieldatei bereits vorhanden ist. In diesem Fall wird sie nicht überschrieben. continue beendet nur den aktuellen Schleifendurchlauf und macht mit der nächsten Datei weiter.

Testmodus und Echtmodus unterscheiden

if testmodus:
    meldung = f'WÜRDE VERSCHIEBEN: "{datei.name}" nach "{ziel_datei}"'
    anzahl_verschoben += 1
    continue

Im Testmodus wird lediglich eine Vorschau ausgegeben. shutil.move() wird durch continue nicht erreicht.

Dateien mit shutil.move() verschieben

shutil.move(str(datei), str(ziel_datei))

shutil.move() verschiebt die Quelldatei zum Zielpfad. str() wandelt die Path-Objekte in Textpfade um.

Fehler mit try und except behandeln

try:
    shutil.move(str(datei), str(ziel_datei))
except OSError as fehler:
    print(fehler)

Tritt beim Erstellen eines Ordners, Lesen eines Ordners, Verschieben oder Schreiben ein Betriebssystemfehler auf, wird er als OSError abgefangen. Das Skript kann anschließend kontrolliert fortfahren und den Fehler ausgeben.

Unbekannte Dateitypen erkennen

if datei.suffix.lower() not in bekannte_erweiterungen:

not in prüft, ob eine Dateiendung nicht in der Gesamtliste der bekannten Erweiterungen enthalten ist. Solche Dateien bleiben unverändert im Ausgangsordner und werden als übersprungen gezählt.

Protokolltext zusammensetzen

protokoll_text = "\n".join(protokoll)

join() verbindet alle Listeneinträge. \n fügt zwischen den Meldungen jeweils einen Zeilenumbruch ein.

Zeitstempel für die Logdatei erstellen

zeitstempel = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
logdatei = basis_ordner / f"sortierprotokoll_{zeitstempel}.log"

datetime.now() liefert Datum und Uhrzeit. strftime() formatiert den Wert zu einem Dateinamen wie sortierprotokoll_2026-08-05_14-30-25.log.

Logdatei mit write_text() schreiben

logdatei.write_text(protokoll_text, encoding="utf-8")

write_text() schreibt den gesamten Protokolltext in die Datei. encoding="utf-8" sorgt dafür, dass Umlaute und Sonderzeichen korrekt gespeichert werden.

Text mit clip in die Zwischenablage kopieren

subprocess.run(
    "clip",
    input=protokoll_text,
    text=True,
    encoding="utf-8",
    check=True,
)

subprocess.run() startet das Windows-Programm clip. Der Protokolltext wird über input an das Programm übergeben. check=True sorgt dafür, dass ein fehlgeschlagener Aufruf als Fehler behandelt werden kann.

Starter-Batchdatei der einfachen Variante

@echo off
REM ============================================================
REM TOPTORIALS OFFICE - Python Grundkurs
REM Script: 004_dateien_nach_typ_sortieren_starter_batch_test.bat
REM Beschreibung: Startet das Python-Skript im Testmodus.
REM Autor: Chris
REM YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
REM Webseite: https://www.toptorials.com
REM Version: 1.0
REM Stand: 2026-08-05
REM
REM Hinweis:
REM Solange _test im Dateinamen steht, wird --test uebergeben.
REM Fuer die echte Ausfuehrung _test aus dem Dateinamen entfernen.
REM ============================================================

chcp 65001 >nul
cd /d "%~dp0"

echo %~n0 | find /i "_test" >nul

if not errorlevel 1 (
    py "004_dateien_nach_typ_sortieren.py" --test
    REM Alternative, falls py nicht funktioniert:
    REM python "004_dateien_nach_typ_sortieren.py" --test
) else (
    py "004_dateien_nach_typ_sortieren.py"
    REM Alternative, falls py nicht funktioniert:
    REM python "004_dateien_nach_typ_sortieren.py"
)

Code der einfachen Starter-Batchdatei erklärt

Konsole vorbereiten und Arbeitsordner wechseln

@echo off
chcp 65001 >nul
cd /d "%~dp0"

@echo off blendet die ausgeführten Batchbefehle aus. chcp 65001 stellt die Konsole auf UTF-8 um. %~dp0 enthält Laufwerk und Ordner der gestarteten Batchdatei; cd /d wechselt dorthin.

Testmodus im Dateinamen erkennen

echo %~n0 | find /i "_test" >nul

%~n0 enthält den Namen der Batchdatei ohne Dateiendung. find /i sucht darin unabhängig von Groß- und Kleinschreibung nach _test.

Python mit oder ohne –test starten

if not errorlevel 1 (
    py "004_dateien_nach_typ_sortieren.py" --test
) else (
    py "004_dateien_nach_typ_sortieren.py"
)

Wurde _test gefunden, startet der Python Launcher py das Skript mit --test. Ohne _test fehlt dieses Argument und das Skript läuft im Echtmodus.

Variante 2: Mehrere Ordner über SendTo sortieren

Die SendTo-Variante bleibt dauerhaft gemeinsam mit ihrer Starter-Batchdatei in einem festen Ordner.

Im Windows-Explorer können anschließend ein oder mehrere Ordner markiert und über Senden an an das Skript übergeben werden. Jeder gültige Ordner wird einzeln verarbeitet.

Einzelne Dateien, ungültige Pfade und nicht erreichbare Ordner werden übersprungen. Im Echtmodus erscheint die Sicherheitsabfrage für jeden gültigen Ordner einzeln.

Der komplette Code der SendTo-Python-Datei

Die Datei heißt:

004_sendto_dateien_nach_typ_sortieren.py

# ============================================================
# TOPTORIALS OFFICE - Python Grundkurs
# Script: 004_sendto_dateien_nach_typ_sortieren.py
# Beschreibung: Sortiert Dateien übergebener Ordner nach Dateityp in Unterordner.
# Autor: Chris
# YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
# Webseite: https://www.toptorials.com
# Version: 1.0
# Stand: 2026-08-05
# ============================================================

from datetime import datetime
from pathlib import Path
import shutil
import subprocess
import sys


print()

argumente = sys.argv[1:]
testmodus = "--test" in argumente

if testmodus:
    argumente.remove("--test")


# ------------------------------------------------------------
# Prüfen, ob mindestens ein Element übergeben wurde
# ------------------------------------------------------------

if not argumente:
    print("Bitte sende mindestens einen Ordner an dieses Skript.")
    print()
    print("Du kannst einen Ordner im Explorer rechts anklicken")
    print("und anschließend 'Senden an' verwenden.")
    print()
    input("Drücke Enter zum Beenden")
    sys.exit()


# ------------------------------------------------------------
# Welche zusätzliche Ausgabe soll erstellt werden?
# Wichtig: Immer nur EINE der folgenden Varianten aktiv lassen.
# ------------------------------------------------------------

# Variante 1: Nur Bildschirmausgabe
logdatei_erstellen = False
zwischenablage_verwenden = False

# Variante 2: Logdatei erstellen
# logdatei_erstellen = True
# zwischenablage_verwenden = False

# Variante 3: Nur in die Zwischenablage kopieren
# logdatei_erstellen = False
# zwischenablage_verwenden = True

# Variante 4: Logdatei erstellen und in die Zwischenablage kopieren
# logdatei_erstellen = True
# zwischenablage_verwenden = True


# ------------------------------------------------------------
# Dateitypen und Zielordner festlegen
# ------------------------------------------------------------

kategorien = {
    "01_Bilder": [".jpg", ".jpeg", ".png", ".gif", ".webp"],
    "02_Videos": [".mp4", ".mov", ".mkv", ".avi"],
    "03_Dokumente": [".pdf", ".docx", ".txt"],
    "04_Tabellen": [".xlsx", ".xls", ".csv"],
    "05_Archive": [".zip", ".rar", ".7z"],
}

bekannte_erweiterungen = []

for erweiterungen in kategorien.values():
    bekannte_erweiterungen.extend(erweiterungen)

if testmodus:
    modus_text = "TESTMODUS"
else:
    modus_text = "ECHTMODUS"

gesamt_protokoll = []
gesamt_anzahl_verschoben = 0
gesamt_anzahl_uebersprungen = 0
gesamt_anzahl_fehler = 0

gesamt_protokoll.append("Dateien werden nach Typ sortiert.")
gesamt_protokoll.append(f"Modus: {modus_text}")
gesamt_protokoll.append("")


# ------------------------------------------------------------
# Alle übergebenen Elemente nacheinander verarbeiten
# ------------------------------------------------------------

for element_pfad in argumente:
    basis_ordner = Path(element_pfad)

    # Die SendTo-Variante verarbeitet ausschließlich Ordner.
    # Einzelne Dateien und nicht vorhandene Pfade werden übersprungen.
    if not basis_ordner.is_dir():
        meldung = "ÜBERSPRUNGEN: Der übergebene Pfad ist kein Ordner"

        print(meldung)
        print(element_pfad)
        print()

        gesamt_protokoll.append(meldung)
        gesamt_protokoll.append(f"Pfad: {element_pfad}")
        gesamt_protokoll.append("")
        gesamt_anzahl_uebersprungen += 1
        continue

    basis_ordner = basis_ordner.resolve()
    anzahl_verschoben = 0
    anzahl_uebersprungen = 0
    anzahl_fehler = 0
    protokoll = []

    protokoll.append("Dateien werden nach Typ sortiert.")
    protokoll.append(f"Modus: {modus_text}")
    protokoll.append(f"Verarbeiteter Ordner: {basis_ordner}")
    protokoll.append("")

    print(f"Modus: {modus_text}")
    print(f"Verarbeiteter Ordner: {basis_ordner}")
    print()


    # --------------------------------------------------------
    # Sicherheitsabfrage bei der echten Ausführung
    # --------------------------------------------------------

    if not testmodus:
        print("ACHTUNG: Dieses Skript wird Dateien in diesem Ordner wirklich verschieben.")
        print()

        antwort = input("Zum Fortfahren JA eingeben: ")

        if antwort.upper() != "JA":
            meldung = "ÜBERSPRUNGEN: Dieser Ordner wurde nicht bearbeitet."

            print()
            print(meldung)
            print()

            protokoll.append(meldung)
            gesamt_protokoll.extend(protokoll)
            gesamt_protokoll.append("")
            gesamt_protokoll.append("============================================================")
            gesamt_protokoll.append("")
            continue


    # --------------------------------------------------------
    # Dateien erfassen
    # Es werden nur Dateien direkt im Basisordner verarbeitet.
    # Unterordner werden nicht durchsucht.
    # --------------------------------------------------------

    dateien = []

    try:
        for pfad in basis_ordner.iterdir():
            if pfad.is_file():
                dateien.append(pfad)
    except OSError as fehler:
        meldung = f'FEHLER: Der Ordner konnte nicht gelesen werden. Grund: {fehler}'
        print(meldung)
        protokoll.append(meldung)
        anzahl_fehler += 1


    # --------------------------------------------------------
    # Bekannte Dateitypen sortieren
    # --------------------------------------------------------

    for kategorie, erweiterungen in kategorien.items():
        ziel_ordner = basis_ordner / kategorie
        passende_dateien = []

        for datei in dateien:
            if datei.suffix.lower() in erweiterungen:
                passende_dateien.append(datei)

        # Im Echtmodus werden alle Kategorieordner erstellt.
        # Das gilt auch dann, wenn momentan keine passende Datei vorhanden ist.
        if not testmodus:
            try:
                ziel_ordner.mkdir(parents=True, exist_ok=True)
            except OSError as fehler:
                if passende_dateien:
                    for datei in passende_dateien:
                        meldung = (
                            f'FEHLER: "{datei.name}" konnte nicht verschoben werden. '
                            f'Zielordner "{kategorie}" konnte nicht erstellt werden. '
                            f"Grund: {fehler}"
                        )
                        print(meldung)
                        protokoll.append(meldung)
                        anzahl_fehler += 1
                else:
                    meldung = (
                        f'FEHLER: Zielordner "{kategorie}" konnte nicht erstellt werden. '
                        f"Grund: {fehler}"
                    )
                    print(meldung)
                    protokoll.append(meldung)
                    anzahl_fehler += 1

                continue

        for datei in passende_dateien:
            ziel_datei = ziel_ordner / datei.name

            if ziel_datei.exists():
                if testmodus:
                    meldung = (
                        f'WÜRDE ÜBERSPRINGEN: "{datei.name}" - '
                        f'Zieldatei existiert bereits: "{ziel_datei}"'
                    )
                else:
                    meldung = (
                        f'ÜBERSPRUNGEN: "{datei.name}" - '
                        f'Zieldatei existiert bereits: "{ziel_datei}"'
                    )

                print(meldung)
                protokoll.append(meldung)
                anzahl_uebersprungen += 1
                continue

            if testmodus:
                meldung = f'WÜRDE VERSCHIEBEN: "{datei.name}" nach "{ziel_datei}"'
                print(meldung)
                protokoll.append(meldung)
                anzahl_verschoben += 1
                continue

            try:
                shutil.move(str(datei), str(ziel_datei))
                meldung = f'VERSCHOBEN: "{datei.name}" nach "{ziel_datei}"'
                print(meldung)
                protokoll.append(meldung)
                anzahl_verschoben += 1
            except OSError as fehler:
                meldung = (
                    f'FEHLER: "{datei.name}" konnte nicht verschoben werden. '
                    f"Grund: {fehler}"
                )
                print(meldung)
                protokoll.append(meldung)
                anzahl_fehler += 1


    # --------------------------------------------------------
    # Unbekannte Dateitypen überspringen
    # Diese Dateien bleiben unverändert im Basisordner liegen.
    # --------------------------------------------------------

    for datei in dateien:
        if datei.suffix.lower() not in bekannte_erweiterungen:
            if datei.suffix:
                endung_text = datei.suffix
            else:
                endung_text = "keine Dateiendung"

            meldung = (
                f'ÜBERSPRUNGEN: "{datei.name}" - '
                f"unbekannter Dateityp ({endung_text})"
            )
            print(meldung)
            protokoll.append(meldung)
            anzahl_uebersprungen += 1


    # --------------------------------------------------------
    # Zusammenfassung für diesen Ordner
    # --------------------------------------------------------

    protokoll.append("")
    protokoll.append("Fertig.")

    print()
    print("Fertig.")
    print()

    if testmodus:
        meldung_1 = f"Anzahl Dateien, die verschoben würden: {anzahl_verschoben}"
        meldung_2 = f"Anzahl übersprungen: {anzahl_uebersprungen}"
        meldung_3 = f"Anzahl Fehler: {anzahl_fehler}"

        print(meldung_1)
        print(meldung_2)
        print(meldung_3)
        print()
        print("Es wurden keine Dateien verschoben und keine Ordner erstellt.")

        protokoll.append(meldung_1)
        protokoll.append(meldung_2)
        protokoll.append(meldung_3)
        protokoll.append("Es wurden keine Dateien verschoben und keine Ordner erstellt.")
    else:
        meldung_1 = f"Anzahl verschoben: {anzahl_verschoben}"
        meldung_2 = f"Anzahl übersprungen: {anzahl_uebersprungen}"
        meldung_3 = f"Anzahl Fehler: {anzahl_fehler}"

        print(meldung_1)
        print(meldung_2)
        print(meldung_3)

        protokoll.append(meldung_1)
        protokoll.append(meldung_2)
        protokoll.append(meldung_3)


    # --------------------------------------------------------
    # Optionale Ausgabe als Logdatei
    # Für jeden verarbeiteten Ordner wird eine Datei erstellt.
    # --------------------------------------------------------

    protokoll_text = "\n".join(protokoll)
    zeitstempel = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    logdatei = basis_ordner / f"sortierprotokoll_{zeitstempel}.log"

    if logdatei_erstellen:
        try:
            logdatei.write_text(protokoll_text, encoding="utf-8")
            print()
            print("Das Protokoll wurde erstellt:")
            print(logdatei)
        except OSError as fehler:
            print()
            print(f"FEHLER: Das Protokoll konnte nicht erstellt werden. Grund: {fehler}")

    gesamt_anzahl_verschoben += anzahl_verschoben
    gesamt_anzahl_uebersprungen += anzahl_uebersprungen
    gesamt_anzahl_fehler += anzahl_fehler

    gesamt_protokoll.extend(protokoll)
    gesamt_protokoll.append("")
    gesamt_protokoll.append("============================================================")
    gesamt_protokoll.append("")

    print()
    print("============================================================")
    print()


# ------------------------------------------------------------
# Gesamtübersicht und optionale Ausgabe in die Zwischenablage
# ------------------------------------------------------------

if testmodus:
    gesamt_meldung_1 = f"Insgesamt würden verschoben: {gesamt_anzahl_verschoben}"
else:
    gesamt_meldung_1 = f"Insgesamt verschoben: {gesamt_anzahl_verschoben}"

gesamt_meldung_2 = f"Insgesamt übersprungen: {gesamt_anzahl_uebersprungen}"
gesamt_meldung_3 = f"Insgesamt Fehler: {gesamt_anzahl_fehler}"

print("Gesamtübersicht:")
print(gesamt_meldung_1)
print(gesamt_meldung_2)
print(gesamt_meldung_3)
print()

gesamt_protokoll.append("Gesamtübersicht:")
gesamt_protokoll.append(gesamt_meldung_1)
gesamt_protokoll.append(gesamt_meldung_2)
gesamt_protokoll.append(gesamt_meldung_3)

if zwischenablage_verwenden and gesamt_protokoll:
    gesamt_protokoll_text = "\n".join(gesamt_protokoll)

    try:
        subprocess.run(
            "clip",
            input=gesamt_protokoll_text,
            text=True,
            encoding="utf-8",
            check=True,
        )
        print("Alle Protokolle wurden zusätzlich in die Zwischenablage kopiert.")
        print()
    except (OSError, subprocess.CalledProcessError) as fehler:
        print(f"FEHLER: Die Protokolle konnten nicht kopiert werden. Grund: {fehler}")
        print()

if testmodus:
    print("Der Test ist abgeschlossen.")
    print("Es wurden keine Dateien verschoben und keine Ordner erstellt.")
    print("Wenn alles richtig aussieht, entferne _test aus dem Namen der Starter-Batchdatei.")
    print()

input("Drücke Enter zum Beenden")

Code der SendTo-Python-Datei erklärt

Startargumente übernehmen

argumente = sys.argv[1:]
testmodus = "--test" in argumente

if testmodus:
    argumente.remove("--test")

sys.argv enthält alle Startargumente. Das Element mit dem Index 0 ist der Name des Python-Skripts. Der Slice [1:] übernimmt deshalb alle danach folgenden Argumente.

Wenn --test vorhanden ist, wird es mit remove() aus der Liste entfernt. Danach enthält argumente nur noch die übergebenen Pfade.

Fehlende Übergabe erkennen

if not argumente:
    print("Bitte sende mindestens einen Ordner an dieses Skript.")
    sys.exit()

Eine leere Liste gilt in einer Bedingung als falsch. if not argumente erkennt deshalb, ob die SendTo-Datei ohne übergebenen Ordner gestartet wurde.

Alle übergebenen Elemente durchlaufen

for element_pfad in argumente:
    basis_ordner = Path(element_pfad)

Die for-Schleife verarbeitet jeden übergebenen Pfad nacheinander. Path() wandelt den Textpfad in ein Path-Objekt um.

Ausschließlich Ordner zulassen

if not basis_ordner.is_dir():
    gesamt_anzahl_uebersprungen += 1
    continue

is_dir() prüft, ob der Pfad einen vorhandenen Ordner bezeichnet. Dateien und ungültige Pfade werden übersprungen.

Vollständigen Ordnerpfad ermitteln

basis_ordner = basis_ordner.resolve()

resolve() erzeugt einen vollständigen, aufgelösten Pfad. Dieser wird für die Ausgabe und die weitere Verarbeitung verwendet.

Sicherheitsabfrage für jeden Ordner

Die Sicherheitsabfrage steht innerhalb der Schleife über alle Argumente. Deshalb wird im Echtmodus jeder gültige Ordner einzeln bestätigt. Wird nicht JA eingegeben, bleibt nur dieser Ordner unverändert; danach geht das Skript zum nächsten übergebenen Ordner weiter.

Einzelprotokoll und Gesamtprotokoll

protokoll = []
gesamt_protokoll = []

protokoll sammelt die Meldungen eines einzelnen Ordners. gesamt_protokoll sammelt anschließend die Ergebnisse aller verarbeiteten Ordner.

Gesamtzähler bilden

gesamt_anzahl_verschoben += anzahl_verschoben
gesamt_anzahl_uebersprungen += anzahl_uebersprungen
gesamt_anzahl_fehler += anzahl_fehler

Nach jedem Ordner werden seine Zähler zu den Gesamtzählern addiert. Am Ende zeigt das Skript eine Gesamtübersicht über alle übergebenen Ordner.

Eine Logdatei pro Ordner

Wenn logdatei_erstellen aktiv ist, schreibt die SendTo-Version ihr jeweiliges Einzelprotokoll direkt in den verarbeiteten Ordner. Bei mehreren Ordnern entsteht damit pro Ordner eine eigene Logdatei.

Alle Protokolle in die Zwischenablage kopieren

Wenn zwischenablage_verwenden aktiv ist, verbindet die SendTo-Version am Ende das Gesamtprotokoll. Dadurch enthält die Zwischenablage die Ergebnisse aller in diesem Durchlauf übergebenen Ordner.

Starter-Batchdatei der SendTo-Variante

@echo off
REM ============================================================
REM TOPTORIALS OFFICE - Python Grundkurs
REM Script: 004_sendto_dateien_nach_typ_sortieren_starter_batch_test.bat
REM Beschreibung: Startet das Python-SendTo-Skript im Testmodus.
REM Autor: Chris
REM YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
REM Webseite: https://www.toptorials.com
REM Version: 1.0
REM Stand: 2026-08-05
REM
REM Hinweis:
REM Solange _test im Dateinamen steht, wird --test uebergeben.
REM Fuer die echte Ausfuehrung _test aus dem Dateinamen entfernen.
REM ============================================================

chcp 65001 >nul
cd /d "%~dp0"

echo %~n0 | find /i "_test" >nul

if not errorlevel 1 (
    py "004_sendto_dateien_nach_typ_sortieren.py" --test %*
    REM Alternative, falls py nicht funktioniert:
    REM python "004_sendto_dateien_nach_typ_sortieren.py" --test %*
) else (
    py "004_sendto_dateien_nach_typ_sortieren.py" %*
    REM Alternative, falls py nicht funktioniert:
    REM python "004_sendto_dateien_nach_typ_sortieren.py" %*
)

Code der SendTo-Starter-Batchdatei erklärt

Die SendTo-Starterdatei funktioniert grundsätzlich wie die einfache Starterdatei. Der entscheidende Unterschied ist %*:

py "004_sendto_dateien_nach_typ_sortieren.py" --test %*

%* enthält alle Argumente, die Windows an die Batchdatei übergeben hat. Dadurch erhält Python alle im Explorer markierten Ordnerpfade.

%* wird nicht zusätzlich als "%*" geschrieben. Andernfalls könnten mehrere getrennte Pfade zu einem einzigen Argument zusammengefasst werden.

SendTo-Verknüpfung einrichten

Den SendTo-Ordner von Windows öffnen:

Windows-Taste + R
shell:sendto
Enter

In diesem Ordner wird eine Verknüpfung zu folgender Datei angelegt:

004_sendto_dateien_nach_typ_sortieren_starter_batch_test.bat

Danach erscheint die Verknüpfung im Windows-Explorer unter:

Rechtsklick auf einen oder mehrere Ordner
Senden an

Die Verknüpfung kann zum Beispiel Dateien nach Typ sortieren - TEST heißen.

Wird _test später für den Echtmodus aus dem Namen der Starter-Batchdatei entfernt, muss die Verknüpfung gegebenenfalls aktualisiert oder neu erstellt werden.

Kategorien und Dateiendungen erweitern

Eine weitere Bildendung kann direkt an die vorhandene Liste angehängt werden:

"01_Bilder": [".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"],

Eine weitere Kategorie wird als neuer Dictionary-Eintrag ergänzt:

"06_Audio": [".mp3", ".wav", ".flac"],

Im Echtmodus wird dann auch der Ordner 06_Audio immer erstellt.

Typische Meldungen

WÜRDE VERSCHIEBEN

Die Datei würde bei der echten Ausführung verschoben. Im Testmodus wird der Ordner nicht verändert.

WÜRDE ÜBERSPRINGEN

Im Zielordner existiert bereits eine gleichnamige Datei. Auch im Echtmodus würde diese Datei nicht überschrieben.

VERSCHOBEN

Die Datei wurde im Echtmodus in den zugehörigen Kategorieordner verschoben.

ÜBERSPRUNGEN

Eine Datei besitzt einen unbekannten Dateityp, eine Zieldatei ist bereits vorhanden oder ein übergebener SendTo-Pfad ist kein gültiger Ordner.

FEHLER

Ein Ordner konnte nicht gelesen oder erstellt, eine Datei nicht verschoben, die Logdatei nicht geschrieben oder der Text nicht in die Zwischenablage kopiert werden.

Typische Fehler und Lösungen

Python wurde nicht gefunden

Die Starterdateien verwenden standardmäßig py. Prüfe mit py --version, ob der Python Launcher verfügbar ist. Falls nur python funktioniert, können die bereits vorbereiteten Alternativzeilen in der Starter-Batchdatei verwendet werden.

Die Python-Datei wurde nicht gefunden

Die Python-Datei und ihre Starter-Batchdatei müssen gemeinsam im gleichen Ordner liegen. Die Dateinamen im Batchcode müssen exakt mit den tatsächlichen Dateinamen übereinstimmen.

Die SendTo-Datei wurde direkt gestartet

Beim Doppelklick wurden keine Ordnerpfade übergeben. Die SendTo-Variante sollte über Rechtsklick – Senden an gestartet werden.

Eine einzelne Datei wurde übergeben

Diese SendTo-Version verarbeitet ausschließlich Ordner. Einzelne Dateien werden als ungültige Eingabe übersprungen.

Eine Datei wurde nicht sortiert

Prüfe, ob ihre Dateiendung im Dictionary kategorien eingetragen ist. Unbekannte Dateitypen bleiben im Ausgangsordner liegen.

Eine Datei wurde übersprungen

Im Zielordner existiert bereits eine Datei mit demselben Namen. Die vorhandene Datei wird nicht überschrieben und die Quelldatei wird nicht automatisch umbenannt.

Alle Kategorieordner wurden erstellt

Das ist in dieser Version vorgesehen. Im Echtmodus werden alle im Dictionary eingetragenen Kategorieordner erstellt, auch wenn momentan keine passende Datei vorhanden ist.

Die Eingabe ja wurde akzeptiert

Auch das ist vorgesehen. Durch antwort.upper() spielt die Groß- und Kleinschreibung bei der Sicherheitsbestätigung keine Rolle.

Keine Logdatei wurde erstellt

Die Logausgabe ist standardmäßig ausgeschaltet. Aktiviere eine der vorbereiteten Varianten mit logdatei_erstellen = True.

Die Zwischenablage funktioniert nicht

Die Zwischenablage-Funktion verwendet das Windows-Programm clip. Sie ist daher für die Ausführung unter Windows vorgesehen.

Umlaute oder Sonderzeichen werden falsch angezeigt

Die Starter-Batchdatei stellt die Konsole mit chcp 65001 auf UTF-8 um. Prüfe außerdem, ob die Dateien als UTF-8 gespeichert wurden.

Nützliche Python-Begriffe aus diesem Teil

datetime
Liefert Datum und Uhrzeit.

Path
Erstellt und verarbeitet Datei- und Ordnerpfade.

Path.cwd()
Liefert den aktuellen Arbeitsordner.

Path()
Wandelt einen Textpfad in ein Path-Objekt um.

iterdir()
Liest die direkten Inhalte eines Ordners aus.

is_file()
Prüft, ob ein Pfad eine Datei bezeichnet.

is_dir()
Prüft, ob ein Pfad einen Ordner bezeichnet.

suffix
Liefert die Dateiendung einschließlich Punkt.

name
Liefert den Datei- oder Ordnernamen.

resolve()
Ermittelt einen vollständigen, aufgelösten Pfad.

exists()
Prüft, ob ein Pfad existiert.

mkdir()
Erstellt einen Ordner.

write_text()
Schreibt Text in eine Datei.

shutil.move()
Verschiebt eine Datei oder einen Ordner.

subprocess.run()
Startet ein externes Programm.

sys.argv
Enthält den Skriptnamen und die Startargumente.

sys.exit()
Beendet das Python-Skript.

Dictionary
Speichert Schlüssel und zugehörige Werte.

Liste
Speichert mehrere Werte in einer Reihenfolge.

items()
Liefert Schlüssel und Werte eines Dictionaries.

values()
Liefert die Werte eines Dictionaries.

append()
Hängt einen einzelnen Wert an eine Liste an.

extend()
Hängt mehrere Werte einzeln an eine Liste an.

remove()
Entfernt einen bestimmten Wert aus einer Liste.

lower()
Wandelt Text in Kleinbuchstaben um.

upper()
Wandelt Text in Großbuchstaben um.

join()
Verbindet mehrere Textelemente.

in
Prüft, ob ein Wert in einer Sammlung enthalten ist.

not in
Prüft, ob ein Wert nicht in einer Sammlung enthalten ist.

try / except
Fängt erwartbare Fehler kontrolliert ab.

OSError
Fehlerklasse für viele Datei-, Ordner- und Betriebssystemfehler.

continue
Springt zum nächsten Durchlauf einer Schleife.

True / False
Boolesche Wahrheitswerte.

f-String
Setzt Variablen direkt in Text ein.

Wichtige Batch-Begriffe aus diesem Teil

@echo off
Blendet die ausgeführten Batchbefehle aus.

chcp 65001
Stellt die Konsole auf UTF-8 um.

>nul
Unterdrückt eine Befehlsausgabe.

cd /d
Wechselt Ordner und bei Bedarf Laufwerk.

%~dp0
Laufwerk und Ordner der gestarteten Batchdatei.

%~n0
Name der gestarteten Batchdatei ohne Dateiendung.

find /i
Sucht unabhängig von Groß- und Kleinschreibung.

errorlevel
Enthält den Rückgabestatus des vorherigen Befehls.

py
Startet Python über den Python Launcher.

%*
Enthält alle an die Batchdatei übergebenen Argumente.

Was haben wir gelernt?

Startargumente mit sys.argv auslesen
den Testmodus mit --test steuern
den aktuellen Arbeitsordner mit Path.cwd() ermitteln
mehrere SendTo-Ordner nacheinander verarbeiten
Kategorien in einem Dictionary speichern
Listen mit append() und extend() füllen
Dateien mit iterdir() erfassen
Dateiendungen mit suffix auslesen
Groß- und Kleinschreibung mit lower() und upper() vereinheitlichen
Pfade mit dem /-Operator zusammensetzen
Dateien und Ordner prüfen
alle Kategorieordner im Echtmodus mit mkdir() erstellen
Dateien mit shutil.move() verschieben
vorhandene Zieldateien schützen
Fehler mit try und except behandeln
Meldungen in Listen sammeln
Protokolle mit join() zusammensetzen
Logdateien mit write_text() schreiben
Text mit clip in die Zwischenablage kopieren
mehrere Batchargumente mit %* weitergeben

Video zu diesem Tutorial:

Das könnte Dich auch interessieren

Keine Einträge gefunden