Structures alternative et répétitive Comparaison de données à l’aide des opérateurs relationnels. Expressions booléennes. Opérateurs logiques : « et » logique, « ou » logique et la négation. Les blocs. La structure alternative : clause « if » avec ou sans « else ». Les opérateurs conditionnels. La structure répétitive : la clause « while ». Présence de sentinelles. Structures imbriquées.

Structures de contrôle Jusqu’à maintenant, les instructions d’un programme ont été exécutées les unes à la suite des autres, dans l’ordre où elles sont écrites. Structure en séquence : exécution séquentielle des opérations L’ordre d’exécution des instructions des algorithmes n’est pas toujours séquentielle et Python offre différentes possibilités pour les décrire : Structure de sélection Choix d’une instruction dépendamment d’une condition. Trois types de structures de sélection (unique, double ou multiple) : structure if : effectue une action si une condition est vraie (True) ou l’omet si elle est fausse (False). structure if else : effectue une action si une condition est vraie (True) ou une autre action si elle est fausse (False). structure if elif else : effectue une action parmi plusieurs, selon la valeur de différentes expressions. Structure de répétition : Répétition d’instructions au moment où une condition est satisfaite. structures while et for.

Opérateurs relationnels Les structures alternative et répétitive renferment toutes une condition à vérifier. Celle-ci compare deux valeurs à l’aide d’opérateurs relationnels. Python Notation utilisée Description > > supérieur >= ≥ supérieur ou égal < < inférieur <=  inférieur ou égal == = égal !=  différent Ex. : >>> x, y = 2.3, 6.7 >>> x < y True >>> x != y >>> (x + 4.4) == y >>> Le résultat est une expression booléenne.

Instruction conditionnelle if C’est une instruction de la forme : >>> if (expression booléenne) : . . . instruction . . . . . . . . . Bloc d’instructions à exécuter si l’expression booléenne est vraie. Autrement, on poursuit l’exécution immédiatement après cette suite. On peut aussi écrire : >>> if (expression booléenne) : instruction lorsque le bloc renferme une seule instruction. Note : Si l’éditeur ne le fait pas, on doit effectuer une tabulation ou entrer quatre espaces avant d’entrer une instruction faisant partie du bloc. Après avoir entré la dernière instruction du bloc, pesez sur la touche une 2ième fois pour exécuter la portion de code. Les instructions d’un bloc doivent être exactement au même niveau. Exemple : >>> indice = 0 >>> if (indice < 10): indice = indice + 2 print "indice = ", indice indice = 2 >>>

Instruction conditionnelle if - else C’est une instruction de la forme : >>> if (expression booléenne) : . . . instruction . . . . . . . . . else : . . . Bloc d’instructions à exécuter si l’expression booléenne est vraie. Bloc d’instructions à exécuter si l’expression booléenne est fausse. >>> centre_x, centre_y, rayon = 1.5, 2.4, 12 >>> coord_x, coord_y = 2.3, 3.1 >>> if (((coord_x - centre_x)**2) + ((coord_y - centre_y)**2) == (rayon * rayon)): print "(", coord_x, ",", coord_y, ")", "est un point du cercle." else: print "Ce n'est pas un point du cercle." Ce n'est pas un point du cercle. >>> Ex. I:

Instruction conditionnelle if - else >>> note = input("Donnez la note d'un étudiant dans un cours sur 100 : ") Donnez la note d'un étudiant dans un cours sur 100 : 74 >>> if (note < 0): print "*** erreur : la note de l'étudiant ne peut être négative. ***" >>> if (note < 60): print "L'étudiant a un échec." else: print "L'étudiant a réussi. : " L'étudiant a réussi. : >>> print "Sa note est : ", note Sa note est : 74 >>> Ex. II: Ex. III: >>> u, v = 75.3, 23.5 >>> if (u < v): min = u max = v else : min = v max = u >>> print "min = ", min, " max = ", max min = 23.5 max = 75.3 >>>

