Python Grundkurs 003: Dateiliste erstellen und in die Zwischenablage kopieren

Worum geht es in diesem Teil?

In diesem dritten Teil des Python-Grundkurses erstellen wir automatisch eine Dateiliste.

Das bedeutet: Python liest Dateien aus einem Ordner aus, erstellt daraus eine Liste und kann diese Liste anschließend in eine Textdatei schreiben und zusätzlich in die Zwischenablage kopieren.

Je nach aktivierter Variante kann die Liste zum Beispiel enthalten:

nur die Dateinamen
relative Pfade
vollständige Pfade
rekursive Dateilisten aus Unterordnern

Es gibt wieder zwei Varianten:

01_Einfach
02_SendTo_Dateiliste_erstellen

Die erste Variante wird direkt in den Ordner kopiert, aus dem eine Dateiliste erstellt werden soll.

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

Was ist das Ziel?

Das Ziel ist ein kleines Python-Tool, mit dem schnell eine Dateiliste erstellt werden kann.

Die fertige Liste kann:

in eine Textdatei geschrieben werden
in die Zwischenablage kopiert werden
oder beides gleichzeitig

Das ist praktisch, wenn man Dateinamen oder Pfade für Dokumentationen, Webseiten, Projektübersichten, Uploads oder weitere Verarbeitungsschritte benötigt.

Warum ist dieser Teil wichtig?

In diesem Teil sieht man sehr gut, wie Python mit Datei- und Ordnerpfaden arbeitet.

Dafür verwenden wir:

pathlib
Path
iterdir()
rglob()
is_file()
is_dir()
name
resolve()
relative_to()

Außerdem verwenden wir:

sys.argv

für die SendTo-Übergabe und:

subprocess

um unter Windows die Zwischenablage über das Programm clip zu befüllen.

Im Vergleich zu Batch und PowerShell ist dieser Teil besonders interessant, weil Python sehr gut lesbar ist, aber trotzdem einige wichtige Konzepte enthält:

Path-Objekte
Listen
for-Schleifen
if-Abfragen
append()
Startparameter
Textausgabe
Dateien schreiben
Zwischenablage nutzen

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 Code ist in diesem Grundkurs bewusst ausführlicher geschrieben. Viele Teile könnte man in Python auch kompakter schreiben, zum Beispiel mit sogenannten List Comprehensions. Für Einsteiger ist die längere Schreibweise aber leichter nachzuvollziehen, weil jeder Schritt einzeln sichtbar bleibt.

Downloads zu diesem Teil

Für diesen Teil gibt es zwei Varianten mit Python-Dateien und Starter-Batchdateien.

C:\TOPTORIALS_CODE\020_Python_Grundkurs

C:\TOPTORIALS_CODE\020_Python_Grundkurs\003_Dateiliste_erstellen

01_Einfach
02_SendTo_Dateiliste_erstellen

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\003_Dateiliste_erstellen

Sicherheitshinweis

Enthaltene Dateien

Zu diesem Teil gehören zwei Varianten.

Variante 1: Einfach

01_Einfach
├── 003_dateiliste_erstellen.py
└── 003_dateiliste_erstellen_starter_batch.bat

Variante 2: SendTo-Dateiliste erstellen

02_SendTo_Dateiliste_erstellen
├── 003_sendto_dateiliste_erstellen.py
└── 003_sendto_dateiliste_erstellen_starter_batch.bat

Variante 1: Einfache Dateiliste erstellen

Die einfache Variante wird in den Ordner kopiert, aus dem eine Dateiliste erstellt werden soll.

Danach wird die Starter-Batchdatei gestartet.

Das Python-Skript erstellt dann:

dateiliste.txt

und kopiert die Liste zusätzlich in die Zwischenablage.

Der komplette Code der einfachen Python-Datei

Die Datei heißt:

003_dateiliste_erstellen.py

# ============================================================
# TOPTORIALS OFFICE - Python Grundkurs
# Script: 003_dateiliste_erstellen.py
# Beschreibung: Erstellt eine Dateiliste und kopiert sie zusaetzlich in die Zwischenablage.
# Autor: Chris
# YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
# Webseite: https://www.toptorials.com
# Version: 1.0
# Stand: 2026-07-30
#
# ============================================================

from pathlib import Path
import subprocess


print()
print("Dateiliste wird erstellt...")
print()

ausgabe_datei = "dateiliste.txt"
basis_ordner = Path.cwd()


# ------------------------------------------------------------
# Welche Dateien sollen aufgelistet werden?
# ------------------------------------------------------------

# Dateien im aktuellen Ordner, nicht rekursiv:
dateien = []

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


# Alternative: Dateien im aktuellen Ordner und in allen Unterordnern:
# dateien = []
#
# for pfad in basis_ordner.rglob("*"):
#     if pfad.is_file():
#         dateien.append(pfad)


