Get to know the brief and start building your calculators from scratch while recapping important object-oriented and software engineering principles such as the Don't Repeat Yourself (DRY) principle. 

Presentazione della sfida

BasicCalculator

FinancialCalculator

Principi di ingegneria del software

Opzioni

Ingegneria del software

Non ingegneria del software

"""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)

Import relativi

# 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)

Import assoluti

Il riuso del codice con l'ereditarietà

Ereditarietà multilivello

Crea la classe del calcolatore di mutui

Introduction to the Case Study

The basics are done, and now it's time to spruce them up! Continue with adding documentation and automated testing, and extend the functionality even further.

Documenting your new class

Using docstring

Using dir()

Overview of Automated Testing

Using doctest

Features of doctest

Custom Class

Using dir on a class

Add a method to an inherited class

Write a Python Module

The main code is written so now it's time to make sure everything works as it should and follows the best practices. Learn how to review, refactor, and improve your code, as well as run more comprehensive tests. 

Maintainability

Using good variable names

Pylint

Reviewing and refactoring code

Code Review

Refactor Code

Testing

Benefits of Unit Testing

Test the code using pytest

Congratulations!


Impara a creare un'applicazione reale — un calcolatore di mutui — mentre padroneggi i principi fondamentali dell'ingegneria del software. Progetterai codice Python modulare, userai l'ereditarietà per ampliare le funzionalità e garantirai la qualità con buone pratiche come il principio DRY, la conformità a PEP 8 e i test automatizzati con pytest. Alla fine, avrai le competenze per creare soluzioni software efficienti, manutenibili e scalabili per sfide del mondo reale.

Questo corso ti dà un'introduzione pratica all'ingegneria del software, guidandoti nello sviluppo di un'applicazione reale: un calcolatore di mutui. Imparerai a calcolare le rate mensili in base a dati chiave come l'importo del prestito, il tasso di interesse e la durata del prestito. Durante il percorso, userai i principi fondamentali dell'ingegneria del software per creare codice efficiente, modulare e facile da mantenere.<br><br>
<h2>Cosa costruirai</h2>
Usando Python, progetterai e realizzerai un calcolatore di mutui che si trasformerà da strumento di base a soluzione affidabile. Partendo da moduli semplici, potrai espandere le funzionalità usando l'ereditarietà per creare calcolatrici avanzate, tra cui una che gestisce calcoli finanziari. Questo progetto pratico ti aiuterà a capire le tecniche di sviluppo software nel mondo reale e come strutturare un codice scalabile.<br><br>
<h2>Tecniche che userai</h2>
Durante il corso, imparerai a seguire le migliori pratiche, come il principio DRY (Don't Repeat Yourself, non ripeterti) e la modularità, per organizzare il tuo codice in modo efficace. Seguirai gli standard PEP 8, userai strumenti come Pylint per mantenere alta la qualità del codice e scriverai test automatizzati con pytest per garantire l'affidabilità della tua app. Alla fine del corso, avrai le competenze per progettare, implementare e testare soluzioni software reali con sicurezza.

Intermediate Object-Oriented Programming in Python

Software Engineering Principles in Python

Crea applicazioni reali con Python: usa OOP e principi di ingegneria software per codice pulito.

Caso di studio: sviluppare software in Python

Crea app per il mondo reale con Python: prova a usare i principi dell'OOP e dell'ingegneria del software per scrivere codice pulito e facile da mantenere.

Ereditarietà multilivello

Caso di studio: sviluppare software in Python

Esercizio pratico interattivo