IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)

Python, de zéro


précédentsommairesuivant

XX. La programmation modulaire

XX-1. Créer ses modules

La programmation modulaire permet de coder un projet Python qui s'appuiera sur plusieurs fichiers sources distincts.

D’une part, cela évite d’avoir un fichier source massif de plusieurs milliers de lignes qui effondrera le codeur sous sa masse et d’autre part, cela offre la possibilité de déporter le projet sur plusieurs codeurs spécifiques, chacun attaché à une partie du projet.

Un module est donc un script contenant une partie du projet. Une fois le module créé, il est alors accessible depuis un autre avec l'instruction import.

L'import peut soit se faire en local et dans ce cas le module est importé dans un scope à son nom ; soit se faire en global et dans ce cas le module est importé directement dans le scope global. Dans ce dernier cas, on doit spécifier explicitement le ou les sous-modules à importer, mais on peut utiliser l’étoile (*) pour signifier « tous les sous-modules disponibles ».

Exemple de module

Fichier « calculs.py »

 
Sélectionnez
1.
2.
3.
4.
5.
#!/usr/bin/env python3
# coding: utf-8

def sqrt(n): return n ** 0.5
def carre(n): return n ** 2

Exemple d'import local

Fichier « main.py »

 
Sélectionnez
1.
2.
3.
4.
5.
#!/usr/bin/env python3
# coding: utf-8

import calculs
print("La racine de 25 est %f et son carré est %d" % (calculs.sqrt(25), calculs.carre(25)))

Exemple d'import global

Fichier « main.py »

 
Sélectionnez
1.
2.
3.
4.
5.
#!/usr/bin/env python3
# coding: utf-8

from calculs import *
print("La racine de 25 est %f et son carré est %d" % (sqrt(25), carre(25)))

Exemple d'import global spécifique

Fichier « main.py »

 
Sélectionnez
1.
2.
3.
4.
5.
#!/usr/bin/env python3
# coding: utf-8

from calculs import sqrt, carre
print("La racine de 25 est %f et son carré est %d" % (sqrt(25), carre(25)))

La seconde méthode semble moins contraignante à l'utilisation. Toutefois, elle montrera ses limites lors de l’import de deux modules distincts contenant chacun des fonctions aux noms identiques. Dans ce cas, c'est le dernier importé qui gagne.

Importer deux fois le même module (ou importer un module « x » puis importer ensuite un module « y » lequel importe lui aussi le module « x ») n’a aucune conséquence (le second import est ignoré). Et importer un module dans le scope à la fois local et global (bien que peu utile et source d’ennuis) reste possible.

XX-2. Tester ses modules

Le souci d'un import est qu'il importe tout le code du fichier importé. Y compris les lignes de tests éventuels qui seront alors exécutées à chaque fois que le fichier est importé.

Exemple

 
Sélectionnez
1.
2.
3.
4.
5.
#!/usr/bin/env python3
# coding: utf-8

def sqrt(n): return n ** 0.5
print(sqrt(25))                    # Test de vérification

Celui qui importera ce module verra systématiquement apparaître « 5.0 » à l'écran à chaque fois qu’il exécutera son programme. Ce qui, même si cela n'est pas néfaste, reste tout de même bien inutile.

Une façon de tester ses modules tout en évitant que ces tests s'exécutent lors de l'import consiste à utiliser le contenu de la variable __name__. En effet, ce contenu change selon que le fichier est exécuté directement (son contenu est alors __main__) ou importé depuis un autre script (son contenu est alors le nom du module).

Un simple test permet alors de détecter le cas et d'agir en conséquence…

 
Sélectionnez
1.
2.
3.
4.
5.
6.
7.
#!/usr/bin/env python3
# coding: utf-8

def sqrt(n): return n ** 0.5
if __name__ == "__main__":
    # Ce code ne s’exécutera pas dans le cas d’un import
    print(sqrt(25))                # Test de vérification

