Familiarisez-vous avec l'énoncé et commencez à bâtir vos calculateurs à partir de zéro tout en révisant des principes importants de la programmation orientée objet et du génie logiciel, comme le principe « Ne vous répétez pas » (DRY). 

Présentation du défi

CalculatriceDeBase

FinancialCalculator

Principes d'ingénierie logicielle

Options

Ingénierie logicielle

Pas de l'ingénierie logicielle

Principes de l'ingénierie logicielle

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

Importations relatives

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

Importations absolues

La réutilisation du code grâce à l'héritage

Héritage à plusieurs niveaux

Créer la classe de calcul d'hypothèque

Introduction à l'étude de cas

Les bases sont en place ; il est temps de rehausser le tout ! Ajoutez de la documentation et des tests automatisés, puis étendez encore davantage les fonctionnalités.

Documenter votre nouvelle classe

Utiliser une docstring

Utiliser dir()

Aperçu des tests automatisés

Utiliser doctest

Fonctionnalités de doctest

Classe personnalisée

Utiliser dir sur une classe

Ajouter une méthode à une classe dérivée

Écrire un module Python

Le code principal est écrit ; il faut maintenant s'assurer que tout fonctionne comme prévu et respecte les meilleures pratiques. Apprenez à revoir, remanier et améliorer votre code, et à exécuter des tests plus complets. 

Maintenabilité

Utiliser de bons noms de variables

Pylint

Révision et remaniement du code

Revue de code

Remanier le code

Tests

Avantages des tests unitaires

Tester le code avec pytest

Félicitations !


Apprenez à concevoir une application concrète — un calculateur d'hypothèque — tout en maîtrisant les principes clés du génie logiciel. Vous élaborerez du code Python modulaire, utiliserez l'héritage pour étendre les fonctionnalités et assurerez la qualité grâce à des pratiques exemplaires comme le principe DRY, la conformité à PEP 8 et les tests automatisés avec pytest. Au terme du cours, vous aurez les compétences pour créer des solutions logicielles efficaces, faciles à maintenir et évolutives pour des défis réels.

Ce cours offre une introduction pratique au génie logiciel en vous guidant dans le développement d’une application concrète : un calculateur hypothécaire. Vous apprendrez à calculer les paiements mensuels en fonction d’éléments clés comme le montant du prêt, le taux d’intérêt et la durée du prêt. En cours de route, vous appliquerez des principes essentiels d’ingénierie logicielle pour créer du code efficace, modulaire et facile à maintenir.<br><br>
<h2>Ce que vous allez créer</h2>
À l’aide de Python, vous concevrez et mettrez en œuvre un calculateur hypothécaire qui évolue d’un outil de base à une solution robuste. En commençant par des modules simples, vous développerez les fonctionnalités à l’aide de l’héritage pour créer des calculateurs avancés, y compris un qui gère les calculs financiers. Ce projet pratique vous aidera à comprendre les techniques de développement logiciel du monde réel et à structurer du code évolutif.<br><br>
<h2>Techniques que vous utiliserez</h2>
Tout au long du cours, vous suivrez des pratiques exemplaires comme le principe DRY (Don't Repeat Yourself) et la modularité pour organiser efficacement votre code. Vous respecterez les normes PEP 8, utiliserez des outils comme Pylint pour maintenir la qualité du code et rédigerez des tests automatisés avec pytest afin d’assurer la fiabilité de votre application. À la fin du cours, vous aurez les compétences nécessaires pour concevoir, mettre en œuvre et tester des solutions logicielles concrètes avec assurance.

Intermediate Object-Oriented Programming in Python

Software Engineering Principles in Python

Créez des applications concrètes avec Python en utilisant la POO et des principes d'ingénierie logicielle.

Étude de cas : créer des logiciels en Python

Créez des applications concrètes avec Python—pratiquez la POO et les principes d’ingénierie logicielle pour écrire du code propre et maintenable.

Héritage à plusieurs niveaux

Étude de cas : créer des logiciels en Python

Exercice interactif pratique