Programmes plus professionnels

structurer un programme : le décomposer en programme principal et en sous-programmes
contrôles de saisie efficaces pour éviter les "plantages" du programme

Un programme structuré

Dès qu'un programme correspond à un algorithme un peu plus complexe (que ce que nous avons vu jusqu'à présent), il faut le structurer.

un programme principal
des sous-programmes

Le programme principal est relativement court car on se contente de saisir des variable, d'appeler des sous-programmes (SP).
Un même sous-programme peut être appelé plusieurs fois par le programme principal.

Les sous-programmes sont appelés plus précisément : procédures ou fonctions.
Les procédures sont des SP qui ne retournent pas de valeurs au programme principal.
Les fonctions sont des SP qui retournent des valeurs au programme principal.

Mais avec Python cette distinction n'a pas d'intérêt pratique : les procédures et fonctions sont définies avec le même mot clé : def.
Dans le code d'une fonction il y aura une instruction return qu'on ne retrouvera pas dans une procédure.

Premier programme structuré

Objectif :

saisir sous forme d'un entier le rayon d'un cercle
calculer la circonférence et de la surface du cercle
afficher ces résultats
dessiner le cercle avec le module turtle

Le code source

# nom du programme : cercle_plus.py
#objet du programme : programme structuré sur le cercle

#procédures et fonctions 
def cercle1(r):
    c = rayon *2 * math.pi
    s = rayon**2 * math.pi
    return c, s

def cercle2(r):
    pencolor('navy')
    pensize(3)
    speed("slow")
    circle(r)
    exitonclick()
#------------------------------------------------
#programme principal
import math
from turtle import *
rayon = input("saisir le rayon (un entier) : ")
rayon =eval(rayon) #conversion chaine en numérique
circonference, aire = cercle1(rayon)    # appel fonction cercle1
print ("circonférence du cercle : " , circonference)
print ("aire du cercle : " , aire)
cercle2(rayon)  #appel procédure cercle2

Nous avons d'abord la description d'une fonction ("cercle1") et d'une procédure ("cercle2")
Puis nous avons le programme principal dans lequel on appelle successivement la fonction "cercle1" et la procédure "cercle2".
Les deux valeurs retournées par la fonction sont récupérées dans le programme principal respectivement dans les variables circonference et aire.
J'affiche ensuite ces deux variables.

Description de la fonction "cercle1"

J'utilise la fonction pi du module math.
Les variables définies dans cette fonction sont : r, c, s

Description de la procédure "cercle2"

La variable utilisée dans cette procédure est r.
Cette variable est utilisée pour dessiner le cercle avec le module turtle.

Batterie de tests

Vous avez saisi le code source et vous vous êtes assuré qu'il fonctionne correctement.
Au fait, n'oubliez pas de cliquer dans la fenêtre graphique pour "reprendre la main".

Maintenant vous allez découvrir via des tests, la notion de portée des variables ainsi que la problèmétique des erreurs de saisie.

Portée des variables

Dans les deux SP ("cercle1" & "cercle2") rajoutez l'instruction "print(rayon)".

Exécutez de nouveau le programme !
Pas de plantage : le rayon est affiché deux fois.
Supprimez logiquement les rajouts : transformer instructions en commentaires.

Deuxième test : dans le programme principal rajoutez " print(c,s)"

Puis lancez l'exécution.
Plantage ! Traceback (most recent call last): File "C:/Users/boulanger/Documents/pythons_programmes/cercle_plus.py", line 28, in <module> print (c,s) NameError: name 'c' is not defined

Tout cela est normal.
Une variable définie au niveau d'un SP (procédure ou fonction) n'est connue que de cette routine ; elle ne peut être manipulée dans le programme principal.
Par contre une variable définie au niveau du programme principal peut être manipulée également dans les SP ; Cette variable a donc une portée plus grande.

Erreur de saisie

Lancez l'exécution du programme et saisissez la chaine "100 cm" .
Il y a "plantage" !
La fonction eval() est incapable de convertir en numérique une chaine comprenant des lettres.

C'est la faute de l'utilisateur qui n'a pas lu l'invite de commande : un entier !
Mais un bon programme doit prévoir les étourderies de l'utilisateur.
Il faut donc améliorer ce programme et prévoir un contrôle de saisie.
C'est l'occasion d'introduire une notion très puissante mais parfois un peu délicate : les expressions régulières.
On retrouve ce concept dans tous les langages. Ainsi le lecteur qui connait JavaScript va retrouver une syntaxe déjà connue.

Nouvelle écriture du programme principal

Extrait : #programme principal import math from turtle import * import re rayon ="" gabarit ="^[0-9]{1,}$" while not re.search(gabarit, rayon): rayon = input("saisir le rayon (un entier !) : ") rayon =eval(rayon) #conversion chaine en numérique ...

