02 Übung: PEP 8 - Level 2: Mehrfache Probleme

October 2025 (4162 Words, 24 Minutes)

Einführung

Willkommen zu den Level 2 PEP 8 Übungen! Diese Übungen sind darauf ausgelegt, Ihnen zu helfen, ein geschärftes Auge für mehrere Code-Qualitätsprobleme gleichzeitig zu entwickeln.

Lernziele:

• 3-5 PEP 8-Verstöße in einem einzelnen Code-Snippet identifizieren
• Verstehen, wie mehrere Stilprobleme die Lesbarkeit verschlechtern
• Systematische Code-Review-Fähigkeiten üben
• Selbstvertrauen beim Erkennen von Mustern aufbauen

Anleitung:

1. Lesen Sie jedes Code-Beispiel sorgfältig
2. Versuchen Sie, ALLE PEP 8-Verstöße zu finden, bevor Sie die Lösung ansehen
3. Schreiben Sie Ihre Antworten auf (empfohlen für besseres Lernen)
4. Klicken Sie erst auf “Lösung anzeigen”, nachdem Sie die Übung versucht haben
5. Vergleichen Sie Ihre Ergebnisse mit der bereitgestellten Lösung

Schwierigkeit: Fortgeschritten
Zeit: 5-10 Minuten pro Übung
Voraussetzungen: Schließen Sie zuerst die Level 1 Übungen ab

Übung 2.1: Datenverarbeitungsfunktion

Problem

import sys,os
import numpy as np

def ProcessData(input_list,threshold=10):
    result=[]
    for item in input_list:
        if item>threshold:result.append(item*2)
    return result

Fragen

1. Listen Sie ALLE PEP 8-Verstöße auf (Ziel: 5-7 Probleme)
2. Geben Sie für jedes Problem die verletzte Regel an
3. Schreiben Sie die vollständig korrigierte Version

Ihre Aufgabe

Bevor Sie die Lösung prüfen, versuchen Sie:

• Jeden Verstoß aufzulisten, den Sie finden
• Die Zeilennummer für jeden Verstoß zu notieren
• Den korrigierten Code selbst zu schreiben

import numpy as np

def process_data(input_list, threshold=10):
    result = []
    for item in input_list:
        if item > threshold:
            result.append(item * 2)
    return result

Übung 2.2: Road Profile Generator

Problem

from dash import Dash,html,dcc
import numpy as np
import sys

def generate_road_profile(num_points=100,x_max=80):
    x=np.linspace(0,x_max,num_points)
    y=0.015*x**3+0.3*np.sin(2*np.pi*x)
    return x,y

camera_position={'x':0,'y':2.0,'z':1.5}
MAX_distance=100

Fragen

1. Listen Sie ALLE PEP 8-Verstöße auf (Ziel: 10-12 Probleme)
2. Geben Sie für jedes Problem die verletzte Regel an
3. Schreiben Sie die vollständig korrigierte Version

Hinweise

• Überprüfen Sie Import-Anweisungen sorgfältig
• Suchen Sie nach Abstandsproblemen um Operatoren
• Untersuchen Sie die Dictionary-Formatierung
• Berücksichtigen Sie Namenskonventionen für Konstanten

from dash import Dash, dcc, html
import numpy as np

def generate_road_profile(num_points=100, x_max=80):
    x = np.linspace(0, x_max, num_points)
    y = 0.015 * x**3 + 0.3 * np.sin(2 * np.pi * x)
    return x, y

camera_position = {'x': 0, 'y': 2.0, 'z': 1.5}
MAX_DISTANCE = 100

Übung 2.3: Hilfsfunktionen

Problem

import numpy as np
from typing import List

def HelperFunction(val):
    result=val*2
    return result

def another_helper(x,y,z): return x+y+z

def calculate_distance(point1,point2):
    dx=point2[0]-point1[0]
    dy=point2[1]-point1[1]
    return np.sqrt(dx**2+dy**2)

# This is a very long comment that definitely exceeds the recommended 79 character limit for code readability

Fragen

1. Listen Sie ALLE PEP 8-Verstöße auf (Ziel: 10-12 Probleme)
2. Geben Sie für jedes Problem die verletzte Regel an
3. Schreiben Sie die vollständig korrigierte Version

Herausforderung

