Définir et importer des modules Python

Introduction

Dans ce laboratoire (lab), vous allez apprendre les modules Python, qui sont des fichiers contenant du code Python pouvant être importés et utilisés dans d'autres programmes. Cette approche modulaire favorise la réutilisation du code et aide à organiser les programmes en composants logiques.

Vous comprendrez ce que sont les modules Python et pourquoi ils sont utiles, apprendrez à créer vos propres modules, pratiquerez l'utilisation de l'instruction import de différentes manières, et saurez ce qu'est un module principal (main module) et quand le code s'exécute. Les prérequis incluent une compréhension de base de la syntaxe et des fonctions Python, ainsi qu'une familiarité avec la création et l'exécution de scripts Python. Il est recommandé de redémarrer votre session d'interpréteur Python avant de commencer cet exercice pour avoir un environnement propre.

Ceci est un Guided Lab, qui fournit des instructions étape par étape pour vous aider à apprendre et à pratiquer. Suivez attentivement les instructions pour compléter chaque étape et acquérir une expérience pratique. Les données historiques montrent que c'est un laboratoire de niveau débutant avec un taux de réussite de 97%. Il a reçu un taux d'avis positifs de 100% de la part des apprenants.

Comprendre les modules Python

En Python, un module est comme un conteneur qui contient des définitions et des instructions Python. Il s'agit essentiellement d'un fichier, et le nom de ce fichier est le nom du module avec l'extension .py ajoutée à la fin. Imaginez les modules comme des boîtes à outils. Ils vous aident à organiser votre code Python de manière logique, facilitant ainsi sa réutilisation et sa maintenance. Tout comme vous garderiez différents outils dans des boîtes séparées pour une meilleure organisation, vous pouvez regrouper le code Python lié dans différents modules.

Regardons les fichiers qui ont été préparés pour ce laboratoire (lab) :

Tout d'abord, nous allons ouvrir le fichier stock.py dans l'éditeur pour voir ce qu'il contient. Pour ce faire, nous allons utiliser les commandes suivantes. La commande cd change le répertoire pour le dossier project où se trouve notre fichier, et la commande cat affiche le contenu du fichier.

cd ~/project
cat stock.py

Ce fichier stock.py définit une classe Stock. Une classe est comme un modèle pour créer des objets. Dans ce cas, la classe Stock représente une action (stock). Elle a des attributs (qui sont comme des caractéristiques) pour le nom de l'action, le nombre de parts et le prix. Elle a également une méthode (qui est comme une fonction associée à la classe) pour calculer le coût de l'action.

Ensuite, examinons le fichier pcost.py. Nous allons à nouveau utiliser la commande cat pour afficher son contenu.

cat pcost.py

Ce fichier définit une fonction appelée portfolio_cost(). Une fonction est un bloc de code qui effectue une tâche spécifique. La fonction portfolio_cost() lit un fichier de portefeuille (portfolio) et calcule le coût total de toutes les actions dans ce portefeuille.

Maintenant, regardons les données d'échantillon de portefeuille. Nous allons utiliser la commande cat pour afficher le contenu du fichier portfolio.dat.

cat portfolio.dat

Ce fichier contient des données sur les actions dans un format simple. Chaque ligne a le symbole du ticker de l'action, le nombre de parts et le prix par part.

Utilisation de l'instruction import

L'instruction import de Python est un outil puissant qui vous permet d'utiliser le code d'autres modules dans votre programme actuel. C'est comme emprunter des outils à d'autres boîtes à outils. Practiquons l'utilisation de différentes manières d'importer du code :

Tout d'abord, nous devons démarrer l'interpréteur Python. L'interpréteur Python est un programme qui exécute le code Python. Nous allons utiliser la commande suivante pour le démarrer.

python3

Maintenant, importons le module pcost et voyons ce qui se passe. Lorsque nous utilisons l'instruction import, Python cherche le fichier pcost.py et rend le code à l'intérieur disponible pour nous l'utiliser.

import pcost

