pip und Virtual Environments in Python

Was ist pip?

pip steht fuer “Pip Installs Packages” und ist der Package-Installer fuer Python. Damit kannst du tausende von Bibliotheken aus dem Internet herunterladen und in deinen Projekten verwenden.

# Pruefen, ob pip installiert ist
pip --version
# pip 24.0 from /usr/lib/python3.12/site-packages/pip (python 3.12)

Stell dir pip wie einen App Store fuer Python vor: Du sagst, was du brauchst, und pip laedt es herunter, installiert es und kuemmert sich um Abhaengigkeiten.

pip — Die wichtigsten Befehle

Packages installieren

# Ein Package installieren
pip install requests

# Eine bestimmte Version installieren
pip install requests==2.31.0

# Mindestversion angeben
pip install requests>=2.28.0

# Mehrere Packages auf einmal
pip install requests flask pandas

Packages entfernen

# Ein Package deinstallieren
pip uninstall requests

# Ohne Nachfrage deinstallieren
pip uninstall requests -y

Installierte Packages anzeigen

# Alle installierten Packages auflisten
pip list

# Beispielausgabe:
# Package    Version
# ---------- -------
# pip        24.0
# requests   2.31.0
# flask      3.0.0
# ...

Package-Informationen

# Details zu einem Package
pip show requests

# Ausgabe:
# Name: requests
# Version: 2.31.0
# Summary: Python HTTP for Humans.
# Home-page: https://requests.readthedocs.io
# ...

Veraltete Packages finden

# Zeige Packages, fuer die Updates verfuegbar sind
pip list --outdated

# Ein bestimmtes Package aktualisieren
pip install --upgrade requests

# pip selbst aktualisieren
pip install --upgrade pip

Freeze — Alle Versionen einfrieren

# Alle installierten Packages mit exakten Versionen ausgeben
pip freeze

# Ausgabe:
# certifi==2024.2.2
# charset-normalizer==3.3.2
# idna==3.6
# requests==2.31.0
# urllib3==2.2.0

PyPI — Der Python Package Index

PyPI (Python Package Index) ist die offizielle Quelle fuer Python-Packages. Unter pypi.org findest du ueber 500.000 Packages.

Wenn du pip install requests ausfuehrst, laedt pip das Package von PyPI herunter.

Packages auf PyPI suchen

# Im Terminal suchen
pip search requests  # Hinweis: Oft deaktiviert

# Besser: Direkt auf pypi.org suchen

Tipp: Suche lieber direkt auf pypi.org oder nutze eine Suchmaschine. Die pip search-Funktion ist auf den offiziellen Servern oft deaktiviert.

Warum Virtual Environments?

Stell dir folgendes Szenario vor:

• Projekt A braucht requests Version 2.28
• Projekt B braucht requests Version 2.31
• Beide Projekte sind auf dem gleichen Computer

Ohne Virtual Environments gibt es eine globale Python-Installation mit einer Version jedes Packages. Das fuehrt zu Konflikten!

Virtual Environments loesen dieses Problem: Jedes Projekt bekommt seine eigene, isolierte Python-Umgebung mit eigenen Packages.

Computer
├── Projekt A/
│   └── venv/          # Eigene Umgebung
│       └── requests 2.28
├── Projekt B/
│   └── venv/          # Eigene Umgebung
│       └── requests 2.31
└── System-Python      # Bleibt sauber

Vorteile:

• Keine Versionskonflikte zwischen Projekten
• Saubere System-Python-Installation (nicht mit Packages zugemuellt)
• Reproduzierbar: Andere Entwickler koennen exakt die gleiche Umgebung aufsetzen
• Einfach loeschbar: Virtual Environment loeschen und fertig

venv erstellen

Python bringt das Modul venv von Haus aus mit. So erstellst du ein Virtual Environment:

# In deinen Projektordner wechseln
cd mein_projekt

# Virtual Environment erstellen
python -m venv venv

Der letzte Parameter (venv) ist der Name des Ordners — du kannst ihn frei waehlen, aber venv ist die gaengige Konvention.

Was passiert dabei? Python erstellt einen Ordner mit:

venv/
├── bin/          (Linux/macOS) oder Scripts/ (Windows)
│   ├── python    # Eigene Python-Kopie
│   ├── pip       # Eigenes pip
│   └── activate  # Aktivierungsskript
├── lib/          # Hier landen installierte Packages
└── pyvenv.cfg    # Konfiguration

venv aktivieren

