La langage python est récemment devenu très populaire de par sa facilité apparente d’utilisation. Il reste néanmoins un langage informatique qui comporte des notions complexes, et une fois les premiers programmes écrits (scripts), il faut assez rapidement réfléchir à structurer le programme pour qu’il devienne exploitable sur le moyen terme, au risque sinon de devenir du code mort, jetable, et donc perdu.

Pour éviter cette dérive, voici quelques conseils avec des exemples rapides d’utilisation.

Version 1 du programme, un "script"

Prenons comme exemple un petit programme en python suivant, qui permet d’afficher un simple "coucou" dans un terminal, que l’on enregistre dans le fichier programme_v1.py :

 

print("Coucou")

 

Pour voir le résultat ce petit programme, on peut l’exécuter ainsi :

python programme_v1.py

... qui affiche donc dans le terminal

Coucou

Version 2 : programme, le rendre exécutable

Cela peut devenir vite fastidieux de mettre à chaque fois le mot "python" devant chacun des programmes que l’on utilise, alors qu’au final c’est le programme dont on a besoin. Il existe une commande pour changer cela, mais qui nécessite de revoir un peu la structure de notre petit programme, il faut lui ajouter un shebang à la première ligne.

#!/usr/bin/env python3

print("Coucou")

Le nouvelle programme s’appelle maintenant programme_v1.1.py.

Remarquez que comme il s’agit d’une version mineure du programme, j’ai incrémenté son numéro simplement (passage de 1 à 1.1). Nous reviendrons sur cette notion plus loin.

Pour rendre ce programme exécutable et le lancer, il faut taper :

chmod +x programme_v1.1.py
./programme_v1.1.py
Coucou

Remarquez qu’il faut préciser l’emplacement du fichier pour que le système lance le programme, en spécifiant "./" au début du nombre du programme. Le point suivi d’une barre oblique "./" indique que l’on utilise le répertoire courant, et qu’il faut exécuter le programme "programme_v1.1.py".

Le résultat ne change pas.

Version 2 du programme, du script au programme

Le "script" par définition est un petit programme qui a vocation à être court, pour répondre à un besoin précis, on peut souvent le réécrire sans trop reprendre un ancien script. C’est l’une des raisons de l’utilisation du shell bash, c’est qu’il permet d’enchaîner plusieurs traitements rapidement, par exemple faire le déplacement et le renommage de milliers de fichiers.

Si l’on utilise python c’est souvent parce que le traitement que l’on envisage va faire beaucoup plus d’étapes qu’envisagé initialement. Il est donc utile de mieux organiser son programme dès le départ, en suivant quelques bonnes pratiques.

La version 2 de notre programme ne va pas faire évoluer grandement encore notre programme, mais elle va permettre de le structurer.

Le fichier programme_v2.py devient ainsi à partir du fichier programme_v1.1.py :

#!/usr/bin/env python3

def main() :
 print("Coucou")

if __name__ == "__main__" :
 main()

Quand on rend exécutable le programme et qu’on le lance, le résultat est toujours le même, pour le moment.

Version 3 : découper les fonctionnalités du programme

Un programme est un ensemble d’étapes que l’on veut faire faire à un ordinateur. La tâche la plus compliquée est de découper les actions pour qu’elles soient réutilisables dès le début, c’est à la fois utile pour clarifier les étapes à exécuter, mais aussi pour mieux isoler les endroits du programme où il faudra réfléchir sur le meilleur moyen d’arriver au résultat, qui le bien souvent doit faire appel à un algorithme simple ou complexe.

Pour réaliser le programme, on va donc le découper en fonction, chaque fonction va contenir des commentaires au format docstrings.

# !/usr/bin/env python3

def affiche_coucou() :
 """
 Fonction qui permet d’afficher le texte Coucou
 """
 print("Coucou")

def main() :
 affiche_coucou()

if __name__ == "__main__" :
 main()

Après avoir donné les permissions d’exécution au programme, le texte "Coucou" s’affiche à nouveau dans le terminal quand lance le programme.

Documenter son programme

L’intérêt d’avoir mieux organisé son programme est qu’il est maintenant plus modulaire, ce qui permet de le rendre plus visible, donc de produire une documentation !

Il existe plusieurs moyens de documenter son programme, mais une manière simple est de faire appel à pydoc3.

Pour l’installer sur son système il faut utiliser la commande pip :

pip install pdoc3

Cela va créer dans votre espace de travail ($HOME) une commande dans le répertoire $HOME/.local/bin.

Il suffit maintenant de générer un fichier HTML du code en version 3 :

$HOME/.local/bin/pdoc3 programme_v3.py —html —force

Cette commande va générer un fichier au format HTML qu’il est possible de regarder en ligne directement avec un navigateur.

Version 4 : continuer à développer son programme

Une fois la première ébauche du programme réalisée, il faut commencer à réfléchir à toutes les étapes que l’on voudrait réaliser, les documenter avec des docstrings, puis ensuite les écrire une par une. Une fois cette implémentation préliminaire réalisée, il sera possible d’avoir des programmes python très complexes, bien documentés et réutilisables.

# !/usr/bin/env python3

def affiche_texte(letexte) :
 """
 Fonction qui permet d’afficher le texte fourni en argument
 """
 print(letexte)

def demande_texte() :
 """
 Fonction qui demande un mot à afficher à l’utilisateur, pour l’instant elle ne fait rien
 """
 pass

def main() :
 demande_texte()
 affiche_texte("Coucou")
 affiche_texte("Bonjour")

if __name__ == "__main__" :
 main()

Dans cette version v4 du programme la fonction affiche_coucou() a été renommée et modifiée pour devenir affiche_texte(letexte), elle devient ainsi plus générique car l’argument passé à la fonction (enregistré dans la variable letexte) est le texte à afficher, et non une valeur statique.

Une seconde fonction a été ajoutée (demande_texte()), elle ne fait pour l’instant rien, mais aura comme objectif de demander à l’utilisateur le mot à afficher. Comme il y a plusieurs moyens pour interroger un utilisateur, en ligne de commande, ou via une interface graphique par exemple, ce point ne sera pas détaillé ici.

En conclusion

Le petit exemple présenté dans un article fait partie des bonnes pratiques qu’il est important de suivre à chaque fois que l’on écrit un programme en python. Avec un peu de rigueur cela permet d’obtenir rapidement un code propre, clair et fonctionnel. Cela permet aussi d’obtenir très rapidement un résultat qui correspond à ce dont on a besoin, c’est donc en plus d’une bonne pratique, une méthode efficace de développement.

Comme indiqué précédemment, un des éléments importants pour éviter d’avoir x version du même programme est de le versionner de manière incrémentale. Cependant cela devient vite compliqué de fonctionner ainsi, c’est pour cela qu’il vaut mieux tout de suite utiliser un gestionnaire de version comme git avec un hébergement sur github, gitlab ou encore un dépôt local. Cela vous permettra de mieux suivre vos changements, même en travaillant seul sur un projet, en faisant des changements importants entre chaque commit.

Le code détaillé rapidement ici est ainsi présent sur mon dépôt github public : https://github.com/TeletcheaLab/pythondemo/.