Vous devriez voir la sortie 44671.15. C'est le coût calculé du portefeuille à partir du fichier portfolio.dat. Lorsque le module pcost est importé, le code en bas du fichier pcost.py s'exécute automatiquement.

Essayons d'appeler la fonction portfolio_cost() avec un autre fichier de portefeuille. Nous allons utiliser la syntaxe pcost.portfolio_cost() pour appeler la fonction du module pcost.

pcost.portfolio_cost('portfolio2.dat')

La sortie devrait être 19908.75, qui représente le coût total des actions dans le deuxième fichier de portefeuille.

Maintenant, importons une classe spécifique du module stock. Au lieu d'importer tout le module, nous pouvons simplement importer la classe Stock en utilisant l'instruction from...import.

from stock import Stock

Après avoir importé la classe Stock, nous pouvons créer un objet Stock. Un objet est une instance d'une classe. Nous allons créer un objet Stock avec le nom GOOG, 100 parts et un prix de 490.10. Ensuite, nous allons afficher le nom de l'action et calculer son coût en utilisant la méthode cost().

s = Stock('GOOG', 100, 490.10)
print(s.name)
print(s.cost())

La sortie devrait être :

GOOG
49010.0

Enfin, lorsque nous avons fini d'utiliser l'interpréteur Python, nous pouvons le quitter en utilisant la fonction exit().

exit()

Ce laboratoire (lab) a démontré deux manières différentes d'importer du code Python :

import module_name - Cela importe tout le module, rendant toutes les fonctions, classes et variables de ce module disponibles pour utilisation.
from module_name import specific_item - Cela importe seulement un élément spécifique (comme une classe ou une fonction) du module, ce qui peut être utile si vous n'avez besoin que d'une partie de la fonctionnalité du module.

Comprendre le module principal (main module) en Python

En Python, lorsque vous exécutez directement un script, il agit comme le "module principal" (main module). Python a une variable spéciale nommée __name__. Lorsqu'un fichier est exécuté directement, Python attribue à la valeur de __name__ la chaîne "__main__". Cela est différent du cas où le fichier est importé comme un module.

Cette fonctionnalité est très utile car elle vous permet d'écrire un code qui se comporte différemment selon que le fichier est exécuté directement ou importé. Par exemple, vous pourriez vouloir que certains codes s'exécutent seulement lorsque vous exécutez le fichier comme un script, mais pas lorsqu'il est importé par un autre script.

Modifier pcost.py pour utiliser le modèle du module principal

Modifions le programme pcost.py pour tirer parti de ce modèle.

Tout d'abord, vous devez ouvrir le fichier pcost.py dans l'éditeur. Vous pouvez utiliser les commandes suivantes pour accéder au répertoire du projet et créer le fichier s'il n'existe pas :

cd ~/project
touch pcost.py

La commande cd change le répertoire actuel pour le répertoire project dans votre répertoire personnel. La commande touch crée un nouveau fichier nommé pcost.py s'il n'existe pas déjà.

Maintenant, modifiez le fichier pcost.py pour qu'il ressemble à ceci :

## pcost.py

def portfolio_cost(filename):
    total_cost = 0.0

    with open(filename, 'r') as f:
        for line in f:
            fields = line.split()
            try:
                nshares = int(fields[1])
                price = float(fields[2])
                total_cost += nshares * price
            except (ValueError, IndexError):
                print(f"Couldn't parse: {line}")

    return total_cost

## Ce code ne s'exécute que lorsque le fichier est exécuté comme un script
if __name__ == "__main__":
    total = portfolio_cost('portfolio.dat')
    print(total)

La principale modification ici est que nous avons enveloppé le code à la fin dans une condition if __name__ == "__main__":. Cela signifie que le code à l'intérieur de ce bloc ne s'exécutera que lorsque le fichier est exécuté directement comme un script, pas lorsqu'il est importé comme un module.

Après avoir effectué ces modifications, enregistrez le fichier et quittez l'éditeur.

Tester le module modifié

Maintenant, testons notre module modifié de deux manières différentes pour voir comment il se comporte.

