Exo Python

Identification

Infoforall

9 - Exercices Python

⏪

⏬

⏩

1 - Variables

2 - IF

3 - Fonction

4 - pour/for

5 - TQ/while

A rendre en version papier.

Ce travail permettra à tout le monde de se retrouver à peu près au même niveau sur les connaissances détaillées ici, que vous les ayez vu en seconde, ou pas. Des activités de cours bien plus détaillées nous permettront d'aller plus loin. Il ne s'agit ici que de découvrir ou de réactiver les connaissances.

1 - Variables

⇩ ⇧ ⤊

Une variable est constituée d'un nom et d'un contenu.

On peut stocker une valeur en lui donnant un nom.

Cette valeur pourra bien entendu varier si on la modifie.

1.1 VARIABLE - Affectation

Affectation

Les variables servent à stocker des données.

une sorte de boite
Image issue de http://hcc-cs.weebly.com/variables.html

Le mécanisme d'affectation de variables consiste à créer une liaison entre un NOM et un CONTENU MEMOIRE.

1
a = 10

L'opérateur = permet de créer une variable nommée a et y stocker la valeur 10.

On peut représenter naïvement ce mécanisme comme une boite qui porte un NOM et dans laquelle on place le CONTENU associé.

Boite a contenant 10

Néanmoins, une affectation est simplement un moyen de faire la liaison entre un NOM et un CONTENU en mémoire :

une sorte de liaison
Notation dans les algorithmes

Notez bien que c'est le CONTENU 10 qu'on associe au NOM a : on va de la droite vers la gauche. C'est pour cela qu'on écrit a ← 10 dans les algorithmes.

Lecture du contenu via la console interactive

Pour obtenir le contenu d'une variable, il suffit de taper le nom de cette variable dans la console interactive. Nous verrons que cela n'est pas suffisant dans un programme.

1.2 - VARIABLE - Incrémentation

Incrémenter veut dire modifier la valeur d'une variable en lui ajoutant une autre valeur.

Incrémenter de 1 veut dire qu'on augmente la valeur de 1 : 45 passe à 46.

Ce +1 est la valeur par défaut en l'absence d'information.

Incrémenter de 2 veut dire qu'on augmente la valeur de 2 : 45 passe à 47.

Incrémenter de -1 veut dire qu'on augmente la valeur de -1 : 45 passe à 44.

On dit plutôt décrémenter.

Pour incrémenter a de 1 : a = a + 1

  1. a = a + 1 : évaluer la valeur actuelle de a,
  2. a = a + 1 : évaluer (calculer) ce que donne cette valeur + 1 et
  3. a = a + 1 : affecter le résultat de cette évaluation à a.
1 2
a = 10 a = a + 1

En ligne 1, on associe 10 à a.

En ligne 2, on évalue a + 1, ce qui donne 11. On place ENSUITE ce résultat de 11 dans a : au final, a contient donc 11.

✎ 01° Expliquer ce que va contenir la variable a en fin de programme.

1 2
a = 10 a = a + 5

✎ 02° Expliquer ce que va contenir la variable paquets_de_chips en fin de programme.

1 2
paquets_de_chips = 4 paquets_de_chips = paquets_de_chips - 1

✎ 03° Expliquer ce que va contenir la variable b en fin de programme.

1 2
b = 10 b = b + b

✎ 04° Expliquer ce que va contenir la variable c en fin de programme.

1 2 3
a = 10 b = 50 c = b - a

2 - Instructions conditionnelles

⇩ ⇧ ⤊

2.1 Instruction conditionnelle

Une instruction conditionnelle permet d'exécuter un bloc d'instructions uniquement si la condition évaluée est vraie (True en Python).

Ci-dessous, un exemple où on change l'appréciation si la note est bonne (if en anglais)

1 2 3 4 5 6
fatigue = "En forme !" appreciation = "Moyen" note = 20 if note > 15: appreciation = "Très bien" fatigue = "Grosse fatigue"

TABULATION : le bloc d'instructions à effectuer est décalé de 4 espaces (ligne 5). Ce décalage permet à l'intepréteur Python de signaler le début et la fin du bloc. La ligne 6 n'appartient donc pas au bloc.

Déroulé pour note = 20 : L1-L2-L3-L4-L5-L6

Déroulé pour note = 10 : L1-L2-L3-L4-L6

