Tutoriel Python - sommaire

Distribuer vos programmes

Dans ce chapitre je vais tenter de vous montrer comment améliorer vos programmes et comment distribuer ensuite votre production : création d'exécutables.

De bonnes pratiques

Les bonnes pratiques de programmation Python sont proposées dans le cadre du PEP (Python Enchancement Proposal : propositions d'améliorations de Python)

Indentation

Vous savez qu'un bloc d'instruction appelé par un while OU un if OU un else OU elif doit être décalé par rapport à l'instruction d'appel.

Consignes :
• utilisez 4 espaces par niveau d'indentation
• ne mélangez jamais dans le même projet des indentations à base d'espaces et de tabulations.

Longueur maximale d'une ligne d'instruction

Une ligne ne doit pas dépasser 79 caractères.
Pour indiquer qu'une instruction n'est pas terminée il faut rajouter en fin de ligne la barre oblique inverse. On peut aussi ouvrir une parenthèse (qui est fermée dans la ligne suivante).

Directives d'importation

Syntaxe déconseillée : import os, math, matplolib, tKinter

Cette instruction est déconseillée car peu lisible
Il est conseillé d'écrire plutôt : import os import math import tKinter as tk

Utilisez des alias pour les modules ayant un nom très long ou qui doit respecter une certaine casse.
Les importations doivent se trouver en début de programme.

Attention à la casse

Python fait la différence entre majuscule et minuscule. On dit qu'il tient "compte de la casse".
Exemple : >>> maChaine ="bonjour" >>> machaine NameError: name 'machaine' is not defined

Il y a une exception (erreur) puisque "machaine" (sans C majuscule) n'existe pas.

Les espaces

Évitez les espaces au coeur des parenthèses, crochets et accolades.
Pas d'espaces autour du signe "=".

Nommer les variables et fonctions

Le premier caractère ne peut être un chiffre, pas de lettres accentuées.
Évitez les lettres majuscules. À défaut au début de chaque mot composé. Exemple : maListe (notation en "CamelCase")

Donnez des noms logiques à vos variables. Si une variable sert de compteur appelez la "compteur" ; si elle doit contenir le score d'une partie appelez la "score".
Je rappelle qu'un mot réservé ne peut être employé pour nommer une variable ou fonction.
Pas de trait d'union dans un nom de variable mais le trait de soulignement("tiret bas").
Pour les variables dont le nom ne comprend qu'un seul caractère il ne faut pas employer : O (o majuscule), l( L minuscule) et I(i majuscule). En effet avec certaines polices le o majuscule peut être confondu avec zéro, le L minuscule avec 1 et I majuscule avec l.
L'usage veut qu'une variable contenant un indice de séquence soit stocké dans une variable "i" (i minuscule).
Les constantes doivent être écrites en majuscules avec des traits de soulignement si le mot est composé.
L'affectation doit se faire avec un tuple.
Exemple : TAUX_REDUIT, TAUX_NORMAL = (5.5, 20)

Les commentaires

Les commentaires peuvent être écrits sur plusieurs lignes à condition d'être encadrés par des guillemets triples (""").

Les messages

Évitez les fautes d'orthographe. Si les messages dans les fonctions input() & print() sont délimités par des guillemets doubles vous pouvez utilisez les apostrophes dans ces chaines.

Évitez les exceptions

Dans le chapitre 12 nous avons abordé la "gestion des exceptions" ; en d'autres termes, les erreurs de saisie.
Personnellement je trouve que la syntaxe correspondant à la gestion des exceptions est lourde.
Gérer les exceptions c'est bien, faire en sorte qu'elles ne puissent survenir c'est encore mieux.

Exemple : programme sur le cercle

Reprenons le programme qui calcule la circonférence et l'aire du cercle à partir du rayon ; le cercle est dessiné.

Le code

Ce programme est structuré :
• deux fonctions
• un programme principal qui appelle ces deux fonctions successivement avec passage d'un argument.

Notez aussi que la première fonction retourne deux valeurs. d'où l'instruction : circonference, aire = cercle1(rayon)

Exécution du programme

L'utilisateur a mal lu les consignes et il saisit "100 cm". Il y alors un plantage !
la fenêtre d'exécution de l'IDLE affiche : saisir le rayon sous forme d'un entier : 100cm Traceback (most recent call last): File "C:\python_prog\cercles.py", line 23, in <module> rayon =eval(rayon) #conversion chaine en entier File "<string>", line 1 100cm ^ SyntaxError: unexpected EOF while parsing

La méthode eval() ne peut convertir une chaine en nombre qu'à la condition que ladite chaine ait un format numérique (des chiffres et éventuellement un point parmi les chiffres).

La solution

Plutôt que gérer l'erreur de saisie, nous allons faire en sorte qu'elle ne puisse plus se produire. Nous allons donc mettre en place un contrôle de saisie efficace.
Dans le programme principal il suffit de remplacer l'instruction input() par trois instructions : rayon ="" while not rayon.isdigit(): rayon = input("saisir le rayon sous forme d'un entier : ")

La méthode de chaine isdigit() retourne VRAI si ladite chaine ne comprend que des chiffres.
Donc on boucle tant que la variable "rayon" comprend autre chose que des chiffres.
N'oubliez pas de créer la variable "rayon" avant l'instruction "while not rayon isdigit()" sinon vous aurez un "plantage" avec le message: "NameError: name 'rayon' is not defined"

Remarque

Et si l'on veut saisir en guise de rayon un nombre décimal ?

Essayez, tapez en guise de rayon le nombre décimal "50.5". Vous ne quittez pas la boucle de saisie puisque la condition dans le WHILE retourne toujours True.
Il faut trouver une solution pour que l'on puisse saisir en guise de rayon un nombre décimal !

Il manque une méthode de classe permettant de vérifier si une chaine a un format décimal (un point entouré de chiffres).
Peut-être dans une version prochaine de Python ...

La solution

Une astuce que j'ai trouvée sur la "toile" et qui est basée sur la méthode replace(). rayon ="" while not rayon.replace("." ,"").isdigit(): rayon = input("saisir le rayon sous forme d'un nombre entier ou décimal : ")

Avant de tester avec la méthode isdigit() il suffit de remplacer dans "rayon" le point décimal par "".

Nous pouvons aller plus loin dans le contrôle de saisie. Il y a des utilisateurs vraiment étourdis qui peuvent saisir des espaces avant et après le nombre. Il faut donc tester une chaine débarassée du point mais aussi d'éventuels espaces. rayon ="" while not rayon.replace("." ,"").strip().isdigit(): rayon = input("saisir le rayon sous forme d'un nombre entier ou décimal : ")

J'ai donc chainé cette fois trois méthodes : replace(), strip(), isdigit()

Solution plus classique

On pourrai aussi utiliser une expression régulière.
Le concept d'expression régulière existe, en effet, dans tous les langages et a été évoquée dans un chapitre précédent.

Nouveau version du programme (extraits): ... import re ... gabarit = "^[0-9.]{1,}$" rayon ="" while not re.search(gabarit,rayon): rayon = input("saisir le rayon sous forme d'un nombre entier ou décimal : ")

Ne pas oublier d'importer le module re (comme "regular expression").
Je définis un gabarit de saisie dans la variable "gabarit". Les caractères autorisés sont les chiffres et le point ; au moins un caractère.
Tant que la valeur saisie dans "rayon" ne correspond pas à ce gabarit, je boucle pour recommencer la saisie.

Trace d'exécution du programme : saisir le rayon sous forme d'un nombre entier ou décimal : 50,5 saisir le rayon sous forme d'un nombre entier ou décimal : 50O saisir le rayon sous forme d'un nombre entier ou décimal : 50.5 circonférence du cercle : 317.3008580125691 aire du cercle : 8011.84666481737 N'oubliez pas de fermer la fenêtre contenant le graphique

Je m'y suis repris à trois fois pour saisir le rayon :
• erreur dans le séparateur décimal : virgule au lieu du point
• confusion entre 0 et O (o majuscule)
• enfin saisie correcte avec le point décimal

Exercice

À vous de bosser un peu. Ainsi vous verrez si vous avez assimilé toutes ces notions.
Vous devez créer un programme structuré qui calcule le périmètre et la surface d'un rectangle et dessine ledit rectangle.
Comme dans l'exemple prévoyez un programme principal contenant deux procédures (dont une fonction) qui retourne deux valeurs.
Dans le programme principal il y a deux saisies (longueur et largeur). Sachant que les dimensions peuvent être des nombres décimaux, prévoyez un contrôle de saisie efficace, toujours en vous inspirant de l'exemple.

Je vous communique la trace d'exécution du programme : Saisir la longueur (pas de symboles autres que chiffres et le point décimal) : 50,50 Saisir la longueur (pas de symboles autres que chiffres et le point décimal) : 50.50 Saisir la largeur (pas de symboles autres que chiffres et le point décimal) : 30,o Saisir la largeur (pas de symboles autres que chiffres et le point décimal) : 30.5 Le rectangle a un périmètre de 162.0 et une aire de 1540.25 N'oubliez pas de fermer la fenêtre contenant le graphique

Encore un programme amélioré

Vous vous souvenez du petit programme qui consistait par essais successifs à trouver un entier généré de façon aléatoire.

Ci-dessous la version améliorée :
• pour éviter l'imbrication de trop de boucles, recours à une fonction
• la fonction correspond à un jeu.
• Une partie comprend 5 jeux.

Le code du programme

La fonction retourne le score d'une partie d'où l'instruction : score_partie = unepartie()

Quelques instructions intéressantes de la fonction :
• while not nbre_joueur.isdigit() : tant que le contenu de "nbre_joueur" n'est pas une suite de chifres ...
• print(f"{nbre_joueur} trop petit",end=" * ") pas de saut de ligne avant la prochaine saisie.
• score -= 1 : décrémente score de 1 ; façon plus simple d'écrire : score = score -1
  Pour incrémenter de 1 la variable "x" il faudrait écrire x+=1

  Trace d'exécution du programme

  Instructions : l'ordinateur produit de façon aléatoire un entier compris entre 1 et 99 Tu dois découvrir cet entier avec le moins d'essais possibles Tu joues 5 fois et ensuite ton score final s'affiche -----------------------------à toi de jouer ---------------------- Saisir un entier inférieur à 100 : 50 50 trop grand * Saisir un entier inférieur à 100 : 30 30 trop grand * Saisir un entier inférieur à 100 : 10 10 trop petit * Saisir un entier inférieur à 100 : 20 Enfin trouvé ; ton score : 7 Saisir un entier inférieur à 100 : 5o Saisir un entier inférieur à 100 : 60 60 trop petit * Saisir un entier inférieur à 100 : ...

  Dans le premier jeu, l'entier a été trouvé au quatrième essai donc le score est 7.
  Aucun "plantage" en cas d'erreur de saisie.

  Ce programme va pouvoir être utilisé par vos connaissances sur leur PC même s'ils n'ont pas installé Python.
  Car nous produire un exécutable. Voir la partie suivante.

  Distribuer vos programmes Python

  Problématique

  Attention toutes les commandes dans ce chapitre s'effectuent dans l'invite de commande Windows.
  Vous avez réalisé un superbe programmme de jeu avec Python et vous voulez en faire profiter vos relations.
  Problème : pour qu'un programme Python fonctionne sur un terminal, il faut que ce langage y soit installé et avec la bonne version et si de plus vous faites appel dans ce programme à des bibliothèques tierces, il faut aussi les installer. Bref pour un non informaticien c'est très compliqué …

  La solution

  Heureusement il existe une bibliothèque externe qui dès qu'elle est installée, permet de produire un programme "standalone" c'est à dire un programme qui fonctionne sans qu'il soit nécessaire d'installer d'autres fichiers.
  Une version "standalone" d'un programme comprend en plus du code, l'exécutable Python et les extensions dont il a besoin.
  Concrétement sous Windows, vous obtiendrez un exécutable (fichier. exe)
  Pour créer cet exécutable il faut utiliser la bibliothèque pyinstaller.

  Pyinstaller

  Pyinstaller est une librairie externe qu'il faut donc installer sur votre ordinateur.

  Installation de pyinstaller

  Si vous avez bien assimilé les chapitre précédents de mon tuto, vous vous doutez qu'il faut utiliser l'outil pip. Et bien vous avez raison.
  Dans la fenêtre de commandes de windows il suffit donc de taper :
  pip install pyinstaller

  Produire un exécutable

  Maintenant que pyinstaller est installé, vous allez voir que la procédure de création d'un exécutable est simple.

  Nous voulons produire un exécutable à partir du programme "nbre_a_trouver_plus.py".

  Ce programme se trouve dans le répertoire "c:\python_prog".

  Procédure à faire dans la console Windows.
  Il n'y a que deux commandes à saisir : cd c:\python_prog" pyinstaller –-onefile nbre_a_trouver_plus.py

  Il faut sélectionner le répertoire qui contient le programme source.
  Attention l'exécution de la deuxième commande peut demander un certain temps ... près d'une minute. Soyez patient. Message final : ... 16768 INFO: Building EXE from EXE-00.toc completed successfully. PS C:\python_prog>

  Le système indique enfin que la fabrication du EXE s'est réalisé avec succès.

  Vérifions !
  Ouvrons le dossier "C:\python_prog".
  Nous constatatons l'existence d'un nouveau sous-dossier "dist" et à l'intérieur de ce sous-dossier un fichier nommé "nbre_a_trouver_plus.exe".
  Ce fichier pèse près de 7 mégas alors que le fichier .py ne pèsait que 1 kilo. Mais c'est logique puisque l'exécutable comprend le "runtime" Python.

  Tester cet exécutable

  Double-cliquez sur le fichier .exe
  Une fenêtre s'ouvre :

  Vous pouvez maintenant distribuer cet exécutable à vos connaissances.
  Mais avant améliorez le ! Ainsi serait mieux que la saisie se fasse dans le cadre d'une interface graphique plutôt que les entrées-sorties basiques à base de input() & print().

  Creer ses propres modules

  Les modules proposés par Python qu'ils soient dans la bibliothèque standard ou dans des librairies externes (ou dépendances) sont nombreux.
  Il se peut cependant que vous ne trouviez pas votre bonheur, que vous ayez besoin de créer vos propres fonctions génériques susceptibles d'être appelés dans différents programmes.

  Le fichier "geometrie.py"

  Je n'ai pas trouvé, mais je n'ai trop cherché, de fonctions relatives aux cercle et rectangle (périmètre et surface).
  J'ai donc crée un fichier "geometrie.py" qui contient deux fonctions personnelles.
  Contenu du fichier : """ Module geometrie qui comprend deux fonctions : cercle() et rectangle() : - cercle() : saisir le rayon lors de l'appel de fonction - rectangle() : saisiri la longueur et la largeur lors de l'appel de fonction """ def cercle(rayon): circonference = rayon *2 * 3.14 aire = rayon**2 * 3.14 return circonference, aire def rectangle(longueur,largeur): perimetre = (longueur *2) + (largeur*2) aire = longueur*largeur return perimetre, aire

  Les commentaires sont très importants dans un module car il feront partie de la documentation sur le module. Pour afficher la documentation sur un module il suffit de taper la commande help(alias).

  Après avoir sauvegardé ce fichier dans le répertoir habituel, je produis la commande Run/Run module ; la fenêtre Shell de l'IDLE s'affiche mais rien ne se produit ...
  C'est logique car dans le fichier il n'y a aucunes instructions appelant ces fonctions.
  Commandes dans le Shell de l'IDLE : >>> import geometrie as geom >>> geom.cercle(50) (314.0, 7850.0) >>> geom.rectangle(50,30) (160, 1500) >>>

  Notez que lorsque vous appelez une fonction, vous êtes assisté, il vous est indiqué par une infobulle les arguments à passer.

  Problème

  Je suis très content de ma réalisation et je me dis que maintenant je vais pouvoir utiliser ces deux fonctions dans le cadre de l'interpréteur Python.
  J'ouvre donc l'interpréteur et je saisis la commande suivante : >>> import geometrie as geo ModuleNotFoundError: No module named 'geometrie'

  Donc l'interpréteur Python ne trouve pas le module ...
  Il ne le trouve pas car il cherche dans le répertoire "c:\Python39" or le fichier de module "geometrie.py" se trouve, comme mes autres fichiers Python, dans "c:\python_prog". Il suffit donc avec le gestionnaire de fichiers de déplacer ce module vers "c:\Python39". Ce que je réalise. Puis j'ouvre de nouveau l'interpréteur : >>> import geometrie as geom >>> help(geom) Help on module geometrie: NAME geometrie DESCRIPTION Module geometrie qui comprend deux fonctions : cercle() et rectangle() : - cercle() : saisir le rayon lors de l'appel de fonction - rectangle() : saisiri la longueur et la largeur lors de l'appel de fonction FUNCTIONS cercle(rayon) rectangle(longueur, largeur) FILE c:\python39\geometrie.py

  Cette fois-ci plus de problème ; mon module de fonctions est accessible à partir de l'interpréteur.
  Notez comment afficher la documentation sur le module ; commande help(nom OU alias du module)