Mon premier script — 5 jours pour comprendre le code et gagner du temps

De la fiche au programme

Programme, algorithme, langage. Un algorithme est une suite d'étapes précises qui résout un problème. La fiche de Nadia, rendue précise :

1. prendre le montant de la facture ;
2. multiplier par le taux annuel (en %), puis diviser par 100 ;
3. multiplier par le nombre de jours de retard, puis diviser par 365 ;
4. ajouter l'indemnité forfaitaire de 40 €.

Un langage est une façon d'écrire ces étapes pour qu'un ordinateur les exécute ; un programme est l'algorithme écrit dans ce langage. Python exécute les lignes dans l'ordre, de haut en bas, exactement comme elles sont écrites : ni plus, ni moins.

montant = 1850
taux_annuel = 12.40
jours_retard = 12
indemnite = 40
penalites = montant * taux_annuel / 100 * jours_retard / 365
total_du = penalites + indemnite
print(penalites)
print(round(penalites, 2))
print(round(total_du, 2))

Affiche 7.5419178082191785, puis 7.54, puis 47.54.

Les variables. montant = 1850 pose l'étiquette montant sur la valeur 1850, comme une cellule de tableur à laquelle vous auriez donné un nom. Le signe = range une valeur ; il ne compare pas. Une variable peut changer : facture = facture + 40 calcule facture + 40, puis range le résultat dans facture. Les noms s'écrivent en minuscules, sans espace ni accent, avec _ entre les mots.

Les types de base.

type(…) donne le type d'une valeur : print(type(1850), type(12.40), type("1850"), type(1850 > 1000)) affiche <class 'int'> <class 'float'> <class 'str'> <class 'bool'>.

Les opérateurs et les priorités. Ce sont ceux de vos formules de tableur, avec deux opérateurs en plus, très utiles pour les jours :

45 jours, ce sont 45 // 7 = 6 semaines pleines et 45 % 7 = 3 jours. Comme dans un tableur, * et / passent avant + et - : 100 + 50 / 2 vaut 125.0, alors que (100 + 50) / 2 vaut 75.0. Les parenthèses comptent.

Les conversions. int("14") donne le nombre 14, float("12.40") donne 12.4, str(14) donne le texte "14". Et round(x, 2) arrondit x à 2 chiffres après la virgule : au centime.

Pourquoi 0.1 + 0.2 n'affiche pas 0.3. Essayez : print(0.1 + 0.2) affiche 0.30000000000000004. L'ordinateur range les nombres à virgule en binaire, et 0,1 ne s'y écrit pas exactement (comme 1/3 ne s'écrit pas exactement en décimal : 0,333…). L'écart est minuscule ; pour un montant, on arrondit au centime à l'affichage : round(0.1 + 0.2, 2) affiche 0.3. Une conséquence à connaître : round(2.675, 2) affiche 2.67, et non 2.68, car 2,675 est rangé comme 2,67499999… Pour un calcul d'aide comme celui de ce livre, c'est sans importance ; pour une comptabilité officielle, c'est votre logiciel comptable qui fait foi.

Lancer, puis lire une erreur en 3 questions

1. Choisir un environnement.

• Dans le navigateur, sans compte : Basthon. Rien à installer ; c'est celui que nous conseillons pour tout ce Boost.
• Sur votre ordinateur : Thonny, un éditeur conçu pour débuter, à télécharger uniquement depuis son site officiel, thonny.org ; ses installateurs pour Windows et macOS contiennent Python. Sur un ordinateur professionnel, installez-le seulement avec l'accord de votre service informatique : beaucoup d'entreprises l'exigent.
• Avec Python : si Python est déjà installé (depuis python.org), il fournit un petit éditeur, IDLE.

2. Console ou script. La console (repérable au signe >>>) exécute une ligne tout de suite, comme une calculatrice : parfait pour essayer. Le script est un fichier .py qu'on écrit en entier, qu'on enregistre, puis qu'on lance (bouton « Exécuter » ou ▶).

3. Afficher et demander. print("Total :", total) affiche plusieurs valeurs séparées par des espaces. input("Montant : ") affiche la question, attend la réponse… et la renvoie toujours sous forme de texte. Pour un nombre, on convertit : float(input("Montant : ")) (nombre à virgule) ou int(input("Jours : ")) (nombre entier).