Instruction conditionnelle elif (contraction de « else if ») Un bloc d’instructions est exécuté dès qu’une expression booléenne est vraie. >>> if (expression booléenne 1) : . . . instruction . . . . . . . . . elif (expression booléenne 2) : … . . . elif (expression booléenne n) : . . . else : Bloc d’instructions à exécuter si l’expression booléenne 1 est vraie. Bloc d’instructions à exécuter si l’expression booléenne 1 est fausse et l’expression 2 est vraie. Bloc d’instructions à exécuter si l’expression booléenne n est vraie et les précédentes fausses. Bloc d’instructions à exécuter si toutes les expressions booléennes sont fausses.

Instruction conditionnelle elif (contraction de « else if ») Ex. : >>> a, b, c = 1., 6., 9. >>> if ((b*b - 4 * a * c) == 0): print "racines doubles" elif ((b*b - 4 * a * c) < 0): print "racines imaginaires:" else: print "racines reelles" racines doubles >>>

Année bissextile Une année est bissextile tous les 400 ans; les siècles ne sont pas bissextiles et une année sur 4 est bissextile Lire une année n. 1. Si n possède comme facteur 400 alors 2. Écrire que n est une année bissextile. 2.1 L’algorithme prend fin. 2.2 Si n possède comme facteur 100 alors 3. Écrire que n n’est pas une année bissextile. 3.1 L’algorithme prend fin. 3.2 Si n possède comme facteur 4 alors écrire que n est une année bissextile. sinon écrire que n n’est pas une année bissextile. 4. L’algorithme prend fin. 5.

Année bissextile >>> # Concevoir un programme qui prend en entrée une année, >>> # détermine si oui ou non l'année est bissextile, >>> # et affiche le résultat. >>> >>> annee = input("Entrez l'année que vous désirez : ") Entrez l'année que vous désirez : 1994 >>> if ((annee % 400) == 0): print "oui" elif ((annee % 100) == 0): print "non" elif ((annee % 4) == 0): else : non

Calcul de la cote d’un élève Exemple : Cote Note A ≥ 90 B [80, 90) C [70, 80) D [60, 70) E < 60 >>> # Concevoir un programme qui prend en entrée une note, >>> # calcule la cote correspondante et >>> # affiche le résultat. >>> >>> note = input("Entrez la note obtenue : ") Entrez la note obtenue : 73 >>> if (note >= 90): cote = 'A' elif (note >= 80): cote = 'B' elif (note >= 70): cote = 'C' elif (note >= 60): cote = 'D' else : cote = 'E' >>> print "Avec la note ", note, ", vous avez la cote ", cote, "." Avec la note 73 , vous avez la cote C .

Instructions imbriquées Nous pouvons imbriquer les unes dans les autres plusieurs instructions composées. x = 3.14159 if x >= 0.0 : if x == 0.0 : print "Valeur nulle" elif x == 3.14159 : print "Valeur de pi" else : print "Valeur negative" Note : 1. Les limites des instructions et des blocs sont définies par la mise en page. Chaque ligne d’instructions se termine par le caractère de fin de ligne. 2. On peut également terminer une ligne d’instructions par un commentaire lequel commence toujours par le caractère spécial # et se termine par le caractère de fin de ligne. 3. Toutes les lignes d’un même bloc d’instructions ou d’une instruction composée doivent être indentées exactement de la même manière. Les blocs d’instructions sont toujours associés à une ligne d’en-tête contenant une instruction (if, elif, else, while, …) suivie d’un double point.

4. L’indentation nous permet de lever toute ambiguïté avec des instructions imbriquées. Ex. : La clause else correspond à quelle clause if d’après vous ? >>> u = 2 >>> v = 3 >>> if (u > 0): if (v < 0): print "valeur négative" else : print "u et v sont positifs." u et v sont positifs. >>> >>> u = 2 >>> v = 3 >>> if (u > 0): if (v < 0): print "valeur négative" else : print "u est négatif" >>> La réponse est fonction de l’indentation.

