Infoforall

Python 20 : Les instructions basiques (Révisions 1)

Cette partie va nous permettre de faire le point sur les variables et sur les structures de données qui se comportent comme des sortes de variables beaucoup plus complexes car elles contiennent elles-mêmes beaucoup d'autres variables. Cela nous permettra également de faire le point sur les grands éléments de la programmation que nous avons rencontré jusqu'à maintenant.

Il s'agit en grande partie d'une activité bilan de fin d'année ou d'une activité permettant de réactiver les connaissances en début d'année.

On y parle donc d'un peu tout également : les modules, l'importation des modules, les bouches, les fonctions et les méthodes.

L'activité suivante introduira de nouveaux outils pour stocker les données.

Si vous avez le moindre doute, n'hésitez pas ici à me poser la quesion : il s'agit bien d'une activité pour remettre tout au clair avant de recommencer à rajouter des couches de connaissances.

Pour gagner du temps et être certain que vous ayez les bonnes réponses, j'ai laissé volontairement beaucoup de réponses visibles. Tachez néanmoins de bien répondre aux questions : lire n'est pas agir.

1 - Les variables numériques

Rappel

Une variable est l'association de quatre choses :

  • Un nom permettant d'y faire appel : x, monNombre, mon_nombre, ma_variable_a_moi ..
  • Une localisation mémoire précise dans laquelle on va regarder lorsqu'on fait appel au nom de la variable
  • Des données stockées à cette adresse sous forme d'octets ( 0010 1001 par exemple)
  • Le type de données que contient la variable : ce type va servir à donner la bonne signification aux octets contenus dans l'espace-mémoire.

Ainsi, si on vous dit qu'on a stocké un octet valant 0100 0001 (65 en décimal) dans la variable ma_variable, cela ne vous servira à rien : vous ne savez pas comment décoder ce contenu...

Pour parvenir à comprendre le contenu d'une variable, il faut connaitre son type : connaissant son type, on en déduit la façon dont on doit décoder le contenu.

Ainsi, si ma_variable est de type integer (int), 0100 0001 veut dire que ma_variable contient le nombre entier 65..

Si ma_variable est de type string (str) et est encodée selon un encodage connu, un octet contenant 0100 0001 veut dire que ma_variable contient certainement A qui correspond au code numérique 65 dans la majorité des encodages : ceux-ci ont été créés pour être compatibles avec les 128 premiers codes de la table ASCII.

Pour en savoir un peu plus sur l'encodage et revoir la conversion binaire-décimal, vous pouvez aller (re)consulter les fiches suivantes :

01° Variables numériques : utiliser la console Python pour taper les instructions directes suivantes :

>>> x=5

>>> x

5

>>> type(x)

<class 'int'>

On retrouve le type integer (int) qui désigne les entiers.

>>> x=3.8

>>> x

3.8

>>> type(x)

<class 'float'>


>>> x=5E-9

>>> x

0,000000005

>>> type(x)

<class 'float'>

Le type float désigne les nombres réels, qu'on peut noter avec la virgule (attention : un point en notation anglosaxone) ou avec la notation exposant E ou e.

>>> x=4+9j

>>> x

(4+9j)

>>> type(x)

<class 'complex'>

Troisième type de variables numériques : les complexes qu'on note z = a + i b en mathématiques mais où le nombre imaginaire i est remplacé par j en informatique et en sciences physiques (pour ne pas le confondre avec le i d'intensité électrique).

Python possède un typage dynamique : c'est le langage lui-même qui choisit le type de la variable associée à un contenu.

02° Trouver le type de la variable c en lisant le code suivant. Vérifier votre réponse en tapant le code dans la console.

>>> a=5

>>> b=0.3

>>> c=a*b

>>> type(c)

Python reste un langage haut-niveau : le codeur lambda n'a pas besoin de connaitre la façon dont Python conserve et traite les données. Si vous voulez aller plus loin, il faudra mettre un peu les pieds dans le C car vous allez retrouver des types de variables qu'on trouve dans ce langage. Renseignez vous alors sur la fonction pack.