Ici, celui qui exécute ce module verra le test s'effectuer tandis que celui qui l'importe ne verra rien de particulier.

XX-3. Les membres implicites

Un module python possède quelques membres implicites et utilisables par le développeur :

  • __builtins__ : contient les builtins (toutes les méthodes et objets) du module ;
  • __doc__ : contient la première docstring (sera vu ultérieurement) du module ;
  • __file__ : contient le nom et chemin du module ;
  • __name__ : contient le nom du module quand il est importé ou la chaîne __main__ quand il est exécuté directement.

XX-4. Import depuis un autre dossier

Python peut très bien importer un module se trouvant dans un sous-dossier.

XX-4-a. Import par le nom du module

Exemple à partir d’un dossier « xxx »

Fichier « xxx/calculs.py »

 
Sélectionnez
1.
2.
3.
4.
5.
#!/usr/bin/env python3
# coding: utf-8

def sqrt(n): return n ** 0.5
def carre(n): return n ** 2

Fichier « main.py » (import du nom complet du module « xxx.calculs.py »)

 
Sélectionnez
1.
2.
3.
4.
5.
#!/usr/bin/env python3
# coding: utf-8

import xxx.calculs
print("La racine de 25 est %f et son carré est %d" % xxx.calculs.sqrt(25), xxx.calculs.carre(25))

Fichier « main.py » (import du nom du module « calculs.py »par rapport à son dossier « xxx »)

 
Sélectionnez
1.
2.
3.
4.
5.
#!/usr/bin/env python3
# coding: utf-8

from xxx import calculs
print("La racine de 25 est %f et son carré est %d" % calculs.sqrt(25), calculs.carre(25))

Fichier « main.py » (import du contenu entier du module « xxx.calculs.py »)

 
Sélectionnez
1.
2.
3.
4.
5.
#!/usr/bin/env python3
# coding: utf-8

from xxx.calculs import *
print("La racine de 25 est %f et son carré est %d" % sqrt(25), carre(25))

XX-4-b. Import par le nom du dossier

Python pourra aussi importer un dossier directement par son nom à condition que ce dossier possède un fichier spécifique nommé « __init__.py ». Lors de l'import du dossier, ce fichier « __init__.py » est alors exécuté.

Exemple (suite du précédent)

Fichier « xxx/__init__.py »

 
Sélectionnez
1.
2.
3.
#!/usr/bin/env python3
# coding: utf-8
import calculs

Fichier « main.py » (import du dossier « xxx » lequel fera importer par « __init__.py » le module « calculs.py » qui restera local à « xxx »)

 
Sélectionnez
1.
2.
3.
4.
5.
#!/usr/bin/env python3
# coding: utf-8

import xxx
print("La racine de 25 est %f et son carré est %d" % xxx.calculs.sqrt(25), xxx.calculs.carre(25))

Fichier « main.py » (import du contenu du dossier « xxx », lequel fera importer par « __init__.py » le module « calculs.py » qui sera alors global dans le code)

 
Sélectionnez
1.
2.
3.
4.
5.
#!/usr/bin/env python3
# coding: utf-8

from xxx import *
print("La racine de 25 est %f et son carré est %d" % calculs.sqrt(25), calculs.carre(25))

À noter : les imports sont recherchés depuis une liste des dossiers stockée dans la variable sys.path. Cette liste contient entre autres un dossier vide ("") signifiant « dossier de l’exécutable appelé ».

XX-5. Quelques modules utiles

XX-5-a. Modules natifs

