Familiarisez-vous avec l’énoncé et commencez à construire vos calculatrices à partir de zéro, tout en révisant des principes importants de programmation orientée objet et d’ingénierie logicielle, comme le principe « Don’t Repeat Yourself » (DRY). 

Présentation du défi

BasicCalculator

FinancialCalculator

Principes d’ingénierie logicielle

Options

Génie logiciel

Pas du génie logiciel

Principes du génie logiciel

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

Créer la classe de calculatrice hypothécaire

Introduction à l’étude de cas

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

Documenter votre nouvelle classe

Utiliser une docstring

Utiliser dir()

Vue d’ensemble des tests automatisés

Utiliser doctest

Fonctionnalités de doctest

Classe personnalisée

Utiliser dir sur une classe

Ajouter une méthode à une classe héritée

Écrire un module Python

Le code principal est écrit ; il faut maintenant s’assurer que tout fonctionne correctement et respecte les bonnes pratiques. Apprenez à relire, refactorer et améliorer votre code, puis à exécuter des tests plus complets. 

Maintenabilité

Utiliser de bons noms de variables

Pylint

Relecture et refactorisation du code

Revue de code

Refactoriser le code

Tests

Avantages des tests unitaires

Tester le code avec pytest

Félicitations !


Apprenez à créer une application concrète — une calculatrice d’emprunt immobilier — tout en maîtrisant les principes essentiels de l’ingénierie logicielle. Vous concevrez du code Python modulaire, utiliserez l’héritage pour étendre les fonctionnalités et garantirez la qualité grâce aux bonnes pratiques comme le principe DRY, la conformité à PEP 8 et les tests automatisés avec pytest. À la fin, vous aurez les compétences pour créer des solutions logicielles efficaces, maintenables et évolutives pour des cas d’usage réels.

Ce cours propose une introduction pratique à l’ingénierie logicielle en vous accompagnant dans le développement d’une application concrète : un calculateur d’hypothèque. Vous apprendrez à calculer les paiements mensuels en fonction d’éléments clés tels que le montant du prêt, le taux d’intérêt et la durée du prêt. Au fil du parcours, vous appliquerez des principes essentiels de l’ingénierie logicielle afin de créer un code efficace, modulaire et facile à maintenir.<br><br>
<h2>Ce que vous allez créer</h2>
En utilisant Python, vous concevrez et mettrez en œuvre un calculateur d’hypothèque qui évolue d’un outil simple vers une solution performante. En commençant par des modules simples, vous élargirez les fonctionnalités grâce à l’héritage afin de créer des calculateurs avancés, y compris un capable de réaliser des calculs financiers. Ce projet pratique vous permettra de comprendre les techniques de développement logiciel utilisées dans le monde réel et la manière de structurer un code évolutif.<br><br>
<h2>Techniques que vous utiliserez</h2>
Tout au long du cours, vous suivrez les meilleures pratiques telles que le principe DRY (Don’t Repeat Yourself) et la modularité afin d’organiser votre code de manière efficace. 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 de garantir 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 en toute confiance.

Intermediate Object-Oriented Programming in Python

Software Engineering Principles in Python

Créez des applications avec Python : utilisez la POO et les principes d'ingénierie pour un code propre.

Étude de cas : développer un logiciel en Python

Créez des applications concrètes avec Python : entraînement à la POO et aux principes d’ingénierie logicielle pour un code propre et maintenable.

Importations absolues

Exercice interactif pratique