D'autres langages imposent ainsi de devoir choisir entre plusieurs types d'"integer" par exemple : les integers "short" peuvent stocker des nombres plus petits mais prennent moins de place. A l'inverse, les integers "long" permettent de stocker des entiers plus grands sans erreur mais prennent plus de place mémoire. Dans Python, c'est totalement transparent : vous n'avez pas à vous en soucier.

Si vous voulez néanmoins convertir un entier en réel, ou l'inverse, vous pouvez utiliser les fonctions int() et float().

03° Utiliser les lignes de code suivantes pour vous persuader de la technique de conversion :

>>> x=int(5.9)

>>> print(x)

5

>>> x

5

>>> type(x)

<class 'int'>


>>> x=float(5)

>>> x

5.0

>>> type(x)

<class 'float'>


>>> x=float(5/100)

>>> x

0.05


>>> x=float(5/100000000)

>>> x

0,00000005

Comme vous pouvez le constater :

Print : Vous pouvez constater que le print semble ne servir à rien. Noter x ou print(x) revient à la même chose. C'est simplement parce que nous sommes dans la console d'instructions de Python. Nous ne sommes pas en train de taper un programme à exécuter plus tard. Dans un programme, taper x dans le code ne le fait pas apparaitre à l'écran, heureusement !

04° Utiliser les exemples suivants pour vous souvenir de la signification des opérateurs /, // et % en Python :

>>> print(5/2)

2.5