Modules intégrés en standard dans la librairie Python :

  • __future__ : bibliothèque de variables et outils qui ordonnent à une version Python de se comporter comme se comportera la version suivante sur certaines caractéristiques ;

  • abc : bibliothèque de variables et d’outils fournissant une infrastructure pour définir des classes abstraites (Abstract Base Class) ;

  • atexit : bibliothèque de variables et d’outils qui permettent d'activer des fonctions qui seront automatiquement appelées lorsque le programme se termine ou s'interrompt ;

  • binascii et base64 : bibliothèques de variables et d’outils qui permettent de coder/décoder un flux binaire en représentation ASCII pour la première et en diverses représentations pour la seconde (la seconde est un enrobage enrichi de la première) ;

  • builtins : bibliothèque contenant toutes les fonctions natives Python. Cela permet de créer sa propre fonction qui surchargera une fonction native et qui pourra donc appeler ladite fonction sans tomber dans un appel récursif ;

  • collections : bibliothèque d’extensions spécifiques des containers de base (tuples, listes, ensembles et dictionnaires) ;

  • configparser (anciennement ConfigParser dans Python 2) : bibliothèque de variables et d’outils qui permettent de gérer un fichier de configuration ;

  • copy : bibliothèque de variables et d’outils permettant de dupliquer des objets Python ;

  • csv : bibliothèque de variables et d’outils permettant de manipuler un fichier de type csv ;

  • ctypes : bibliothèque de variables et d’outils permettant d'attaquer des modules écrits en C ;

  • curses : bibliothèque de variables et d’outils permettant de gérer l'écran et son affichage ;

  • dataclasses : bibliothèque de décorateurs qui peuvent créer automatiquement des méthodes standards (telles __init__() ou __repr__()) aux objets sur certaines spécifications ;

  • datetime : bibliothèque de variables et d’outils qui permettent de gérer les dates et les heures ;

  • decimal : bibliothèque de variables et d’outils qui permettent de gérer et calculer les nombres décimaux avec une précision absolue ;

  • doctest : bibliothèque de variables et d’outils qui permettent de tester la documentation ;

  • enum : bibliothèque de variables et d’outils qui permettent de créer des constantes symboliques (n'existe pas dans Python 2) ;

  • fileinput : bibliothèque de variables et d’outils qui permettent de manipuler les fichiers standards (stdin, stdout et stderr) ;

  • fractions : bibliothèque de variables et d’outils qui permettent de manipuler les fractions ;

  • functools : bibliothèque de variables et d’outils qui permettent de manipuler les fonctions ;

  • getopt : bibliothèque de variables et d’outils qui permettent de gérer les options format Unix ;

  • grp : bibliothèque de variables et d’outils de manipulation de la base de données Unix gérant l’association entre groupe et gid (fichier « /etc/group ») ;

  • hashlib : bibliothèque de variables et d’outils qui permettent de hasher (signer) un flux ;

  • importlib : bibliothèque de variables et d’outils qui permettent d’importer des modules de façon dynamique ou paramétrable ;

  • inspect : bibliothèque de variables et d’outils qui permettent de récupérer des informations sur les objets du code ;

  • io : bibliothèque de variables et d’outils qui permettent de manipuler des descripteurs de fichiers (des flux IO) ;

  • itertools : bibliothèque de variables et d’outils qui permettent de créer des itérateurs puissants ;

  • json : bibliothèque de variables et d’outils qui permettent de manipuler des données au format JSON ;

  • keyword : bibliothèque de variables et d’outils qui permettent de gérer les mots‑clef du langage ;

  • logging : bibliothèque de variables et d’outils qui permettent de logguer des événements et actions ;

  • math : bibliothèque de variables et d’outils qui permettent d'accéder à des fonctions mathématiques avancées ;

  • numbers : classe de base abstraite numérique gérant la hiérarchie des nombres ;

  • operator : contient toutes les fonctions correspondant aux opérateurs natifs, opérateurs pouvant alors être utilisables en tant qu’objets ;

  • os : bibliothèque de variables et d’outils permettant d'accéder au système d'exploitation ;

  • pathlib : bibliothèque représentant le système de fichiers avec la sémantique appropriée pour différents systèmes d'exploitation ;

  • pdb : débogueur Python interactif ;

  • pickle et _pickle (nommé cpickle dans Python 2) : bibliothèque de variables et d’outils qui permettent de sérialiser des objets Python. Le second _pickle (ou cpickle dans Python 2) correspond au premier, mais a été écrit en C pour être plus rapide ;

  • pwd : bibliothèque de variables et d’outils de manipulation de la base de données Unix gérant l’association entre utilisateur et uid (fichier « /etc/passwd ») ;

  • random : bibliothèque de variables et d’outils de génération de nombres aléatoires ;

  • re : bibliothèque de variables et d’outils qui permettent d’utiliser des expressions régulières ;

  • spwd : bibliothèque de variables et d’outils de manipulation de la base de données Unix gérant l’association entre utilisateur et mot de passe (fichier « /etc/shadow ») ;

  • StringIO (Python 2 uniquement) : bibliothèque de variables et d’outils qui permettent de manipuler une chaîne comme un flux IO (intégré au module io dans Python 3) ;

  • struct : bibliothèque de variables et d’outils qui permettent d’effectuer des conversions entre valeurs Python et structures binaires du C ;

  • statistics : bibliothèque de variables et d’outils de calculs statistiques ;

  • subprocess : bibliothèque de variables et d’outils permettant de lancer des programmes externes (des processus) et récupérer leur travail au travers de tubes de communication ;

  • sys : bibliothèque de variables et d’outils permettant d'accéder au système dans lequel se déroule le script ;

  • time : bibliothèque de variables et d’outils qui permettent de gérer les heures ;

  • timeit : bibliothèque de variables et d’outils qui permettent d’effectuer des statistiques sur le temps d’exécution d’une fonction ;

  • types : contient les types Python sous forme de variables. Dans Python 2, ce module contenait tous les types possibles (str, int, long, etc). Dans Python 3, il ne contient que les types qui ne sont pas déjà un objet existant (ex int n'est pas présent dans ce module, car l'objet int existe et peut être utilisé à sa place) ;

  • typing : contient un support de prise en charge des annotations ;

  • unicodedata : bibliothèque de variables et d’outils qui permettent de manipuler l’Unicode ;

  • unittest : bibliothèque de variables et d’outils qui permettent d'automatiser des tests de fonctions et classes ;

  • uuid : bibliothèque de variables et d’outils qui permettent de générer des UUID (Unique UID).

  • xml : bibliothèque de variables et d’outils qui permettent de manipuler les fichiers xml.

  • zlib : bibliothèque de variables et d’outils qui permettent de compresser ou décompresser un flux.

XX-5-b. Modules spécifiques

Modules nécessitant une installation spécifique, mais très souvent utilisés par nombre de développeurs Python :

  • Cryptodome (anciennement nommé Crypto) : bibliothèque de variables et d’outils de chiffrement/déchiffrement selon différents algorithmes (Diffie-Hellman, RSA, etc.) ;

  • matplotlib : bibliothèque de visualisation de fonctions et courbes mathématiques ;

  • numpy : bibliothèque permettant la manipulation de matrices et tableaux multidimensionnels ;

  • pandas : bibliothèque permettant la manipulation et l'analyse des données, tableaux numériques et séries temporelles ;

  • psutil : bibliothèque de variables et d’outils de contrôle des processus et de charge système ;

  • tkinter (nommé Tkinter dans Python 2) : bibliothèque de variables et d’outils qui permettent de créer des IHM graphiques minimalistes basée sur la librairie tcl/tk ;

  • Pygtk : bibliothèque permettant de créer des IHM graphiques basées sur la librairie graphique GTK ;

  • PyQt et PySide : bibliothèques permettant de créer des IHM graphiques basées sur la librairie graphique Qt. Le module PySide est une branche dérivée issue de PyQt ayant maintenant sa propre vie;


précédentsommairesuivant

Copyright © 2022 Svear (svear@free.fr) Permission est accordée de copier, distribuer ou modifier ce document selon les termes de la « Licence de Documentation Libre GNU » (GNU Free Documentation License), version 1.1 ou toute version ultérieure publiée par la Free Software Foundation.