Whou ! ça se complique sérieusement.
Voyons toutes les nouveautés :
import re : activation du module re (Regular Expressions) donc le module qui traite des expressions régulières
gabarit ="^[0-9]{1,}$" : la variable gabarit contient une expression régulière qui veut dire "au moins un chiffre".
while not re.search(gabarit, rayon) : tant que le contenu de rayon ne correspond pas au format de saisie défini dans gabarit il faut boucler donc ressaisir le rayon.
Nous avons donc utilisé la méthode search() du module re. et aussi la syntaxe while not … (tant que FAUX)

Construction d'une expression régulière

Une expression régulière est une chaine qui commence par le caractère "^" et se termine pas "$" puis comprend 1 à N couples "classe – quantificateur".
Une classe est délimitée par des crochets, le quantificateur est délimité par des accolades.
Dans l'exemple précédent il n'y avait qu'un couple "classe-quantificateur".

Les classes

Une classe indique le ou les caractères autorisés à la saisie. On reconnait une classe car elle est entre crochets.
Une classe peut être un énumération de caractères autorisés ou un intervalle ou un mélange des deux.

[@] : seul l'arobase est autorisé
[.-_] : seuls le point, le tiret et le souligné sont autorisés
[éèê] : seuls les e accentués sont autorisés
[a-z] : seules les lettres minuscules (de a à z) sont autorisées
[A-z] : seules les lettres (minuscules et majuscules) sont autorisées
[0-9] : seuls les chiffres sont autorisés
[A-z0-9] : deux intervalles ; les lettres et les chiffres sont autorisés
[a-zéèê] : un intervalle suivi d'une liste ; les lettres minuscules y compris les e accentués sont autorisés

Les quantificateurs

Un quantificateur suit une classe et indique le nombre de caractères autorisés à la saisie. Un quantificateur est entre accolades ou est un symbole :

{2} : saisir deux caractères autorisés par la classe
{3,8} : saisir entre 3 et 8 caractères autorisés par la classe
{3,} : saisir au moins 3 caractères autorisés par la classe

* : 0 à plusieurs fois
+ : 1 à plusieurs fois
? : 0 à 1 fois

Expressions régulières : exemples

nom_g = "^[A-z ']{2,}$"
prenom_g = "^[A-z ']{2,}$"
telephone_g = "^[0-9]{10}$"
motpasse_g = "^[A-z0-9 ]{8,}$"

Les expressions régulières nom_g & prenom_g autorisent seulement les lettres minuscules et majuscules mais non accentuée ; au moins deux.
L'expression telephone_g autorise seulement 10 chiffres.
L'expression motpasse_g autorise les chiffres et les lettres non accentuées ; au moins 8 caractères.

Programme "cercle_plus.py" : autre solution

Comme le rayon doit être un entier (donc uniquement des chiffres) il y a une solution plus simple concernant le contrôle de saisie du rayon : c'est à dire sans recourir aux expressions régulières.
Ci-dessus extrait du programme avec une autre technique pour le contrôle de saisie. ... rayon ="" while not rayon.isdigit(): rayon = input("saisir le rayon (un entier !) : ") rayon =eval(rayon) #conversion chaine en numérique ...

Avec la méthode is.digit() la saisie ne doit comporter que des chiffres.
Tant que la saisie dans rayon comprend autre chose que des chiffres, on reste dans la boucle de saisie.

Tirage au sort de cinq cartes : version définitive

Je reviens sur le thème "tirage au sort de cinq cartes dans un jeu de 32".

Dans le chapitre 8 ce programme avait déjà été amélioreé avec l'emploi d'un ensemble interdisant les doublons mais alors "la main" du joueur pouvait alors être inférieure à 5 cartes ...

Dans la version définitive le programme est structuré afin d'être flexible.
Il faut parfois plus de cinq tirages, si le tirage au sort produit des doublons.
Une fonction nommée "tirage_carte()" sera appelée au moins 5 fois (parfois plus) par le programme principal. ... Il faut appeler cette fonction jusqu'à ce que la longueur de l'ensemble "mon_jeu" soit égale à 5.

Le code

# nom programme : tirage_carte_fonction
#objet : tirage au sort de 5 cartes.
""" Version améliorée :
les cartes tirées sont rangées dans un ensemble.
Ainsi il ne peut y avoir de doublons.
"""
# fonction 
def tirage_carte():
        carte_e = choice (enseignes)
        carte_r = choice (rang)
        carte_tiree = str(carte_r) + " de " + carte_e
        return carte_tiree