>>> print(5//2)

2

>>> print(5%2)

1

>>> print(50/6)

8.333333333333334

>>> print(50//6)

8

>>> print(50%6)

2

...CORRECTION...

L'opérateur / donne simplement le résultat de la division.

L'opérateur // donne le résultat d'une division entière : c'est l'équivalent de int(5/2).

L'opérateur % donne le reste de la division entière :

Exemple 1 : 5 = 2*2+1 donc 5//2 donne 2 et 5%2 donne 1.

50 = 8*6 + 2 donc 50//6 donne 8 et 50%6 donne 2.

En guise de conclusion, on remarquera qu'on peut également transformer des entiers en complexes avec complex() :

>>> x=5

>>> x=complex(x)

>>> x

(5+0j)

2 - Les modules et leurs importations

Et si on veut gérer les arrondis lorsqu'on transforme un réel en entier ? Comment faire ?

C'est un peu plus compliqué : il faut importer le module math et utiliser les méthodes floor (sol en français : on arrondit vers le bas) et ceil (plafond en français : on arrondit vers le haut).

>>> import math

>>> print(math.floor(5.9))

5

>>> print(math.ceil(5.9))

6

On notera ici que j'ai importé math en gardant son nom : si je veux utiliser la fonction floor contenue dans math, je dois noter math.floor en placant bien un point entre math et floor.

05° Utilser type() pour découvrir le type des entités print, math et math.floor par exemple.

>>> type(print)

<class 'builtin_function_or_method'>

>>> type(math)

<class 'module'>

>>> type(math.floor)

<class 'builtin_function_or_method'>

Conclusion : print() et floor() sont des méthodes, des fonctions internes (on dit également fonctions propres)

L'intêret de ce style d'importation, c'est qu'on peut avoir deux méthodes portant le même nom dans Python et dans un module et ne pas les confondre : print et math.print sont clairement deux entités différentes. Par contre, si le module se nomme mon_module_de_math_qui_fait_des_trucs_trop_bien, cela va vite être saoulant d'y faire référence...

1er solution : Importer sous un alias plus petit à l'aide de l'instruction as :

>>> import math as m

>>> m.floor(50.3)

50

2e solution : Importer totalement le module dans Python à l'aide de l'étoile * : vous n'aurez plus besoin de faire référence à son nom mais il peut y avoir confusion entre une méthode Python et une méthode du module:

>>> from math import *

>>> floor(50/6)

8

3e solution : Importer uniquement floor depuis le module dans Python : c'est la solution à privilégier si vous voulez des programmes légers ou en faire des executables :

>>> from math import floor

>>> floor(50/6)

8

Pour obtenir un descriptif assez complet du module math, vous pouvez aller voir la fiche Python à ce propos (dans l'onglet fiches) ou allez directement sur le site de Python : PYTHON3.6 : le module math.

3 - Strings

En plus des variables numériques, on peut avoir des variables contenant des écrits, des chaînes de caractères.

Nous allons commencer par un code utilisant input(), la fonction 'inverse' de print : c'est celle qui demande à l'utilisateur de rentrer un résultat au clavier.

06° Deviner les réponses que va donner l'ordinateur en le décodant ligne par ligne puis taper les instructions pour comparer les réponses à vos attentes.

>>> x=input("Tapez un nombre entier\n")

Tapez un nombre entier

45

>>> x

????

>>> type(x)

????

>>> x=int(x)

>>> x

????

>>> type(x)

????

Explications des lignes de code :

>>> x=input("Tapez un nombre entier\n")

Tapez un nombre entier

45

L'argument passé à la fonction (c'est à dire ce qui est entre les parenthèses : "Tapez un nombre entier\n" ) va être affiché AVANT que l'ordinateur n'attende la réponse. Le \n n'est pas affiché mais interprété comme une demande de passage à la ligne.

>>> x

'45'

>>> type(x)

<class 'str'>

On demande à afficher le contenu de x en tapant x. Si on était dans un programme et non pas dans la console d'exécution immédiate, il aurait fallu taper print(x). On voit clairement que x est un string

>>> x=int(x)

>>> x

45

>>> type(x)

<class 'int'>

Pour convertir le string en integer, on utilise la méthode int() et x contient alors bien un entier : l'ordinateur affiche 45 sans guillemet. Le résultat de type(x) donne bien <class 'int'>

Pour en finir avec les conversions, utilisons la méthode str().

07° Même question qu'au dessus : il faut deviner ce que va afficher le code suivant puis vérifier.

>>> x=120

>>> print(x*3)

????

>>> x=str(120)

>>> print(x*3)

????

Correction : la multiplication de 120 par 3 donne bien 360 et la multiplication de '120' par 3 donne '120120120' comme si on avait concatener '120'+'120'+'120'. Le résultat en image.

>>> x=120

>>> print(x*3)

360

>>> x=str(120)

>>> print(x*3)

120120120

Il nous reste à voir tout ce qu'on peut faire avec les strings.

3-1 Stockage des caractères : encodage

Commençons par faire un rappel sur le stockage des strings : l'objet string est constitué d'un ensemble de cases et chaque case contient le caractère voulu. Or, un ordinateur ne peut stocker que des octets et donc au final des nombres... Il faut donc utiliser un code qui associe un caractère précis à une valeur précise. C'est ce qu'on appelle un encodage.

Python 3 travaille avec l'encodage universel UNICODE. Chaque case contient en réalité un nombre : le code UNICODE du caractère qu'on veut représenter. 'A', 'a' ou ' ' (espace) sont représentés par un code différent. Comment obtenir le code UNICODE d'un caractère ? Il suffit d'utiliser la fonction ord(x) où x est un caractère.

>>> ord('A')

65

>>> ord('B')

66

>>> ord(' ')

32

08° Utiliser la console Python pour trouver les codes de 'B', 'b' et '€'. Il faudra penser à faire du copier/coller dans la console pour le dernier caractère. Tentez le clic-droit sur le cadre haut de la console si vous bloquez.

Pour visualiser le caractère qui correspond à un code UNICODE, il faut taper chr(x) où x est le code voulu cette fois.

>>> chr(65)

'A'

>>> chr(66)

'B'

>>> chr(32)

' '

10° Faire une recherche Internet sur le code ASCII. Vérifier ensuite la compatibilité de l'UNICODE avec les caractères ASCII. Vérifier par exemple les caractères UNICODE correspondant à 124, 125 et 126 en utilisant ord() puis comparer aux caractères contenus dans l'ASCII pour ces valeurs.

11° Faire une recherche Internet pour trouver les codes UNICODE (en décimal, base 10) des caractères non contenus dans l'ASCII comme € ou ⊗. Vérifier la correspondance en utilisant chr ou ord, au choix.

Nous savons maintenant que Python mémorise un nombre lorsqu'on lui demande de stocker un caractère. Mais comment stocke-t-il un mot ? Par une suite de nombre qu'il stocke dans un tableau : un string.

3-2 Accéder aux caractèrs d'un string

Pour accéder au contenu de la première case, il faut utiliser les crochets et taper [0] : x[0] va vous renvoyer le caractère associé à la première case de votre string. La case [1] correspond donc ensuite à la deuxième case ...

>>> x="Bonjour"

>>> x[0]

'B'

>>> x[1]

'o'

>>> ord(x[0])

66

>>> ord(x[1])

111

Case  contient stocké en mémoire sous le code
x[0]  B 66
x[1]  o 111
x[2]  n ...
x[3]  j ...
x[4]  o ...
x[5]  u ...
x[6]  r ...

12° Déterminer les codes UNICODE des différents caractères associés à 'Bonjour'.

Il est temps de revoir comment récupérer des bouts de la chaîne uniquement :

Si vous voulez récupérer les caractéres des cases 1 et 2, il suffit de taper :

>>> x="Bonjour"

>>> x[1:3]

'on'

Cette instruction veut dire : prendre à partir de la case 1 (INCLUSE) et s'arrêter à la case 3 (EXCLUE).

Pour récupérer les caractères des cases 3 et plus, on peut omettre la fin et ne placer que les :. Comme on ne place aucune valeur, Python interprète ça en "jusqu'au bout".

>>> x="Bonjour"

>>> x[3:]

'jour'

Pour ne récupérer qu'un caractère sur 2 en partant de la case 1 :

>>> x="Bonjour"

>>> x[1::2]

'oju'

J'ai omis le numéro final car je veux lire la chaîne jusqu'au bout. Comme elle contient 7 caractères contenus dans les cases de 0 à 6, il faut lire jusqu'à la case 7 (EXCLUE). Le code suivant donne la même chose :

>>> x="Bonjour"

>>> x[1:7:2]

'oju'

Et si je ne connais pas la longueur de ma chaîne de caractère ? Et bien, il faut utiliser la fonction len(x) qui renvoie la longueur de la chaine :

>>> x="Bonjour"

>>> len(x)

7

>>> x[1:len(x):2]

'oju'

Par contre, ici, autant ne rien mettre puisque Python le fait tout seul comme un grand. Le code suivant marche, gardons le :

>>> x[1::2]

13° Déterminer la signification cachée dans x='ratietxattes accarcnhlé' en commençant par le caractère [2] puis en ne gardant qu'un caractère sur deux. Alors ?

Nous avons vu qu'on peut écrire x[3:], ce qui veut dire de garder l'ensemble des caractères à partir de la case n°3. On peut faire l'inverse : ne récupérer que les premiers caractères.

Imaginons qu'on dispose des fichiers mon_image.png et mon_texte.txt. On peut utiliser ceci pour récupérer les 6 premiers caractères : (attention à la place de :, c'est important)

>>> x1="mon_image.png"

>>> x2="mon_texte.txt"

>>> x1[:6]

'mon_im'

>>> x2[:6]

'mon_te'

C'est l'inverse du précédent : ne rien mettre devant le : veut dire "depuis le début".

Dernier truc rigolo : on peut aussi vouloir prendre l'extension ou au contraire uniquement le nom. Le mieux est d'utiliser la fonction split() mais nous ne l'avons pas encore revue. Alors comment faire ?

Solution à la dure : on utilise len(x) pour obtenir la longueur et on ne garde que de x[len(x)-3:len(x)]. Ca fonctionne, mais c'est long. Il y a plus simple !

>>> x1="mon_image.png"

>>> x1[-3]

'p'

>>> x1[-3:]

'png'


>>> x2="mon_texte.txt"

>>> x2[-3]

't'

>>> x2[-3:]

'txt'

Ce qui veut dire :

3-3 Modification des strings

Dernier rappel sur les strings : ce sont des objets NON MODIFIABLES : on ne peut pas les modifier après création.

Imaginons qu'on veuille transformer x contenant "Bonjour" en x contenant "Jonjour". On va tenter d'utiliser la commande x[0]="J". Voyons voir :

>>> x="Bonjour"

>>> x[0]="J"

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: 'str' object does not support item assignment

Que fait ce code ?

  1. On affecte "Bonjour" dans x.
  2. On demande de modifier le contenu de la première case en y placant "J" plutôt que "B".
  3. Le programme répond en mentionnant que les objets de type string (str) ne peuvent pas être modifiés par élément (item).

Comment faire alors ?

Et bien, nous n'avons pas le choix : il faut récréer un string qui porte le même nom sans être réellement le même objet.

14° Utiliser le code suivant pour vérifier que vous avez un résultat similaire. Donner ensuite l'explication ligne par ligne.

Rappel : la fonction id() permet d'obtenir le numéro-mémoire d'un objet ou d'une variable. Si deux objets ont le même numéro, c'est qu'il s'agit d'un seul objet portant deux noms d'identification.

>>> x="Bonjour"

>>> id(x)

2699139870368

>>> x[0]="J"

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

TypeError: 'str' object does not support item assignment

>>> x=x+" et au revoir !"

>>> x

'Bonjour et au revoir !'

>>> id(x)

2699139881912

>>>

...CORRECTION...

On crée un string nommé x contenant "Bonjour" et on affiche son numéro.

On tente de modifier sa case 0 et cela ne fonctionne pas : normal, le string n'est pas modifiable.

On utilise la concaténation pour créer un string contenant x auquel on rajoute " et au revoir !". On nomme ce nouveau string x.

On affiche x et bizarrement, cela fonctionne cette fois.

Pourquoi ? L'affichage de l'identifiant permet de le comprendre : le numéro a changé : il s'agit bien d'un nouveau string qui porte simplement le même nom que l'ancien.

4 - Les boucles : le FOR

Premier test que nous allons revoir : celui qui permet d'effectuer la même action plusieurs fois de suite et de lire un à un les éléments d'un ensemble ordonné d'éléments.

Commençons par le FOR numérique : il a besoin de 3 arguments mais seul le second élément (valeur exclue de fin) est obligatoire :

Exemples :

CodeIntervalle crééValeurs obtenues
for x in range(0,5,1):[ 0 ; 5 [0, 1, 2, 3, 4
for x in range(5):[ 0 ; 5 [0, 1, 2, 3, 4
for x in range(0,5,2):[ 0 ; 5 [0, 2, 4
for x in range(1,7,3):[1 ; 7 [1, 4
for x in range(5,0,-1):]0 ; 5 ]5, 4, 3, 2, 1

for x in range(debut,fin,incrémentation): veut dire :

Rappel : les instructions à répéter devront être tabulées par rapport à la position du FOR. Sous Notepad++, n'oubliez pas d'activer le menu AFFICHAGE - AFFICHER LES SYMBOLES SPECIAUX pour être certain de ne pas mélanger les tabulations et l'utilisation des espaces. Si vous mélangez les deux façon de faire une indentation, l'interpéteur Python va être perdu et signaler des erreurs lors de l'exécution du programme.

15° Utiliser le code suivant pour vérifier les valeurs données dans le tableau puis réaliser un programme qui décompte de 10 en 10 en commençant à 200.

#!/usr/bin/env python

# -*- coding: utf-8 -*-

print("Début de la boucle")

for x in range(4,10,2):

    print(x)

print("Fin de la boucle")

Deuxième type de boucle FOR : la boucle nominative qui permet d'accéder à tous les éléments internes d'un objet plus complexe. Par exemple, on peut lire un à un les caractères d'une chaîne de caractères.

A titre d'exemple, voici un code qui permet de trouver les codes Unicode des caractères d'un string :

#!/usr/bin/env python

# -*- coding: utf-8 -*-

objet="Bonjour"

print("Début de la boucle")

for x in objet:

    print("Le caractère ",x," est codé par ",ord(x))

16° Lancer le code pour vérifier son fonctionnement.

5 - Les tests logiques : le IF

Si on veut faire prendre une décision à un programme, il faut utiliser une condition permettant de faire un choix. Nous allons revoir ici le SI, IF en anglais.

A l'aide d'un SI, on peut coder plusieurs actions possibles en fonction de conditions booléennes, c'est à dire des tests pouvant valoir True (vrai) ou False(faux). Attention à la présence de la majuscule dans les valeurs True et False, contrairement aux autres langages.

Pour rappel, nous avions vu la structure suivante :

En françaisCodage Python
SI la première condition est vraie alorsif condition_1:
    Fait les actions 1    Instructions_1
SINON SI la deuxième condition est vraie alorselif (condition_2):
    Fait les actions 2    Instructions_2
SINONelse:
    Fait les actions 3    Instructions_3
Fin du testRien sinon le retour à l'indentation de base

Rappel sur les conditions :

Symbole du testSignificationExemple
==Est égal àA == B
!=Est différent deA != B
>Est supérieur àA > B
>=Est supérieur ou égal àA >= B
<Est inférieur àA < B
<=Est inférieur ou égal àA <= B

17° Lancer le code pour vérifier son fonctionnement : il devrait vous donner une estimation de votre niveau en fonction de votre moyenne. Vous devriez constater qu'il ne fonctionne pas. Si on note 16, il indique AB... Pourquoi ? A vous de répondre en modifiant le programme.

#!/usr/bin/env python

# -*- coding: utf-8 -*-

moyenne = float(input("Quelle est votre moyenne ?"))

if moyenne<10:

    print("Il va falloir travailler !")

elif moyenne>12:

    print("AB")

elif moyenne>14:

    print("B")

elif moyenne>16:

    print("TB")

else:

    print("Passable")

Vous devriez pouvoir trouver deux solutions pour "réparer" le code :

...RAISON POUR LAQUELLE LE CODE NE FONCTIONNE PAS...

Il faut se souvenir qu'on ne peut rentrer que dans une des actions à réaliser.

Ainsi si la note est de 16, la première condition est fausse (car 16 n'est pas strictement inférieur à 10), mais la deuxième est vraie : 16 est bien supérieur strictement à 12 !

De la même façon, habituellement, la mention AB s'obtient avec AB, il aurait donc fallu écrire moyenne>=12.

...CORRECTION 1 AVEC DES AND...

On crée des conditions doubles utilisant les opérateurs supérieurs, strictement supérieurs ... On s'arrange ainsi pour n'avoir que des cas qui n'ont aucune intersection.

if moyenne<0:

    print("Il va falloir travailler !")

elif moyenne>=12 and moyenne<14:

    print("AB")

elif moyenne>=14 and moyenne<16:

    print("B")

elif moyenne>=16:

    print("TB")

else:

    print("Passable")

RAPPEL : on peut utiliser des conditions utilisant des OU avec le mot-clé OR plutôt que le AND du ET.

TEST LOGIQUEEn FrançaisEn Python
andcode ETA and B : Renvoie True si les deux conditions A et B sont True.
orcode OUA or B : Renvoie True si l'une deux conditions au moins est True.
notcode NONnot(A) : Renvoie True si A == False et renvoie False si A == True.

...CORRECTION 2 AVEC SUBTILITE...

Aucune condition double : on utilise le fait qu'on ne peut rentrer que dans un cas. On inverse ainsi l'ordre des tests pour s'assurer qu'on est bien dans le bon cas. On commence par vérifier les grandes moyennes.

if moyenne<0:

    print("Il va falloir travailler !")

elif moyenne>=16:

    print("TB")

elif moyenne>=14:

    print("B")

elif moyenne>=12:

    print("TB")

else:

    print("Passable")

6 - La boucle WHILE

Si on désire effectuer une certaine tâche jusqu'à ce qu'un événement arrive, il faut utiliser une 'nouvelle' boucle : la boucle FAIRE TANT QUE, WHILE en Python.

Tant que la condition donnée est vraie, le programme va lancer les instructions à l’intérieur de la structure. Il est donc possible que cette instruction ne se fasse jamais si la condition n’est pas vérifiée initialement.

Cette boucle s'utilise comme ceci :

while condition :

    Instruction 1 à répéter

    Instruction 2 à répéter

Tout ce qui est tabulé sera répété tant que la condition est vérifiée (True). Attention donc au copier-coller : si l’une des tabulations est mal encodée, ça peut modifier tout le programme…

Voilà un premier exemple qui vous montre comment demander une note tant que la note est supérieure à 20.

#!/usr/bin/env python

# -*-coding:Utf-8 -*

import os

# Acquisition des donnees note 1

note1=21

while (note1>20):

    note1 = input("Quelle est votre note (entière) ? ")

    note1=int(note1)

print("Votre note est ", note1)

18° Pourquoi rentre-t-on forcément au moins une fois dans la boucle ? Quelle est la fonction qui transforme la chaîne de caractères en integer ? Modifier le programme pour qu’il vérifie en plus que la note soit bien supérieure à 0 : il faut rajouter une condition dans la condition du while).

Une autre façon de faire : on part d’un test True et on le rend False lorsqu’on estime qu’on peut sortir :

19° Vérifier que le code suivant fonctionne correctement.

#!/usr/bin/env python

# -*-coding:Utf-8 -*

import os

# Acquisition des donnees note 1

test = True

while test:

    note1 = input("Quelle est votre note (entière) ? ")

    note1=int(note1)

    test = (note1<0 or note1>20) # Boolean

print("Votre note est ", note1)

os.system("pause")

Et si on veut vérifier que la chaîne tapée par l’utilisateur est bien un nombre, même à virgule ?

Il faudrait utiliser un dernier logique : le try suivi d'un except qui va gérer le cas où il y a une erreur.

Il s'agit d’attraper l’exception (l’erreur) et de lui dire ce qu’il doit faire si ça n’a pas marché.

Si l’action échoue en provoquant une exception ValueError (voir la ligne avec except ValueError :), on lui dit comment réagir : ici, je ne complique pas : je lui dis juste de mettre note1 à la valeur –1 si l’entrée clavier était illisible avec float.

#!/usr/bin/env python

# -*-coding:Utf-8 -*

import os

# Acquisition des donnees note 1

test = True

while test:

    note1 = input("Quelle est votre note (entière) ? ")

    try:

        note1=float(note1)

    except ValueError:

        note1 = -1

    if (note1>=0 and note1<=20):

        test=False

print("Votre note est ", note1)

os.system("pause")

20° Vérifier que le code précédent fonctionne correctement et en comprendre le fonctionnement. Utilisez par exemple les notes "14", "14.3", "14,3" ou "A".

Et bien, voilà. Vous avez désormais en main les outils pour tester les entrées des utilisateurs pour éviter qu’elles ne provoquent l’arrêt de votre beau code.

Nous avons vu les principaux éléments de gestion des choix et conditions :