FAQ-Glossar zur Python Schulung

In der Python Schulung verbinden wir saubere Sprachelemente mit praxisnahen Aufgaben: Daten einlesen, transformieren, auswerten und automatisieren. Wir legen Wert auf lesbaren Code (PEP 8), kleine Funktionen, Tests und reproduzierbare Umgebungen (venv).

Beispielcode aus der Python Schulung:

# Mini-Beispiel aus der Python Schulung
name = 'SemaTrain'
print(f'Willkommen zur Python Schulung bei {name}!')

f-Strings für klare Formatierung; sofort sichtbares Feedback am Terminal.

Python steuert Blöcke über Einrückungen statt Klammern. In der Python Schulung nutzen wir 4 Leerzeichen als Standard und vermeiden gemischte Einrückungen.

Beispielcode aus der Python Schulung:

for i in range(3):
    print('Tag', i+1)

Einrückungen definieren den Schleifenkörper; kein zusätzliches begin/end nötig.

Integers, Floats, Booleans und Strings bilden das Fundament. Wir üben Umwandlungen (str(), int(), float()) und nutzen Typannotationen für bessere Lesbarkeit.

Beispielcode aus der Python Schulung:

tage: int = 4
online: bool = True
preis: float = 450.0
kurs: str = 'Python Grundlagen'

Optionale Typannotationen verbessern Tooling (z. B. mypy) und Dokumentation.

Liste: geordnete Sammlung; Tupel: unveränderliche Gruppe; Set: einzigartige Elemente; Dict: Schlüssel→Wert. Wir wählen nach Zugriffsmuster, Änderungsbedarf und Speicherverhalten.

Beispielcode aus der Python Schulung:

teilnehmer = ['Anna', 'Bernd', 'Carla']
tage = (1, 2, 3, 4)
themen = {'Syntax', 'Funktionen', 'Pandas'}
agenda = {'Tag1': 'Syntax', 'Tag2': 'Funktionen'}

Dicts zum Nachschlagen, Sets zum Entduplizieren, Tupel als feste Rückgaben.

Mit if/elif/else steuern wir den Ablauf. Wir achten auf sprechende Bedingungen, nutzen truthy/falsy bewusst und vermeiden verschachtelte Kaskaden.

Beispielcode aus der Python Schulung:

ist_online = True
if ist_online:
    ort = 'Online'
else:
    ort = 'Hamburg'

Klarer Pfad pro Fall; ternäre Ausdrücke nur für sehr kurze Alternativen.

for für Iteration über Sequenzen/Iteratoren, while für bedingte Wiederholung. Wir bevorzugen for und List Comprehensions für deklarative Datentransformationen.

Beispielcode aus der Python Schulung:

themen = ['Syntax', 'Funktionen', 'Pandas']
for t in themen:
    print('Thema:', t)

enumerate() für Indizes, range() für Zähler; explizite, gut lesbare Iteration.

Kleine, fokussierte Funktionen mit klaren Parametern, Rückgabe und Docstring. Vorbedingungen früh prüfen, Fehler klar melden.

Beispielcode aus der Python Schulung:

def tagespreis(preis_pro_tag: float, tage: int) -> float:
    """Berechnet den Gesamtpreis der Python Schulung."""
    if tage <= 0:
        raise ValueError('tage > 0')
    return preis_pro_tag * tage

Vorbedingung prüfen, dann rechnen – ideal für Unit-Tests.

Comprehensions drücken Transformation + Filter kompakt und lesbar aus. Wir verwenden sie, wenn eine Zeile die Intention klar transportiert.

Beispielcode aus der Python Schulung:

namen = ['anna', 'bernd', 'carla']
upper = [n.upper() for n in namen if n.startswith('a')]

Deklarative Schreibweise statt Schleife + append – solange gut lesbar.

Wir teilen Code in Module/Packages, importieren gezielt statt wildcards und gruppieren Imports konsistent. Absolute Imports bevorzugt, relative sparsam.

