Kostenlose Tutorials für Anfänger

Appearance

Kapitel 18: Code-Standards und Sicherheit ​

🎯 Lernziele ​

In diesem Kapitel wirst du:

  • Bewährte Praktiken für Python-Code kennenlernen
  • Sicherheitsüberlegungen bei der Python-Programmierung verstehen
  • Fehlerbehebungsstrategien erlernen
  • Werkzeuge zur Code-Analyse kennenlernen

18.1 Bewährte Praktiken (Best Practices) ​

📏 PEP 8 - Der Python Style Guide ​

PEP 8 ist der offizielle Style Guide für Python-Code. Hier sind die wichtigsten Regeln:

1. Einrückung (Indentation) ​

python
# Richtig: 4 Leerzeichen
def funktion():
    if True:
        return True

# Falsch: Tabs oder andere Einrücktiefen
def funktion():
  if True:      # Falsch: 2 Leerzeichen
      return True

2. Maximale Zeilenlänge ​

python
# Richtig: Zeilen unter 79-100 Zeichen
def lange_funktion_mit_vielen_parametern(
    parameter1, parameter2, parameter3,
    parameter4, parameter5
):
    pass

# Lange Strings aufteilen
langer_string = (
    "Dies ist ein sehr langer String, der "
    "auf mehrere Zeilen aufgeteilt wurde."
)

3. Leerzeichen in Ausdrücken ​

python
# Richtig
x = 1
y = 2
lange_liste = [1, 2, 3, 4, 5]

# Falsch
x=1
y  =  2
lange_liste = [ 1,2,3,4,5 ]

4. Benennungskonventionen ​

python
# Variablen und Funktionen: snake_case
meine_variable = 10
def berechne_durchschnitt(liste):
    pass

# Klassen: PascalCase
class MeineKlasse:
    pass

# Konstanten: UPPER_CASE
MAX_WERT = 100
PI = 3.14159

# Private Attribute: _unterstrich
class Beispiel:
    def __init__(self):
        self._private_attribut = 42

📝 Dokumentationsstrings (Docstrings) ​

python
def berechne_fläche(länge, breite):
    """
    Berechnet die Fläche eines Rechtecks.
    
    Argumente:
        länge (float): Die Länge des Rechtecks
        breite (float): Die Breite des Rechtecks
    
    Rückgabe:
        float: Die berechnete Fläche
    """
    return länge * breite

class Person:
    """
    Eine Klasse zur Repräsentation einer Person.
    
    Attribute:
        name (str): Der Name der Person
        alter (int): Das Alter der Person
    """
    def __init__(self, name, alter):
        self.name = name
        self.alter = alter

✅ Code-Linting mit pylint und flake8 ​

bash
# Installation
pip install pylint flake8

# Verwendung
pylint meine_datei.py
flake8 meine_datei.py

18.2 Sicherheitsüberlegungen ​

🔒 Häufige Sicherheitsrisiken ​

1. SQL-Injection ​

python
# UNSICHER!
def unsichere_abfrage(benutzer_eingabe):
    abfrage = f"SELECT * FROM benutzer WHERE name = '{benutzer_eingabe}'"
    cursor.execute(abfrage)

# SICHER!
def sichere_abfrage(benutzer_eingabe):
    abfrage = "SELECT * FROM benutzer WHERE name = ?"
    cursor.execute(abfrage, (benutzer_eingabe,))

2. Command Injection ​

python
# UNSICHER!
import os
def unsichere_dateiausführung(dateiname):
    os.system(f"ls -l {dateiname}")

# SICHER!
import subprocess
def sichere_dateiausführung(dateiname):
    subprocess.run(["ls", "-l", dateiname])

3. Unsichere Deserialisierung ​

python
# UNSICHER! (Verwendung von pickle mit nicht-vertrauenswürdigen Daten)
import pickle
def unsicheres_laden(datei_pfad):
    with open(datei_pfad, 'rb') as f:
        daten = pickle.load(f)  # Gefährlich!
    return daten

# SICHER! (Verwendung von JSON)
import json
def sicheres_laden(datei_pfad):
    with open(datei_pfad, 'r') as f:
        daten = json.load(f)
    return daten

4. Hardcoded Secrets ​

python
# UNSICHER!
api_key = "mein_geheimer_schlüssel123"

# SICHER!
import os
api_key = os.environ.get("API_KEY")

🛡️ Sicherheits-Best Practices ​

  1. Verwende immer parametrisierte Abfragen für Datenbanken
  2. Validiere und bereinige alle Benutzereingaben
  3. Verwende Umgebungsvariablen für sensible Daten
  4. Aktualisiere Abhängigkeiten regelmäßig
  5. Verwende HTTPS für API-Aufrufe
  6. Implementiere ordnungsgemäße Authentifizierung und Autorisierung