#programme principal
from random import *
enseignes = ['pique', 'coeur', 'carreau', 'trèfle']
rang = ['As', 'Roi', 'Dame', 'Valet', 10, 9, 8 , 7]
reponse ="o"
while reponse in "Oo":
        mon_jeu =set()      # la main stockée dans un ensemble
        n = 0
        while n < 5:
                carte = tirage_carte()            #appel fonction 
                mon_jeu.add(carte)
                n = len(mon_jeu)
        print("Mon jeu : ")
        for carte in mon_jeu:
                print(carte, end =" - ")
        print("\n ----------------------------------------------")
        reponse =input("Encore un tirage o/n  ? : " )

Tant que n (nombre d'éléments du set "mon_jeu" est inférieur à 5, il faut boucler.
La variable "carte" récupère la valeur retournée par la fonction.

end = " " : espace à la place d'un saut de ligne
\n : saut de ligne avant affichage d'une ligne pointillée

Trace de l'exécution

Mon jeu : 
As de coeur - Dame de trèfle - 7 de coeur - 9 de trèfle - Valet de coeur - 
 ----------------------------------------------
Encore un tirage o/n  ? : o
Mon jeu : 
10 de pique - 8 de pique - Dame de coeur - Roi de pique - 9 de coeur - 
 ----------------------------------------------
Encore un tirage o/n  ? : o
Mon jeu : 
As de coeur - 7 de pique - 9 de carreau - 8 de carreau - Valet de coeur - 
 ----------------------------------------------
Encore un tirage o/n  ? : n

Formater les sorties

Les chaines de format ou "f-strings" permettent d'afficher les sorties selon un format approprié.
Il suffit à l'intérieur du print() d'un f majuscule ou minuscule juste après la parenthèse ouvrante.

Thématique

Calcul de la TVA, du montant TTC à partir du montant HT.

Solution basique

#nom du programme : tva.py
#objet : calcul tva et ttc à partir du ht

ht = input("saisir le montant HT: ")
ht =eval(ht)

print("TVA : ", ht * 0.055)
print("TTC : ", ht * 1.055)

Si vous saisissez 1000, ce programme retourne :
TVA : 55
TTC : 1055

au niveau des sorties il faut préciser qu'il s'agit de montants en €
il n'y a pas de contrôle de saisie du montant HT, si vous saisissez un chaine non numérique il y a plantage !
ce programme calcule la TVA selon le taux réduit. Or il existe aussi le taux normal ...

Un programme très amélioré

#nom du programme : tva_plus.py
#objet : calcul tva et ttc à partir du ht avec contrôles de saisie et en fonction du taux
ht =""
while not ht.isdigit():
    ht = input("saisir le montant HT sous forme d'un entier  ! ")
ht = eval(ht)

type ="F"
while type not in "NnRr":
    type = input("saisir R ou N : ")
if type in "Rr":
        taux = 0.055
if type in "Nn" :
        taux = 0.2

print(f"TVA : {ht * taux} €")
print(f"TTC : {ht * (1 + taux)} €")

Ce programme calcule la TVA et le TTC au taux réduit ou au taux normal.

De plus il y a des contrôles de saisie.
Vous pouvez faire plusieurs tentatives pour la saisie du montant HT et du code_tva. Il y a donc un bémol : le montant HT doit obligatoirement être un entier ...

On associe aux instructions print des "f-strings". Les montants affichés sont libellés en € !
Notez bien la syntaxe à l'intérieur des parenthèses de la fonction print :
f"TVA : {ht * taux} €" : le f doit précèder la chaine entre guillemets. Dans la chaine il y peut y avoir une expression de calcul (entre accolades). Juste après l'accolade fermante rajoutez € !

Trace d'exécution du programme

saisir le montant HT sous forme d'un entier  ! 1000 €
saisir le montant HT sous forme d'un entier  ! 1000
saisir R ou N : réduit
saisir R ou N : normal
saisir R ou N : n
TVA : 200.0 €
TTC : 1200.0 €
>>>

Constatez que malgré de nombreuses erreurs de saisie, il n'y a pas plantage du programme.
Pour préciser le taux réduit on peut saisir r ou R et pour le taux normal : n ou N.
L'affichage des sorties est correct.

Un esprit chagrin peut faire remarquer qu'il serait préférable que les montants affichés apparaissent avec deux décimales.
La solution : print(f"TVA : {ht * taux:.2f} €") print(f"TTC : {ht * (1 + taux):.2f} €")

J'ai donc rajouté juste avant l'accolade fermante la chaine ":.2f". ":" pour indiquer le début d'un format et ".2f" qui signifie "toujours deux décimales".

Traduction

Tutoriel Python - sommaire

Débuter en Python

Python - approfondissements

Tutoriel Python - recherche

L'auteur : Patrick Darcheville