Nach dem Erstellen musst du das Virtual Environment aktivieren:

Windows (CMD)

venv\Scripts\activate

Windows (PowerShell)

venv\Scripts\Activate.ps1

Falls du in PowerShell eine Fehlermeldung bekommst, musst du die Ausfuehrungsrichtlinie aendern: Set-ExecutionPolicy -Scope CurrentUser RemoteSigned

macOS / Linux

source venv/bin/activate

Woher weiss ich, dass es aktiv ist?

Nach der Aktivierung siehst du den Namen des Environments in deiner Kommandozeile:

(venv) $ python --version
Python 3.12.0

(venv) $ pip list
Package    Version
---------- -------
pip        24.0

Die Klammern (venv) am Anfang zeigen dir: Du arbeitest jetzt in der isolierten Umgebung.

Deaktivieren

deactivate

Danach bist du wieder in der normalen System-Python-Umgebung.

requirements.txt — Abhaengigkeiten verwalten

Die Datei requirements.txt ist der Standard, um die Abhaengigkeiten eines Projekts festzuhalten. Andere Entwickler (oder du selbst auf einem anderen Computer) koennen damit exakt die gleiche Umgebung aufsetzen.

Erstellen

# Alle installierten Packages mit Versionen speichern
pip freeze > requirements.txt

Die Datei sieht dann so aus:

# requirements.txt
certifi==2024.2.2
charset-normalizer==3.3.2
flask==3.0.0
idna==3.6
requests==2.31.0
urllib3==2.2.0

Aus requirements.txt installieren

# Alle Packages aus der Datei installieren
pip install -r requirements.txt

Manuell pflegen

Du kannst die requirements.txt auch manuell erstellen und pflegen:

# requirements.txt -- Mein Webprojekt
flask>=3.0
requests>=2.28
python-dotenv>=1.0
gunicorn>=21.2

Hier werden Mindestversionen statt exakter Versionen angegeben — flexibler, aber weniger reproduzierbar.

Der typische Workflow

So sieht der Workflow fuer ein neues Python-Projekt aus:

# 1. Projektordner erstellen
mkdir mein_projekt
cd mein_projekt

# 2. Virtual Environment erstellen
python -m venv venv

# 3. Aktivieren
# Windows:
venv\Scripts\activate
# macOS/Linux:
source venv/bin/activate

# 4. Packages installieren
pip install requests flask

# 5. Abhaengigkeiten speichern
pip freeze > requirements.txt

# 6. Code schreiben und ausfuehren
python main.py

# 7. Am Ende: Deaktivieren
deactivate

Und wenn du das Projekt auf einem neuen Rechner einrichtest:

# 1. Projekt klonen (z.B. von GitHub)
git clone https://github.com/user/mein_projekt.git
cd mein_projekt

# 2. Virtual Environment erstellen
python -m venv venv

# 3. Aktivieren
source venv/bin/activate  # bzw. Windows-Variante

# 4. Abhaengigkeiten installieren
pip install -r requirements.txt

# 5. Fertig -- alles ist wie auf dem Originalrechner!

.gitignore nicht vergessen!

Der venv-Ordner gehoert nicht in die Versionskontrolle (Git). Er ist gross und kann auf jedem System neu erstellt werden. Fuege ihn zur .gitignore hinzu:

# .gitignore
venv/
__pycache__/
*.pyc
.env

Was soll ins Git-Repository:

• Dein Quellcode (.py-Dateien)
• requirements.txt
• Konfigurationsdateien

Was nicht ins Repository soll:

• venv/ (kann neu erstellt werden)
• __pycache__/ (kompilierter Bytecode)
• .env (Geheimnisse wie Passwoerter/API-Keys)

Populaere Python-Packages

Hier eine Auswahl beliebter Packages, die du mit pip installieren kannst:

Webentwicklung

Datenverarbeitung

HTTP und APIs

Werkzeuge

Praxis: requests installieren und nutzen

Lass uns ein echtes Package installieren und verwenden. requests ist die beliebteste Bibliothek fuer HTTP-Anfragen.

Installation

# Virtual Environment aktiv? Dann:
pip install requests

Einfache GET-Anfrage

import requests

# Daten von einer API abrufen
antwort = requests.get("https://jsonplaceholder.typicode.com/users/1")

# Statuscode pruefen
print(f"Status: {antwort.status_code}")  # 200 = Erfolg

