Python-Skript schreiben: Einfache Anleitung mit Beispielen (2025)

Du willst in kurzer Zeit ein Python‑Skript bauen, das mehr macht als „Hello, World“ - am besten eins, das Dateien liest, Argumente versteht und stabil läuft. Genau das bekommst du hier. Realistisch? Ja. In 15-30 Minuten hast du dein erstes Skript am Start, egal ob Windows, macOS oder Linux. Erwartung: Du lernst die Basics, vermeidest die typischen Anfängerfehler und bekommst eine klare Routine für neue Skripte. Ziel: Python Script schreiben, ausführen und Fehler finden.

TL;DR

• Installiere Python 3.12+ und VS Code, öffne ein Terminal, lege eine Datei main.py an, schreibe print("Hallo") - und starte sie mit python main.py (macOS/Linux) oder py main.py (Windows).
• Nutze venv: python -m venv .venv → aktivieren → pip install ... → Skript sauber und reproduzierbar entwickeln.
• Für Argumente nimm argparse; für Webanfragen requests; für Pfade pathlib; für Logs logging statt print.
• Häufige Fehler: ModuleNotFoundError (venv nicht aktiv), IndentationError (Tabs/Mixes), UnicodeDecodeError (encoding='utf-8').
• Spickzettel: OS-spezifische Befehle, Dateipfade, Ausführungsmethoden und Shebang stehen unten als Tabelle.

Setup in 10 Minuten: Python, Editor, Terminal

Bevor du irgendwas schreibst, kläre drei Dinge: Welche Python-Version läuft, mit welchem Editor arbeitest du, und welches Terminal nutzt du? Diese Basis spart später Zeit.

1. Python-Version prüfen
   • Windows: Terminal öffnen (Windows‑Taste → „cmd“ oder „PowerShell“) → py --version
   • macOS/Linux: Terminal → python3 --version oder python --version

   Empfehlung 2025: Python 3.12 oder neuer. Wenn du 3.10/3.11 hast, passt es meist auch. Falls gar nichts kommt: installiere Python.

2. Python installieren
   • Windows: python.org → Windows‑Installer. Beim Setup „Add Python to PATH“ anhaken. Alternativ: Microsoft Store.
   • macOS: Offizieller Installer von python.org oder Homebrew: brew install python
   • Ubuntu/Debian: sudo apt-get update && sudo apt-get install -y python3 python3-venv python3-pip

   Warum die offizielle Quelle? Stabil, sicher, und du bekommst die Standard‑Tools (pip, venv). Quelle: Python.org (Downloads), offizieller Installer.

3. Editor wählen

   VS Code ist für den Start top: kostenlos, schnell, Python‑Extension mit Debugger. Natürlich gehen auch PyCharm (Community) oder Sublime Text - aber VS Code hat die beste Mischung aus Einfachheit und Features.

4. Terminal kurz erklärt

   Du führst Skripte über das Terminal aus. Wechsle in den Ordner deines Projekts:

   # Windows (PowerShell)
   cd C:\Users\deinname\projekte\mein_skript
   
   # macOS/Linux
   cd ~/projekte/mein_skript
   

Pro‑Tipp: Unter Windows nutzt du oft den Befehl py; unter macOS/Linux python3. Wenn python auf Linux/macOS bereits Python 3 ist, kannst du python nutzen. Teste es mit python --version.

Erstes Skript step‑by‑step: schreiben, speichern, ausführen

Wir schreiben ein erstes Skript, führen es aus und machen es optional direkt „anklickbar“ (Linux/macOS) oder startbar per Doppelklick (Windows).

1. Projektordner anlegen

   mkdir mein_skript
   cd mein_skript
   

2. Datei erstellen: main.py

   print("Hallo, Python!")
   

   Speichere als main.py.

3. Skript ausführen
   • Windows: py main.py
   • macOS/Linux: python3 main.py (oder python main.py, je nach System)
4. Eingabe lesen und rechnen

   # main.py
   name = input("Wie heißt du? ")
   print(f"Hi {name}! ")
   
   zahl = int(input("Gib eine Zahl ein: "))
   print(f"Quadrat: {zahl ** 2}")
   

   Falls ValueError auftaucht: Du hast wahrscheinlich etwas eingegeben, das keine Zahl ist. Das fangen wir später ab.

5. „Anklickbar“ machen (Linux/macOS)

   # erste Zeile (Shebang) hinzufügen
   #!/usr/bin/env python3
   print("Start per Doppelklick/ausführbar")
   

   chmod +x main.py
   ./main.py
   

   Unter Windows kannst du .py via Doppelklick starten, oft öffnet sich aber nur kurz ein Fenster. Besser: Terminal nutzen oder eine .bat bauen, die py main.py aufruft.

Fehler, die jetzt häufig passieren