Minimum et maximum de 3 entiers >>> A, B, C = input("Saisir 3 entiers quelconques : ") Saisir 3 entiers quelconques : 9, 5, 12 >>> if (A <= B): if(A <= C): min = A if (B >= C): max = B else : max = C else : # C < A <= B min = C max = B else : # B < A if (B <= C): min = B if (A >= C): max = A else : # C < B < A max = A >>> print "La plus petite valeur est : ", min La plus petite valeur est : 5 >>> print "La plus grande valeur est : ", max La plus grande valeur est : 12 Note : Dans une structure imbriquée, c’est souvent plus rapide que plusieurs structures simples dans le cas d’une sortie hâtive. À cette fin, il est préférable de tester les conditions les plus susceptibles d’être vraies au début.

Minimum et maximum de 3 entiers – variante >>> A, B, C = input("Saisir 3 entiers quelconques : ") Saisir 3 entiers quelconques : 9, 5, 12 >>> if (A <= B): min = A else : min = B >>> if (min > C): min = C >>> if (A <= B): max = B else : max = A >>> if (max < C): max = C >>> print "La plus petite valeur est : ", min La plus petite valeur est : 5 >>> print "La plus grande valeur est : ", max La plus grande valeur est : 12 >>>

Identification d’un triangle Écrire un programme qui lit en entrée trois valeurs réelles, A, B et C. Ce programme doit afficher un message indiquant - si nous ne sommes pas en présence d’un triangle dont les côtés sont de longueur A, B et C respectivement. max(A, B, C) ≥ (A + B + C) / 2  Ce n’est pas un triangle. - Autrement, s’il s’agit d’un triangle scalène, s’il s’agit d’un triangle isocèle, s’il s’agit d’un triangle équilatéral, s’il s’agit d’un triangle rectangle, max(A, B, C)2 = (A2 + B2 + C2) / 2  C’est un triangle rectangle. s’il s’agit d’un triangle rectangle isocèle.

Identification d’un triangle >>> A, B, C = input("Entrez les 3 paramètres A, B et C : ") Entrez les 3 paramètres A, B et C : 2, 5, 4 >>> # Recherche du maximum. >>> max = A >>> if (max < B): max = B >>> if (max < C): max = C >>> if (max >= (A + B + C) / 2.0): print "Ce n'est pas un triangle." else: sortie = "C'est un triangle " if (max * max == (A*A + B*B + C*C)/2.0): sortie = sortie + "rectangle." if ( A == B): if (B == C): sortie = sortie + "equilatéral." else: sortie = sortie + "isocèle." if (A == C): sortie = sortie + "isocèle." elif (B == C): sortie = sortie + "isocèle." else: sortie = sortie + "scalène." >>> print sortie C'est un triangle scalène.

Opérateurs ternaires expression_1 if (expression booléenne) else expression_2 Cela retourne la valeur de expression_1 si l’expression booléenne est vraie; Autrement, la valeur de expression_2 est retournée. Ex. : >>> u = 3 >>> v = 2 >>> petit = u if (u < v) else v >>> petit 2 >>> Utilisé à outrance, cet opérateur peut nuire à la lisibilité du programme.

Instructions répétitives – l’instruction while >>> while (expression booléenne) : . . . instruction . . . . . . Tant et aussi longtemps que l’expression booléenne est vraie, le bloc d’instructions est exécuté. Si la condition est fausse, on poursuit l’exécution après le bloc d’instructions. Attention : on a une boucle infinie si l’expression booléenne est toujours vraie. Lorsque la valeur numérique d’une expression booléenne est non nulle, celle-ci est toujours vraie. Ex. 1 : i = 0 while (i < 10) : i = i + 1 print i, i * i, i **3 >>> i = 5 >>> while i : print i i = i - 1 5 4 3 2 1 Ex. 2 : Affichage de la suite de Fibonacci. u, v, w = 1, 1, 1 while w <= 10 : print v, u, v, w = v, u + v, w + 1 La virgule permet d’afficher les termes sur la même ligne.

Ex. 3 : # Plus petite puissance de 2 plus grande que 1000. >>> produit = 2 >>> while (produit <= 1000): produit *= 2 >>> print produit 1024 1024 Note : Omettre d’inclure dans le corps d’une structure while une action qui permette à la condition du while de devenir fausse provoque habituellement une erreur (boucle infinie). Ex. 4 : # Calcul de mn où m et n sont des entiers positifs. # >>> m, n = input("Saisie des valeurs de m et de n : ") Saisie des valeurs de m et de n : 5, 4 >>> i, resultat = 1, 1 >>> while (i <= n): resultat *= m i = i + 1 >>> print resultat 625 >>>