Beispielcode aus der Python Schulung:

from pathlib import Path
import json

Standardbibliothek zuerst, dann Drittanbieter, dann eigene Pakete.

Mit virtuellen Umgebungen (venv) isolieren wir Pakete pro Projekt; pip installiert gezielt. Versionen frieren wir in requirements.txt ein.

Beispielcode aus der Python Schulung:

python -m venv .venv
source .venv/bin/activate  # Windows: .venv\Scripts\activate
pip install pandas==2.2.2
pip freeze > requirements.txt

Reproduzierbare Umgebungen vermeiden „Works on my machine“-Effekte.

Mit Context Manager (with open(...)) sind Dateien sicher geöffnet/geschlossen. Wir achten auf Encodings und nutzen pathlib für portable Pfade.

Beispielcode aus der Python Schulung:

from pathlib import Path

pfad = Path('teilnehmer.txt')
with pfad.open('r', encoding='utf-8') as f:
    for zeile in f:
        print(zeile.strip())

with garantiert Schließen; pathlib ist portabel und aussagekräftig.

Gezielt abfangen, klare Messages, nicht alles pauschal try/except. Eigene Exception-Klassen bei Bedarf; Logging statt print für Diagnosen.

Beispielcode aus der Python Schulung:

try:
    betrag = float('450,00')  # löst ValueError aus
except ValueError as ex:
    print('Ungültiger Betrag:', ex)

Nur erwartete Fehler abfangen; ansonsten früh scheitern und testen.

Wir nutzen das logging-Modul mit Leveln (INFO/WARNING/ERROR) und strukturierten Nachrichten. Konfiguration zentral; keine sensiblen Daten loggen.

Beispielcode aus der Python Schulung:

import logging
logging.basicConfig(level=logging.INFO)
logging.info('Start Python Schulung')

Konsistente Logs verkürzen die Fehlersuche – besonders in Automationsskripten.

Für robuste Textsuche/Validierung (E-Mail, IDs). Wir kapseln Muster und testen Randfälle mit Beispielen.

Beispielcode aus der Python Schulung:

import re
mail = 'anna@example.org'
ok = bool(re.fullmatch(r'[^@]+@[^@]+\.[^@]+', mail))

re.fullmatch für vollständige Übereinstimmung; Muster in Konstanten ablegen.

Mit json/csv aus der Standardbibliothek; bei größeren Datenmengen mit Pandas. Wir achten auf Dialekte, Trennzeichen und Unicode.

Beispielcode aus der Python Schulung:

import json, csv
data = json.loads('{"kurs":"Python"}')
with open('teilnehmer.csv','w',newline='',encoding='utf-8') as f:
    w = csv.writer(f, delimiter=';')
    w.writerow(['name','email'])

Standardbibliothek reicht oft; Pandas für komfortables Lesen/Filtern/Export.

Gemeinsamer Stil erhöht Lesbarkeit und Teamgeschwindigkeit. Wir nutzen Formatter/Checker (black, ruff) und Typchecker (mypy).

Beispielcode aus der Python Schulung:

pip install black ruff mypy
black .
ruff check .
mypy src/

Automatisierte Qualitätssicherung lässt uns Inhalte statt Formatierung diskutieren.

Wir modellieren domänennah, halten Klassen klein und bevorzugen Komposition vor Vererbung. Datentransfer ab Python 3.7+ oft als dataclass.

Beispielcode aus der Python Schulung:

class Kurs:
    def __init__(self, titel: str, tage: int) -> None:
        self.titel = titel
        self.tage = tage

__init__ initialisiert gültige Objekte; öffentliche API bleibt minimal.

dataclass reduziert Boilerplate für einfache Datencontainer und integriert gut mit Typprüfern.

Beispielcode aus der Python Schulung:

from dataclasses import dataclass

@dataclass(frozen=True)
class Teilnehmer:
    name: str
    email: str

