Les Fonctions et les Classes en Python

Dans cette partie, nous allons explorer deux autres concepts importants en programmation Python : les fonctions et les classes.

Les fonctions permettent de regrouper des blocs de code réutilisables, tandis que les classes permettent de créer des objets avec des attributs et des méthodes spécifiques.

Ces deux concepts sont essentiels pour structurer et organiser votre code de manière plus efficace, surtout lorsqu'il s'agit de résoudre des problèmes financiers complexes.

Les fonctions en Python

Les fonctions sont des blocs de code réutilisables qui effectuent une tâche spécifique.

Elles permettent de découper un programme en parties plus petites et plus faciles à comprendre.

Pour créer une fonction en Python, on utilise le mot-clé def suivi du nom de la fonction et d'une paire de parenthèses contenant les arguments de la fonction. Le bloc de code à exécuter est indenté sous la définition de la fonction.

Voici un exemple simple de fonction pour calculer l'intérêt composé :

def compound_interest(principal, rate, time):
    amount = principal * (1 + rate) ** time
    interest = amount - principal
    return interest

Dans cet exemple, nous avons défini une fonction appelée compound_interest qui prend trois arguments :

• le montant initial (principal),
• le taux d'intérêt (rate)
• la durée en années (time).

La fonction calcule l'intérêt composé en utilisant la formule standard et retourne le résultat. Le fait de retourner le résultat grâce à return nous permet de pouvoir récupérer une valeur en faisant par exemple result = ma_fonction(). Ce n’est pas obligatoire de retourner une valeur si l’on ne souhaite pas récupérer de résultat en particulier (par exemple si on cherche juste à afficher quelque chose).

Pour appeler cette fonction, il suffit de l'utiliser avec les arguments appropriés :

initial_investment = 1000
interest_rate = 0.04
years = 5

interest = compound_interest(initial_investment, interest_rate, years)
print(f"L'intérêt composé après {years} années est de {round(interest, 2)} €")

Cet exemple calcule l'intérêt composé pour un investissement initial de 1000 €, un taux d'intérêt de 4 % et une durée de 5 ans.

Dans cet exemple, vous découvrez également un nouveau moyen d’attribuer une valeur à un string, grâce à l’utilisation de f devant “” et l’utilisation de {} à l’intérieur des “”.

name = "Thomas"
age = 41.75254
print(f"Bonjour {name} tu as {round(age, 2)} ans")
# Affiche Bonjour Thomas tu as 41.75 ans

On utilise ici la fonction round() pour arrondir la valeur de l’âge à 2 chiffres après la virgule

Les fonctions sont particulièrement utiles pour éviter la duplication de code et pour simplifier les tâches répétitives. Par exemple, vous pouvez réutiliser la fonction compound_interest pour calculer l'intérêt composé pour différents investissements et taux d'intérêt.

Arguments optionnels et valeurs par défaut

Il est possible de définir des valeurs par défaut pour certains arguments d'une fonction, ce qui les rend optionnels lors de l'appel de la fonction. Par exemple, on peut définir une valeur par défaut pour le taux d'intérêt annuel :

def compound_interest(principal, time, rate=0.05):
    amount = principal * (1 + rate) ** time
    interest = amount - principal
    return interest

# Utilisation de la fonction sans spécifier le taux d'intérêt
investment = 1000
years = 5

earned_interest = compound_interest(investment, years)
print(f"L'intérêt composé sur {years} ans pour un investissement de {investment} € est de {round(earned_interest, 2)} €.")

Dans cet exemple, si le taux d'intérêt n'est pas spécifié lors de l'appel de la fonction compound_interest, la valeur par défaut de 0.05 sera utilisée.

earned_interest = compound_interest(investment, years, 0.07)
print(f"L'intérêt composé sur {years} ans pour un investissement de {investment} € est de {round(earned_interest, 2)} €.")

Cet exemple quant à lui montre que l’on peut bien évidemment par ailleurs spécifier le paramètre rate.

Pour appeler une fonction vous pouvez également spécifier le nom de chaque paramètre avec un =, voici comment faire.

earned_interest = compound_interest(
	rate=0.07,
	principal=investment,
	time=years,
)
print(f"L'intérêt composé sur {years} ans pour un investissement de {investment} € est de {round(earned_interest, 2)} €.")

On peut ainsi remarquer qu'avec l’utilisation des =, nous n’avons plus besoin de garder le même ordre des paramètres.

Classes en Python

Une classe est une structure qui permet de créer facilement des objets qui suivent le même modèle. Les objets peuvent avoir des attributs (variables) et des méthodes (fonctions). Les classes permettent d'organiser et de structurer le code en regroupant des données et des fonctionnalités liées.

Exemple de classe : Compte bancaire

Supposons que vous souhaitiez modéliser un compte bancaire avec des fonctions pour déposer, retirer et afficher le solde. Vous pouvez créer une classe BankAccount pour représenter un compte bancaire :

