Une boucle permet d'exécuter une portion de code plusieurs fois de suite.
L'instruction while
![\"\"](\"http://fsincere.free.fr/isn/python/picto/python_while.png\" "\\"instruction")
Syntaxe
while expression:\t\t# ne pas oublier le signe de ponctuation ':'\n bloc d'instructions\t\t# attention à l'indentation\n# suite du programme
Si l'expression est vraie (True) le bloc d'instructions est exécuté, puis l'expression est à nouveau évaluée.
Le cycle continue jusqu'à ce que l'expression soit fausse (False) : on passe alors à la suite du programme.
Table de multiplication par 8
# script Boucle2.py\n\ncompteur = 1\t# initialisation de la variable de comptage\nwhile compteur <= 10:\n # ce bloc est exécuté tant que la condition (compteur <= 10) est vraie\n print(compteur, '* 8 =', compteur*8)\n compteur += 1 # incrémentation du compteur, compteur = compteur + 1\nprint(\"Et voilà c'est facile!\")
# script Boucle3.py\n\nimport time # importation du module time\nquitter = 'n' # initialisation\nwhile quitter != 'o':\n # ce bloc est exécuté tant que la condition est vraie\n # strftime() est une fonction du module time\n print('Heure courante ', time.strftime('%H:%M:%S'))\n quitter = input(\"Voulez-vous quitter le programme (o/n) ? \")\nprint(\"A bientôt\")
# script Boucle3.py\n\nimport time # importation du module time\nquitter = 'n' # initialisation\nwhile quitter != 'o':\n # ce bloc est exécuté tant que la condition est vraie\n # strftime() est une fonction du module time\n print('Heure courante ', time.strftime('%H:%M:%S'))\n quitter = input(\"Voulez-vous quitter le programme (o/n) ? \")\nprint(\"A bientôt\")
Syntaxe
for élément in séquence :\n bloc d'instructions\n# suite du programme
Les éléments de la séquence sont issus d'une chaîne de caractères ou bien d'une liste.
Tester le programme et conclure.
","title":"L'instruction for"}, {"code":"liste = [\"rouge\" , 1 , 3 , \"vert\"]Fonction range()
L'association avec la fonction range() est très utile pour créer des séquences automatiques de nombres entiers :
# script Boucle6.py\nprint(list(range(1,5)))\n\nfor i in range(1,5):\n print(i)\nprint(\"Fin de la boucle\")
La création d'une table de multiplication paraît plus simple avec une boucle for qu'avec une bouclewhile :
# script Boucle7.py\n\nfor compteur in range(1,11):\n print(compteur, '* 9 =', compteur*9)\nprint(\"Et voilà !\")
L'instruction break provoque une sortie immédiate d'une boucle while ou d'une boucle for.
Dans l'exemple suivant, l'expression True est toujours ... vraie : on a une boucle sans fin.
L'instruction break est donc le seul moyen de sortir de la boucle.
# script Boucle8.pychaine = \">\" \nwhile True:\n # strftime() est une fonction du module time\n print(chaine)\n quitter = input('Voulez-vous quitter le programme (o/n) ? ')\n if quitter == 'o':\n break\n chaine = chaine + \">\"\nprint(\"A bientôt\")
Nous avons déjà vu beaucoup de fonctions : print(), type(), len(), input(), range()...
Ce sont des fonctions pré-définies (built-in functions).
Nous avons aussi la possibilité de créer nos propres fonctions !
Intérêt des fonctions
Une fonction est une portion de code que l'on peut appeler au besoin (c'est une sorte de sous-programme).
L'utilisation des fonctions évite des redondances dans le code : on obtient ainsi des programmes plus courts et plus lisibles.
Par exemple, nous avons besoin de convertir à plusieurs reprises des degrés en radians :
>>> import math\n>>> print(90*math.pi/180)
>>> print(30*math.pi/180)>>> print(45*math.pi/180)Tester la programme de conversion.
import math\nprint(\"90° <=>\",90*math.pi/180,\"rad\")
print(\"30° <=>\",30*math.pi/180,\"rad\")print(\"45° <=>\",45*math.pi/180,\"rad\")La même chose en utilisant une fonction :
>>> def degenrad(degre):\n # Conversion degré en radian \n print(degre , \"<=>\" , degre * math.pi / 180 , \"rad\")\n>>> degenrad(90)
>>> degenrad(30)>>> angle = 45\n>>> degenrad(angle)
Rien ne vous oblige à définir des fonctions dans vos scripts, mais cela est tellement pratique qu'il serait improductif de s'en passer !
"}, {"code":"def degenrad(degre):# Conversion degré en radian
print(degre , \"<=>\" , degre * math.pi / 180 , \"rad\")
L'instruction def
Syntaxe
def nom_de_la_fonction(parametre1, parametre2, parametre3, ...):\n \"\"\" Documentation\nqu'on peut écrire\nsur plusieurs lignes \"\"\"\t# docstring entouré de 3 guillemets (ou apostrophes)\n\n bloc d'instructions\t\t# attention à l'indentation\n\n return resultat \t\t# la fonction retourne le contenu de la variable resultat
Exemple n°1
# script Fonction1.py\n\ndef mapremierefonction():\t# cette fonction n'a pas de paramètre\n \"\"\" Cette fonction affiche 'Bonjour' \"\"\"\n print(\"Bonjour\")\n return\t\t\t# cette fonction ne retourne rien ('None')\n\t\t\t\t# l'instruction return est ici facultative
# script Fonction1.py
\t\t\t\t
La fonction suivante simule le comportement d'un dé à 6 faces.
Pour cela, on utilise la fonction randint() du module random.
import random# script Fonction2.py\n\ndef tirage_de():\n \"\"\" Retourne un nombre entier aléatoire entre 1 et 6 \"\"\"\n valeur = random.randint(1, 6)\n return valeur
Tester le code plusieurs fois et conclure sur son rôle.","title":"Exemple n°2"}, {"code":"
import random
def tirage_de():
\"\"\" Retourne un nombre entier aléatoire entre 1 et 6 \"\"\"
valeur = random.randint(1, 6)
return valeur
#Appeler la fonction tirage_de()\nprint(tirage_de())"}, {"input":"","place":"Conclure ici."}, {"text":"Modifier le programme pour qu'il tire, au hasard, un nombre entre 1 et 10."}], [{"text":"
Une fonction qui affiche la parité d'un nombre entier.
Il peut y avoir plusieurs instructions return dans une fonction.
L'instruction return provoque le retour immédiat de la fonction.
# script Fonction6.py\n\n# définition de fonction\ndef parite(nombre):\n \"\"\" Affiche la parité d'un nombre entier \"\"\"\n if nombre%2 == 1: # L'opérateur % donne le reste d'une division\n print(nombre, 'est impair')\n return\n if nombre%2 == 0:\n print(nombre, 'est pair')\n return\n
parite(7)
La portée d'une variable est l'endroit du programme où on peut accéder à la variable.
Observons le script suivant :
a = 10\t\t# variable globale au programme\n\ndef mafonction():\n a = 20\t# variable locale à la fonction\n print(a)\n return
print(a)\t\t# nous sommmes dans l'espace global du programme\n\nmafonction()\t# nous sommes dans l'espace local de la fonction\n\nprint(a)\t\t# de retour dans l'espace global\n
Nous avons deux variables différentes qui portent le même nom a
Une variable a de valeur 20 est créée dans la fonction : c'est une variable locale à la fonction.
Elle est détruite dès que l'on sort de la fonction.
Tester le programme et conclure.
","title":"Portée de variables : variables globales et locales"}, {"code":""}, {"input":"","place":"Conclure ici."}], [{"text":"