18.3 Fehlerbehebung und Debugging ​

🐛 Häufige Fehlertypen ​

1. Syntaxfehler ​

python
# Syntaxfehler: Falsche Einrückung
def funktion():
print("Hallo")  # IndentationError

# Syntaxfehler: Fehlendes Doppelpunkt
if True  # SyntaxError
    print("Hallo")

2. Laufzeitfehler (Runtime Errors) ​

python
# ZeroDivisionError
zahl = 10 / 0  # ZeroDivisionError

# TypeError
zahl = 10 + "5"  # TypeError

# IndexError
liste = [1, 2, 3]
element = liste[5]  # IndexError

# KeyError
wörterbuch = {"a": 1}
wert = wörterbuch["b"]  # KeyError

3. Logische Fehler ​

python
# Logischer Fehler: Falsche Bedingung
alter = 20
if alter >= 18:
    print("Minderjährig")  # Falsche Ausgabe!
else:
    print("Volljährig")

🔍 Debugging-Techniken ​

1. Print-Debugging ​

python
def berechnung(a, b):
    ergebnis = a + b
    print(f"Debug: a={a}, b={b}, ergebnis={ergebnis}")  # Debug-Ausgabe
    return ergebnis

2. Verwendung des pdb-Debuggers ​

python
import pdb

def problematische_funktion():
    x = 10
    y = 0
    pdb.set_trace()  # Debugger-Haltepunkt
    ergebnis = x / y  # ZeroDivisionError
    return ergebnis

3. Verwendung einer IDE (PyCharm, VS Code) ​

  • Setze Haltepunkte (Breakpoints)
  • Untersuche Variablenwerte
  • Schreite durch den Code zeilenweise

📊 Logging ​

python
import logging

# Logging konfigurieren
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(levelname)s - %(message)s',
    filename='app.log',
    filemode='w'
)

# Verschiedene Log-Level
logging.debug("Dies ist eine Debug-Nachricht")
logging.info("Dies ist eine Info-Nachricht")
logging.warning("Dies ist eine Warnung")
logging.error("Dies ist eine Fehlermeldung")
logging.critical("Dies ist eine kritische Meldung")

def division(a, b):
    try:
        ergebnis = a / b
        logging.info(f"Division erfolgreich: {a} / {b} = {ergebnis}")
        return ergebnis
    except ZeroDivisionError:
        logging.error(f"Division durch Null: {a} / {b}")
        return None

18.4 Nützliche Werkzeuge ​

🔧 Statische Code-Analyse ​

  1. pylint - Überprüft Code auf Fehler und Style-Verstöße
  2. flake8 - Kombiniert PyFlakes, pycodestyle und McCabe
  3. mypy - Statische Typüberprüfung für Python
  4. bandit - Sucht nach Sicherheitsproblemen in Python-Code

📦 Virtuelle Umgebungen ​

bash
# Erstellen einer virtuellen Umgebung
python -m venv mein_venv

# Aktivieren der virtuellen Umgebung
# Windows:
mein_venv\Scripts\activate
# macOS/Linux:
source mein_venv/bin/activate

# Deaktivieren
deactivate

📋 Requirements-Datei ​

txt
# requirements.txt
flask==2.0.1
numpy>=1.21.0
pandas>=1.3.0
requests>=2.26.0
bash
# Installation aller Abhängigkeiten
pip install -r requirements.txt

# Generieren einer requirements.txt
pip freeze > requirements.txt

📝 Zusammenfassung ​

In diesem Kapitel hast du gelernt:

  • ✅ Die bewährten Praktiken für Python-Code (PEP 8)
  • ✅ Sicherheitsüberlegungen und häufige Risiken
  • ✅ Techniken zur Fehlerbehebung und Debugging
  • ✅ Nützliche Werkzeuge für die Python-Entwicklung

🎯 Übung ​

  1. Analysiere deinen eigenen Code mit pylint oder flake8
  2. Implementiere ein sicheres Datenbankabfrage-Beispiel
  3. Verwende den pdb-Debugger, um einen Fehler in deinem Code zu finden
  4. Erstelle eine requirements.txt für eines deiner Projekte

⏭️ Nächstes Kapitel ​

In Kapitel 19 werden wir häufige Fehler und Fallen in Python behandeln - wie man sie vermeidet und behebt!

Frei für alle Anfänger

Copyright © 2026 Programmier-Tutorials