Les Modules en Python

Un module en Python est un fichier contenant des définitions et instructions. Il permet de regrouper des fonctions, classes et variables pour favoriser la réutilisation du code. On l'importe avec le mot-clé import.

1. Importation d'un module

Pour importer un module standard, on utilise import. Par exemple, avec le module random :

import random

nombre_aleatoire = random.randint(1, 10)
print(nombre_aleatoire)  # Affiche un entier entre 1 et 10

2. Alias pour les modules

On peut renommer un module avec as pour simplifier son utilisation :

import random as rnd

valeur = rnd.choice(['a', 'b', 'c'])
print(valeur)  # Affiche un élément aléatoire de la liste

3. Importation partielle

Pour importer uniquement une fonction spécifique, on utilise from ... import ... :

from random import shuffle

mes_liste = [1, 2, 3, 4]
shuffle(mes_liste)
print(mes_liste)  # Affiche la liste mélangée

4. Création de modules personnalisés

On peut créer son propre module en sauvegardant du code dans un fichier .py. Par exemple, fichier calcul.py :

# calcul.py
def additionner(x, y):
    return x + y

def multiplier(a, b):
    return a * b

Puis, dans un autre script :

import calcul

resultat = calcul.additionner(5, 3)
print(resultat)  # Affiche 8

5. Chemin de recherche des modules

L'interpréteur Python cherche les modules dans les répertoires listés dans sys.path, incluant le répertoire courant et les modules intégrés.

Les Packages en Python

Un package est un répertoire contenant un fichier __init__.py, utilisé pour organiser des modules et sous-packages de manière hiérarchique.

1. Structure d'un package

Exemple de structure :

mon_package/
    __init__.py
    module_util.py
    sous_package/
        __init__.py
        module_avance.py

2. Importation depuis un package

On peut importer un module d'un package avec la notation pointée :

import mon_package.module_util

mon_package.module_util.fonction_util()

3. Alias pour les packages

Utilisation d'un alias pour simplifier l'accès :

import mon_package.module_util as mu

mu.fonction_util()

4. Importation partielle d'un package

Importer directement une fonction d'un module dans un package :

from mon_package.module_util import fonction_util

fonction_util()

5. Hiérarchie et importations relatives

Les packages peuvant contenir des sous-packages. Les importations relatives utilisent . pour le niveau courant et .. pour le niveau parent. Par exemple, dans module_avance.py :

# module_avance.py dans sous_package
from . import autre_module
from .. import module_util

6. Rôle du fichier __init__.py

Ce fichier initialise le package et peut définir des symboles publics. Il peut être vide ou contenir du code d'initialisation.

7. Gestion des packages tiers

Des outils comme pip permettent d'installer des packages externes, par exemple requests pour les requêtes HTTP :

pip install requests

La Gestion des Exceptions

Les exceptions gèrent les erreurs à l'exécution, améliorant la robustesse du code. On utilise try-except pour les capturer.

1. Types d'exceptions courants

Python offre plusieurs exceptions intégrées, comme :

• ValueError : valeur incorrecte pour une opération.
• TypeError : type incompatible dans une opération.
• FileNotFoundError : fichier introuvable.
• IndexError : accès à un index invalide dans une liste.

2. Utilisation de try-except

Pour attraper et traiter une exception :

try:
    nombre = int(input("Entrez un entier : "))
    resultat = 100 / nombre
except ValueError:
    print("Entrée invalide. Veuillez entrer un nombre.")
except ZeroDivisionError:
    print("Division par zéro non autorisée.")

3. Capture de l'objet exception

On peut stocker l'exception dans une variable pour accéder à ses détails :

try:
    fichier = open("donnees.txt", "r")
    contenu = fichier.read()
except IOError as erreur:
    print(f"Erreur d'E/S : {erreur}")
finally:
    fichier.close() if 'fichier' in locals() else None

4. Traitement de multiples exceptions

Plusieurs types d'exceptions peuvent être gérés dans un seul bloc :

try:
    # Code risqué
except (TypeError, KeyError) as e:
    print(f"Erreur de type ou de clé : {e}")

5. Bloc finally

Le code dans finally s'exécute toujours, que l'exception survienne ou non, pour des nettoyages :

try:
    connexion = etablir_connexion()
    effectuer_operation()
except Exception:
    print("Une erreur s'est produite.")
finally:
    fermer_connexion(connexion)  # Toujours exécuté

6. Lever des exceptions

On peut déclencher une expection avec raise :

def verifier_age(age):
    if age < 0:
        raise ValueError("L'âge ne peut pas être négatif.")
    return age

try:
    verifier_age(-5)
except ValueError as ve:
    print(f"Erreur : {ve}")

7. Hiérarchie des exceptions

Les exceptions forment une hiérarchie par héritage. Par exemple, ArithmeticError est parent de ZeroDivisionError. Atraper une exception parente capture aussi ses enfants.

8. Bloc else dans try-except

Le bloc else s'exécute si aucune exception n'est levée dans try :

try:
    valeur = calculer()
except CalculError:
    print("Erreur de calcul.")
else:
    print(f"Résultat : {valeur}")

9. Création d'exceptions personnalisées

On peut définir ses propres exceptions en héritant de Exception :

class ErreurPersonnalisee(Exception):
    pass

try:
    raise ErreurPersonnalisee("Condition spécifique non satisfaite.")
except ErreurPersonnalisee as ep:
    print(f"Exception attrapée : {ep}")