• IndentationError: In Python zählen Einrückungen. Nutze 4 Leerzeichen, keine Tabs.
• SyntaxError: Ein Anführungszeichen oder eine Klammer fehlt. Der Fehler zeigt die Zeile mit dem Problem.

Praktische Beispiele: Dateien, Argumente, Pakete, venv

Jetzt wird es nützlich: Dateien verarbeiten, Argumente annehmen, Pakete installieren - und das sauber in einer virtuellen Umgebung.

Datei lesen und schreiben

# read_write.py
from pathlib import Path

pfad = Path("daten.txt")

# Schreiben
pfad.write_text("Zeile 1\nZeile 2\n", encoding="utf-8")

# Lesen
inhalt = pfad.read_text(encoding="utf-8")
print("Dateiinhalt:\n", inhalt)

Pathlib löst Pfad-Probleme elegant - keine Backslash‑Hölle unter Windows. Achte auf encoding="utf-8", das vermeidet UnicodeDecodeError.

Argumente mit argparse

# cli.py
import argparse
from pathlib import Path

parser = argparse.ArgumentParser(description="Kopiert eine Datei an einen neuen Ort")
parser.add_argument("quelle", type=Path, help="Pfad zur Quelldatei")
parser.add_argument("ziel", type=Path, help="Pfad zur Zieldatei")
parser.add_argument("--force", action="store_true", help="Zieldatei überschreiben")

args = parser.parse_args()

if args.ziel.exists() and not args.force:
    raise FileExistsError(f"{args.ziel} existiert. Nutze --force, um zu überschreiben.")

args.ziel.write_bytes(args.quelle.read_bytes())
print(f"Kopiert: {args.quelle} → {args.ziel}")

Aufruf: Windows: py cli.py C:\\tmp\\a.txt C:\\tmp\\b.txt --force. macOS/Linux: python3 cli.py /tmp/a.txt /tmp/b.txt --force.

Virtuelle Umgebung (venv) und Pakete

1. Erstellen: python -m venv .venv
2. Aktivieren:
   • Windows (PowerShell): .\.venv\Scripts\Activate.ps1
   • Windows (CMD): .\.venv\Scripts\activate.bat
   • macOS/Linux: source .venv/bin/activate
3. Pakete installieren: pip install requests
4. Versionen einfrieren: pip freeze > requirements.txt
5. Später reproduzieren: pip install -r requirements.txt

Warum venv? Saubere Trennung der Abhängigkeiten pro Projekt. Quelle: Python Packaging User Guide (Offizielle Doku).

Kleines Tool: HTTP‑Request und JSON

# weather.py (Beispiel ohne echten API-Schlüssel)
import requests
import sys

stadt = sys.argv[1] if len(sys.argv) > 1 else "Berlin"
url = f"https://wttr.in/{stadt}?format=j1"  # einfache, öffentliche Wetter-API

r = requests.get(url, timeout=10)
if r.status_code != 200:
    raise SystemExit(f"HTTP-Fehler: {r.status_code}")

daten = r.json()

aktuell = daten["current_condition"][0]
print(f"{stadt}: {aktuell['temp_C']}°C, {aktuell['weatherDesc'][0]['value']}")

Hinweis: Für richtige APIs brauchst du üblicherweise einen Schlüssel. Dokumentation lesen, Rate Limits beachten. Quelle: Requests‑Dokumentation.

Fehler abfangen und loggen

# robust.py
import logging
from pathlib import Path

logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")

try:
    pfad = Path("daten.txt")
    text = pfad.read_text(encoding="utf-8")
except FileNotFoundError:
    logging.error("daten.txt fehlt. Bitte zuerst erzeugen.")
else:
    logging.info("Datei erfolgreich gelesen (%d Zeichen)", len(text))

Nutze logging für alles, was im Betrieb wichtig ist - print ist nur für schnelle Checks.

Checklisten, Best Practices und Spickzettel

Hier ist das, was dich in der Praxis schnell macht: klare Regeln, kurze Listen und ein kompakter Überblick.

Checkliste: Neues Skript starten

• Ordner anlegen, Git init (optional): git init
• venv erstellen und aktivieren
• main.py anlegen, Shebang (wenn Linux/macOS), docstring oben: Kurz sagen, was das Skript tut
• argparse planen (falls CLI), Pfade mit pathlib, Logs mit logging
• requirements.txt pflegen, .gitignore hinzufügen (.venv, __pycache__/)

Best Practices