print("Calcul des pénalités de retard")
montant = float(input("Montant de la facture en euros : "))
jours_retard = int(input("Nombre de jours de retard : "))
taux_annuel = float(input("Taux annuel des pénalités en % : "))
penalites = montant * taux_annuel / 100 * jours_retard / 365
print("Pénalités :", round(penalites, 2), "euros")
print("Indemnité forfaitaire : 40 euros")
print("Total à réclamer :", round(penalites + 40, 2), "euros")

Essai réel :

4. Lire une erreur en 3 questions.

1. Quelle ligne ? Le message donne le numéro de ligne (line 2).
2. Quel type d'erreur ? C'est le premier mot de la dernière ligne du message.
3. Qu'est-ce qui ne va pas à cet endroit ? La fin de la dernière ligne l'explique ; les signes ^ ou ~ montrent où regarder.

Le message de Nadia, lu avec la méthode : ligne 2 (penalites = montant * 0.124) ; TypeError ; can't multiply sequence by non-int of type 'float' = « impossible de multiplier une séquence par un nombre non entier ». La séquence, c'est montant : du texte, car input renvoie toujours du texte. Correction : montant = float(input("Montant de la facture : ")).

L'ordinateur suit votre texte à la lettre et s'arrête à la première chose qu'il ne peut pas faire. Le message d'erreur décrit ce moment précis : où, quoi, pourquoi. Le lire d'abord évite de modifier au hasard un script qui n'avait qu'une seule faute, ou de coller une « solution » trouvée en ligne qui répond à un autre problème. Depuis Python 3.10, les messages sont plus précis et proposent parfois la correction : Did you mean: 'penalites'? (« Vouliez-vous dire : penalites ? »). Un message d'erreur n'est pas une sanction : votre ordinateur et vos fichiers ne risquent rien.

Bon réflexe ou piège ?

Comparer, puis décider

Comparer. Une comparaison donne True (vrai) ou False (faux) : == (égal), != (différent), <, <=, >, >=. Attention : = range une valeur, == compare deux valeurs. On combine les comparaisons avec and (et : les deux doivent être vraies), or (ou : une seule suffit) et not (non). Avec montant = 1850 :

montant = 1850
print(montant > 1000, montant == 1850, montant != 1850)
print(montant > 0 and montant < 1000, montant < 0 or montant > 1000, not montant > 1000)

Affiche True True False, puis False True False.

Décider : if / elif / else. Le nombre de jours d'un mois :

mois = 2
annee = 2028
bissextile = (annee % 4 == 0 and annee % 100 != 0) or annee % 400 == 0
if mois == 2 and bissextile:
    jours_du_mois = 29
elif mois == 2:
    jours_du_mois = 28
elif mois == 4 or mois == 6 or mois == 9 or mois == 11:
    jours_du_mois = 30
else:
    jours_du_mois = 31
print("Ce mois compte", jours_du_mois, "jours.")

Affiche Ce mois compte 29 jours. Les conditions sont testées dans l'ordre ; la première vraie s'exécute, les autres sont ignorées. if veut dire « si », elif « sinon, si », else « sinon » (facultatif). Chaque ligne de test finit par deux-points :, et ce qui en dépend est décalé de 4 espaces : c'est le retrait (ou indentation). Il indique ce qui dépend de la condition, comme un sous-point dans une liste.

