Différences

Ci-dessous, les différences entre deux révisions de la page.

--- python:bases:controle [2021/07/24 09:08] – phil
+++ python:bases:controle [2022/08/16 09:02] (Version actuelle) – phil
@@ Ligne 1: / Ligne 1: @@
+{{ :suivant.png?nolink&30|}} [[python:bases:variables|{{ :retour.png?nolink&30|Variables, constantes}}]] [[:python:accueilpython|{{ :iconemaison.jpg?nolink&30|Sommaire Python et microPython}}]]
+===== Python - Instructions de contrôle =====
+[Mise à jour le :3/7/2022]
+  * **Sources**
+    * **Documentation** sur Python.org : <html><a href="https://docs.python.org/fr/3.6/reference/index.html" target="_blank">référence du langage</a>, <a href="https://docs.python.org/fr/3.6/reference/compound_stmts.html#the-if-statement" target="_blank">if, while et for</a>, <a href="https://docs.python.org/fr/3.5/library/functions.html" target="_blank">fonctions natives</a></html> (built-in)
+  * **Lectures connexes**
+    * **Real Python**
+      * <html><a href="https://realpython.com/python-enumerate/" target="_blank">Python enumerate(): Simplify Looping With Counters</a></html>
+      * <html><a href="https://realpython.com/python-range/" target="_blank">The Python range() Function (Guide)</a></html>
+      * <html><a href="https://realpython.com/python-for-loop/" target="_blank">Python "for" Loops (Definite Iteration)</a></html>
+  * **Mots-clés** : opérateurs de comparaison, tests, boucles
+<callout type="warning" icon="true">Les mots ci-dessous sont dits "réservés". Ils ne peuvent pas être utilisés comme nom de variable. Les mots __soulignés__ sont une nouveauté de Python 3. Les mots en **gras** sont utilisés dans cette page.</callout>
+|  **and**    |  **continue**   |  finally  |  is            |  raise         |
+|  as         |  def            |  **for**  |  lambda        |  return        |
+|  assert     |  del            |  from     |  __None__      |  **__True__**  |
+|  __async__  |  **elif**       |  global   |  __nonlocal__  |  try           |
+|  __await__  |  **else**       |  **if**   |  **not**       |  **while**     |
+|  **break**  |  except         |  import   |  **or**        |  with          |
+|  class      |  **__False__**  |  **in**   |  **pass**      |  yield         |
+  * <html><a href="https://docs.python.org/fr/3.5/library/functions.html" target="_blank">Fonctions natives</a></html>** (built-in)**((Fonctions toujours disponibles.)) utilisées dans les exemples : **enumerate**(), **list**(), **print**(), **range**().
+----
+==== Généralités ===
+  *  **Structure d'une instruction de contrôle "if ... elif ... else ..."**
+<code python *.py>
+if test1:
+    <bloc d'instruction 1>
+elif test2:
+    <bloc d'instruction 2>
+elif test3:
+    <bloc d'instruction 3>
+...
+else:
+    <bloc d'instruction n>
+</code>
+<callout type="warning" icon="true">Dans une structure** if elif else** un seul bloc d'instruction est exécuté.</callout>
+  * **Mécanisme d'évaluation d'un test**
+<callout type="warning" icon="true">Un test peut contenir n'importe quelle expression !</callout>
+L'expression contenue dans le test est exécutée. Elle produit un objet sur lequel Python appelle la fonction built-in **bool**(//objet//).
+Selon l'objet renvoyé : \\
+    * la fonction buit-in bool(objet) => //objet//.<nowiki>__</nowiki>**bool**<nowiki>__</nowiki>() qui renvoie **True** ou **False**
+ou
+    * la fonction buit-in bool(objet) => //objet//.<nowiki>__</nowiki>**len**<nowiki>__</nowiki>()
+      * si <nowiki>__</nowiki>**len**<nowiki>__</nowiki>() retourne **0** alors **False**
+      * si <nowiki>__</nowiki>**len**<nowiki>__</nowiki>() retourne autre chose alors **True**
+<callout type="warning" icon="true">Un objet **vide** est considéré comme **faux**. Un objet **non-vide** est considéré comme **vrai**.</callout>
+// Exemples d'expressions //
+  * **Un type built-in**
+    * Est **Faux** : False 0 None [] {} () '' (liste, dictionnaire, ensemble et chaîne de caractères vides)
+    * Est **Vrai** : tout le reste
+<code python *.py>
+d = {'marc':10}
+if d: # dictionnaire non vide, on affiche
+    print(d) # Résulat {'marc': 10}
+</code>
+  * **Une Comparaison**
+    * > >= < <= == !=
+<code python *.py>
+a=10;b=12
+if a != b:
+    print('La cimparaison est fausse')
+</code>
+  * **Un test d'appartenance**
+<code python *.py>
+if 'a' in 'marc':
+    print('ok') # Résultat : ok
+</code>
+  * **Un retour de fonction**
+    * On évalue l'objet retourné.
+<code python *.py>
+s='123'
+if s.isdecimal():
+    print(2*int(s)) # Résultat : 246
+</code>
+  * ** Un opérateur de test booléen and , or, not**
+<code python *.py>
+s='123'
+if '1' in s and s.isdecimal():
+    print(2*int(s)) # Résultat : 246
+</code>
+==== 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     ^supérieur^inférieur^supérieur ou égal^inférieur ou égal^différent ^ se situe dans ^
+|  **==** |  **>**  |  **<**  |  **>=**         |  **<=**         |  **!=**  |  **in**       |
+<callout type="warning" icon="true">Ne pas confondre l'opérateur d'égalité **==** avec l'opérateur d'affectation **=**</callout>
+//Exemple//
+<code python exop.py>
+a >=5 # se traduit par a supérieur ou égal à 5
+<=a<=10 # pour un intervalle
+</code>
+=== 1.2 Les opérateurs logiques ===
+> Les opérateurs **not**, **or** et **and**  sont utilisés pour combiner des conditions.
+//Exemple//
+<code python exop.py>
+a >=5 and a<=10 # à placer dans un test comme dans l'exemple ci-dessous
+</code>
+==== 2. Les tests (ou structures alternatives) ====
+> Ce type d'instruction permet au code de suivre différents chemins.
+=== 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
+</code>
+<callout type="warning" icon="true">On dit du code décalé vers la droite qu'il est **indenté**. En Python l'indentation est **fondamentale**. Elle fait intégralement partie de la syntaxe du langage.</callout>
+// Exemple 1 // : comparaison d'une variable à une valeur
+<code python extest1.py>
+a=5
+if a<10:
+   print("C'est vrai")
+else:
+   print("c'est faux") # Résultat : C'est vrai
+</code>
+// Exemple 2 // : utilisation de **in**
+<code python exin.py>
+chaine = "Bonjour. Comment allez-vous ?"
+for lettre in chaine:
+    if lettre in "AEIOUYaeiouy":  # lettre est une voyelle
+        print(lettre)
+    else: # lettre est une consonne
+        print("*")
+</code>
+=== 2.2 if ... elif ... else ...===
+<callout type="tip" icon="true">On utilise **elif** lorsqu'il est nécessaire d'enchaîner plusieurs tests.</callout>
+//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
+</code>
+<callout type="primary" icon="true">**elif** est une **concaténation** de **else if**. On peut utiliser autant de elif que nécessaire.</callout>
+//Exemples//
+<code python extest2a.py>
+a=5
+if a<0:
+   print("a est positif est inférieur à 5")
+elif a >=5 and a<=10:
+   print("a appartient à [5,10]")
+elif a >10 and a<=20:
+   print("a appartient à [11,20]")
+else:
+   print("a est supérieur à 20") # Résultat : a appartient à [5,10]
+</code>
+<code python extest2b.py>
+mot = input("Saisissez un mot: ")
+if 'e' in mot:
+    print("Le mot",mot,"contient le caractère 'e'.")
+else:
+    print("Le mot",mot,"ne contient pas le caractère 'e'.")
+</code>
+=== 2.3 L'instruction pass ===
+<callout type="tip" icon="true">Python ne disposant pas d'accolades pour délimiter les blocs de code, il existe une instruction** pass**, qui ne fait rien.</callout>
+//Exemple//
+<code python *.py>
+if condition:
+    pass       # pass remplace un bloc de code que l'on a supprimé. Cette instruction évite d'inverser le test
+else:
+    action(s)
+</code>
+==== 3. Les boucles (ou structures répétitives) ====
+{{ :python:bases:t.png?nolink|}}
+Ce type d'instruction permet au programme de **répéter**, de **compter** ou d'**accumuler** avec très peu d'instructions.
+=== 3.1 La boucle while ===
+<callout type="tip" icon="true">On utilise une boucle **while** lorsqu'on ne connait pas le nombre de répétition à effectuer. Les instructions du corps de la boucle sont exécutées tant qu'une condition est vraie.</callout>
+//Syntaxe//
+<code python>
+while prédicat:
+   bloc de code # le bloc de code est
+   # exécuté tant que la condition est vraie
+</code>
+<callout icon="fa fa-hand-stop-o" color="red" title="ATTENTION">Afin que la boucle puisse s'interrompre, il faut veiller à faire évoluer dans le corps de la boucle au moins une des variables intervenant dans la condition.</callout>
+//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'arrêt de la boucle pour compteur = 10
+</code>
+//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.
+</code>
+=== 3.2 La boucle for ===
+<callout type="tip" icon="true">On utilise une boucle **for** lorsqu'on connait le nombre de répétitions à effectuer. Elle est utilisée pour **parcourir** une séquence (une **liste**, un **tuple**, un **dictionnaire**, un **ensemble** ou une **chaîne**)</callout>
+  * **Cas 1 : itérer sur une séquence** (**for** //element// **in** //sequence//)
+> L'instruction for //element// in //sequence// permet d'itérer sur une collection de données, tels une **liste** ou un **dictionnaire**. \\ //element// est une variable créée par for. Elle prend successivement chacune des valeurs figurant dans la séquence parcourue.
+//Syntaxe//
+<code python>
+for nom_variable in collection:
+  bloc de code
+</code>
+//Exemple//
+<code python exboucle2.py>
+ma_liste = ["chien", "chat", "souris", "cheval"]
+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
+</code>
+  * **Cas 2 : répéter l'exécution du code** (**for** et la fonction **range()**)
+<callout type="primary" icon="true">Pour répéter l'exécution de code un nombre de fois spécifié, on utilise la fonction range().
+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é.</callout>
+//Syntaxe//
+<code python *.py>
+for variable in range(début, fin, pas):
+          # au premier tour de boucle variable = début
+          # à chaque tour variable = variable + pas
+          # la boucle s'arrête lorsque variable = fin
+</code>
+//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("A") # Affichage A A A
+</code>
+<code python *.py>
+# Avec un indice (ou compteur) de boucle
+for i in range(3):
+    print(i) # Affichage : 0 1 2
+</code>
+// 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'arrête pour i=4
+             # Affichage : 1 2 3
+</code>
+// Exemple 3 // : boucle for avec **trois paramètres**
+<code python *.py>
+for i in range(1,11,2):
+    print(i) # la première valeur de i=1, l'incrément est 2, la boucle s'arrête à 11
+             # Affichage : 1 3 5 7 9
+</code>
+=== 3.3. Les mots-clés break, continue et pass ===
+  * **break**
+<callout type="primary" icon="true">Le mot-clé **break** permet d'**interrompre** une boucle.</callout>
+//Exemple//
+<code python exbreak.py>
+while 1: # 1 est toujours vrai -> boucle infinie
+    lettre = input("Entrer Q pour quitter : ")
+    if lettre=="Q":
+        print("Fin de boucle !")
+        break
+</code>
+  * **continue**
+<callout type="primary" icon="true">Le mot-clé **continue** permet de **poursuivre l'exécution** d'une boucle en repartant du //while// ou du //for//.</callout>
+//Exemple//
+<code python excontinue.py>
+i=1
+while i<20:
+    if i%3 == 0:
+        i = i + 4 # on incrémente i de 4
+        print("i est maintenant égale à",i)
+        continue # retourne au while sans exécuter les lignes ci-dessous
+    print("La variable i =",i)
+    i = i + 1 # si i%3!=0 on incrémente i de 1
+</code>
+  * **pass**
+<callout type="tip" icon="true">Python ne disposant pas d'accolades pour délimiter les blocs de code, il existe une instruction** pass**, qui ne fait rien.</callout>
+//Exemple//
+<code python *.py>
+liste = list(range(10))
+print('avant', liste)
+while liste.pop() != 5:
+    pass
+print('après', liste)
+</code>
+----
+===3.4 La fonction built-in enumerate() ===
+<callout type="tip" icon="true">enumerate permet de boucler sur un iterable tout en disposant d'un compteur.</callout>
+// Exemples//
+  * // Liste simple //
+<code python *.py>
+lst=['a','b','c','d','e','f','g','h','i']
+for compteur, valeur in enumerate(lst):
+    print(compteur, valeur) # Résultat : 0 a
+b
+c etc.
+</code>
+On peut fixer la première valeur de la variable compteur.
+<code python *.py>
+lst = ['apple', 'banana', 'grapes', 'pear']
+for compteur, valeur in enumerate(lst, 1):
+    print(compteur, valeur)
+# Résultat
+# 1 apple
+# 2 banana
+# 3 grapes
+# 4 pear
+</code>
+  * //Liste de listes//
+<code python *.py>
+lst = [
+    ['a','b','c','d'],
+    ['e','f','g','h'],
+    ['i','j','k','l'],
+    ['m','n','o','p'],
+]
+for x, ligne in enumerate(lst):
+    print(x,ligne)
+    for y, val in enumerate(ligne):
+        print(x,y,val)
+# Résultat
+# 0 ['a', 'b', 'c', 'd']
+# 0 0 a
+# 0 1 b
+# 0 2 c
+# 0 3 d etc.
+</code>
+  * //Création d'une liste de tuples//
+<code python *.py>
+lst=['a','b','c','d','e','f','g','h','i']
+list(enumerate(lst,1))
+# Résultat [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f'), (7, 'g'), (8, 'h'), (9, 'i')]
+</code>
+{{ :python:bases:realpython.png?nolink|}}
+=== Quiz ===
+  * <html><a href="https://realpython.com/python-conditional-statements/" target="_blank">Conditional Statements in Python</a></html>
+=== Pour aller plus loin ... ===
+  * <html><a href="https://medium.com/techtofreedom/for-else-a-weird-but-useful-feature-in-python-2076d8dafad1" target="_blank">For-Else: A Weird but Useful Feature in Python</a></html>
+  * <html><a href="https://realpython.com/python-all/#evaluating-the-truth-value-of-items-in-iterables" target="_blank">Python's all(): Check Your Iterables for Truthiness</a></html>
+  * <html><a href="https://realpython.com/python-do-while/" target="_blank">How Can You Emulate Do-While Loops in Python?</a></html>
+==== 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é **//while//** suivi d'un prédicat.
+  * On peut parcourir une séquence grâce à la syntaxe **for** //element// **in** //sequence//:
+  * Python ne disposant pas d'accolades pour délimiter les blocs de code, il existe une instruction** pass**, qui ne fait rien.