Diese Übung testet Ihre Fähigkeit zu erkennen:

• Verstöße gegen Namenskonventionen
• Leerzeichenprobleme in mehreren Kontexten
• Zeilenlängenprobleme
• Probleme mit zusammengesetzten Anweisungen

import numpy as np
from typing import List

def helper_function(val):
    result = val * 2
    return result

def another_helper(x, y, z):
    return x + y + z

def calculate_distance(point1, point2):
    dx = point2[0] - point1[0]
    dy = point2[1] - point1[1]
    return np.sqrt(dx**2 + dy**2)

# Dies ist ein Kommentar, der ordnungsgemäß auf
# mehrere Zeilen aufgeteilt wurde für bessere Lesbarkeit

Übung 2.4: Klassendefinition

Problem

import sys,os,json

class DataProcessor:
    def __init__(self,data,config=None):
        self.data=data
        self.config=config if config else {}
    
    def Process(self,threshold=0):
        filtered=[x for x in self.data if x>threshold]
        return filtered
    
    def GetStats(self):
        return {'mean':np.mean(self.data),'std':np.std(self.data)}

max_items=1000

Fragen

1. Listen Sie ALLE PEP 8-Verstöße auf (Ziel: 12-15 Probleme)
2. Geben Sie für jedes Problem die verletzte Regel an
3. Schreiben Sie die vollständig korrigierte Version

Extra-Herausforderung

Können Sie das Bonusproblem erkennen, das nicht strikt PEP 8 ist, aber einen Laufzeitfehler verursachen würde?

import numpy as np

class DataProcessor:
    def __init__(self, data, config=None):
        self.data = data
        self.config = config if config else {}
    
    def process(self, threshold=0):
        filtered = [x for x in self.data if x > threshold]
        return filtered
    
    def get_stats(self):
        return {'mean': np.mean(self.data), 'std': np.std(self.data)}

MAX_ITEMS = 1000

Übung 2.5: Komplexe Funktion

Problem

from typing import List,Tuple
import numpy as np

def find_intersection(x_road,y_road,angle_degrees,camera_x=0,camera_y=1.5):
    angle_rad=np.radians(angle_degrees)
    ray_dx=np.cos(angle_rad)
    ray_dy=np.sin(angle_rad)
    
    for i in range(len(x_road)-1):
        x1,y1=x_road[i],y_road[i]
        x2,y2=x_road[i+1],y_road[i+1]
        
        # Check intersection - this calculation is complex and might need refactoring for better maintainability
        t=((camera_y-y1)*ray_dx-(camera_x-x1)*ray_dy)/((x2-x1)*ray_dy-(y2-y1)*ray_dx)
        
        if 0<=t<=1:
            x_intersect=x1+t*(x2-x1)
            return x_intersect,y1+t*(y2-y1)
    
    return None,None

Fragen

1. Listen Sie ALLE PEP 8-Verstöße auf (Ziel: 15+ Probleme)
2. Geben Sie für jedes Problem die verletzte Regel an
3. Schreiben Sie die vollständig korrigierte Version

Experten-Level

Dies ist die komplexeste Übung. Sie enthält Verstöße in:

• Import-Anweisungen
• Funktionsparametern
• Variablenzuweisungen
• Mathematischen Ausdrücken
• Vergleichsoperatoren
• Kommentaren
• Return-Anweisungen

Nehmen Sie sich Zeit und gehen Sie systematisch vor!

from typing import List, Tuple
import numpy as np

def find_intersection(
    x_road,
    y_road,
    angle_degrees,
    camera_x=0,
    camera_y=1.5
):
    angle_rad = np.radians(angle_degrees)
    ray_dx = np.cos(angle_rad)
    ray_dy = np.sin(angle_rad)
    
    for i in range(len(x_road) - 1):
        x1, y1 = x_road[i], y_road[i]
        x2, y2 = x_road[i + 1], y_road[i + 1]
        
        # Überprüfe Schnittpunkt - diese Berechnung ist komplex und
        # könnte für bessere Wartbarkeit refaktoriert werden
        numerator = (camera_y - y1) * ray_dx - (camera_x - x1) * ray_dy
        denominator = (x2 - x1) * ray_dy - (y2 - y1) * ray_dx
        t = numerator / denominator
        
        if 0 <= t <= 1:
            x_intersect = x1 + t * (x2 - x1)
            return x_intersect, y1 + t * (y2 - y1)
    
    return None, None