# JSON-Daten auslesen
daten = antwort.json()
print(f"Name: {daten['name']}")
print(f"Email: {daten['email']}")
print(f"Stadt: {daten['address']['city']}")

Liste von Daten abrufen

import requests

antwort = requests.get("https://jsonplaceholder.typicode.com/posts")
beitraege = antwort.json()

print(f"Anzahl Beitraege: {len(beitraege)}")
print()

# Die ersten 5 Beitraege anzeigen
for beitrag in beitraege[:5]:
    print(f"#{beitrag['id']}: {beitrag['title'][:50]}...")

Fehlerbehandlung

import requests

def daten_abrufen(url):
    """Ruft Daten von einer URL ab mit Fehlerbehandlung."""
    try:
        antwort = requests.get(url, timeout=10)
        antwort.raise_for_status()  # Fehler bei 4xx/5xx
        return antwort.json()
    except requests.exceptions.ConnectionError:
        print("Keine Internetverbindung!")
        return None
    except requests.exceptions.Timeout:
        print("Zeitlimit ueberschritten!")
        return None
    except requests.exceptions.HTTPError as fehler:
        print(f"HTTP-Fehler: {fehler}")
        return None

# Test
daten = daten_abrufen("https://jsonplaceholder.typicode.com/users")
if daten:
    for benutzer in daten:
        print(f"  {benutzer['name']} ({benutzer['email']})")

Wetter-Abfrage (Beispiel-Konzept)

import requests

def wetter_abrufen(stadt):
    """
    Beispiel fuer eine Wetter-API-Abfrage.
    Hinweis: Du brauchst einen API-Key von einem Wetterdienst.
    """
    api_key = "dein_api_key_hier"  # z.B. von openweathermap.org
    url = f"https://api.openweathermap.org/data/2.5/weather"
    params = {
        "q": stadt,
        "appid": api_key,
        "units": "metric",
        "lang": "de"
    }

    antwort = requests.get(url, params=params, timeout=10)
    if antwort.status_code == 200:
        daten = antwort.json()
        print(f"Wetter in {stadt}:")
        print(f"  Temperatur: {daten['main']['temp']}°C")
        print(f"  Beschreibung: {daten['weather'][0]['description']}")
    else:
        print(f"Fehler: {antwort.status_code}")

# wetter_abrufen("Berlin")  # Braucht einen gueltigen API-Key

Uebungen

Uebung 1: Eigenes Projekt aufsetzen

Erstelle ein neues Projekt mit Virtual Environment und installiere requests:

# 1. Ordner erstellen
mkdir api_projekt
cd api_projekt

# 2. venv erstellen und aktivieren
python -m venv venv
source venv/bin/activate  # bzw. Windows-Variante

# 3. requests installieren
pip install requests

# 4. requirements.txt erstellen
pip freeze > requirements.txt

# 5. Pruefe den Inhalt
pip list

Uebung 2: API-Daten abrufen

Erstelle ein Skript, das Benutzerdaten von einer API abruft und huebsch formatiert ausgibt:

# api_benutzer.py
import requests

def benutzer_laden():
    """Laedt Benutzer von der JSONPlaceholder-API."""
    url = "https://jsonplaceholder.typicode.com/users"
    antwort = requests.get(url, timeout=10)
    antwort.raise_for_status()
    return antwort.json()

def benutzer_anzeigen(benutzer_liste):
    """Zeigt eine formatierte Liste der Benutzer an."""
    print("=" * 50)
    print("  BENUTZERLISTE")
    print("=" * 50)
    for b in benutzer_liste:
        print(f"\n  Name:    {b['name']}")
        print(f"  E-Mail:  {b['email']}")
        print(f"  Stadt:   {b['address']['city']}")
        print(f"  Firma:   {b['company']['name']}")
        print("-" * 50)

if __name__ == "__main__":
    try:
        benutzer = benutzer_laden()
        benutzer_anzeigen(benutzer)
    except Exception as fehler:
        print(f"Fehler beim Laden: {fehler}")

Uebung 3: requirements.txt verstehen

Erstelle manuell eine requirements.txt fuer ein Webprojekt und installiere die Packages:

# requirements.txt
flask>=3.0
requests>=2.28
python-dotenv>=1.0

pip install -r requirements.txt
pip list  # Pruefe, was installiert wurde

# Mit Python 3.11 erstellen
python3.11 -m venv venv

# Mit Python 3.12 erstellen
python3.12 -m venv venv

# Auf Windows oft:
py -3.12 -m venv venv