L'année bissextile, une condition composée. Une année est bissextile si elle est divisible par 4, sauf les années de siècle, qui ne le sont que si elles sont divisibles par 400. « Divisible par 4 », c'est « le reste de la division par 4 vaut 0 » : annee % 4 == 0 (l'opérateur % du jour 1). La ligne bissextile = … range donc True ou False.

Le piège de l'ordre. Le même programme, avec les deux tests de février inversés :

mois = 2
annee = 2028
bissextile = (annee % 4 == 0 and annee % 100 != 0) or annee % 400 == 0
if mois == 2:
    jours_du_mois = 28
elif mois == 2 and bissextile:
    jours_du_mois = 29
elif mois == 4 or mois == 6 or mois == 9 or mois == 11:
    jours_du_mois = 30
else:
    jours_du_mois = 31
print("Ce mois compte", jours_du_mois, "jours.")

Affiche Ce mois compte 28 jours. pour février 2028 ! Le premier test (mois == 2) est vrai : Python s'arrête là et ne voit jamais le cas bissextile. On place donc le cas le plus précis en premier.

Comme la fonction SI d'un tableur. =SI(B2>1000;"gros";"petit") s'écrit en Python if montant > 1000: … else: … Les elif évitent d'imbriquer des SI les uns dans les autres.

« Une étape, un test, un cas connu »

Rappels : conversions (voir épisode 1), lecture d'erreur (voir épisode 2), nombre de jours d'un mois (voir épisode 3).

1. Les cas de référence : calculez à la main, avec un calendrier, quatre échéances :

1. Une étape à la fois : demander jour, mois, année et délai ; puis le nombre de jours du mois (copié du jour 3) ; puis ajouter le délai ; puis le passage au mois suivant ; puis le changement d'année ; puis l'affichage.
2. Un test après chaque étape, avec les cas de référence.
3. On compare l'obtenu et l'attendu. Seulement si c'est juste, on passe à l'étape suivante.

Le calcul d'échéance :

jour = int(input("Jour de la facture : "))
mois = int(input("Mois de la facture (1 à 12) : "))
annee = int(input("Année de la facture : "))
delai = int(input("Délai de paiement en jours (1 à 28) : "))
bissextile = (annee % 4 == 0 and annee % 100 != 0) or annee % 400 == 0
if mois == 2 and bissextile:
    jours_du_mois = 29
elif mois == 2:
    jours_du_mois = 28
elif mois == 4 or mois == 6 or mois == 9 or mois == 11:
    jours_du_mois = 30
else:
    jours_du_mois = 31
jour_echeance = jour + delai
mois_echeance = mois
annee_echeance = annee
if jour_echeance > jours_du_mois:
    jour_echeance = jour_echeance - jours_du_mois
    mois_echeance = mois + 1
if mois_echeance == 13:
    mois_echeance = 1
    annee_echeance = annee + 1
print("Échéance :", str(jour_echeance) + "/" + str(mois_echeance) + "/" + str(annee_echeance))

Essai réel avec le quatrième cas de référence :

Les quatre cas donnent l'échéance attendue (sorties réelles : 25/3/2026, 13/5/2026, 6/3/2028, 17/1/2027). Le treizième mois de Nadia venait de l'étape oubliée : sans le dernier if, le programme affiche Échéance : 17/13/2026.

Comment lire ce programme. Si le jour obtenu dépasse la fin du mois (jour_echeance > jours_du_mois), on retire le nombre de jours du mois et on passe au mois suivant : 15 avril + 28 = « 43 avril », moins 30 jours, = 13 mai. Si l'on arrive au mois 13, c'est janvier de l'année suivante. Pour afficher la date, str(…) convertit chaque nombre en texte, et + colle les textes avec des / (jour 1).

Pourquoi un délai de 28 jours au plus. Le programme ne passe qu'un mois. Avec un délai de 28 jours au plus, c'est toujours suffisant, car aucun mois n'a moins de 28 jours. Au-delà, il se tromperait : le 30 janvier + 30 jours donnerait un « 29 février 2026 » qui n'existe pas. Nous avons comparé ce programme au calendrier de Python pour toutes les dates de 1900 à 2100 et tous les délais de 1 à 28 jours : aucun écart sur 2 055 592 cas. Les délais plus longs (45 jours fin de mois, 60 jours) se calculent avec le module datetime, que vous découvrirez dans le Pro.

Quand on ajoute une seule étape à la fois, une erreur apparaît juste après l'étape qui l'a introduite : on sait où chercher. Et le cas calculé à la main transforme « ça a l'air de marcher » en « c'est juste » : un résultat plausible peut être faux, comme le total de 100250 € du jour 2. C'est la logique d'un rapprochement bancaire : on vérifie sur quelques lignes connues avant de faire confiance au reste.

Bon réflexe ou piège ?