Calcul de la racine carrée d’un nombre réel positif Calculer la racine carrée d’un nombre réel positif A par approximations successives en utilisant la relation de récurrence suivante : x0 = A; xj+1 = (xj + A / xj) / 2; j = 1, 2, ..., n. Les paramètres A et n sont entrés au clavier; de plus, on doit s’assurer que A est un nombre réel positif et que n est un entier naturel positif. Toutes les approximations de la racine de A, c’est-à-dire toutes les valeurs de xj doivent être affichées. A = input("Entrez un nombre réel positif : ") Nombre_d_iterations = input("Fournir le nombre d'itérations : ") x = A j = 1 print "La racine carrée de ", A, " est : " while (j <= Nombre_d_iterations): x = (x + A / x) / 2.0 print x j = j + 1

Calcul de la moyenne des notes d’une classe >>> # Ce programme saisit le nombre d'élèves d'une classe et la note de chaque >>> # élève; puis, calcule la moyenne des notes obtenues par les élèves et affiche >>> # cette moyenne. >>> >>> Nombre_d_eleves = input("Entrez le nombre d'élèves : ") Entrez le nombre d'élèves : 12 >>> somme_des_notes = 0 >>> i = 1 >>> while (i <= Nombre_d_eleves): print "Entrez la ", i, " ième note : " une_note = input() somme_des_notes += une_note i += 1 Entrez la 1 ième note : 75 Entrez la 2 ième note : 23.9 Etc. Entrez la 12 ième note : 34 >>> print "La moyenne de la classe est : ", somme_des_notes / float(Nombre_d_eleves) La moyenne de la classe est : 55.575

Présence d’une sentinelle On ne connaît pas à priori le nombre d’élèves dans la classe et on ne veut pas exiger de l’enseignant d’entrer au clavier le nombre d’élèves dans sa classe. On introduit une valeur sentinelle (-1 par exemple) qui ne peut coïncider avec une note. >>> # Ce programme saisit au clavier la note de chaque élève, entre -1 >>> # lorsque toutes les notes ont été saisies, calcule la moyenne des >>> # notes saisies et affiche le résultat si au moins une note a été saisie; >>> # autrement, on affiche un message d'erreur. >>> >>> sentinelle = -1 >>> Nombre_d_eleves, somme_des_notes = 0, 0.0 >>> une_note = input("Entrez une note ou -1 pour terminer : ") Entrez une note ou -1 pour terminer : 45 >>> while (une_note != sentinelle): somme_des_notes += une_note Nombre_d_eleves += 1 une_note = input("Entrez une note ou -1 pour terminer : ")

Entrez une note ou -1 pour terminer : 98 >>> if (Nombre_d_eleves != 0): print "La moyenne de la classe est : ", \ somme_des_notes / float(Nombre_d_eleves) else : print "On doit entrer au moins une note." La moyenne de la classe est : 62.0 >>>

Calcul du nième nombre de Catalan Parenthèses 2 lettres 3 lettres 4 lettres 5 lettres ab a ( bc ) ( (ab ) c ) d ... ( ab ) c (ab ) ( cd ) ( a ( bc ) ) d a ( (bc) d ) a ( b (cd ) ) 1 2 5 14 => Nombres de Catalan Combien de façons différentes avons-nous de placer des parenthèses autour d'une suite de n+1 lettres, en plaçant à chaque fois 2 lettres (au moins) dans les parenthèses? Polygone convexe : # de façons de diviser un polygone convexe à n + 2 côtés en triangles. n = 2 Le 2ième nombre de Catalan est 2.