class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance

    def deposit(self, amount):
        self.balance += amount
        print(f"Vous avez déposé {amount} €. Nouveau solde : {self.balance} €.")

    def withdraw(self, amount):
        if amount > self.balance:
            print("Solde insuffisant.")
        else:
            self.balance -= amount
            print(f"Vous avez retiré {amount} €. Nouveau solde : {self.balance} €.")

    def display_balance(self):
        print(f"Votre solde est de {self.balance} €.")

Dans cet exemple, la classe BankAccount a un attribut balance et trois méthodes : deposit, withdraw et display_balance. La méthode spéciale __init__ est appelée un constructeur et est exécutée lors de la création d'une instance de la classe.

Utilisation de la classe BankAccount

Pour illustrer l'utilisation de la classe BankAccount, créons quelques instances et effectuons quelques opérations bancaires courantes, telles que les dépôts et les retraits.

# Création d'un compte bancaire avec un solde initial de 500 €
account1 = BankAccount(500)

# Création d'un autre compte bancaire avec un solde initial de 2000 €
account2 = BankAccount(2000)

# Affichage du solde des deux comptes
account1.display_balance()
account2.display_balance()

# Dépôt de 1000 € sur le compte1
account1.deposit(1000)

# Retrait de 300 € sur le compte1
account1.withdraw(300)

# Affichage du solde des deux comptes après les opérations
account1.display_balance()
account2.display_balance()

# Dépôt de 1000 € sur le compte2
account2.deposit(1000)

# Retrait de 1500 € sur le compte2
account2.withdraw(1500)

# Affichage du solde des deux comptes après les opérations
account1.display_balance()
account2.display_balance()

Dans cet exemple, nous avons créé deux instances de la classe BankAccount avec des soldes initiaux différents. Nous avons effectué des dépôts et des retraits sur les deux comptes et affiché leur solde.

Exercice de mise en application : Classe Portfolio

Dans cet exercice, nous allons créer une classe Portfolio pour gérer un portefeuille d'investissements. Le portefeuille contiendra plusieurs actifs financiers, tels que des actions ou des obligations, avec leur quantité respective et leur valeur unitaire.

Votre objectif est de définir et d'utiliser la classe Portfolio pour effectuer les opérations suivantes :

1. Ajouter un actif financier au portefeuille avec sa quantité et sa valeur unitaire.
2. Supprimer un actif financier du portefeuille.
3. Mettre à jour la quantité ou la valeur unitaire d'un actif financier.
4. Calculer la valeur totale du portefeuille.

Instructions

1. Créez une classe Portfolio avec un attribut assets qui sera un dictionnaire pour stocker les actifs financiers et leurs informations (quantité et valeur unitaire).
2. Définissez une méthode add_asset pour ajouter un actif financier au portefeuille. La méthode prendra en paramètre le nom de l'actif, la quantité et la valeur unitaire. Si l'actif existe déjà dans le portefeuille, mettez à jour la quantité et la valeur unitaire.
3. Définissez une méthode remove_asset pour supprimer un actif financier du portefeuille. La méthode prendra en paramètre le nom de l'actif à supprimer.
4. Définissez une méthode update_asset pour mettre à jour la quantité ou la valeur unitaire d'un actif financier. La méthode prendra en paramètre le nom de l'actif, la nouvelle quantité et la nouvelle valeur unitaire.
5. Définissez une méthode calculate_total_value pour calculer la valeur totale du portefeuille. Cette méthode ne prendra pas de paramètres et retournera la somme des produits de la quantité et de la valeur unitaire pour chaque actif financier du portefeuille.

Exemple d'utilisation

# Création d'un portefeuille vide
my_portfolio = Portfolio()

# Ajout d'actifs financiers
my_portfolio.add_asset("AAPL", 10, 150)
my_portfolio.add_asset("GOOG", 5, 1000)
my_portfolio.add_asset("TSLA", 8, 800)

# Mise à jour d'un actif financier
my_portfolio.update_asset("AAPL", 12, 160)

# Suppression d'un actif financier
my_portfolio.remove_asset("GOOG")

# Calcul de la valeur totale du portefeuille
total_value = my_portfolio.calculate_total_value()
print(f"La valeur totale du portefeuille est de {total_value} €.")

Cet exercice vous permettra de pratiquer la création et l'utilisation de classes en Python dans le contexte de la finance. Un exemple de correction se trouve ici: https://github.com/RobotTraders/Python_For_Finance/blob/main/exercise_correction_chapter_4.ipynb. N'hésitez pas à adapter cet exemple à vos propres besoins et à explorer d'autres fonctionnalités liées à la gestion d'un portefeuille d'investissements.

Récapitulatif

Dans cette partie, nous avons abordé les concepts de fonctions et de classes en Python, qui sont des éléments essentiels pour structurer et organiser votre code. Nous avons vu comment définir des fonctions et des classes, ainsi que comment les utiliser dans des exemples concrets liés à la finance.

En maîtrisant ces concepts, vous pourrez écrire des programmes plus complexes et modulaires, ce qui facilitera la maintenance et l'évolution de votre code.

Dans la suite de cette formation, nous explorerons des bibliothèques spécifiques à la finance qui vous permettront d'analyser des données financières et de créer des modèles prédictifs.