frozen=True erzeugt unveränderliche Instanzen – hilfreich für Hashbarkeit und Sicherheit.

Optionale Typen verbessern Tooling und Verständlichkeit. Wir nutzen builtins (list[str], dict[str,int]) sowie Optional/Union.

Beispielcode aus der Python Schulung:

from typing import Optional

def finde(name: str, namen: list[str]) -> Optional[int]:
    try:
        return namen.index(name)
    except ValueError:
        return None

Rückgabewert kann fehlen → Optional. mypy erkennt Inkonsistenzen früh.

Für speichereffiziente Pipelines (lazy). yield ermöglicht Streams ohne Listenmaterialisierung.

Beispielcode aus der Python Schulung:

def zeilen(pfad):
    with open(pfad, encoding='utf-8') as f:
        for z in f:
            yield z.strip()

Große Dateien zeilenweise verarbeiten – geringe Speicherlast, gute Performance.

Dekoratoren kapseln Querschnittsaufgaben (Caching, Timing, Auth). Wir achten auf functools.wraps für Erhalt von Metadaten.

Beispielcode aus der Python Schulung:

import time, functools

def timed(fn):
    @functools.wraps(fn)
    def inner(*a, **kw):
        t0 = time.perf_counter()
        try:
            return fn(*a, **kw)
        finally:
            print('dauer:', time.perf_counter()-t0)
    return inner

wraps bewahrt __name__/Docstring – wichtig für Debugging und Doku.

Kleine, deterministische Tests nach Arrange–Act–Assert. pytest für lesbare Assertions und Fixtures; CI optional als Bonus.

Beispielcode aus der Python Schulung:

def test_tagespreis():
    assert tagespreis(450.0, 4) == 1800.0

Kurze, sprechende Tests sichern Verhalten und erleichtern Refactoring.

DataFrames für tabellarische Daten: Einlesen, Filtern, Gruppieren, Export. Wir üben idiomatische, vektorisierte Operationen statt Python-Schleifen.

Beispielcode aus der Python Schulung:

import pandas as pd
df = pd.read_csv('teilnehmer.csv', sep=';')
df = df[df['name'].str.startswith('A')]

Vektorisiertes Filtern ist kurz und performant – keine explizite Schleife nötig.

Für numerische Arrays und Vektoroperationen, als Basis vieler Daten-/ML-Bibliotheken. Wir zeigen Zusammenspiel mit Pandas.

Beispielcode aus der Python Schulung:

import numpy as np
a = np.array([1,2,3,4], dtype=float)
b = a * 1.19

Vektoroperationen sind kurz und effizient – ideal für Berechnungen.

Mit Matplotlib erzeugen wir schnelle Diagramme; für Bequemlichkeit oft pandas.DataFrame.plot(). Wir achten auf Achsen, Labels und klare Botschaften pro Chart.

Beispielcode aus der Python Schulung:

import matplotlib.pyplot as plt
werte = [3,4,2,5]
plt.plot(werte)
plt.title('Buchungen/Tag')

Schnelles Linienchart für erste Einblicke – Achsen/Labels nach Bedarf ergänzen.

Für schnelle Exercises: sqlite3 (Standardbibliothek). Für Portabilität/ORM: SQLAlchemy (Core/ORM). Wir demonstrieren sichere Parametrisierung und Verbindungspools.

Beispielcode aus der Python Schulung:

import sqlite3
con = sqlite3.connect(':memory:')
cur = con.cursor()
cur.execute('CREATE TABLE teilnehmer(name TEXT)')
cur.execute('INSERT INTO teilnehmer VALUES (?)', ('Anna',))
con.commit()

Parametrisierung verhindert SQL-Injection; für größere Projekte nutzen wir SQLAlchemy.

Mit requests rufen wir REST-Endpunkte ab und verarbeiten JSON. Timeouts, Retry-Strategien und Fehlerprüfung gehören dazu.