Calcul du nième nombre de Catalan Cat(n) = (2n)! , n ≥ 0. (n+1)! n! >>> # Ce programme prend en entrée un entier n, calcule le n ième nombre de >>> # Catalan, et affiche le résultat. >>> >>> n = input("Entrez la valeur de n : ") Entrez la valeur de n : 10 >>> i, den = 1, 1 >>> while (i <= n): den *= i i += 1 >>> num = den >>> den = den * den * (n + 1) >>> i = n + 1 >>> while (i <= 2 * n): num *= i >>> print "Le ", n, " ième nombre de Catalan est : ", num / den Le 10 ième nombre de Catalan est : 16796

Cat(n) = (2n)! , n ≥ 0. (n+1)! n! Cet algorithme fonctionne-t-il pour n’importe quelle valeur de n ? Lorsque le programme est écrit en Python, l’algorithme fonctionne car il n’y a pas de débordements de capacité avec les entiers; par contre, l’algorithme peut être inefficace. En C++, cela ne fonctionne pas pour n  7. >>> print "Les numérateur et dénominateur sont : ", num, den Les numérateur et dénominateur sont : 2432902008176640000 144850083840000 >>> Voici une autre solution : Cat(n) = (1 + n/2) (1 + n/3) … (1 + n/(n-1)) 2

>>> # Ce programme prend en entrée un entier n, >>> # calcule le n ième nombre de Catalan, >>> # et affiche le résultat. >>> >>> n = input("Entrez la valeur de n : ") Entrez la valeur de n : 10 >>> resultat = 2.0 >>> i = 2 >>> while (i <= n - 1): resultat *= (1.0 + n / float(i)) i += 1 >>> print "Le ", n, " ième nombre de Catalan est : ", resultat Le 10 ième nombre de Catalan est : 16796.0

Confusion entre = et == Confusion entre = et == = désigne l’opérateur d’affectation tandis que == représente l’opérateur de comparaison d’égalité. >>> i = 1 >>> if (i = 1): print i SyntaxError: invalid syntax >>> >>> x, y, z = 1.0, 1.0, 1.0 >>> y == x * x + 2.4 * z - 0.5 False >>> y = x * x + 2.4 * z - 0.5 >>> print x, y, z 1.0 2.9 1.0 >>> 2 interprétations différentes.

Affichage de la table des produits entre 0 et 10 titre = "X*Y | " i = 0 while (i <= 9): titre = titre + " " titre = titre + str(i) i = i + 1 print titre i = 1 souligne = '-' while (i <= 65): souligne = souligne + '-' print souligne ligne = " " + str(i) + " | " j = 0 while (j <= 9): ligne = ligne + " " if (i * j <= 9): ligne = ligne + " " ligne = ligne + str(i * j) j = j + 1 print ligne X*Y | 0 1 2 3 4 5 6 7 8 9 ------------------------------------------------------------------ 0 | 0 0 0 0 0 0 0 0 0 0 1 | 0 1 2 3 4 5 6 7 8 9 2 | 0 2 4 6 8 10 12 14 16 18 3 | 0 3 6 9 12 15 18 21 24 27 4 | 0 4 8 12 16 20 24 28 32 36 5 | 0 5 10 15 20 25 30 35 40 45 6 | 0 6 12 18 24 30 36 42 48 54 7 | 0 7 14 21 28 35 42 49 56 63 8 | 0 8 16 24 32 40 48 56 64 72 9 | 0 9 18 27 36 45 54 63 72 81 Note : Ce programme a été compilé à partir d’un fichier.

Affichage d’un cercle centré à l’origine import math rayon = input("Entrez le rayon du cercle : ") y = - rayon while (y <= rayon): x = int(math.sqrt(rayon * rayon - y * y) + 0.5) i = 1 ligne = "" while (i <= rayon - x): ligne = ligne + " " i = i + 1 ligne = ligne + "*" i = 1 - x while (i <= x - 1): print ligne y = y + 1 Entrez le rayon du cercle : 6 ** * * * * * * * * * * * * * * * * * * * * * * **

Calcul d’une somme Il s’agit de calculer la somme suivante : n f(i) où f(i) = 2i si i est pair i=1 i-1 sinon. >>> n = input("Entrez le paramètre n : ") Entrez le paramètre n : 5 >>> >>> somme = 0 >>> i = 1 >>> while (i <= n): if ((i % 2) == 0): terme = 2 * i else: terme = i - 1 somme = somme + terme i = i + 1 >>> print "La sommation est : ", somme La sommation est : 18