# Kompaktere Python-Schreibweise als Alternative:
# Diese Variante nennt man List Comprehension.
# Sie ist kuerzer, aber fuer Einsteiger oft schwerer zu lesen.
#
# dateien = [pfad for pfad in basis_ordner.iterdir() if pfad.is_file()]
#
# Rekursiv waere es entsprechend:
# dateien = [pfad for pfad in basis_ordner.rglob("*") if pfad.is_file()]


# ------------------------------------------------------------
# Was soll in der Liste stehen?
# Wichtig: Immer nur EINE der folgenden Varianten aktiv lassen.
# ------------------------------------------------------------

# Variante 1: Nur Dateinamen
liste = []

for datei in dateien:
    liste.append(datei.name)


# Variante 2: Relative Pfade
# liste = []
#
# for datei in dateien:
#     relativer_pfad = datei.relative_to(basis_ordner)
#     liste.append(str(relativer_pfad))


# Variante 3: Absolute Pfade
# liste = []
#
# for datei in dateien:
#     absoluter_pfad = datei.resolve()
#     liste.append(str(absoluter_pfad))


# Kompaktere Python-Schreibweisen als Alternative:
# Diese Varianten machen das Gleiche, sind aber kuerzer.
#
# Nur Dateinamen:
# liste = [datei.name for datei in dateien]
#
# Relative Pfade:
# liste = [str(datei.relative_to(basis_ordner)) for datei in dateien]
#
# Absolute Pfade:
# liste = [str(datei.resolve()) for datei in dateien]


# ------------------------------------------------------------
# Ausgabe
# Wenn eine Ausgabe nicht gewuenscht ist, kann die passende Zeile
# einfach auskommentiert werden.
# ------------------------------------------------------------

inhalt = "\n".join(liste)

# Liste in Textdatei schreiben:
Path(ausgabe_datei).write_text(inhalt, encoding="utf-8")

# Liste in die Zwischenablage kopieren:
subprocess.run(
    "clip",
    input=inhalt,
    text=True,
    encoding="utf-8",
    check=True
)


print("Fertig.")
print(f"Die Datei {ausgabe_datei} wurde erstellt.")
print("Der Inhalt wurde zusaetzlich in die Zwischenablage kopiert.")
print()

input("Drücke Enter zum Beenden")

Code der einfachen Python-Datei erklärt

Import von Path

from pathlib import Path

Damit importieren wir Path aus dem Modul pathlib.

pathlib ist in Python für Datei- und Ordnerpfade zuständig.

Mit Path können Pfade als Path-Objekte verarbeitet werden.

Ein Path-Objekt ist mehr als nur Text. Es besitzt Eigenschaften und Methoden, zum Beispiel:

is_file()
is_dir()
exists()
iterdir()
rglob()
resolve()
relative_to()
write_text()
name

Dadurch kann Python komfortabel mit Dateien und Ordnern arbeiten.

Import von subprocess

import subprocess

subprocess wird verwendet, wenn Python ein externes Programm starten soll.

In diesem Skript brauchen wir es für das Windows-Programm:

clip

Damit kopieren wir die Dateiliste in die Zwischenablage.

Name der Ausgabedatei

ausgabe_datei = "dateiliste.txt"

Hier wird der Name der Textdatei gespeichert.

Die Variable heißt:

ausgabe_datei

und enthält den Text:

dateiliste.txt

Später wird diese Variable verwendet, wenn die Liste in eine Datei geschrieben wird.

Aktuellen Arbeitsordner speichern

basis_ordner = Path.cwd()

Path.cwd() liefert den aktuellen Arbeitsordner.

cwd steht für:

current working directory

also:

aktueller Arbeitsordner

Wichtig:

Path.cwd()
= aktueller Arbeitsordner des laufenden Python-Prozesses

Path(__file__).parent
= Ordner, in dem die Python-Datei liegt

In diesem Skript passt Path.cwd(), weil die Starter-Batchdatei vorher mit:

cd /d "%~dp0"

in den Ordner der Batchdatei wechselt. Python übernimmt diesen Arbeitsordner beim Start.

Dadurch arbeitet Python in dem Ordner, in dem die Starter-Batchdatei und die Python-Datei liegen.

Leere Liste für Dateien erstellen

dateien = []

Hier wird eine leere Liste erstellt.

In diese Liste werden später die gefundenen Dateien eingefügt.

Ordnerinhalt durchgehen

for pfad in basis_ordner.iterdir():

Diese Schleife geht die direkten Inhalte des Basisordners durch.

basis_ordner.iterdir() ist ein Methodenaufruf auf dem Path-Objekt basis_ordner.

Er liefert die Elemente des Ordners nacheinander als Path-Objekte.