Beispielcode aus der Python Schulung:

import requests
resp = requests.get('https://api.example.org/courses', timeout=5)
resp.raise_for_status()
data = resp.json()

raise_for_status() macht HTTP-Fehler sichtbar; JSON sofort nutzbar.

Mit Flask zeigen wir den minimalen Einstieg: Routing, Templates und JSON-Antworten. Für wachsende Apps empfehlen wir Blueprints und ein klares Projektlayout.

Beispielcode aus der Python Schulung:

from flask import Flask, jsonify
app = Flask(__name__)

@app.get('/ping')
def ping():
    return jsonify({'ok': True})

Kleiner Service für Healthchecks/Integrationen; deploybar als WSGI/ASGI.

Bei vielen I/O-gebundenen Tasks (HTTP, Dateien, Sockets). Wir erklären Event-Loop, await und Task-Koordination – und wann CPU-Bound Alternativen brauchen.

Beispielcode aus der Python Schulung:

import asyncio

async def hello():
    await asyncio.sleep(0.1)
    return 'hi'

print(asyncio.run(hello()))

Nicht für CPU-Bound – dort multiprocessing/NumPy einsetzen.

Threads für I/O-Bound, Multiprocessing für CPU-Bound Workloads. Wir berücksichtigen GIL, Prozesse vs. Threads und sichere Kommunikation.

Beispielcode aus der Python Schulung:

from concurrent.futures import ThreadPoolExecutor

def download(url: str) -> bytes:
    ...

with ThreadPoolExecutor() as ex:
    results = list(ex.map(download, ['u1','u2']))

Hoher I/O-Durchsatz über Thread-Pools; CPU-lastig → ProcessPoolExecutor.

Pfadobjekte sind portabel und lesbarer als String-Pfad-Bastelei. Globbing, Joinen, Lesen/Schreiben sind integriert.

Beispielcode aus der Python Schulung:

from pathlib import Path
for p in Path('data').glob('*.csv'):
    print(p.name)

Kürzere, robuste Dateiarbeit; weniger Fehler durch falsche Trennzeichen.

Wir lesen Settings aus Umgebungsvariablen/.env und vermeiden Hardcoding. Secrets gehören in sichere Stores – nicht ins Repo.

Beispielcode aus der Python Schulung:

import os
dsn = os.getenv('DATABASE_URL', 'sqlite:///local.db')

Konfiguration bleibt getrennt vom Code – erleichtert Deployment und Tests.

Mit pyproject.toml und src-Layout. Wir definieren Abhängigkeiten und nutzen Build-Tools (pip, hatch/poetry – je nach Team).

Beispielcode aus der Python Schulung:

[project]
name = 'seminar-tools'
version = '0.1.0'
requires-python = '>=3.10'

Klares Projektsetup erleichtert Testing, CI und Distribution.

Bausteine für effiziente Iterator-Pipelines (chain, groupby, islice). Wir ersetzen damit oft Hilfslisten und sparen Speicher.

Beispielcode aus der Python Schulung:

from itertools import islice
first_ten = list(islice(range(1000), 10))

Lazy-Slicing großer Streams – schnell und speicherschonend.

Erst messen, dann optimieren (time/perf_counter, cProfile). Vektorisierung mit NumPy/Pandas, passende Datenstrukturen, I/O bündeln.

Beispielcode aus der Python Schulung:

import time
t0 = time.perf_counter()
# ... Arbeit ...
print('dauer:', time.perf_counter()-t0)

Messen verhindert Scheinoptimierungen und fokussiert die Maßnahmen.

Eingaben validieren, Parametrisierung bei DB/HTTP, Secrets schützen, abhängige Pakete prüfen und aktualisieren (z. B. pip-audit).

Beispielcode aus der Python Schulung:

pip install pip-audit
pip-audit

Regelmäßige Audits und Updates reduzieren Angriffsflächen merklich.