Simulation d’une calculatrice simple >>> x, y = input("Entrez deux entiers : ") Entrez deux entiers : 23, 9 >>> operateur = " " >>> while (operateur != "+" and operateur != "-" and operateur != "*" \ and operateur != "/" and operateur != "%"): operateur = input("Entrez un opérateur valide : ") Entrez un opérateur valide : "/" >>> if (operateur == "+"): print x, " + ", y, " = ", x + y elif (operateur == "-"): print x, " - ", y, " = ", x - y elif (operateur == "*"): print x, " * ", y, " = ", x * y elif (operateur == "/"): print x, " / ", y, " = ", x / y else: print x, " % ", y, " = ", x % y 23 / 9 = 2

Décompte des lettres représentant les notes d’examen >>> cote = " " >>> acomptage, bcomptage, ccomptage, dcomptage, ecomptage = 0, 0, 0, 0, 0 >>> while (cote != "#"): cote = input("Entrez la cote d'un étudiant (# pour terminer) : ") if (cote == "A" or cote == "a"): acomptage += 1 elif (cote == "B" or cote == "b"): bcomptage += 1 elif (cote == "C" or cote == "c"): ccomptage += 1 elif (cote == "D" or cote == "d"): dcomptage += 1 elif (cote == "E" or cote == "e"): ecomptage += 1 elif (cote == "#"): print "C'est terminé." else: print "Cette cote est invalide." Entrez la cote d'un étudiant (# pour terminer) : "A" Entrez la cote d'un étudiant (# pour terminer) : "e" Entrez la cote d'un étudiant (# pour terminer) : "C" Entrez la cote d'un étudiant (# pour terminer) : "c" Entrez la cote d'un étudiant (# pour terminer) : "F" Cette cote est invalide. Entrez la cote d'un étudiant (# pour terminer) : "B" Entrez la cote d'un étudiant (# pour terminer) : "#" C'est terminé.

>>> print "Les totaux pour chaque cote sont : " >>> print "A : ", acomptage A : 1 >>> print "B : ", bcomptage B : 1 >>> print "C : ", ccomptage C : 2 >>> print "D : ", dcomptage D : 0 >>> print "E : ", ecomptage E : 1 >>>

Instruction break break Lorsque exécutée dans une structure while ou for, elle provoque la sortie immédiate de cette structure. L’exécution du programme se poursuit avec la première instruction suivant cette structure. On utilise souvent l’instruction break pour sortir d’une boucle plus tôt. Exemple : >>> # Ce programme saisit un entier naturel au clavier, >>> # calcule le plus grand diviseur de cet entier et >>> # affiche le résultat. >>> >>> n = input("Entrez un nombre entier naturel : ") Entrez un nombre entier naturel : 27 >>> pgd = n / 2 >>> while (pgd > 0): if (n % pgd == 0): print pgd, " est le plus grand diviseur de ", n break pgd = pgd - 1 9 est le plus grand diviseur de 27

Instruction continue continue Lorsque exécutée dans une structure while ou for, elle ignore les instructions restantes dans le corps de cette structure et procède à l’itération suivante de la boucle. while : La condition est évaluée immédiatement après l’exécution de l’instruction continue. Et ce n’est que si la condition est vraie que l’itération suivante débute. Exemple : >>> while (True): n = input("Entrez un entier naturel : ") if (n <= 0): continue else: pgd = n / 2 while (pgd > 0): if ((n % pgd) == 0): print pgd, " est le plus grand diviseur de ", n break pgd = pgd - 1

Instruction pass pass Si vous écrivez une instruction Python qui attend un sous-bloc de code et que celui-ci est vide, il ne peut être absent. L’instruction pass joue ce rôle. Cette instruction peut être utile durant les stades de développement ou de mise au point. Exemple : >>> while (True): n = input("Entrez un entier naturel : ") if (n <= 0): continue else: pgd = n / 2 while (pgd > 0): if ((n % pgd) == 0): print pgd, " est le plus grand diviseur de ", n break else: pass pgd = pgd - 1

Instruction else else L’instruction else peut être utilisée non seulement avec les instructions conditionnelles mais aussi avec les instructions itératives while ou for. Dans une boucle, else ne sera exécutée que si celle-ci se termine normale- ment, autrement dit si elle n’a pas été abandonnée par une clause break. Exemple : >>> while (True): n = input("Entrez un entier naturel : ") if (n <= 0): continue else: pgd = n / 2 while (pgd > 1): if ((n % pgd) == 0): print pgd, " est le plus grand diviseur de ", n break pgd = pgd - 1 else: print n, " est premier."

Utilisation de variables booléennes Dans les structures alternative et répétitive que nous avons vues, on retrouve des expressions logiques à évaluer dont le résultat est vrai ou faux. Pour stocker la valeur d’une condition afin de l’utiliser ailleurs, vous devez recourir à une variable booléenne de type bool. Exemple : >>> x = 3.2 >>> V = x < 6.4 >>> if (V): print "La condition est vérifiée." La condition est vérifiée. Attention : Ne pas écrire if (V== True): print "La condition est vérifiée."

Utilisation de variables booléennes lecture_inachevee = True acomptage, bcomptage, ccomptage, dcomptage, ecomptage = 0, 0, 0, 0, 0 while (lecture_inachevee): cote = input("Entrez la cote d'un étudiant (# pour terminer) : ") if (cote == "A" or cote == "a"): acomptage += 1 elif (cote == "B" or cote == "b"): bcomptage += 1 elif (cote == "C" or cote == "c"): ccomptage += 1 elif (cote == "D" or cote == "d"): dcomptage += 1 elif (cote == "E" or cote == "e"): ecomptage += 1 elif (cote == "#"): print "C'est terminé." lecture_inachevee = False else: print "Cette cote est invalide." print "Les totaux pour chaque cote sont : " print "A : ", acomptage print "B : ", bcomptage print "C : ", ccomptage print "D : ", dcomptage print "E : ", ecomptage

Utilisation d’opérateurs logiques Jusqu’à présent, nous n’avons étudié que des conditions simples telles que compteur <= 10, total > 1000 ou nombre != sentinelle et nous les avons exprimées à l’aide des opérateurs relationnels <, <=, >, >=, == et !=. Python offre des opérateurs logiques : and (ET logique) or (OU logique) not (NON logique) pour former des conditions plus complexes par une combinaison de conditions simples. >>> x, y = 2.76, 1.98 >>> n = 2 >>> not (x > y and n == 2) False >>> x >= y or n != 2 True

Tables de vérité U V U and V U or V false false false false false true vraie true false false true true true true true Exemple : Les instructions pour la déclaration de revenus 1992 disent que vous pouvez vous déclarer comme célibataire si une quelconque des conditions suivantes est vraie : - Vous ne vous êtes jamais marié. - Vous êtes légalement divorcé ou séparé au 31 déc. 92. - Vous étiez veuf avant le 1er janv. 92 et ne vous êtes pas remarié. ou Vous pouvez employer le statut marié, si toutes les conditions suivantes sont satisfaites : - Votre épouse est décédée en 90 ou en 91 et vous ne vous êtes pas remarié en 92. - Vous avez un enfant à charge. - Cet enfant habitait chez vous tout au long de 92. - vous avez payé plus de la ½ de ses frais d’entretien. et

Année bissextile >>> annee = input("Entrez l'année désirée : ") Entrez l'année désirée : 1954 >>> bissextile = ((annee % 400) == 0) >>> bissextile = bissextile or (((annee % 100) != 0) and ((annee % 4) == 0)) >>> print bissextile False Écrire un programme qui lit 2 entiers A et B et vérifie si les 3 conditions suivantes sont satisfaites simultanément : A > 3  B < 2 B > 1  A = 3 A = 1  B  1 A, B = input("Entrez les valeurs de A et de B : ") C1 = (A > 3) <= (B < 2) C2 = (B > 1) <= (A == 3) C3 = (A == 1) <= (B <= 1) print C1 and C2 and C3