Zum Beispiel:

Path-Objekt zu bild_start.jpg
Path-Objekt zu notiz.txt
Path-Objekt zu Bilder
Path-Objekt zu protokoll.log

Wichtig:

iterdir()
= direkte Inhalte des Ordners durchgehen
= nicht rekursiv
= Unterordner werden nicht automatisch durchsucht

Bei jedem Durchlauf steht das aktuelle Path-Objekt in der Variable:

pfad

Prüfen, ob es eine Datei ist

if pfad.is_file():

Diese Zeile prüft, ob das aktuelle Path-Objekt eine Datei ist.

is_file() gibt entweder True oder False zurück.

Beispiel:

bild_start.jpg  = True
notiz.txt       = True
Bilder          = False

Dadurch werden Ordner übersprungen.

Datei zur Liste hinzufügen

dateien.append(pfad)

Diese Zeile wird nur ausgeführt, wenn pfad.is_file() wahr ist.

append() bedeutet:

hinten an die Liste anhängen

Hier wird also das aktuelle Path-Objekt an die Liste dateien angehängt.

Nach der Schleife enthält dateien die gefundenen Dateien als Path-Objekte.

Rekursive Alternative mit rglob

Im Skript gibt es zusätzlich diese auskommentierte Alternative:

# dateien = []
#
# for pfad in basis_ordner.rglob("*"):
#     if pfad.is_file():
#         dateien.append(pfad)

rglob steht sinngemäß für:

recursive glob

also:

rekursive Mustersuche

basis_ordner.rglob("*") bedeutet:

Suche alles im Basisordner und in allen Unterordnern.

Der Stern * bedeutet:

alles

Da rglob("*") Dateien und Ordner liefern kann, wird danach wieder mit is_file() geprüft, ob das aktuelle Element eine Datei ist.

Kompakte Alternative: List Comprehension

Im Skript steht außerdem diese kompakte Alternative:

# dateien = [pfad for pfad in basis_ordner.iterdir() if pfad.is_file()]

Diese Schreibweise nennt man:

List Comprehension

Sie ist kürzer, aber für Einsteiger oft schwerer zu lesen.

Sie entspricht dieser ausführlichen Variante:

dateien = []

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

Die Struktur ist:

[WAS soll in die Liste  for aktuelles_element in datenquelle  if Bedingung]

Bei:

[pfad for pfad in basis_ordner.iterdir() if pfad.is_file()]

bedeutet das:

Füge pfad in die Liste ein
für jedes pfad aus basis_ordner.iterdir()
wenn pfad.is_file() wahr ist.

Das erste pfad steht also für den Wert, der in die Liste eingefügt wird.

Wenn man zum Beispiel nur die Namen speichern wollte, könnte man schreiben:

[pfad.name for pfad in basis_ordner.rglob("*") if pfad.is_file()]

Dann würden nicht die Path-Objekte selbst, sondern nur die Dateinamen in der Liste landen.

Leere Liste für die Ausgabe erstellen

liste = []

Hier wird eine neue leere Liste erstellt.

In dateien liegen die gefundenen Dateien als Path-Objekte.

In liste sollen die fertigen Textzeilen für die Ausgabe landen.

Dateinamen in die Liste schreiben

for datei in dateien:
    liste.append(datei.name)

Diese Schleife geht alle gefundenen Dateien durch.

Bei jedem Durchlauf steht das aktuelle Path-Objekt in der Variable:

datei

Mit:

datei.name

wird nur der Dateiname gelesen.

Beispiel:

Path:
C:\Test\Bilder\bild01.png

datei.name:
bild01.png

Mit:

liste.append(datei.name)

wird dieser Dateiname an die Ausgabeliste angehängt.

Nach der Schleife enthält liste nur noch Textwerte.

Merksatz:

dateien = Path-Objekte
liste   = Textzeilen

Variante 2: Relative Pfade

Die zweite Listenvariante ist auskommentiert:

# liste = []
#
# for datei in dateien:
#     relativer_pfad = datei.relative_to(basis_ordner)
#     liste.append(str(relativer_pfad))

relative_to() berechnet den Pfad relativ zu einem angegebenen Basisordner.

Beispiel:

Vollständiger Pfad:

C:\TOPTORIALS_CODE\020_Python_Grundkurs\003_Dateiliste_erstellen\01_Einfach\Bilder\bild01.png

Basisordner:

C:\TOPTORIALS_CODE\020_Python_Grundkurs\003_Dateiliste_erstellen\01_Einfach

Ergebnis:

Bilder\bild01.png

Da relative_to() wieder ein Path-Objekt liefert, wird es mit str(...) in Text umgewandelt.

Variante 3: Absolute Pfade

Die dritte Listenvariante ist ebenfalls auskommentiert:

# liste = []
#
# for datei in dateien:
#     absoluter_pfad = datei.resolve()
#     liste.append(str(absoluter_pfad))

resolve() liefert den vollständigen, aufgelösten Pfad.

Beispiel:

C:\TOPTORIALS_CODE\020_Python_Grundkurs\003_Dateiliste_erstellen\01_Einfach\bild_start.jpg

Auch hier wird das Path-Objekt mit str(...) in Text umgewandelt, damit es in die Textliste geschrieben werden kann.

Wichtig: Nur eine Listenvariante aktiv lassen

Im Skript steht bewusst:

# Wichtig: Immer nur EINE der folgenden Varianten aktiv lassen.

Das ist wichtig, weil jede Variante die Variable liste neu setzt.

Wenn mehrere Varianten gleichzeitig aktiv wären, würde die letzte aktive Variante die vorherige überschreiben.

Liste zu einem Text verbinden

inhalt = "\n".join(liste)

liste enthält mehrere einzelne Textwerte.

Zum Beispiel:

["bild_start.jpg", "notiz.txt", "protokoll.log"]

Für eine Textdatei oder die Zwischenablage brauchen wir daraus einen zusammenhängenden Text.

\n bedeutet:

neue Zeile

join(liste) verbindet alle Einträge aus der Liste.

Diese Zeile bedeutet also:

Verbinde alle Listeneinträge mit einem Zeilenumbruch dazwischen.

Aus:

["bild_start.jpg", "notiz.txt", "protokoll.log"]

wird:

bild_start.jpg
notiz.txt
protokoll.log

Textdatei schreiben

Path(ausgabe_datei).write_text(inhalt, encoding="utf-8")

Diese Zeile schreibt den fertigen Text in eine Datei.

Path(ausgabe_datei) macht aus dem Text dateiliste.txt ein Path-Objekt.

write_text() schreibt Text in diese Datei.

encoding="utf-8" sorgt dafür, dass die Datei als UTF-8 gespeichert wird.

Wichtig:

write_text()
= Datei erstellen oder vorhandenen Inhalt überschreiben

Wenn dateiliste.txt schon existiert, wird der Inhalt ersetzt.

Liste in die Zwischenablage kopieren

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

Python startet hier das Windows-Programm:

clip

clip übernimmt Text und kopiert ihn in die Zwischenablage.

Die Bestandteile:

subprocess.run()
= externes Programm starten

"clip"
= Windows-Programm für die Zwischenablage

input=inhalt
= dieser Text wird an clip übergeben

text=True
= input wird als Text behandelt

encoding="utf-8"
= Text wird als UTF-8 übergeben

check=True
= bei Fehler wird ein Python-Fehler ausgelöst

Das ist vergleichbar mit Set-Clipboard in PowerShell.

Starter-Batchdatei der einfachen Variante

Die Datei heißt:

003_dateiliste_erstellen_starter_batch.bat

@echo off
REM ============================================================
REM TOPTORIALS OFFICE - Python Grundkurs
REM Script: 003_dateiliste_erstellen_starter_batch.bat
REM Beschreibung: Startet das Python-Skript 003_dateiliste_erstellen.py.
REM Autor: Chris
REM YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
REM Webseite: https://www.toptorials.com
REM Version: 1.0
REM Stand: 2026-07-30
REM
REM ============================================================

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

py "003_dateiliste_erstellen.py"

REM Alternative, falls py nicht funktioniert:
REM python "003_dateiliste_erstellen.py"

Code der einfachen Starter-Batchdatei erklärt

@echo off

@echo off

Diese Zeile verhindert, dass die Befehle der Batchdatei selbst im Fenster angezeigt werden.

Codepage auf UTF-8 setzen

chcp 65001 >nul

Diese Zeile setzt die Codepage der Eingabeaufforderung auf UTF-8.

65001 steht für UTF-8.

>nul sorgt dafür, dass die Rückmeldung von chcp nicht angezeigt wird.

In den Ordner der Starter-Batchdatei wechseln

cd /d "%~dp0"

Diese Zeile wechselt in den Ordner, in dem die Starter-Batchdatei liegt.

%~dp0 steht für Laufwerk und Pfad der aktuellen Batchdatei.

Wichtig:

%~dp0 enthält bereits den abschließenden Backslash.

Mit cd /d "%~dp0" wird zuerst in den richtigen Ordner gewechselt. Python übernimmt diesen Ordner dann als aktuellen Arbeitsordner.

Der Teil /d sorgt dafür, dass auch das Laufwerk gewechselt wird.

Python starten

py "003_dateiliste_erstellen.py"

Diese Zeile startet das Python-Skript über den Python Launcher.

Falls py nicht funktioniert, ist im Skript eine Alternative vorbereitet:

REM python "003_dateiliste_erstellen.py"

Variante 2: Dateiliste über SendTo erstellen

Die SendTo-Variante ist flexibler.

Damit können Dateien oder Ordner im Windows-Explorer markiert und an das Skript übergeben werden.

Der Ablauf ist:

Dateien oder Ordner im Explorer markieren
Rechtsklick
Senden an
Python-Skript starten
Liste wird erstellt
Ausgabe in TXT und Zwischenablage

Der komplette Code der SendTo-Python-Datei

Die Datei heißt:

003_sendto_dateiliste_erstellen.py

# ============================================================
# TOPTORIALS OFFICE - Python Grundkurs
# Script: 003_sendto_dateiliste_erstellen.py
# Beschreibung: Erstellt aus uebergebenen Dateien und Ordnern eine Liste und kopiert sie in die Zwischenablage.
# Autor: Chris
# YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
# Webseite: https://www.toptorials.com
# Version: 1.0
# Stand: 2026-07-30
#
# ============================================================

from pathlib import Path
import subprocess
import sys


print()

elemente = sys.argv[1:]

if not elemente:
    print("Bitte markiere Dateien oder Ordner und sende sie an dieses Skript.")
    print()
    print("Du kannst im Explorer Dateien oder Ordner markieren,")
    print("dann Rechtsklick - Senden an verwenden.")
    print()
    input("Drücke Enter zum Beenden")
    sys.exit()


print("Dateiliste wird erstellt...")
print()

ausgabe_datei = "dateiliste_sendto.txt"
basis_ordner = Path.cwd()


# ------------------------------------------------------------
# Uebergebene Elemente in Path-Objekte umwandeln
# ------------------------------------------------------------

uebergebene_elemente = []

for element in elemente:
    pfad = Path(element)

    if pfad.exists():
        uebergebene_elemente.append(pfad)


# Kompaktere Python-Schreibweise als Alternative:
# Diese Variante nennt man List Comprehension.
# Sie ist kuerzer, aber fuer Einsteiger oft schwerer zu lesen.
#
# uebergebene_elemente = [
#     Path(element)
#     for element in elemente
#     if Path(element).exists()
# ]


# ------------------------------------------------------------
# Was soll in der Liste stehen?
# Wichtig: Immer nur EINE der folgenden Varianten aktiv lassen.
# ------------------------------------------------------------

# Variante 1: Nur Namen der markierten Dateien und Ordner
liste = []

for element in uebergebene_elemente:
    liste.append(element.name)


# Variante 2: Vollstaendige Pfade der markierten Dateien und Ordner
# liste = []
#
# for element in uebergebene_elemente:
#     liste.append(str(element.resolve()))


# Variante 3: Rekursiv - absolute Pfade aller Dateien in uebergebenen Ordnern
# Einzelne Dateien werden direkt uebernommen.
# liste = []
#
# for element in uebergebene_elemente:
#     if element.is_dir():
#         for datei in element.rglob("*"):
#             if datei.is_file():
#                 liste.append(str(datei.resolve()))
#     else:
#         liste.append(str(element.resolve()))


# Variante 4: Rekursiv - relative Pfade aller Dateien in uebergebenen Ordnern
# Einzelne Dateien werden mit relativem Pfad ausgegeben.
# Bei Ordnern wird relativ zum jeweils uebergebenen Ordner ausgegeben.
# liste = []
#
# for element in uebergebene_elemente:
#     if element.is_dir():
#         for datei in element.rglob("*"):
#             if datei.is_file():
#                 relativer_pfad = datei.relative_to(element)
#                 liste.append(str(relativer_pfad))
#     else:
#         try:
#             relativer_pfad = element.relative_to(basis_ordner)
#             liste.append(str(relativer_pfad))
#         except ValueError:
#             liste.append(element.name)


# Kompaktere Python-Schreibweisen als Alternative:
# Diese Varianten machen das Gleiche, sind aber kuerzer.
#
# Nur Namen:
# liste = [element.name for element in uebergebene_elemente]
#
# Vollstaendige Pfade:
# liste = [str(element.resolve()) for element in uebergebene_elemente]
#
# Rekursiv mit absoluten Pfaden:
# liste = []
#
# for element in uebergebene_elemente:
#     if element.is_dir():
#         liste.extend(
#             str(datei.resolve())
#             for datei in element.rglob("*")
#             if datei.is_file()
#         )
#     else:
#         liste.append(str(element.resolve()))


# ------------------------------------------------------------
# Ausgabe
# Wenn eine Ausgabe nicht gewuenscht ist, kann die passende Zeile
# einfach auskommentiert werden.
# ------------------------------------------------------------

inhalt = "\n".join(liste)

# Liste in Textdatei schreiben:
Path(ausgabe_datei).write_text(inhalt, encoding="utf-8")

