Module und Pakete: import, pip, venv

Im Kurs Python Grundlagen hast du gelernt, einzelne Skripte zu schreiben. Sobald ein Projekt wächst, willst du den Code aber auf mehrere Dateien aufteilen und externe Bibliotheken nutzen. Genau hier kommen Module und Pakete ins Spiel – die Bausteine, mit denen du in Python größere Anwendungen strukturierst.

Diese Lektion zeigt dir, wie du eigene Module schreibst, sie zu Paketen zusammenfasst, wie der import-Mechanismus funktioniert, wie du externe Bibliotheken mit pip installierst und warum du fast immer eine virtuelle Umgebung (venv) dafür nutzen solltest.

1) Was ist ein Modul?

Ein Modul ist in Python schlicht eine Datei mit der Endung .py. Jede Datei kann Funktionen, Klassen und Variablen enthalten – und wenn du sie importierst, sind diese in deinem Programm verfügbar.

# Datei: mathe.py
def addiere(a, b):
    return a + b

def multipliziere(a, b):
    return a * b

PI = 3.14159

# Datei: hauptprogramm.py
import mathe

ergebnis = mathe.addiere(2, 3)
print(ergebnis)         # 5
print(mathe.PI)         # 3.14159

Ein Modul wiederzuverwenden ist so einfach. Du musst die Datei nur im selben Verzeichnis (oder im Python-Pfad) haben. Mehr dazu in Abschnitt 7.

2) import-Varianten

Es gibt verschiedene Wege, Inhalte aus einem Modul zu importieren. Die wichtigsten:

Beispiele:

import mathe
print(mathe.addiere(2, 3))

import mathe as m
print(m.addiere(2, 3))

from mathe import addiere
print(addiere(2, 3))

from mathe import addiere as plus
print(plus(2, 3))

3) Was ist ein Paket?

Ein Paket ist ein Verzeichnis, das mehrere Module bündelt. Es enthält in der Regel eine Datei __init__.py, die den Inhalt als Paket markiert (seit Python 3.3 optional, aber häufig genutzt).

4) Import aus Paketen

# Modul im Paket importieren
import werkzeuge.mathe
werkzeuge.mathe.addiere(2, 3)

# Untermodul direkt
from werkzeuge import mathe
mathe.addiere(2, 3)

# Funktion direkt
from werkzeuge.mathe import addiere
addiere(2, 3)

# Tiefer verschachtelt
from werkzeuge.datum.formate import formatiere

5) Was steht in __init__.py?

Die Datei __init__.py wird beim Importieren des Pakets automatisch ausgeführt. Sie kann:

• leer sein (markiert nur das Paket – funktioniert)
• Initialisierungscode enthalten, der einmal beim ersten Import läuft
• Imports aus Untermodulen bündeln, damit Nutzer kürzer schreiben können
• eine Variable __all__ definieren, die steuert, was bei from paket import * mitkommt

# werkzeuge/__init__.py
from .mathe import addiere, multipliziere
from .strings import kleinbuchstaben

__version__ = "1.0"

Mit den obigen Imports in der __init__.py kann jetzt der Nutzer from werkzeuge import addiere schreiben statt from werkzeuge.mathe import addiere. Praktisch, wenn das Paket eine schlanke Außen-API haben soll.

6) Relative Imports

Innerhalb eines Pakets kannst du Geschwister-Module relativ importieren – mit Punkten:

# In werkzeuge/strings.py
from . import mathe          # Geschwister-Modul
from .mathe import addiere   # Funktion aus Geschwister
from .datum import parser    # Modul aus Sub-Paket
from .. import hauptprogramm # Eltern-Paket (zwei Punkte)

Ein Punkt = aktuelles Paket, zwei Punkte = Eltern-Paket, drei = Großeltern usw. Relative Imports sind nur innerhalb von Paketen erlaubt – nicht in Skripten, die direkt ausgeführt werden.

7) Wie findet Python ein Modul?

Wenn du import x schreibst, sucht Python in einer bestimmten Reihenfolge:

1. Im aktuellen Skript-Verzeichnis (bzw. dem Ausführungs-Verzeichnis)
2. In den Verzeichnissen aus der Umgebungsvariable PYTHONPATH
3. In den Standard-Bibliotheks-Verzeichnissen (kommen mit Python mit)
4. Im site-packages-Verzeichnis (dort liegen mit pip installierte Pakete)

Die komplette Liste siehst du in sys.path:

import sys
print(sys.path)
# ['', '/usr/lib/python3.11', '/usr/lib/python3.11/site-packages', ...]

Der erste leere String steht für „aktuelles Verzeichnis" – deswegen findet Python deine eigenen Module ohne Konfiguration.

8) Die Standardbibliothek

Python kommt mit einer riesigen Standardbibliothek: hunderte Module für alle möglichen Aufgaben, die du ohne Installation nutzen kannst. Ein paar wichtige:

Beispiel-Nutzung:

import json
from datetime import datetime
from pathlib import Path

daten = {"name": "Anna", "datum": datetime.now().isoformat()}
Path("k.json").write_text(json.dumps(daten))

9) pip – externe Pakete installieren

Was die Standardbibliothek nicht hat, holt sich Python aus dem Python Package Index (PyPI) – das offizielle Paket-Repository mit über einer halben Million Pakete. Verwaltet wird das alles mit dem Werkzeug pip:

10) Wichtige PyPI-Pakete

Die Standard-Werkzeuge in fast jedem Python-Projekt:

11) Virtuelle Umgebungen mit venv

Ein häufiges Problem: Projekt A braucht requests==2.30, Projekt B braucht requests==2.31. Installierst du beide systemweit, kollidieren sie. Die Lösung: virtuelle Umgebungen. Jedes Projekt bekommt seine eigene isolierte Python-Installation mit eigenen Paketen.

12) venv anlegen und nutzen

Die Schritte:

# 1. Virtuelle Umgebung erzeugen (im Projekt-Verzeichnis)
python3 -m venv .venv

# 2. Aktivieren
# Linux/Mac:
source .venv/bin/activate
# Windows (PowerShell):
.venv\Scripts\Activate.ps1
# Windows (cmd):
.venv\Scripts\activate.bat

# 3. Pakete installieren (landen nur in .venv)
pip install requests pandas

# 4. Arbeiten...

# 5. Deaktivieren (zurück zum System-Python)
deactivate

Nach activate siehst du in deiner Shell ein (.venv) vor dem Prompt – das zeigt, dass die Umgebung aktiv ist. Alle python- und pip-Aufrufe wirken jetzt nur in dieser Umgebung.

13) requirements.txt – reproduzierbare Umgebungen

Damit andere genau dieselbe Umgebung bekommen wie du, fixiert man die Versionen in einer Datei:

# requirements.txt
requests==2.31.0
pandas==2.1.4
pytest==7.4.3

Erzeugen mit pip freeze > requirements.txt, nachladen mit pip install -r requirements.txt. In modernen Projekten ersetzt die pyproject.toml diese Form zunehmend – sie enthält neben Abhängigkeiten auch Projekt-Metadaten und Build-Konfiguration.

14) Das __name__ == "__main__"-Muster

Eine Python-Datei kann zwei Rollen haben: Modul (wird importiert) oder Skript (wird direkt ausgeführt). Mit der speziellen Variable __name__ unterscheidet man:

# mathe.py
def addiere(a, b):
    return a + b

if __name__ == "__main__":
    # läuft nur, wenn die Datei DIREKT ausgeführt wird
    print("Selbsttest:")
    print(addiere(2, 3))

Wenn du python mathe.py startest, läuft der untere Block. Wenn jemand import mathe schreibt, wird der Block übersprungen. Damit kann eine Datei sowohl als Bibliothek dienen als auch eigenständig laufen – ideal für Selbsttests und kleine CLI-Tools.

15) Häufige Fehler

• ModuleNotFoundError: das Modul liegt nicht im Suchpfad. Prüfe das Verzeichnis und ob die venv aktiv ist
• Zirkuläre Imports: A importiert B, B importiert A. Lösung: gemeinsame Funktionen in ein drittes Modul auslagern
• Globale Installation statt venv: pip install ohne aktive venv installiert systemweit. Auf manchen Systemen sogar mit Fehler („externally-managed-environment")
• import * verwendet: Namensraum wird unkontrolliert gefüllt, später schwer zu warten
• requirements.txt ohne Versionen: requests statt requests==2.31.0 – andere bekommen eine andere Version, plötzlich funktioniert nichts mehr
• Modul mit reserviertem Namen: eine eigene Datei random.py oder json.py kann den Import des Standard-Moduls verhindern
• Aktivierung vergessen: pip installiert in der falschen Umgebung – immer den (.venv)-Indikator im Prompt prüfen

Zusammenfassung

Ein Modul in Python ist eine .py-Datei, ein Paket ein Verzeichnis mit (meist) einer __init__.py. Mit import bindest du sie ein – verschiedene Varianten je nach Bedarf: ganzes Modul, einzelne Funktion, mit Alias. Python sucht Module in sys.path; eigene Skripte liegen meist im aktuellen Verzeichnis, Standardbibliothek und mit pip installierte Pakete im site-packages-Verzeichnis. Externe Pakete kommen vom Python Package Index (PyPI). Praktisch immer empfehlenswert: eine eigene virtuelle Umgebung mit venv pro Projekt – verhindert Versionskonflikte. requirements.txt oder pyproject.toml machen Umgebungen reproduzierbar. Das Idiom if __name__ == "__main__": erlaubt Dateien, sowohl als Modul als auch als Skript zu funktionieren.