Traduction :

  • L3 : note vaut 20.
  • L4 : si la note fournie est strictement supérieure à 15
  • L5 tabulée : alors appreciation passe à "Très bien".
  • L6 : fatigue passe à "Grosse fatigue" (sans condition car pas de tabulation).

✎ 05° Justifier le contenu des variables appreciation et fatigue à la fin de l'exécution du programme en fournissant la succession des lignes que va suivre l'interpréteur.

1 2 3 4 5 6
fatigue = "En forme !" appreciation = "Moyen" note = 12 if note > 15: appreciation = "Très bien" fatigue = "Grosse fatigue"

✎ 06° Justifier le contenu des variables appreciation et fatigue à la fin de l'exécution du programme en fournissant la succession des lignes que va suivre l'interpréteur..

1 2 3 4 5 6
fatigue = "En forme !" appreciation = "Moyen" note = 17 if note > 15: appreciation = "Très bien" fatigue = "Grosse fatigue"

✎ 07° Justifier le contenu des variables appreciation et fatigue à la fin de l'exécution du programme en fournissant la succession des lignes que va suivre l'interpréteur. Attention au décalage de la ligne finale.

1 2 3 4 5 6
fatigue = "En forme !" appreciation = "Moyen" note = 5 if note > 15: appreciation = "Très bien" fatigue = "Grosse fatigue"

3 - Fonction

⇩ ⇧ ⤊

3.1 FONCTION : notion
ENTREE(S)  ⇒   Fonction   ⇒  SORTIE

Description

Les fonctions sont des instructions particulières qui :

  • reçoivent des données d'entrée et
  • renvoient leur réponse en sortie.

Un exemple avec la fonction VALEUR_ABSOLUE qui n'attend qu'une entrée (un nombre) et qui renvoie la valeur absolue du nombre (le même nombre mais sans son signe).

-12  ⇒   Fonction VALEUR ABSOLUE   ⇒  12

12  ⇒   Fonction VALEUR ABSOLUE   ⇒  12
D'autres exemples
5; 10; 50; 0; 20  ⇒   Fonction MAXIMUM   ⇒  50

5; 10; 50; 0; 20  ⇒   Fonction MINIMUM   ⇒  0

5; 10; 50; 0; 20  ⇒   Fonction SOMME   ⇒  85
3.2 - FONCTION : native

Une fonction native est une fonction présente de base dans Python.

On en fait l'appel en notant son nom et en fournissant entre parenthèses les entrées séparées par des virgules.

nom_fonction(a, b, c, d...)

Dans le cadre de ce site, les fonctions natives sont toujours écrites en vert.

Fonction VALEUR ABSOLUE : cette fonction se nomme abs() en Python.

>>> abs(-12) 12 >>> abs(12) 12

Fonction MAXIMUM : cette fonction se nomme max() en Python.

>>> max(10, 0, 50, 40) 50
3.3 FONCTION : personnelle
1 2 3 4
def double(x): # Déclaration return 2 * x # Déclaration n = double(12) # Appel

