Importation de Modules Python — Guide Pratique avec Exemples

Que Sont les Modules Python ?

Un module est un fichier Python unique qui peut contenir variables, fonctions et classes. Quand vous nommez le fichier guru99.py, le module est accessible comme guru99. Les modules permettent de diviser un gros programme en pièces logiques, gardant votre code organisé et réutilisable.

Pourquoi Importer des Modules ?

Pour utiliser du code défini dans un autre fichier, vous devez l'importer. L'importation donne accès aux fonctions, classes et variables du module, comme le mot-clé import dans langages tels que JavaScript, Java ou Ruby.

Créer et Importer un Module

Parcourons un exemple simple.

Structure de dossiers :

modtest/
  test.py
  display.py

1. Créer test.py :

def display_message():
    return 'Bienvenue aux Tutoriels Guru99 !'

2. Créer display.py et importer test :

import test
print(test.display_message())

L'exécution de display.py affiche :

Bienvenue aux Tutoriels Guru99 !

Importer une Classe depuis un Module

Supposons que Car.py définit une classe voiture :

class Car:
    brand_name = 'BMW'
    model = 'Z4'
    manu_year = '2020'
    def __init__(self, brand_name, model, manu_year):
        self.brand_name = brand_name
        self.model = model
        self.manu_year = manu_year
    def car_details(self):
        print('Marque voiture :', self.brand_name)
        print('Modèle voiture :', self.model)
        print('Année fabrication :', self.manu_year)
    def get_car_brand(self):
        print('Marque voiture :', self.brand_name)
    def get_car_model(self):
        print('Modèle voiture :', self.model)

Utilisez-le dans display.py :

import Car
car_det = Car.Car('BMW', 'Z5', 2020)
print(car_det.brand_name)
car_det.car_details()
car_det.get_car_brand()
car_det.get_car_model()

Sortie :

BMW
Marque voiture : BMW
Modèle voiture : Z5
Année fabrication : 2020
Marque voiture : BMW
Modèle voiture : Z5

Utiliser from pour Importer des Éléments Spécifiques

Quand vous n'avez besoin que de quelques fonctions ou variables, importez-les directement :

from test import display_message
print(display_message())

Si vous tentez d'utiliser un nom non importé, Python lève NameError :

from test import display_message
print(display_message1())

Importer Tout depuis un Module

Importez le module entier avec import test et préfixez les noms avec le module, ou importez tous les noms dans l'espace de noms courant avec from test import *. Ce dernier est pratique mais peut polluer l'espace de noms.

Comprendre dir()

La fonction intégrée dir() liste tous les attributs d'un objet, y compris ceux définis dans un module :

import Car
print(dir(Car))

Pour bibliothèques standards :

import json
print(dir(json))

Travailler avec des Packages

Un package est un répertoire contenant un fichier __init__.py et un ou plusieurs modules. Par exemple :

Structure de répertoire :

mypackage/
  __init__.py
  module1.py
  module2.py
  module3.py

Dans module1.py :

def mod1_func1():
    print('Bienvenue dans Module1 fonction1')
def mod1_func2():
    print('Bienvenue dans Module1 fonction2')
# …

Importer avec un alias :

import mypackage.module1 as mod1
mod1.mod1_func1()
mod1.mod1_func2()

Chemin de Recherche des Modules Python

Quand Python résout un import, il vérifie :

1. Le répertoire de travail courant.
2. Modules intégrés.
3. Répertoires listés dans sys.path.

Inspectez-le avec :

import sys
print(sys.path)

Utiliser des Alias pour Modules

Donnez un nom plus court à un module pour améliorer la lisibilité :

import test as t
print(t.display_message())
print(t.my_name)

Imports Absolus vs Relatifs

Dans un projet multi-modules, vous pouvez référencer modules soit par leur chemin complet (absolu) soit relativement au fichier courant.

Exemple Import Absolu

from package1.module1 import myfunc1
# ou
import package1.module1
package1.module1.myfunc1()

Exemple Import Relatif

from .module1 import myfunc1
# ou
from .subpkg.module3 import myfunc3

Les imports absolus sont plus clairs et moins propices aux erreurs quand un projet est déplacé, mais peuvent devenir verbeux. Les imports relatifs gardent le code concis mais peuvent être plus difficiles à tracer dans gros projets.

Points Clés à Retenir

• Les modules permettent de diviser le code Python en fichiers séparés.
• Utilisez import ou from … import … pour accéder au contenu des modules.
• Les alias (as) rendent les noms de modules longs plus faciles à manipuler.
• Les packages organisent les modules en répertoires, avec __init__.py les marquant.
• Comprenez sys.path pour dépanner erreurs d'import.
• Choisissez imports absolus pour clarté, imports relatifs pour brièveté.