Guide complet : Créer, importer et réutiliser vos propres modules Python

Que vous soyez débutant ou expert en programmation Python, vous maîtrisez la commande import pour charger des modules. Mais savez-vous d'où ils proviennent et comment en créer vos propres ?

Découvrons l'origine des modules, leur création, leur importation et leur réutilisation pour optimiser votre code.

Qu'est-ce que la réutilisabilité du code et pourquoi l'adopter ?

L'une des meilleures pratiques en programmation serveur est la modularisation du code pour le rendre réutilisable. Python, en tant que langage orienté objet, excelle dans ce domaine.

La modularisation consiste à encapsuler des instructions dans des blocs nommés, facilitant leur séparation et leur réemploi.

En assignant un nom unique à chaque bloc, vous n'avez qu'à l'invoquer au lieu de recoder l'ensemble, accélérant le développement de projets réels.

Cette approche améliore la vitesse d'exécution, simplifie les tests et rend le code plus lisible et efficace.

Bien que cet exemple se concentre sur des fonctions simples, notons que la réutilisabilité s'étend aux méthodes de classes en programmation orientée objet (POO).

Programmation orientée objet (POO) en Python

La POO modélise le code sous forme d'objets indépendants regroupés en classes, dotés d'attributs (caractéristiques) et de méthodes (comportements).

Contrairement à la programmation procédurale, où fonctions et données sont séparées, la POO les unit dans des classes autonomes, rendant le code plus efficace et spécifique.

Chaque classe acquiert une identité unique, importable comme un module.

Pour approfondir, consultez notre guide du débutant sur la POO.

Créer des fonctions réutilisables : exemple pratique

Illustrons avec une fonction de comptage de mots réutilisable dans un autre fichier Python. Nous nous concentrons ici sur des fonctions autonomes, hors classes.

Créez un dossier projet via l'invite de commande : mkdir word_count. Activez un environnement virtuel.

Pour le comptage, une approximation basique : nombre de mots ≈ nombre d'espaces + 1.

Créez wordcounter.py dans le dossier projet.

Version brute fonctionnelle :

# Crée une liste contenant une chaîne
word = ['comment faire un compteur de mots en python']
# Compte les mots via list comprehension
NumberOfWords = [EachWord.count(' ') + 1 for EachWord in word]
print(NumberOfWords)
# Sortie : [8]

Maintenant, modularisons en fonction réutilisable :

def CountWords(words):
    if words is not None:
        NumberOfWords = [EachWord.count(' ') + 1 for EachWord in words]
        return NumberOfWords

mywords = ['faire un compteur de mots en python']
print(CountWords(mywords))
# Sortie : [7]

Votre module de comptage de mots est prêt. Voyons son importation.

Importer le module créé

Les fichiers doivent être dans le même répertoire. Créez un nouveau fichier Python dans ce dossier.

Exemple d'utilisation :

from wordcounter import CountWords
mots = ["comment importer et réutiliser votre code en Python"]
print(CountWords(mots))
# Sortie : [8]

CountWords est importée depuis wordcounter.py.

Importation absolue du module

Si les fichiers sont dans des répertoires différents, utilisez une importation absolue.

Exemple : déplacez wordcounter.py dans un sous-dossier subword_count.

Dans un fichier du répertoire racine :

from subword_count.wordcounter import CountWords
mots = ["comment importer et réutiliser votre code en Python pour des fichiers dans différents dossiers"]
print(CountWords(mots))
# Sortie : [14]

Python parcourt subword_count pour charger CountWords.

Où appliquer la réutilisabilité du code ?

Utilisez-la dans tout projet : importez classes, méthodes ou fonctions, explicitement ou absolument selon la structure.

Cette pratique optimise tout développement Python.