Tout d'abord, exécutez le programme directement comme un script en utilisant la commande suivante :

python3 pcost.py

Vous devriez voir la sortie 44671.15, comme avant. C'est parce que lorsque vous exécutez le script directement, la variable __name__ est définie sur "__main__", donc le code à l'intérieur du bloc if __name__ == "__main__": est exécuté.

Ensuite, redémarrez l'interpréteur Python et importez le module :

python3

import pcost

Cette fois, vous ne verrez aucune sortie. Lorsque vous importez le module, la variable __name__ est définie sur "pcost" (le nom du module), pas "__main__". Donc, le code à l'intérieur du bloc if __name__ == "__main__": ne s'exécute pas.

Pour vérifier que la fonction portfolio_cost fonctionne toujours, vous pouvez l'appeler comme ceci :

pcost.portfolio_cost('portfolio.dat')

La fonction devrait retourner 44671.15, ce qui signifie qu'elle fonctionne correctement.

Enfin, quittez l'interpréteur Python en utilisant la commande suivante :

exit()

Ce modèle est très utile lors de la création de fichiers Python qui peuvent être utilisés à la fois comme des modules importables et comme des scripts autonomes. Le code à l'intérieur du bloc if __name__ == "__main__": ne s'exécute que lorsque le fichier est exécuté directement, pas lorsqu'il est importé comme un module.

Créer votre propre module

Maintenant que vous savez utiliser les modules existants, il est temps de créer un nouveau module à partir de zéro. Un module en Python est un fichier contenant des définitions et des instructions Python. Il vous permet d'organiser votre code en parties réutilisables et gérables. En créant votre propre module, vous pouvez regrouper les fonctions et les variables liées, rendant votre code plus modulaire et plus facile à maintenir.

Créer un module de rapport

Créons un simple module pour générer des rapports sur les actions (stocks). Ce module aura des fonctions pour lire un fichier de portefeuille et imprimer un rapport formaté des actions dans le portefeuille.

Tout d'abord, nous devons créer un nouveau fichier nommé report.py. Pour ce faire, nous utiliserons la ligne de commande. Accédez au répertoire project dans votre répertoire personnel et créez le fichier en utilisant la commande touch.

cd ~/project
touch report.py

Maintenant, ouvrez le fichier report.py dans votre éditeur de texte préféré et ajoutez le code suivant. Ce code définit deux fonctions et un bloc principal.

## report.py

def read_portfolio(filename):
    """
    Read a stock portfolio file into a list of dictionaries with
    keys: name, shares, price
    """
    portfolio = []
    with open(filename, 'r') as f:
        for line in f:
            fields = line.split()
            try:
                stock = {
                    'name': fields[0],
                    'shares': int(fields[1]),
                    'price': float(fields[2])
                }
                portfolio.append(stock)
            except (ValueError, IndexError):
                print(f"Couldn't parse: {line}")
    return portfolio

def print_report(portfolio):
    """
    Print a report showing the stock name, shares, price, and total value
    """
    print("Name    Shares    Price    Value")
    print("-" * 40)
    total_value = 0.0
    for stock in portfolio:
        value = stock['shares'] * stock['price']
        total_value += value
        print(f"{stock['name']:6s} {stock['shares']:9d} {stock['price']:9.2f} {value:9.2f}")
    print("-" * 40)
    print(f"Total Value: {total_value:16.2f}")

if __name__ == "__main__":
    portfolio = read_portfolio('portfolio.dat')
    print_report(portfolio)