Übung 2.6: Konfigurationsverwaltung

Problem

import json,sys
from pathlib import Path

class ConfigManager:
    def __init__(self,config_file="config.json"):
        self.config_file=config_file
        self.data=self.load_config()
    
    def load_config(self):
        if Path(self.config_file).exists():return json.load(open(self.config_file))
        return {}
    
    def get_value(self,key,default=None):
        return self.data.get(key,default)
    
    def update_config(self,updates):
        self.data.update(updates)
        with open(self.config_file,"w") as f:json.dump(self.data,f)

DEFAULT_timeout=30
max_retries=3

Fragen

1. Listen Sie ALLE PEP 8-Verstöße auf (Ziel: 15+ Probleme)
2. Geben Sie für jedes Problem die verletzte Regel an
3. Schreiben Sie die vollständig korrigierte Version

import json
from pathlib import Path

class ConfigManager:
    def __init__(self, config_file="config.json"):
        self.config_file = config_file
        self.data = self.load_config()
    
    def load_config(self):
        if Path(self.config_file).exists():
            with open(self.config_file) as f:
                return json.load(f)
        return {}
    
    def get_value(self, key, default=None):
        return self.data.get(key, default)
    
    def update_config(self, updates):
        self.data.update(updates)
        with open(self.config_file, "w") as f:
            json.dump(self.data, f)

DEFAULT_TIMEOUT = 30
MAX_RETRIES = 3

Zusammenfassung und nächste Schritte

Was Sie gelernt haben

Nach Abschluss dieser Level 2 Übungen sollten Sie in der Lage sein:

✅ Mehrere Verstöße gleichzeitig in echtem Code zu erkennen
✅ Muster verwandter Probleme zu erkennen (z.B. alle fehlenden Kommas)
✅ Probleme nach Auswirkung auf die Lesbarkeit zu priorisieren
✅ Systematische Review-Techniken anzuwenden
✅ Saubereren Code von Anfang an zu schreiben

Lernpfad

Level 1 (Einzelne Probleme)
    ↓
Level 2 (Mehrfache Probleme) ← Sie sind hier
    ↓
Level 3 (Echter Code)
    ↓
Automatisierte Tools (Ruff, Black)
    ↓
Produktions-Workflow (CI/CD)

Empfohlene Übungspraxis

1. Tägliche Übung: Bearbeiten Sie 1-2 Übungen pro Tag
2. Echter Code: Wenden Sie diese Fähigkeiten auf Ihre eigenen Projekte an
3. Peer Review: Tauschen Sie Code mit Kommilitonen aus
4. Vor den Tools: Beherrschen Sie manuelle Überprüfung, bevor Sie sich auf Automatisierung verlassen
5. Geschwindigkeit aufbauen: Stoppen Sie die Zeit—streben Sie 5 Minuten pro Übung an

Lerntipps

Für maximales Lernen

1. Schreiben Sie Ihre Antworten auf
   • Denken Sie es nicht nur—schreiben Sie es
   • Verstärkt Lernen durch motorisches Gedächtnis
   • Erstellt eine Lernreferenz
2. Überprüfen Sie vor dem Prüfen der Lösungen
   • Widerstehen Sie dem Drang, sofort nachzuschauen
   • Kämpfen ist Teil des Lernens
   • Vergleichen Sie Ihre Gründlichkeit mit der Antwort
3. Verfolgen Sie Ihren Fortschritt
   • Notieren Sie, welche Probleme Sie konsequent übersehen
   • Konzentrieren Sie Übung auf schwache Bereiche
   • Feiern Sie Verbesserungen!
4. Üben Sie in Gruppen
   • Diskutieren Sie Erkenntnisse mit Kommilitonen
   • Lernen Sie von verschiedenen Perspektiven
   • Lehren Sie andere, um Ihr Verständnis zu festigen
5. Auf echte Projekte anwenden
   • Überprüfen Sie Ihren eigenen vergangenen Code
   • Beheben Sie Verstöße, die Sie finden
   • Bemerken Sie, wie sich die Lesbarkeit verbessert

Viel Erfolg beim Üben! 🚀