Prérequis

Avant de vous plonger dans cette leçon, vous devez être familiarisé avec :

• Le travail avec les fonctions
• La création de scripts Python

Objectifs pédagogiques

À la fin de cette leçon, vous serez capable de :

• Créer vos propres modules
• Importer et utiliser vos modules
• Utiliser les modules de la bibliothèque standard Python

Au fur et à mesure que vos projets Python grandissent, votre code peut rapidement devenir long et difficile à gérer. Au lieu de placer tout votre code dans un seul fichier, Python vous permet de le diviser en modules. Un module est simplement un fichier Python (avec l'extension .py) contenant du code connexe — comme des variables, des fonctions et des classes — regroupé selon les fonctionnalités.

Prenons un scénario où vous construisez un programme qui gère différents aspects des opérations d'une entreprise — comme la gestion des clients, l'analyse des ventes et le contrôle des stocks. Initialement, vous pourriez commencer à écrire tout votre code dans un grand fichier :

# Code for managing customers
customers = {"Alice": {"age": 30}, "Bob": {"age": 25}}

# Code for analyzing sales
sales_data = [100, 200, 300]
total_sales = sum(sales_data)

# Code for managing inventory
inventory = {"item1": 50, "item2": 30}

Bien que cette approche puisse fonctionner pour de petits projets, elle devient ingérable à mesure que le projet grandit. Le code est difficile à naviguer, déboguer ou étendre car il manque d'organisation. De plus, si différentes équipes travaillent sur différentes parties du programme, un seul fichier rend la collaboration difficile.

Une façon plus efficace de gérer des programmes complexes est d'utiliser des modules. En divisant votre code en plusieurs fichiers (modules) basés sur les fonctionnalités — comme customer_management.py, sales_analysis.py, et inventory_control.py — vous rendez la base de code plus facile à lire, maintenir et faire évoluer.

Dans cette leçon, vous apprendrez à créer vos propres modules, à les importer et à les utiliser dans vos projets, et à tirer pleinement parti de la riche bibliothèque standard de Python. Cela vous permettra de construire des programmes bien structurés, faciles à maintenir et adaptables aux exigences changeantes.

Comme mentionné précédemment, un module est simplement un fichier Python contenant du code organisé en variables, fonctions et même classes. Supposons que nous ayons besoin de gérer des opérations liées aux clients, nous pouvons alors créer un module nommé customer_management.py qui contiendra les fonctions liées à la gestion des données clients :

"""
customer_management.py
Simple module with three functions to manage customer
"""

customers = {}

def add_customer(name, age, email):
    """Adds a new customer to the customers dictionary."""
    customers[name] = {"age": age, "email": email}
    print(f"Customer {name} added successfully.")

def remove_customer(name):
    """Removes a customer from the customers dictionary."""
    if name in customers:
        del customers[name]
        print(f"Customer {name} removed successfully.")
    else:
        print(f"Customer {name} does not exist.")

def get_customer_info(name):
    """Returns the details of a customer."""
    return customers.get(name, "Customer not found.")

Tu peux créer ce fichier appelé customer_management.py dans un dossier spécifique, par exemple dans un dossier modules de ton projet. On va l’utiliser pour la suite.

Ce module maintient un dictionnaire appelé customers, qui stocke les détails des clients comme leur nom, âge et email. Les fonctions définies dans le module permettent d'ajouter un nouveau client, de supprimer un client existant et de récupérer les informations d'un client. Une docstring en haut du fichier fournit une brève description de ce que fait le module.

Pour utiliser les fonctions et variables définies dans votre module (comme customer_management.py) dans un autre script Python ou Jupyter Notebook, vous devez importer le module. Assurez-vous que le fichier du module est dans le même répertoire que votre Jupyter Notebook ou script Python.

La façon la plus simple d'importer un module est d'utiliser l'instruction import suivie du nom du module :

import customer_management

Vous pouvez maintenant utiliser n'importe quelle fonction ou variable du module en la préfixant avec le nom du module :

# Add a new customer
customer_management.add_customer("Carmine", 39, "carmine@example.com")

# Get and print customer info
print(customer_management.get_customer_info("Carmine"))

# Output:
# {'age': 39, 'email': 'carmine@example.com'}

Outre les librairies que vous pouvez créer vous-même, il existe une multitude de librairies déjà développées par la communauté Python. Parmi les plus populaires, on peut citer NumPy, Pandas, Matplotlib, Scikit-learn, et bien d'autres. Ces librairies sont largement utilisées pour leurs fonctionnalités puissantes et leur efficacité dans des domaines variés tels que le calcul scientifique, l'analyse de données, la visualisation, ou encore le machine learning.

Si vous avez installé Anaconda, une grande partie de ces librairies est déjà préinstallée sur votre ordinateur. Lorsque vous appelez une librairie dans votre code, l'interpréteur Python la charge directement depuis votre disque dur. Pour cette raison, il est crucial d'éviter de nommer vos propres modules avec des noms identiques à ceux des librairies existantes. Cela pourrait entraîner des conflits d'importation et causer des erreurs inattendues dans votre programme. Par exemple, si vous créez un module nommé numpy.py, Python pourrait importer votre fichier à la place de la librairie NumPy, ce qui rendrait votre code dysfonctionnel. Pour éviter cela, choisissez des noms uniques et explicites pour vos modules personnels.

Importer des fonctions ou variables spécifiques

Si vous n'avez besoin que de fonctions ou variables spécifiques d'un module, vous pouvez utiliser la syntaxe from ... import :

from customer_management import add_customer, get_customer_info

Cela importe uniquement les fonctions spécifiées add_customer et get_customer_info du module customer_management. Vous pouvez maintenant utiliser ces fonctions directement sans les préfixer avec le nom du module :

# Add a new customer and retrieve info for an existing one
add_customer("Sara", 34, "sara@example.com")
print(get_customer_info("Sara"))

# Output:
# {'age': 34, 'email': 'sara@example.com'}

Vous pouvez également importer tout depuis un module :

from customer_management import *

L'astérisque (*) dans l'instruction import est utilisée pour importer toutes les fonctions, variables et classes d'un module. Cela signifie :

• Vous pouvez utiliser toutes les fonctions et variables du module importé sans les préfixer avec le nom du module.
• Cependant, ce n'est généralement pas recommandé dans le code de production car cela peut conduire à des conflits de noms et rendre le code moins lisible.

Importer avec un alias

Vous pouvez aussi importer un module avec un alias pour lui donner un nom plus court en utilisant le mot-clé as :

import customer_management as cm

Cela peut rendre le code plus court et plus propre :

# Add a new customer and retrieve their info
cm.add_customer("Eva", 35, "eva@example.com")
print(cm.get_customer_info("Eva"))

# Output:
# {'age': 35, 'email': 'eva@example.com'}

print(cm.customers)

# Output:
# {'Carmine': {'age': 39, 'email': 'carmine@example.com'},
#  'Sara': {'age': 34, 'email': 'sara@example.com'},
#  'Eva': {'age': 35, 'email': 'eva@example.com'}}

Importer des modules de la bibliothèque standard Python

La bibliothèque standard Python contient plus de 200 modules que vous pouvez importer selon vos besoins. Par exemple, pour effectuer des opérations de statistiques mathématiques — comme calculer la moyenne, la médiane, le mode, l'écart-type — vous pouvez importer le module statistics et utiliser ses fonctions. Voici comment cela fonctionne :

# import standard statistics module
from statistics import mean, median, mode, stdev

# Example data
data = [1, 2, 2, 3, 4, 5, 5, 5, 6]

# Calculating mean, median, and mode
average = mean(data)
med = median(data)
mod = mode(data)
st_dev = stdev(data)

# Output
print(f"Mean: {average}")
print(f"Median: {med}")
print(f"Mode: {mod}")
print(f"Standard Deviation: {st_dev}")

# Output:
# Mean: 3.6666666666666665
# Median: 4
# Mode: 5
# Standard Deviation: 1.6583123951777

Dans l'exemple ci-dessus, nous utilisons plusieurs fonctions du module statistics :

• mean(data) : Calcule la moyenne arithmétique des données fournies.
• median(data) : Trouve la médiane (valeur centrale) des données fournies.
• mode(data) : Identifie la valeur la plus fréquente.
• stdev(data) : Calcule l'écart-type des données fournies.

Les autres modules couramment utilisés de la bibliothèque standard Python incluent :

1. Module math : Offre accès à des fonctions mathématiques comme la trigonométrie, les logarithmes et les factorielles, essentielles pour effectuer des calculs mathématiques complexes.
2. Module random : Permet de générer des nombres aléatoires, mélanger des séquences et choisir des éléments aléatoires dans une collection, utile pour les simulations, les jeux et les tests.

Module re

Le module re en Python est un outil pour travailler avec les expressions régulières (ou RegEx). Une expression régulière est un motif (pattern en anglais) qui définit un ensemble de règles pour rechercher ou identifier des séquences de caractères spécifiques dans un texte. Par exemple, le motif "\d{4}" recherchera toute séquence de 4 chiffres. Pour la conformité RGPD, ce module est inestimable car il permet de détecter et d'anonymiser les informations personnelles identifiables (IPI) comme les noms, emails et numéros de carte de crédit dans le texte en utilisant ces motifs de recherche. En remplaçant les informations sensibles par des espaces réservés, nous pouvons gérer les données de manière sécurisée et respecter les exigences du RGPD.

Fonctions clés de re

• re.sub(pattern, repl, string) : Remplace toutes les occurrences d'un motif dans une chaîne par un substitut spécifié. Idéal pour anonymiser les informations sensibles.
• re.findall(pattern, string) : Recherche toutes les occurrences d'un motif et les renvoie sous forme de liste. Utile pour localiser et auditer les données sensibles.
• re.match(pattern,string) et re.fullmatch(pattern,string) : Ces fonctions vérifient si une chaîne correspond à un motif spécifique. re.match() vérifie une correspondance au début de la chaîne, tandis que re.fullmatch() s'assure que toute la chaîne correspond au motif.

Le script Python suivant utilise re.sub() pour rechercher et remplacer les noms, les adresses e-mail et les numéros de carte de crédit par des espaces réservés, garantissant ainsi la sécurité des informations sensibles.

import re

def anonymize_for_gdpr(text):

    # Regular expression for Credit card numbers (13 to 16 digits)
    card_pattern = r'\b(?:\d[ -]*?){13,16}\b'

    # Regular expression for names (First Last)
    name_pattern = r'\b[A-Z][a-z]*\s[A-Z][a-z]*\b'

    # Regular expression for email
    email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'

    # Replace credit card numbers with '[CARD REDACTED]'
    text = re.sub(card_pattern, '[CARD REDACTED]', text)

    # Replace names with '[NAME REDACTED]'
    text = re.sub(name_pattern, '[NAME REDACTED]', text)

    # Replace email addresses with '[EMAIL REDACTED]'
    text = re.sub(email_pattern, '[EMAIL REDACTED]', text)

    return text

# Example text in the context of a financial report
financial_report = """
Quarterly Financial Report - Q4 2023

Client: Ada Lovelace
Account Manager: Jane Smith
Transaction Summary:
- Credit Card Payment: 4111-1111-1111-1111
- Contact Email: ada.lovelace@domain.fr

Notes:
Ada Lovelace's investment portfolio has increased by 15% this quarter. For additional details, please reach out to the assigned account manager.

Prepared by: Financial Services Team
"""

# Apply anonymization
anonymized_text = anonymize_for_gdpr(financial_report)
print(anonymized_text)

Examinons de près chaque motif :

Motif de carte de crédit : r'\b(?:\d[ -]*?){13,16}\b'

Ce motif est conçu pour correspondre aux numéros de carte de crédit, qui contiennent souvent 13 à 16 chiffres et peuvent être formatés avec des espaces ou des tirets.

• \b : C'est un word boundary ou (“frontière de mots” en français). Elle indique que la correspondance doit se produire au début ou à la fin d’un mot, ce qui aide à éviter les correspondances partielles.
• (?:\d[ -]*?) : Cette partie du motif est un Non-capturing group qui aide à structurer la séquence de chiffres.
  • \d : Correspond à un seul chiffre (0–9).
  • [ -]*? : Correspond à zéro ou plusieurs espaces ou tirets de manière minimale.
• {13,16} : Ce quantificateur spécifie que le groupe précédent doit se répéter entre 13 et 16 fois.

Motif de nom : r'\b[A-Z][a-z]*\s[A-Z][a-z]*\b'

Ce motif correspond aux noms simples qui consistent en un prénom et un nom de famille, tous deux commençant par des majuscules.

• \b : Une frontière de mot.
• [A-Z] : Correspond à une seule lettre majuscule (A–Z).
• [a-z]* : Correspond à zéro ou plusieurs lettres minuscules.
• \s : Correspond à un espace entre le prénom et le nom.

Motif d'email : r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'

Ce motif est conçu pour capturer les adresses email.

• \b : Frontière de mot.
• [A-Za-z0-9._%+-]+ : Correspond à un ou plusieurs caractères autorisés dans un nom d'utilisateur email.
• @ : Correspond au symbole @ dans les adresses email.
• [A-Za-z0-9.-]+ : Correspond aux caractères du nom de domaine.
• \. : Correspond à un point littéral.
• [A-Z|a-z]{2,} : Correspond à l'extension de domaine.

Tableau des motifs clés

Excellent travail ! Dans cette leçon, vous avez découvert les modules Python, un outil fondamental qui vous aide à organiser votre code en parties réutilisables et gérables.

Vous savez maintenant qu'un module est simplement un fichier Python contenant des variables, des fonctions et des classes qui peuvent être importés et utilisés dans d'autres scripts ou programmes. Vous avez exploré comment créer vos propres modules en organisant le code connexe dans des fichiers séparés et en les important à l'aide du mot-clé import.

De plus, vous avez appris différentes façons d'importer des modules, comme l'importation de fonctions spécifiques avec from module import function, l'importation de modules avec un alias en utilisant le mot-clé as, et l'importation de tout le contenu d'un module avec from module import *.

Continuez votre excellent travail !