# Liste in die Zwischenablage kopieren:
subprocess.run(
    "clip",
    input=inhalt,
    text=True,
    encoding="utf-8",
    check=True
)


print("Fertig.")
print("Die Liste wurde erstellt.")
print(f"Die Datei {ausgabe_datei} wurde erstellt.")
print("Der Inhalt wurde zusaetzlich in die Zwischenablage kopiert.")
print()

input("Drücke Enter zum Beenden")

Code der SendTo-Python-Datei erklärt

Zusätzlicher Import von sys

import sys

In der SendTo-Variante brauchen wir zusätzlich das Modul sys.

Damit können wir auf die Startparameter zugreifen, die an das Python-Skript übergeben wurden.

Diese Startparameter stehen in:

sys.argv

Übergebene Dateien und Ordner auslesen

elemente = sys.argv[1:]

sys.argv ist eine Liste mit den Startargumenten.

Dabei gilt:

sys.argv[0]  = Name oder Pfad des Python-Skripts
sys.argv[1]  = erster übergebener Parameter
sys.argv[2]  = zweiter übergebener Parameter
sys.argv[3]  = dritter übergebener Parameter

Mit:

sys.argv[1:]

nehmen wir alles ab Position 1.

Also alle übergebenen Dateien oder Ordner, aber nicht den Skriptnamen.

Beispiel:

sys.argv[0] = 003_sendto_dateiliste_erstellen.py
sys.argv[1] = C:\Test\bild01.png
sys.argv[2] = C:\Test\notiz.txt
sys.argv[3] = C:\Test\Bilder

Dann enthält elemente:

elemente[0] = C:\Test\bild01.png
elemente[1] = C:\Test\notiz.txt
elemente[2] = C:\Test\Bilder

Am Anfang sind das noch Textwerte.

Prüfen, ob überhaupt etwas übergeben wurde

if not elemente:

Diese Zeile prüft, ob die Liste elemente leer ist.

Wenn die SendTo-Datei direkt per Doppelklick gestartet wird, wurden keine Dateien oder Ordner übergeben.

Dann ist elemente leer.

not elemente bedeutet hier:

Wenn keine Elemente vorhanden sind.

In diesem Fall zeigt das Skript eine Meldung an, wartet auf Enter und beendet sich mit:

sys.exit()

Ausgabedatei der SendTo-Variante

ausgabe_datei = "dateiliste_sendto.txt"

Hier wird der Name der SendTo-Ausgabedatei gespeichert.

Basisordner speichern

basis_ordner = Path.cwd()

Auch hier wird der aktuelle Arbeitsordner gespeichert.

In der SendTo-Variante brauchen wir diesen Wert besonders für relative Pfade bei einzeln übergebenen Dateien.

Leere Liste für gültige übergebene Elemente

uebergebene_elemente = []

Diese Liste nimmt später nur die übergebenen Dateien und Ordner auf, die wirklich existieren.

Übergebene Textpfade durchgehen

for element in elemente:

Diese Schleife geht alle übergebenen Werte aus elemente durch.

Bei jedem Durchlauf steht ein einzelner Textpfad in der Variable:

element

Textpfad in Path-Objekt umwandeln

pfad = Path(element)

Diese Zeile macht aus dem Textpfad ein Path-Objekt.

Vorher:

element = Textpfad

Nachher:

pfad = Path-Objekt

Dadurch können wir anschließend Methoden verwenden wie:

exists()
is_dir()
is_file()
name
resolve()
rglob()

Prüfen, ob der Pfad existiert

if pfad.exists():

Diese Zeile prüft, ob der übergebene Pfad wirklich existiert.

Nur wenn das der Fall ist, wird der Pfad weiterverarbeitet.

Gültiges Path-Objekt speichern

uebergebene_elemente.append(pfad)

Wenn der Pfad existiert, wird das Path-Objekt an die Liste uebergebene_elemente angehängt.

Nach der Schleife enthält uebergebene_elemente gültige Dateien und Ordner als Path-Objekte.

Variante 1: Nur Namen der markierten Dateien und Ordner

Aktiv ist zuerst:

liste = []

for element in uebergebene_elemente:
    liste.append(element.name)

Diese Variante gibt nur die Namen der markierten Dateien und Ordner aus.

Beispiel Datei:

C:\Test\bild01.png
→ bild01.png

Beispiel Ordner:

C:\Test\Bilder
→ Bilder

Wichtig: Wenn ein Ordner übergeben wurde, wird in dieser Variante nur der Ordnername ausgegeben. Es wird nicht automatisch in den Ordner hineingeschaut.

Variante 2: Vollständige Pfade der markierten Dateien und Ordner

Die zweite Variante ist auskommentiert:

# liste = []
#
# for element in uebergebene_elemente:
#     liste.append(str(element.resolve()))

Diese Variante gibt die vollständigen Pfade der markierten Dateien oder Ordner aus.

element.resolve() liefert den vollständigen Pfad als Path-Objekt.

Mit str(...) wird daraus Text.

Variante 3: Rekursiv mit absoluten Pfaden

Die dritte Variante ist für übergebene Ordner besonders interessant:

# liste = []
#
# for element in uebergebene_elemente:
#     if element.is_dir():
#         for datei in element.rglob("*"):
#             if datei.is_file():
#                 liste.append(str(datei.resolve()))
#     else:
#         liste.append(str(element.resolve()))

Diese Variante prüft jedes übergebene Element.

Mit:

element.is_dir()

wird geprüft, ob das Element ein Ordner ist.

Wenn ja, wird dieser Ordner rekursiv durchsucht:

for datei in element.rglob("*"):

rglob("*") bedeutet:

Suche alles in diesem Ordner und in allen Unterordnern.

Da dabei Dateien und Ordner gefunden werden können, wird zusätzlich geprüft:

if datei.is_file():

Nur Dateien werden übernommen.

Mit:

liste.append(str(datei.resolve()))

wird der vollständige Pfad der gefundenen Datei als Text in die Liste geschrieben.

Wenn das übergebene Element kein Ordner ist, wird im else-Teil direkt der vollständige Pfad dieses Elements übernommen:

liste.append(str(element.resolve()))

Variante 4: Rekursiv mit relativen Pfaden

Die vierte Variante gibt rekursive Dateilisten mit relativen Pfaden aus:

# liste = []
#
# for element in uebergebene_elemente:
#     if element.is_dir():
#         for datei in element.rglob("*"):
#             if datei.is_file():
#                 relativer_pfad = datei.relative_to(element)
#                 liste.append(str(relativer_pfad))
#     else:
#         try:
#             relativer_pfad = element.relative_to(basis_ordner)
#             liste.append(str(relativer_pfad))
#         except ValueError:
#             liste.append(element.name)

Wenn ein Ordner übergeben wurde, werden Dateien darin rekursiv gesucht.

Mit:

datei.relative_to(element)

wird der Pfad der gefundenen Datei relativ zum übergebenen Ordner berechnet.

Beispiel:

Übergebener Ordner:

C:\Test\Projekt

Gefundene Datei:

C:\Test\Projekt\Bilder\bild01.png

Ergebnis:

Bilder\bild01.png

Wenn eine einzelne Datei übergeben wurde, versucht das Skript mit:

element.relative_to(basis_ordner)

einen relativen Pfad zum aktuellen Basisordner zu berechnen.

Das funktioniert nur, wenn die Datei innerhalb dieses Basisordners liegt.

Falls das nicht möglich ist, würde Python einen ValueError auslösen.

Damit das Skript nicht abbricht, wird dieser Fehler mit:

except ValueError:

abgefangen.

Dann wird als sichere Ersatzlösung nur der Name übernommen:

liste.append(element.name)

append und extend

Im Kommentarbereich kommt außerdem extend() vor.

Der Unterschied ist:

append()
= einen einzelnen Eintrag anhängen

extend()
= mehrere Einträge aus einer Sammlung anhängen

Für diesen Grundkurs verwenden wir hauptsächlich append(), weil es leichter zu verstehen ist.

Starter-Batchdatei der SendTo-Variante

Die Datei heißt:

003_sendto_dateiliste_erstellen_starter_batch.bat

@echo off
REM ============================================================
REM TOPTORIALS OFFICE - Python Grundkurs
REM Script: 003_sendto_dateiliste_erstellen_starter_batch.bat
REM Beschreibung: Startet das Python-SendTo-Skript.
REM Autor: Chris
REM YouTube: https://www.youtube.com/@TOPTORIALS-OFFICE
REM Webseite: https://www.toptorials.com
REM Version: 1.0
REM Stand: 2026-07-30
REM
REM ============================================================

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

py "003_sendto_dateiliste_erstellen.py" %*

REM Alternative, falls py nicht funktioniert:
REM python "003_sendto_dateiliste_erstellen.py" %*

Code der SendTo-Starter-Batchdatei erklärt

Der Anfang ist wie bei der einfachen Variante:

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

Danach wird das Python-Skript gestartet:

py "003_sendto_dateiliste_erstellen.py" %*

Der wichtige Unterschied ist hier:

%*

%* steht in Batch für alle übergebenen Parameter.

Wenn im Explorer mehrere Dateien oder Ordner markiert und über Senden an an die Starter-Batchdatei übergeben werden, werden diese Werte mit %* an Python weitergereicht.

In Python kommen sie in sys.argv an.

Mit:

elemente = sys.argv[1:]

