Maak kennis met de opdracht en begin je calculators vanaf nul te bouwen, terwijl je belangrijke objectgeoriënteerde en software-engineeringprincipes herhaalt, zoals het Don't Repeat Yourself (DRY)-principe.

De uitdaging introduceren

BasicCalculator

FinancialCalculator

Software-engineeringprincipes

Opties

Software engineering

Geen software engineering

Principes van 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)

Relatieve imports

# 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

Met overerving hergebruik je code

Meerlagige overerving

Maak de hypotheekcalculatorklasse

Introductie van de casestudy

De basis staat, en nu is het tijd om die te verfijnen! Ga verder met het toevoegen van documentatie en geautomatiseerde tests, en breid de functionaliteit nog verder uit.

Je nieuwe class documenteren

Docstring gebruiken

dir() gebruiken

Overzicht van geautomatiseerd testen

Doctest gebruiken

Kenmerken van doctest

Aangepaste klasse

dir gebruiken op een klasse

Voeg een methode toe aan een overgenomen klasse

Schrijf een Python-module

De hoofdcode is geschreven, dus nu is het tijd om te zorgen dat alles werkt zoals het hoort en de best practices volgt. Leer hoe je je code kunt reviewen, refactoren en verbeteren, en voer daarnaast uitgebreidere tests uit.

Onderhoudbaarheid

Goede variabelenamen gebruiken

Pylint

Code reviewen en refactoren

Code review

Code refactoren

Testen

Voordelen van unit testing

Test de code met pytest

Gefeliciteerd!


Leer een echte toepassing bouwen—een hypotheekcalculator—terwijl je kernprincipes van software engineering onder de knie krijgt. Je ontwerpt modulaire Python-code, gebruikt overerving om functionaliteit uit te breiden, en borgt kwaliteit met best practices zoals het DRY-principe, naleving van PEP 8 en geautomatiseerd testen met pytest. Aan het einde heb je de vaardigheden om efficiënte, onderhoudbare en schaalbare softwareoplossingen te creëren voor echte uitdagingen.

Deze cursus geeft je een praktische introductie in software engineering door je te helpen bij het maken van een handige app: een hypotheekcalculator. Je leert hoe je maandelijkse betalingen kunt berekenen op basis van belangrijke gegevens zoals het geleende bedrag, de rente en de looptijd van de lening. Onderweg ga je belangrijke software engineering-principes gebruiken om code te maken die efficiënt, modulair en makkelijk te onderhouden is.<br><br>
<h2>Wat je gaat bouwen</h2>
Met Python ga je een hypotheekcalculator ontwerpen en maken die van een simpele tool uitgroeit tot een stevige oplossing. Je begint met simpele modules en breidt de functies uit met behulp van overerving om geavanceerde rekenmachines te maken, zoals een rekenmachine voor financiële berekeningen. Dit praktische project helpt je om echte softwareontwikkelingstechnieken te begrijpen en te leren hoe je schaalbare code kunt maken.<br><br>
<h2>Technieken die je gaat gebruiken</h2>
Tijdens de cursus leer je best practices zoals het DRY-principe (Don't Repeat Yourself) en modulariteit om je code goed te organiseren. Je houdt je aan de PEP 8-standaarden, gebruikt tools zoals Pylint om de kwaliteit van de code te behouden en schrijft geautomatiseerde tests met pytest om de betrouwbaarheid van je app te garanderen. Aan het einde van de cursus heb je de vaardigheden om met vertrouwen echte softwareoplossingen te ontwerpen, te implementeren en te testen.

Intermediate Object-Oriented Programming in Python

Software Engineering Principles in Python

Bouw echte apps met Python—oefen OOP en softwareprincipes voor schone, onderhoudbare code.

Casestudy: Software bouwen in Python

Maak echte apps met Python – oefen met OOP en software engineering om nette en makkelijk te onderhouden code te schrijven.

Meerlagige overerving

Casestudy: Software bouwen in Python

Interactieve oefening met praktijkervaring