Différences
Ci-dessous, les différences entre deux révisions de la page.
Les deux révisions précédentes Révision précédente Prochaine révision | Révision précédente Prochaine révisionLes deux révisions suivantes | ||
python:bases:controle [2021/06/30 20:49] – [3. Les boucles (ou structures répétitives)] phil | python:bases:controle [2022/08/09 12:02] – [3.4 La fonction built-in enumerate()] phil | ||
---|---|---|---|
Ligne 1: | Ligne 1: | ||
+ | {{ : | ||
+ | ===== Python - Instructions de contrôle ===== | ||
+ | |||
+ | [Mise à jour le :3/7/2022] | ||
+ | |||
+ | * **Sources** | ||
+ | * **Documentation** sur Python.org : < | ||
+ | |||
+ | * **Lectures connexes** | ||
+ | * **Real Python** | ||
+ | * < | ||
+ | * < | ||
+ | * < | ||
+ | |||
+ | * **Mots-clés** : opérateurs de comparaison, | ||
+ | |||
+ | <callout type=" | ||
+ | |||
+ | | **and** | ||
+ | | as | ||
+ | | assert | ||
+ | | __async__ | ||
+ | | __await__ | ||
+ | | **break** | ||
+ | | class | **__False__** | ||
+ | |||
+ | * < | ||
+ | |||
+ | ---- | ||
+ | |||
+ | ==== Généralités === | ||
+ | |||
+ | * **Structure d'une instruction de contrôle "if ... elif ... else ..." | ||
+ | |||
+ | <code python *.py> | ||
+ | if test1: | ||
+ | <bloc d' | ||
+ | elif test2: | ||
+ | <bloc d' | ||
+ | elif test3: | ||
+ | <bloc d' | ||
+ | ... | ||
+ | else: | ||
+ | <bloc d' | ||
+ | </ | ||
+ | |||
+ | <callout type=" | ||
+ | |||
+ | * **Mécanisme d' | ||
+ | <callout type=" | ||
+ | |||
+ | L' | ||
+ | |||
+ | Selon l' | ||
+ | * la fonction buit-in bool(objet) => // | ||
+ | ou | ||
+ | * la fonction buit-in bool(objet) => // | ||
+ | * si < | ||
+ | * si < | ||
+ | |||
+ | <callout type=" | ||
+ | |||
+ | // Exemples d' | ||
+ | * **Un type built-in** | ||
+ | * Est **Faux** : False 0 None [] {} () '' | ||
+ | * Est **Vrai** : tout le reste | ||
+ | |||
+ | <code python *.py> | ||
+ | d = {' | ||
+ | if d: # dictionnaire non vide, on affiche | ||
+ | print(d) # Résulat {' | ||
+ | </ | ||
+ | |||
+ | * **Une Comparaison** | ||
+ | * > >= < <= == != | ||
+ | |||
+ | <code python *.py> | ||
+ | a=10;b=12 | ||
+ | if a != b: | ||
+ | print(' | ||
+ | </ | ||
+ | |||
+ | * **Un test d' | ||
+ | |||
+ | <code python *.py> | ||
+ | if ' | ||
+ | print(' | ||
+ | </ | ||
+ | |||
+ | * **Un retour de fonction** | ||
+ | * On évalue l' | ||
+ | <code python *.py> | ||
+ | s=' | ||
+ | if s.isdecimal(): | ||
+ | print(2*int(s)) # Résultat : 246 | ||
+ | </ | ||
+ | |||
+ | * ** Un opérateur de test booléen and , or, not** | ||
+ | |||
+ | <code python *.py> | ||
+ | s=' | ||
+ | if ' | ||
+ | print(2*int(s)) # Résultat : 246 | ||
+ | </ | ||
+ | |||
+ | ==== 1. Les opérateurs dans les instructions de contrôle ==== | ||
+ | Les instructions de contrôle utilisent des opérateurs logiques et de comparaison. | ||
+ | |||
+ | === 1.1 Les opérateurs de comparaison === | ||
+ | |||
+ | > Les opérateurs de comparaison permettent de réaliser les conditions placées dans les structures de contrôle (**prédicats**). | ||
+ | |||
+ | ^égal | ||
+ | | **==** | **> | ||
+ | |||
+ | <callout type=" | ||
+ | |||
+ | //Exemple// | ||
+ | <code python exop.py> | ||
+ | a >=5 # se traduit par a supérieur ou égal à 5 | ||
+ | 5< | ||
+ | </ | ||
+ | |||
+ | === 1.2 Les opérateurs logiques === | ||
+ | |||
+ | > Les opérateurs **not**, **or** et **and** | ||
+ | |||
+ | //Exemple// | ||
+ | <code python exop.py> | ||
+ | a >=5 and a<=10 # à placer dans un test comme dans l' | ||
+ | </ | ||
+ | |||
+ | ==== 2. Les tests (ou structures alternatives) ==== | ||
+ | > Ce type d' | ||
+ | |||
+ | === 2.1 if ... else ... === | ||
+ | //Syntaxe// | ||
+ | |||
+ | <code python> | ||
+ | if prédicat: | ||
+ | bloc de code 1 # si le prédicat est vrai alors on exécute le bloc de code 1 | ||
+ | else: | ||
+ | bloc de code 2 # sinon on exécute le bloc de code 2 | ||
+ | </ | ||
+ | |||
+ | <callout type=" | ||
+ | |||
+ | // Exemple 1 // : comparaison d'une variable à une valeur | ||
+ | <code python extest1.py> | ||
+ | a=5 | ||
+ | if a<10: | ||
+ | | ||
+ | else: | ||
+ | | ||
+ | </ | ||
+ | |||
+ | // Exemple 2 // : utilisation de **in** | ||
+ | |||
+ | <code python exin.py> | ||
+ | chaine = " | ||
+ | for lettre in chaine: | ||
+ | if lettre in " | ||
+ | print(lettre) | ||
+ | else: # lettre est une consonne | ||
+ | print(" | ||
+ | </ | ||
+ | |||
+ | === 2.2 if ... elif ... else ...=== | ||
+ | |||
+ | <callout type=" | ||
+ | |||
+ | //Syntaxe// | ||
+ | <code python> | ||
+ | if prédicat 1: | ||
+ | bloc de code 1 # si le prédicat 1 est vrai alors on exécute le bloc de code 1 | ||
+ | elif prédicat 2: | ||
+ | bloc de code 2 # sinon si le prédicat 2 est vrai alors on exécute le bloc de code 2 | ||
+ | else: | ||
+ | bloc de code 3 # sinon on exécute le bloc de code 3 | ||
+ | </ | ||
+ | |||
+ | <callout type=" | ||
+ | |||
+ | // | ||
+ | <code python extest2a.py> | ||
+ | a=5 | ||
+ | if a<0: | ||
+ | | ||
+ | elif a >=5 and a<=10: | ||
+ | | ||
+ | elif a >10 and a<=20: | ||
+ | | ||
+ | else: | ||
+ | | ||
+ | </ | ||
+ | |||
+ | <code python extest2b.py> | ||
+ | mot = input(" | ||
+ | if ' | ||
+ | print(" | ||
+ | else: | ||
+ | print(" | ||
+ | </ | ||
+ | |||
+ | === 2.3 L' | ||
+ | |||
+ | <callout type=" | ||
+ | |||
+ | //Exemple// | ||
+ | <code python *.py> | ||
+ | if condition: | ||
+ | pass # pass remplace un bloc de code que l'on a supprimé. Cette instruction évite d' | ||
+ | else: | ||
+ | action(s) | ||
+ | </ | ||
+ | |||
+ | |||
+ | ==== 3. Les boucles (ou structures répétitives) ==== | ||
+ | {{ : | ||
+ | Ce type d' | ||
+ | |||
+ | === 3.1 La boucle while === | ||
+ | |||
+ | <callout type=" | ||
+ | |||
+ | |||
+ | //Syntaxe// | ||
+ | <code python> | ||
+ | while prédicat: | ||
+ | bloc de code # le bloc de code est | ||
+ | # exécuté tant que la condition est vraie | ||
+ | </ | ||
+ | |||
+ | <note warning> | ||
+ | |||
+ | //Exemple 1// | ||
+ | <code python exboucle1.py> | ||
+ | compteur = 0 # Initialisation de la variable utilisée dans la boucle | ||
+ | while compteur < 10: | ||
+ | print(compteur) # Résultat : 0 1 2 3 4 5 6 7 8 9 | ||
+ | compteur = compteur + 1 # Cette instruction assure l' | ||
+ | </ | ||
+ | |||
+ | //Exemple 2// | ||
+ | <code python *.py> | ||
+ | while True: | ||
+ | bloc de code # cette boucle ne se termine jamais ! Cette structure est utilisée dans quelques cas particuliers. | ||
+ | </ | ||
+ | |||
+ | === 3.2 La boucle for === | ||
+ | |||
+ | <callout type=" | ||
+ | |||
+ | * **Cas 1 : itérer sur une séquence** (**for** //element// **in** // | ||
+ | |||
+ | > L' | ||
+ | |||
+ | //Syntaxe// | ||
+ | <code python> | ||
+ | for nom_variable in collection: | ||
+ | bloc de code | ||
+ | </ | ||
+ | |||
+ | //Exemple// | ||
+ | <code python exboucle2.py> | ||
+ | ma_liste = [" | ||
+ | for x in ma_liste: | ||
+ | print(x) # A chaque itération x prend la valeur pointée dans la liste, | ||
+ | # la variable de boucle est gérée automatiquement. | ||
+ | # Résultat affiché dans la console : chien chat souris cheval | ||
+ | </ | ||
+ | |||
+ | * **Cas 2 : répéter l' | ||
+ | |||
+ | <callout type=" | ||
+ | La fonction range() renvoie une séquence de nombres, commençant par 0, incrémente de 1 (par défaut) et se termine par un nombre spécifié.</ | ||
+ | |||
+ | //Syntaxe// | ||
+ | <code python *.py> | ||
+ | for variable in range(début, | ||
+ | # au premier tour de boucle variable = début | ||
+ | # à chaque tour variable = variable + pas | ||
+ | # la boucle s' | ||
+ | </ | ||
+ | |||
+ | //Exemple 1 // : boucle for avec **un seul paramètre** | ||
+ | <code python *.py> | ||
+ | # cas particulier : si la variable n'est pas utilisée, on peut la remplacer par _ | ||
+ | for _ in range(3): | ||
+ | print(" | ||
+ | </ | ||
+ | |||
+ | <code python *.py> | ||
+ | # Avec un indice (ou compteur) de boucle | ||
+ | for i in range(3): | ||
+ | print(i) # Affichage : 0 1 2 | ||
+ | </ | ||
+ | |||
+ | // Exemple 2 // : boucle for avec **deux paramètres** | ||
+ | <code python *.py> | ||
+ | for i in range(1,4): | ||
+ | print(i) # la première valeur de i est 1, la boucle s' | ||
+ | # Affichage : 1 2 3 | ||
+ | </ | ||
+ | |||
+ | // Exemple 3 // : boucle for avec **trois paramètres** | ||
+ | <code python *.py> | ||
+ | for i in range(1, | ||
+ | print(i) # la première valeur de i=1, l' | ||
+ | # Affichage : 1 3 5 7 9 | ||
+ | </ | ||
+ | |||
+ | |||
+ | === 3.3. Les mots-clés break, continue et pass === | ||
+ | * **break** | ||
+ | |||
+ | <callout type=" | ||
+ | |||
+ | //Exemple// | ||
+ | |||
+ | <code python exbreak.py> | ||
+ | while 1: # 1 est toujours vrai -> boucle infinie | ||
+ | lettre = input(" | ||
+ | if lettre==" | ||
+ | print(" | ||
+ | break | ||
+ | </ | ||
+ | |||
+ | * **continue** | ||
+ | |||
+ | <callout type=" | ||
+ | |||
+ | //Exemple// | ||
+ | |||
+ | <code python excontinue.py> | ||
+ | i=1 | ||
+ | while i< | ||
+ | if i%3 == 0: | ||
+ | i = i + 4 # on incrémente i de 4 | ||
+ | print(" | ||
+ | continue # retourne au while sans exécuter les lignes ci-dessous | ||
+ | print(" | ||
+ | i = i + 1 # si i%3!=0 on incrémente i de 1 | ||
+ | </ | ||
+ | |||
+ | * **pass** | ||
+ | |||
+ | <callout type=" | ||
+ | //Exemple// | ||
+ | <code python *.py> | ||
+ | liste = list(range(10)) | ||
+ | print(' | ||
+ | while liste.pop() != 5: | ||
+ | pass | ||
+ | print(' | ||
+ | </ | ||
+ | |||
+ | ---- | ||
+ | |||
+ | ===3.4 La fonction built-in enumerate() === | ||
+ | |||
+ | <callout type=" | ||
+ | |||
+ | // Exemples// | ||
+ | |||
+ | * // Liste simple // | ||
+ | <code python *.py> | ||
+ | lst=[' | ||
+ | for compteur, valeur in enumerate(lst): | ||
+ | print(compteur, | ||
+ | 1 b | ||
+ | 2 c etc. | ||
+ | </ | ||
+ | |||
+ | On peut fixer la première valeur de la variable compteur. | ||
+ | |||
+ | <code python *.py> | ||
+ | lst = [' | ||
+ | for compteur, valeur in enumerate(lst, | ||
+ | print(compteur, | ||
+ | |||
+ | # Résultat | ||
+ | # 1 apple | ||
+ | # 2 banana | ||
+ | # 3 grapes | ||
+ | # 4 pear | ||
+ | </ | ||
+ | |||
+ | * //Liste de listes// | ||
+ | <code python *.py> | ||
+ | lst = [ | ||
+ | [' | ||
+ | [' | ||
+ | [' | ||
+ | [' | ||
+ | ] | ||
+ | |||
+ | for x, ligne in enumerate(lst): | ||
+ | print(x, | ||
+ | for y, val in enumerate(ligne): | ||
+ | print(x, | ||
+ | |||
+ | # Résultat | ||
+ | # 0 [' | ||
+ | # 0 0 a | ||
+ | # 0 1 b | ||
+ | # 0 2 c | ||
+ | # 0 3 d etc. | ||
+ | </ | ||
+ | |||
+ | * //Création d'une liste de tuples// | ||
+ | <code python *.py> | ||
+ | lst=[' | ||
+ | list(enumerate(lst, | ||
+ | # Résultat [(1, ' | ||
+ | </ | ||
+ | |||
+ | {{ : | ||
+ | === Quiz === | ||
+ | * < | ||
+ | |||
+ | === Pour aller plus loin ... === | ||
+ | * < | ||
+ | * < | ||
+ | * < | ||
+ | ==== Résumé ==== | ||
+ | * Les conditions sont identifiées par les mots-clés **if** (si), **elif** (sinon si) et **else** (sinon). | ||
+ | * Les mots-clés **if** et **elif** doivent être suivis d'un test (appelé aussi **prédicat**) | ||
+ | * Les booléens sont des données soit vraies(**True**) soit fausses (**False**) | ||
+ | * Une boucle sert à **répéter** une portion de code en fonction d'un **prédicat**. | ||
+ | * On peut créer une boucle grâce au mot-clé **// | ||
+ | * On peut parcourir une séquence grâce à la syntaxe **for** //element// **in** // | ||
+ | * Python ne disposant pas d' |