Familiarizează-te cu cerințele proiectului și începe să-ți construiești calculatoarele de la zero, recapitulând în același timp principii importante de programare orientată pe obiecte și inginerie software, precum principiul Don't Repeat Yourself (DRY).

Prezentarea provocării

BasicCalculator

FinancialCalculator

Principii de inginerie software

Opțiuni

Inginerie software

Nu este inginerie 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)

Importuri relative

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

Importuri absolute

Moștenirea reutilizează codul

Moștenirea pe mai multe niveluri

Creează clasa calculatorului de ipotecă

Introducere în studiul de caz

Elementele de bază sunt gata – acum e momentul să le îmbunătățești! Continuă prin adăugarea de documentație și testare automată, și extinde și mai mult funcționalitatea.

Documentarea noii tale clase

Folosirea docstring-urilor

Folosirea dir()

Prezentare generală a testării automate

Folosirea modulului doctest

Caracteristicile doctest

Clasă personalizată

Utilizarea dir pe o clasă

Adaugă o metodă la o clasă moștenită

Scrie un modul Python

Codul principal este scris, așa că acum e timpul să te asiguri că totul funcționează corect și respectă bunele practici. Învață cum să revizuiești, să refactorizezi și să îmbunătățești codul, precum și cum să rulezi teste mai cuprinzătoare.

Mentenabilitate

Folosirea unor nume bune pentru variabile

Pylint

Revizuirea și refactorizarea codului

Recenzie de cod

Refactorizează codul

Testare

Beneficiile testării unitare

Testează codul folosind pytest

Felicitări!


Învață să construiești o aplicație reală – un calculator de credite ipotecare – și stăpânește principiile fundamentale ale ingineriei software. Vei proiecta cod Python modular, vei folosi moștenirea pentru a extinde funcționalitatea și vei asigura calitatea prin bune practici precum principiul DRY, conformitatea cu PEP 8 și testarea automată cu pytest. La final, vei avea abilitățile necesare pentru a crea soluții software eficiente, ușor de întreținut și scalabile pentru provocările din lumea reală.

Acest curs oferă o introducere practică în ingineria software, ghidându-te prin dezvoltarea unei aplicații utile: un calculator de credite ipotecare. Vei învăța cum să calculezi plățile lunare pe baza unor date cheie precum suma împrumutului, rata dobânzii și durata împrumutului. Pe parcurs, vei aplica principii esențiale de inginerie software pentru a crea cod eficient, modular și ușor de întreținut.<br><br>
<h2>Ce vei construi</h2>
Folosind Python, vei proiecta și implementa un calculator de credite ipotecare care evoluează de la un instrument de bază la o soluție robustă. Începând cu module simple, vei extinde funcționalitatea folosind moștenirea pentru a crea calculatoare avansate, inclusiv unul care gestionează calcule financiare. Acest proiect practic te va ajuta să înțelegi tehnici reale de dezvoltare software și cum să structurezi cod scalabil.<br><br>
<h2>Tehnici pe care le vei folosi</h2>
Pe parcursul cursului, vei urma bune practici precum principiul DRY (Don’t Repeat Yourself) și modularitatea pentru a-ți organiza eficient codul. Vei respecta standardele PEP 8, vei folosi instrumente precum Pylint pentru a menține calitatea codului și vei scrie teste automate cu pytest pentru a asigura fiabilitatea aplicației tale. La finalul cursului, vei avea abilitățile necesare pentru a proiecta, implementa și testa cu încredere soluții software din lumea reală.

Intermediate Object-Oriented Programming in Python

Software Engineering Principles in Python

Creează aplicații reale cu Python—folosește OOP și principii de inginerie software pentru cod curat.

Studiu de caz: Construirea de software în Python

Construiește aplicații reale cu Python—exersează OOP și principiile ingineriei software pentru a scrie cod curat și ușor de întreținut.

Moștenirea pe mai multe niveluri

Studiu de caz: Construirea de software în Python

Exercițiu interactiv practic