• Stil: PEP 8 (offizieller Python Style Guide). 4 Leerzeichen pro Einrückung, snake_case für Funktionen/Variablen.
• Keine Magic Numbers: Konstanten oben definieren.
• Fehler eng fangen: außer bei klaren Fällen keine blanken excepts. Lieber konkrete Exceptions.
• Pfad‑Probleme vermeiden: pathlib statt os.path; encoding explizit setzen.
• Performance‑Regel: Erst korrekt, dann schnell. Messen mit time/perf_counter, nicht raten.
• Tests früh: pytest für kritische Funktionen, selbst wenn es nur 2-3 Tests sind.
• Automatische Qualität: black (Format), ruff oder flake8 (Lint), mypy (optional, Typen).

Spickzettel: Häufige OS‑Befehle

Häufige Stolperfallen

• pip vs pip3: Nimm einfach pip in der aktiven venv, dann passt es.
• ModuleNotFoundError: venv nicht aktiv oder falsches Python benutzt. Prüfen mit which python (macOS/Linux) bzw. Get-Command py (Windows PowerShell).
• UnicodeDecodeError: encoding="utf-8" beim Lesen setzen; bei CSVs explizit Dialekt/Delimiter angeben.
• Relative Pfade: Nutze Path(__file__).parent für projektbezogene Pfade.
• Zeilenenden: Git auf „autocrlf“ (Windows) oder Editor‑Standard setzen; Python kommt mit beidem klar, aber Mischformen nerven.

FAQ, Fehlersuche und nächste Schritte

Mini‑FAQ

• Welche Python‑Version soll ich nehmen? 3.12+ ist ein guter Standard 2025. Alles ab 3.10 ist für Lernprojekte ok. Quelle: Downloads und Release‑Hinweise auf Python.org.
• Brauche ich eine IDE? Nein. VS Code + Python‑Extension reicht. Für große Projekte ist PyCharm komfortabel.
• Wie plane ich Skripte zeitgesteuert? Windows: Aufgabenplanung. Linux/macOS: cron (z. B. crontab -e). Innerhalb von Python: schedule‑Paket.
• Wie baue ich eine EXE? pyinstaller kann aus Skripten ausführbare Dateien packen. Starte mit pip install pyinstaller und pyinstaller --onefile main.py.
• Wie lese ich große Dateien effizient? Datei zeilenweise streamen: for line in open(...) mit encoding="utf-8"; oder mit pathlib.Path.open() und Pufferung.
• Wo finde ich verlässliche Infos? Offizielle Python‑Doku (docs.python.org), PEP 8 Style Guide, Python Packaging User Guide. Das sind die Primärquellen.

Fehlersuche (Troubleshooting)

• „python nicht gefunden“:
  • Windows: Installer erneut ausführen und „Add Python to PATH“ aktivieren; oder py statt python.
  • macOS: Homebrew installieren, dann brew install python.
  • Linux: Paketmanager (apt/dnf/pacman) nutzen und python3 verwenden.
• ModuleNotFoundError: requests:
  • venv aktiv? Schau auf die Eingabezeile (sollte (venv) zeigen).
  • pip install requests in der venv ausführen.
  • Sicherstellen, dass du dasselbe Python nutzt: python -m pip install requests.
• IndentationError:
  • VS Code: unten rechts „Spaces: 4“; Ctrl+Shift+P → „Convert Indentation to Spaces“.
  • Keine Tabs mischen. Black‑Formatter aktivieren.
• UnicodeDecodeError beim Lesen:
  • open(datei, encoding="utf-8") oder Path(...).read_text(encoding="utf-8").
  • Wenn Datei ISO‑8859‑1 ist: encoding="latin-1" testen.
• Permission denied (Linux/macOS):
  • chmod +x main.py für Ausführrechte.
  • Ordnerrechte prüfen, nicht mit sudo „alles“ lösen.
• „pip“ installiert in falsches Python:
  • Immer: python -m pip install paket, dann stimmt die Zuordnung.

Nächste Schritte

• Struktur: Aus einem Ein‑Datei‑Skript ein Mini‑Projekt machen: src/‑Layout, Module, __main__.py.
• Qualität: black, ruff, pytest einrichten; VS Code Tasks/Debug‑Konfiguration anlegen.
• Verteilen: requirements.txt pflegen, README mit Beispielen, ggf. pyproject.toml (PEP 621) für Packaging.
• Lernen: Offizielle Docs zu argparse, logging, pathlib, itertools - die tragen weit.

Ein letzter Praxis‑Block, der oft Gold wert ist: defensive Programmierung. Prüfe Eingaben, gib klare Fehlermeldungen, und schreibe oben im Skript, was es tut, wie man es aufruft und welche Beispiele es gibt. Dein zukünftiges Ich wird dir danken.

Quellen, auf die ich mich stütze: Offizielle Python‑Dokumentation (docs.python.org), PEP 8 (Style Guide), Python Packaging User Guide, Requests‑Dokumentation, argparse‑Dokumentation. Diese Primärquellen sind der Standard für verlässliche Infos.