Lerne das Briefing kennen und baue deine Rechner von Grund auf, während du wichtige objektorientierte und softwaretechnische Prinzipien wie das „Don't Repeat Yourself“ (DRY)-Prinzip wiederholst.

Die Herausforderung kennenlernen

BasicCalculator

FinancialCalculator

Grundprinzipien des Software Engineerings

Optionen

Software Engineering

Kein Software Engineering

Grundsätze des Software Engineering

"""A module to implement the BasicCalcualtor.
"""
import numpy as np

class BasicCalculator:
    """A class for arithmetic operations on numbers    
    """
    def add(self, x, y):
        return np.add(x, y)

    def subtract(self, x, y):
        return np.subtract(x, y)

    def multiply(self, x, y):
        return np.multiply(x, y)

    def divide(self, x, y):
        return np.divide(x, y)

    def power(self, x, y):
        return np.power(x, y)

# Use a relative import to import BasicCalculator from basic_calculator in the same directory
from ____ import BasicCalculator

class FinancialCalculator(BasicCalculator):
    def monthly_interest(self, annual_interest_rate):
        return self.divide(annual_interest_rate, 12)

    def months_from_years(self, years):
        return self.multiply(years, 12)

# Message
print("We'll write code for main.py in the next exercise.")

# Use a relative import to import BasicCalculator from basic_calculator in the same directory
from .basic_calculator import BasicCalculator

class FinancialCalculator(BasicCalculator):
    def monthly_interest(self, annual_interest_rate):
        return self.divide(annual_interest_rate, 12)

    def months_from_years(self, years):
        return self.multiply(years, 12)

Relative Importe

# Relative import
from .basic_calculator import BasicCalculator

class FinancialCalculator(BasicCalculator):
    def monthly_interest(self, annual_interest_rate):
        return self.divide(annual_interest_rate, 12)

    def months_from_years(self, years):
        return self.multiply(years, 12)

# Import the financial_calculator module in the calculators package using an absolute import
from ____ import FinancialCalculator

financial_calculator = FinancialCalculator()
monthly_interest = financial_calculator.monthly_interest(0.06)

# Print the monthly interest
print(____)

# Import the financial_calculator module in the calculators package using an absolute import
from calculators.financial_calculator import FinancialCalculator

financial_calculator = FinancialCalculator()
monthly_interest = financial_calculator.monthly_interest(0.06)

# Print the monthly interest
print(monthly_interest)

Absolute Imports

Vererbung nutzt Code wieder

Mehrstufige Vererbung

Erstelle die Klasse MortgageCalculator

Einführung in die Fallstudie

Die Grundlagen stehen – jetzt wird aufpoliert! Führe Dokumentation und automatisierte Tests ein und erweitere die Funktionalität noch weiter.

Deine neue Klasse dokumentieren

Docstring verwenden

dir() verwenden

Überblick über automatisiertes Testen

doctest verwenden

Funktionen von doctest

Eigene Klasse

dir auf einer Klasse verwenden

Füge einer geerbten Klasse eine Methode hinzu

Ein Python-Modul schreiben

Der Hauptcode steht, jetzt stell sicher, dass alles wie vorgesehen funktioniert und Best Practices folgt. Lerne, Code zu reviewen, zu refaktorisieren und zu verbessern sowie umfassendere Tests auszuführen.

Wartbarkeit

Gute Variablennamen verwenden

Pylint

Code überprüfen und refaktorieren

Code-Review

Code refaktorisieren

Tests

Vorteile von Unit-Tests

Teste den Code mit pytest

Glückwunsch!


Lerne, eine echte Anwendung zu bauen – einen Hypothekenrechner – und beherrsche dabei zentrale Prinzipien des Software Engineerings. Du entwirfst modularen Python-Code, nutzt Vererbung, um die Funktionalität zu erweitern, und sicherst die Qualität mit Best Practices wie dem DRY-Prinzip, PEP 8-Konformität und automatisierten Tests mit pytest. Am Ende kannst du effiziente, wartbare und skalierbare Softwarelösungen für reale Herausforderungen entwickeln.

Dieser Kurs bietet dir eine praxisnahe Einführung in die Softwareentwicklung, indem er dich Schritt für Schritt bei der Entwicklung einer praktischen Anwendung begleitet: einem Hypothekenrechner. Du lernst, wie du monatliche Zahlungen auf Basis wichtiger Eingaben wie Darlehensbetrag, Zinssatz und Laufzeit berechnest. Unterwegs wendest du wichtige Prinzipien des Software Engineerings an, um Code zu schreiben, der effizient, modular und wartbar ist.<br><br>
<h2>Was du entwickeln wirst</h2>
Mit Python entwickelst und implementierst du einen Hypothekenrechner, der sich von einem einfachen Tool zu einer leistungsstarken Lösung weiterentwickelt. Du beginnst mit einfachen Modulen und erweiterst deren Funktionalität mithilfe von Vererbung, um fortgeschrittene Rechner zu erstellen – darunter auch einen, der Finanzberechnungen durchführt. In diesem praxisorientierten Projekt lernst du, wie moderne Softwareentwicklung in der Praxis funktioniert und wie du skalierbaren Code strukturierst.<br><br>
<h2>Techniken, die du anwenden wirst</h2>
Im Verlauf des Kurses lernst du, bewährte Methoden wie das DRY-Prinzip (Don’t Repeat Yourself) und Modularität anzuwenden, um deinen Code effektiv zu organisieren. Du hältst dich an die PEP 8-Standards, nutzt Tools wie Pylint, um die Codequalität zu sichern, und schreibst automatisierte Tests mit pytest, damit deine Anwendung zuverlässig funktioniert. Am Ende des Kurses verfügst du über die Fähigkeiten, praxisnahe Softwarelösungen selbstbewusst zu entwerfen, umzusetzen und zu testen.

Intermediate Object-Oriented Programming in Python

Software Engineering Principles in Python

Erstellen Sie Anwendungen mit Python: Nutzen Sie OOP und Softwareprinzipien für sauberen Code.

Fallstudie: Software in Python entwickeln

Erstelle praxisnahe Anwendungen mit Python – übe OOP und Software Engineering, um sauberen, wartbaren Code zu schreiben.

Relative Importe

Interaktive praktische Übung