On distingue deux choses :

  1. La déclaration (mise en mémoire d'instructions pour les utiliser plus tard)
  2. L'appel (utilisation de ces instructions)
A - Déclarer une fonction

Déclarer la fonction revient à stocker ses instructions.

Pour déclarer une fonction, on écrit dans l'ordre

  1. le mot-clé def.
  2. le nom de la fonction
  3. entre parenthèses : les variables d'entrée séparées par des virgules
  4. le caractère :
  5. les instructions du bloc tabulé
1 2
def double(x): return 2 * x

Important : lors de la déclaration, on ne lance aucun appel, on ne fait que mettre en mémoire.

Le mot-clé return permet d'indiquer ce que la fonction devra renvoyer si on l'appelle.

Placer des commentaires en français dans le code Python

On peut placer du texte à destination des développeurs qui vont lire le programme en utilisant le caractère #. Voir la partie suivante pour un exemple.

Attention : sur votre ligne, tout ce qui se trouve derrière ce # sera purement ignoré par l'interpréteur.

B - Lancer un appel de fonction

Lancer un appel revient à fournir les entrées et attendre la réponse de la fonction.

Sur l'exemple, l'appel se fait LIGNE 4.

1 2 3 4
def double(x): # Déclaration return 2 * x # Déclaration n = double(12) # Appel

Déroulé

  • L1 (déclaration)
  • L4 (appel) - L1 - L2 (envoi) - L4 (réception de la réponse)

Traduction (et déroulé)

  • Ligne 1 : déclaration d'une fonction double() qui va recevoir une donnée qu'on placera dans une variable x.
  • Ligne 4 (appel à la fonction double() en lui envoyant 12)
  • Ligne 1 : l'interpréteur place 12 dans x.
  • Ligne 2 : la fonction envoie 24 à la ligne qui a lancé l'appel
  • Ligne 4 (réception de la réponse qu'on stocke dans une variable n.

✎ 08° Justifier le contenu de la variable n à la fin de l'exécution du programme en fournissant notamment la succession des lignes que va suivre l'interpréteur..

1 2 3 4
def double(x): return 2 * x n = double(100)

✎ 09° Justifier le contenu de la variable n à la fin de l'exécution du programme en fournissant notamment la succession des lignes que va suivre l'interpréteur.

1 2 3 4
def mystere(x): return x + 10 n = mystere(100)
3.4 FONCTION : plus complexe
1 2 3 4 5 6 7
def nouvelle_note(note): note = note + 5 if note > 20: note = 20 return note n = nouvelle_note(12)

Cette fonction récupère la valeur d'une note, rajoute 5, bloque la note à 20 si elle dépassait 20 et renvoie le résultat final.

Déroulé

  • L1 (déclaration)
  • L7 (appel) - L1 - L2 - L3 - L5 (envoi) - L7 (réception)

Traduction et déroulé

  • Ligne 1 : déclaration de nouvelle_note() qui va recevoir une donnée qu'on placera dans note.
  • Ligne 7 (appel à la fonction nouvelle_note() en lui envoyant 12).
  • Ligne 1 à 5 : on exécute les lignes avec note contenant 12 initialement. Après la ligne 2, note contient donc 17. Le test de la condition étant alors faux (17 n'est pas supérieur à 20), on passe en ligne 5 : la fonction répond 17
  • L7 (réception) : on stocke 17 dans n.

✎ 10° Justifier le contenu de la variable n à la fin de l'exécution du programme en fournissant notamment la succession des lignes que va suivre l'interpréteur..

1 2 3 4 5 6 7
def nouvelle_note(note): note = note + 5 if note > 20: note = 20 return note n = nouvelle_note(18)

4 - Boucle POUR / FOR

⇩ ⇧ ⤊

4.1 Boucle POUR : réaliser plusieurs fois EXACTEMENT la même action

A - Principe

Pour réaliser plusieurs fois exactement la même série d'actions, il suffit d'utiliser une boucle bornée POUR, qu'on déclare à l'aide du mot-clé for en Python.

B - Exemple
1 2 3 4 5 6 7
print("Avant boucle") # Pas tabulée : avant la boucle for _ in range(3): # Déclaration de la boucle print("A") # Tabulée : dans la boucle print("-- B") # Tabulée : dans la boucle print("Après boucle") # Pas tabulée : avant la boucle

Déroulé du programme

L1
L3 - L4 - L5
L3 - L4 - L5
L3 - L4 - L5
L7

Résultat du programme

Avant boucle A -- B A -- B A -- B Après boucle
C - Sémantique
3
for _ in range(3):

Traduction en français : "Réalise 3 fois le bloc d'instructions indentées"

✎ 11° Compléter le texte proposé pour justifier le contenu de la variable n à la fin de l'exécution du programme en signalant la succession des lignes suivies par l'interpréteur.

1 2 3 4
n = 0 for _ in range(5): n = n + 10 n = n + 5

Solution à compléter :

  • L1 : n = 0.
  • L2-L3 (1er tour) : n = 10
  • ...
4.2 Boucle POUR : réaliser plusieurs fois PRESQUE la même action

A - Valeurs successives de la variable de boucle

On réalise des actions un peu différentes car utilisant une variable de boucle dont le nom se situe derrière le mot clé for.

for k in range(5):

Sur cet exemple :

  • k est la variable de boucle.
  • k commence à 0
  • k est incrémentée de 1 à chaque tour de boucle.
  • Ainsi, k va prendre les valeurs 0 puis 1 puis 2 puis 3 puis 4.

Attention

  • k n'ira pas jusqu'à 5, c'est une borne exclue.
  • 5 correspond au nombre de tours de boucle effectués : 0-1-2-3-4.
  • La valeur finale de k est 4, obtenue en calculant (5 - 1).
B - Déroulé d'une boucle avec variable de boucle
1 2 3 4 5 6 7
print("Avant boucle") for k in range(3): # Pour k variant de 0 à 2 print("A") # Affiche le string "A" print(k) # Affiche le contenu de k print("Après boucle")

Déroulé du programme

L1
L3(k=0) - L4 - L5
L3(k=1) - L4 - L5
L3(k=2) - L4 - L5
L7

Résultat du programme

Avant boucle A 0 A 1 A 2 Après
C - Sémantique
3
for k in range(3):

Traduction en français : "Pour chaque valeur de k dans [0, 1, 2], réalise le bloc d'instructions indentées"

✎ 12° Compléter le texte proposé pour justifier le contenu de la variable n à la fin de l'exécution du programme en signalant la succession des lignes suivies par l'interpréteur.

1 2 3 4
n = 10 for k in range(6): n = n + k n = n + 100

Solution à compléter :

  • L1 : n=10
  • L2(k=0) - L3 : n = 10+0 = 10.
  • L2(k=1) - L3 : n = 10+1 = 11.
  • ...

5 - Boucle TANT QUE

⇩ ⇧ ⤊

5.1 Boucle TANT QUE

A - Principe

Il s'agit de réaliser une boucle sans prévoir à l'avance combien de tours on va réaliser exactement.

Le mot-clé while déclare cette boucle TANT QUE. C'est l'indentation qui renseigne sur le bloc à réaliser :

L1 début du programme L2 L3 while condition de poursuite: L4 instruction A L5 instruction B L6 instruction C L7 L8 suite du programme

A chaque début de tour, on teste la condition de poursuite :

  • si poursuite est True, on fait un tour en réalisant les lignes 4-5-6 puis on revient en début de boucle, la ligne 3 ici.
  • si poursuite est False, on quitte la boucle en partant en ligne 8.

Il s'agit donc d'une sorte de mélange entre un if et un for : tant que la condition est vraie, on réalise le bloc et on revient au début de la boucle.

B - Un classique : valeur de seuil

Le programme suivant permet de répondre à ce problème :

  • on considère un gain initial de 10 euros.
  • On double le gain tous les mois.
  • Tant qu'il y a moins de 5000 euros, on laisse la somme sur le compte.
  • Au bout de combien de mois va-t-on atteindre 5000 euros ou plus ?
1 2 3 4 5 6 7 8 9
gain = 10 nb_mois = 0 while gain < 5000: gain = gain * 2 nb_mois = nb_mois + 1 print(gain) print(nb_mois)

Principe de la boucle sur cet exemple

  • Ligne 4 : évaluation de la condition de poursuite.
  • SI son évaluation donne True, on réalise le bloc des lignes 5-6 puis on revient à la ligne 4.
  • SINON, on quitte et part en ligne 8.

Si on lance le programme :

>>> %Run boucleTQ.py 5120 9

On voit qu'on atteint 5120 euros au bout de 9 mois. Un compte bancaire qui rapporte 100% tous les mois, c'est rentable mais malheureusement totalement imaginaire.

Traduction et déroulé

  • L1-2 : initialisation à 10 et 0 des variables.
  • L4-L5-L6 (évaluation à True car gain vaut 10, gain passe à 20 et nb_mois à 1).
  • L4-L5-L6 (évaluation à True car gain vaut 10, gain passe à 40 et nb_mois à 2).
  • ...
  • L4-L5-L6 (évaluation à True car gain vaut 10, gain passe à 2560 et nb_mois à 8).
  • L4-L5-L6 (évaluation à True car gain vaut 10, gain passe à 5120 et nb_mois à 9).
  • L4 : évaluation à False de la condition car gain vaut 5120. FIN DU TANT QUE.
  • L8-9 : affichage des variables

✎ 13° Compléter le texte proposé pour justifier le contenu de la variable x à la fin de l'exécution du programme en signalant la succession des lignes suivies par l'interpréteur.

1 2 3 4 5 6 7
x = 0 while x < 40: print(x) x = x + 10 print("Fin du TANT QUE")

Solution à compléter :

  • Ligne 1 : x vaut 0.
  • Lignes 3 (avec x valant 0)-4-5 : on affiche 0 puis on affecte 10 à x.
  • Lignes 3 (avec x valant 10)-4-5 : on affiche 10 puis on affecte 20 à x.
  • ...

FIN

Activité publiée le 12 06 2021
Dernière modification : 15 06 2023
Auteur : ows. h.


⏪

⏫

⏩