werden alle übergebenen Werte ohne Skriptnamen übernommen.

Wichtig:

%*
= alle Parameter weitergeben

"%*"
= alles zu einem einzigen Parameter zusammenfassen

Deshalb wird %* hier nicht komplett in Anführungszeichen gesetzt.

SendTo-Verknüpfung einrichten

Damit die SendTo-Variante bequem über den Explorer genutzt werden kann, wird eine Verknüpfung zur Starter-Batchdatei im SendTo-Ordner abgelegt.

Den SendTo-Ordner öffnet man mit:

Windows-Taste + R
shell:sendto
Enter

In diesen Ordner legt man eine Verknüpfung zu:

003_sendto_dateiliste_erstellen_starter_batch.bat

Danach kann man im Explorer Dateien oder Ordner markieren und über:

Rechtsklick
Senden an
003_sendto_dateiliste_erstellen_starter_batch

die Dateiliste erstellen lassen.

Typische Fehler

Python wurde nicht gefunden

Wenn py nicht funktioniert, ist der Python Launcher eventuell nicht installiert oder nicht verfügbar.

In der Starter-Batchdatei ist deshalb eine Alternative vorbereitet:

REM python "003_dateiliste_erstellen.py"

oder bei der SendTo-Variante:

REM python "003_sendto_dateiliste_erstellen.py" %*

Dann kann man testen, ob der Start mit python funktioniert.

Die SendTo-Datei wurde direkt gestartet

Wenn die SendTo-Starter-Batchdatei direkt per Doppelklick gestartet wird, wurden keine Dateien oder Ordner übergeben.

Dann zeigt das Skript eine Meldung an:

Bitte markiere Dateien oder Ordner und sende sie an dieses Skript.

Die SendTo-Variante ist dafür gedacht, dass Dateien oder Ordner über Senden an übergeben werden.

Es wird nur ein Ordnername ausgegeben

Wenn nur ein Ordner markiert wurde und Variante 1 aktiv ist, ist das korrekt.

Variante 1 gibt nur den Namen des markierten Elements aus.

Wenn der Inhalt eines Ordners ausgegeben werden soll, muss Variante 3 oder Variante 4 aktiviert werden.

Mehrere Listenvarianten sind aktiv

Wenn mehrere Varianten gleichzeitig aktiv sind, wird liste mehrfach gesetzt.

Dann gilt am Ende die letzte aktive Variante.

Deshalb:

Immer nur eine Listenvariante aktiv lassen.

Relative Pfade funktionieren nicht bei jeder Datei

relative_to() funktioniert nur dann, wenn der Pfad wirklich innerhalb des angegebenen Basisordners liegt.

Deshalb wird in der SendTo-Variante bei einzeln übergebenen Dateien mit try und except ValueError gearbeitet.

Wenn kein relativer Pfad berechnet werden kann, wird als sichere Ersatzlösung nur der Dateiname verwendet.

Umlaute oder Sonderzeichen werden falsch angezeigt

Die Starter-Batchdatei setzt die Codepage auf UTF-8:

chcp 65001 >nul

Außerdem schreibt Python die Textdatei mit:

encoding="utf-8"

Die Skriptdateien sollten ebenfalls als UTF-8 gespeichert werden.

Nützliche Python-Begriffe aus diesem Teil

Was haben wir gelernt?

In diesem Teil wurden mehrere wichtige Grundlagen gezeigt:

Path.cwd() liefert den aktuellen Arbeitsordner.
iterdir() geht die direkten Inhalte eines Ordners durch.
rglob("*") durchsucht einen Ordner rekursiv.
is_file() prüft, ob ein Element eine Datei ist.
is_dir() prüft, ob ein Element ein Ordner ist.
exists() prüft, ob ein Pfad existiert.
append() fügt einen Eintrag an eine Liste an.
name liefert den Namen eines Path-Objekts.
resolve() liefert den vollständigen Pfad.
relative_to() berechnet einen relativen Pfad.
sys.argv enthält die Startargumente.
sys.argv[1:] enthält alle übergebenen Parameter ohne Skriptnamen.
"\n".join(liste) verbindet Listeneinträge mit Zeilenumbrüchen.
write_text() schreibt Text in eine Datei.
subprocess.run() kann externe Programme starten.
clip kopiert Text in die Windows-Zwischenablage.
%* gibt in Batch alle übergebenen Parameter weiter.

Damit haben wir in diesem Teil eine einfache Dateiliste und eine praktische SendTo-Variante erstellt.

Die einfache Variante ist gut zum Lernen.

Die SendTo-Variante ist praktisch für den Alltag, weil Dateien und Ordner direkt aus dem Explorer heraus an das Skript übergeben werden können.

Video zu diesem Tutorial:

Das könnte Dich auch interessieren

Keine Einträge gefunden