La fonction read_portfolio lit un fichier contenant des informations sur les actions et retourne une liste de dictionnaires, où chaque dictionnaire représente une action avec les clés name, shares et price. La fonction print_report prend un portefeuille (une liste de dictionnaires d'actions) et imprime un rapport formaté montrant le nom de l'action, le nombre de parts, le prix et la valeur totale. Le bloc principal à la fin s'exécute lorsque le fichier est exécuté directement. Il lit le fichier de portefeuille et imprime le rapport.

Après avoir ajouté le code, enregistrez et quittez l'éditeur.

Tester votre module

Testons notre nouveau module pour nous assurer qu'il fonctionne comme prévu.

Tout d'abord, nous exécuterons le script directement depuis la ligne de commande. Cela exécutera le bloc principal dans le fichier report.py.

python3 report.py

Vous devriez voir un rapport formaté montrant les actions du portefeuille et leurs valeurs. Ce rapport inclut le nom de l'action, le nombre de parts, le prix et la valeur totale, ainsi que la valeur totale de l'ensemble du portefeuille.

Name    Shares    Price    Value
----------------------------------------
AA         100     32.20   3220.00
IBM         50     91.10   4555.00
CAT        150     83.44  12516.00
MSFT       200     51.23  10246.00
GE          95     40.37   3835.15
MSFT        50     65.10   3255.00
IBM        100     70.44   7044.00
----------------------------------------
Total Value:         44671.15

Ensuite, nous utiliserons le module depuis l'interpréteur Python. Démarrez l'interpréteur Python en exécutant la commande python3 dans le terminal.

python3

Une fois que l'interpréteur est en cours d'exécution, nous pouvons importer le module report et utiliser ses fonctions.

import report
portfolio = report.read_portfolio('portfolio.dat')
len(portfolio)  ## Should return 7, the number of stocks
portfolio[0]    ## First stock in the portfolio

L'instruction import report rend les fonctions et les variables définies dans le fichier report.py disponibles dans la session Python actuelle. Nous utilisons ensuite la fonction read_portfolio pour lire le fichier de portefeuille et stocker le résultat dans la variable portfolio. L'instruction len(portfolio) retourne le nombre d'actions dans le portefeuille, et portfolio[0] retourne la première action du portefeuille.

Vous devriez voir la sortie suivante :

7
{'name': 'AA', 'shares': 100, 'price': 32.2}

Maintenant, utilisons le module importé pour calculer nous-mêmes le coût total du portefeuille. Nous allons itérer sur les actions du portefeuille et additionner la valeur totale de chaque action.

total = 0.0
for stock in portfolio:
    total += stock['shares'] * stock['price']
print(total)

La sortie devrait être 44671.15, qui est la même que la valeur totale imprimée par la fonction print_report.

Enfin, créons un rapport personnalisé pour un type d'action spécifique. Nous allons filtrer le portefeuille pour inclure seulement les actions IBM, puis utiliser la fonction print_report pour imprimer un rapport pour ces actions.

ibm_stocks = [stock for stock in portfolio if stock['name'] == 'IBM']
report.print_report(ibm_stocks)

Cela devrait imprimer un rapport montrant seulement les actions IBM et leurs valeurs.

Name    Shares    Price    Value
----------------------------------------
IBM         50     91.10   4555.00
IBM        100     70.44   7044.00
----------------------------------------
Total Value:         11599.00

Lorsque vous avez terminé les tests, quittez l'interpréteur Python en exécutant la commande exit().

exit()

Vous avez maintenant créé et utilisé avec succès votre propre module Python, combinant à la fois des fonctions et un bloc principal qui ne s'exécute que lorsque le fichier est exécuté directement. Cette approche modulaire de la programmation vous permet de réutiliser le code et de rendre vos projets plus organisés et plus faciles à maintenir.

Résumé

Dans ce laboratoire (lab), vous avez appris les concepts fondamentaux des modules Python et comment les utiliser pour organiser votre code. Les modules sont des fichiers Python contenant du code réutilisable, et l'instruction import vous permet d'utiliser le code d'autres modules dans votre programme. Le modèle if __name__ == "__main__" permet aux fichiers de fonctionner à la fois comme des modules importables et comme des scripts autonomes.

Ces concepts sont essentiels pour écrire un code Python maintenable, en particulier lors du développement d'applications plus importantes. Au fur et à mesure que vous continuez à apprendre Python, rappelez-vous que les modules aident à regrouper le code lié, l'importation d'éléments spécifiques garde l'espace de noms propre, et le modèle du module principal est une bonne pratique. Appliquer ces techniques rendra votre code plus organisé, maintenable et réutilisable.