Exo Python

Identification

Infoforall

9 - Exercices Python

⏪

⏬

⏩

1 - Variables

2 - IF

3 - Fonction

4 - pour/for

5 - TQ/while

Exercices liés à cette activité Python

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 vues en seconde, ou pas. Il ne s'agit ici que de découvrir ou de réactiver les connaissances, des leçons plus détaillées vous permettront d'aller plus loin cette année.

1 - Variables

⇩ ⇧ ⤊

1.1 VARIABLE - Affectation

Affectation

L'affectation est le nom qu'on donne au mécanisme permettant de créer une liaison entre un NOM et un CONTENU MEMOIRE.

une sorte de boite
Image issue de http://hcc-cs.weebly.com/variables.html
L'opérateur d'affectation = en Python
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
L'opérateur d'affectation ← 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 plutôt ceci dans les algorithmes :

a ← 10

Lire une variable

Pour obtenir le contenu d'une variable, il suffit

  • Dans la console interactive : de taper le nom de cette variable .
    • >>> a = 100 >>> a 100
  • Dans un programme : d'utiliser print() sur cette variable .
    • 1 2
    a = 100 print(a)
1.2 - VARIABLE - Incrémentation

Vocabulaire

Incrémenter veut dire utiliser la valeur actuelle d'une variable pour calculer sa nouvelle valeur.

Incrémenter de 1 en partant de 45 veut dire qu'on passe à 46.

Incrémenter de 2 en partant de 45 veut dire qu'on passe à 47.

Incrémenter de 5 en partant de 45 veut dire qu'on passe à 50.

Incrémenter de -1 en partant de 45 veut dire qu'on passe à 44.

On dit plutôt décrémenter.

Incrémenter (sans autre information donnée) veut dire qu'on incrémenter de +1. il s'agit de la valeur par défaut.

Faire une incrémentation en Python
1 2
a = 10 # après cette ligne, a référence 10 a = a + 1 # après cette ligne, a référence 11

La demande s'effectue bien de la droite vers la gauche :

  1. a = a + 1 : évaluer ce que donne cette valeur + 1 (donc 10+1=11 sur l'exemple)
  2. a = a + 1 : affecter le résultat de cette évaluation à a.

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

1 2
a = 10 a = a + 5

...CORRECTION...

  • L1 : a référence 10.
  • L2 : on calcule 10+5 puis a référence maintenant 15.

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

...CORRECTION...

  • L1 : elle référence 4.
  • L2 : on calcule 4-1, puis elle référence maintenant 3.

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

1 2
b = 10 b = b + b

...CORRECTION...

  • L1 : b référence 10.
  • L2 : on calcule 10+10, puis b référence maintenant 20.

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

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

...CORRECTION...

  • L1 : a référence 10.
  • L2 : b référence 50.
  • L3 : c référence 50-10, puis c référence maintenant 40.

2 - Instructions conditionnelles

⇩ ⇧ ⤊

2.1 Instruction conditionnelle

Idée générale

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"
Signification des lignes en français
  • L3 : note référence 20.
  • L4 : si la note est strictement supérieure à 15
  • (L5 tabulée, appartient au if) : alors appreciation référence "Très bien".
  • L6 (pas tabulée, n'appartient pas au if) : fatigue passe à "Grosse fatigue" (sans condition car pas de tabulation).
Importance de la tabulation

La tabulation (4 espaces) permet de signaler à l'intepréteur Python le début et la fin du bloc de la condition. La ligne 6 n'appartient donc pas au bloc : elle sera exécutée que la condition soit vraie ou fausse.

On peut rendre le code plus clair pour un débutant en utilisant des lignes vides :

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

L1 - L2 - L3 - L4 (avec condition vraie) - L5 - L6 - fin

1 2 3 4 5 6
fatigue = "En forme !" appreciation = "Moyen" note = 20 if note > 15: # Vrai pour une note de 20 appreciation = "Très bien" # donc on effectue cette ligne fatigue = "Grosse fatigue"
Déroulé pour note = 10

L1-L2-L3-L4 (avec condition fausse) - L6 - fin

1 2 3 4 5 6
fatigue = "En forme !" appreciation = "Moyen" note = 14 if note > 15: # Faux pour une note de 14 appreciation = "Très bien" # donc on n'effectue pas cette ligne fatigue = "Grosse fatigue"

05° Donner la succession des lignes qui vont être exécutées sur ce programme. Justifier ensuite 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"

...CORRECTION...

L1 - L2 - L3 - L4 (condition fausse) - L6 - fin

Puisqu'on n'exécute pas la ligne 5, appreciation référence toujours "Moyen".

La ligne 6 ne fait pas partie du if et fatigue référence alors "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"

...CORRECTION...

L1 - L2 - L3 - L4 (condition vraie) - L5 - L6 - fin

Puisqu'on exécute la ligne 5, appreciation référence maintenant "Très bien".

La ligne 6 ne fait pas partie du if et fatigue référence alors "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"

...CORRECTION...

L1 - L2 - L3 - L4 (condition fausse) - fin

Puisqu'on n'exécute ni la ligne 5, ni la ligne 6 qui sont toutes les deux tabulées, appreciation référence toujours "Moyen" et fatigue référence toujours "En forme !".

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 de la réponse) - L4 (réception de la réponse) - fin

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 la réponse 24 à la ligne qui a lancé l'appel
  • Ligne 4 : réception de la réponse et n référence 24.
C - Lancer plusieurs appels

Les fonctions ont deux avantages :

  1. Permettre l'envoi d'une sortie dont la valeur dépend des entrées reçues;
  2. Permettre plusieurs appels successifs à une même fonction.
1 2 3 4 5
def double(x): return 2 * x a = double(10) b = double(30)

Déroulé

  • L1 (déclaration)
  • L4 (appel) - L1 - L2 (envoi de la réponse) - L4 (réception de la réponse et a référence 20)
  • L5 (appel) - L1 - L2 (envoi de la réponse) - L5 (réception de la réponse et b référence 60) - fin

08° Fournir la succession des lignes que va suivre l'interpréteur et justifier le contenu de la variable n à la fin de l'exécution du programme.

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

...CORRECTION...

L1 (déclaration) - L4 (appel en envoyant 100)

L1 (x référence 100) - L2 (envoi de la réponse 2*100=200) - L4 (n référence 200) - fin

09° Fournir la succession des lignes que va suivre l'interpréteur et justifier le contenu de la variable n à la fin de l'exécution du programme.

1 2 3 4
def mystere(x): return x + 10 n = mystere(100)

...CORRECTION...

L1 (déclaration) - L4 (appel en envoyant 100)

L1 (x référence 100) - L2 (envoi de la réponse 100+10=110) - L4 (n référence 110) - fin

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) - fin

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 envoie 17 en sortie.
  • L7 (réception) : on stocke 17 dans n.

10° Fournir la succession des lignes que va suivre l'interpréteur et justifier le contenu de la variable n et de la variable m à la fin de l'exécution du programme.

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

...CORRECTION...

L1 (déclaration)

L7 (appel en envoyant 18) - L1 (note référence 18) - L2 (note référence 23) - L3 (condition vraie) - L4 (note référence 20) - L5 (envoi de la réponse 20) - L7 (n référence 20) -

L8 (appel en envoyant 12) - L1 (note référence 12) - L2 (note référence 17) - L3 (condition fausse) - L5 (envoi de la réponse 17) - L8 (m référence 17) -

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 (1er tour) - L3 (n = 0+10 = 10)
  • L2 (2e tour) - L3 (n = 10+10 = 20)
  • ...

...CORRECTION...

  • L1 (n = 0)
  • L2 (1er tour) - L3 (n = 0+10 = 10)
  • L2 (2e tour) - L3 (n = 10+10 = 20)
  • L2 (3e tour) - L3 (n = 20+10 = 30)
  • L2 (4e tour) - L3 (n = 30+10 = 40)
  • L2 (5e tour) - L3 (n = 40+10 = 50)
  • L4 : (droite) on calcule 50+5=55 puis (gauche) n référence ensuite 55.
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 néanmoins bien au nombre de tours de boucle effectuées : 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° Donner les valeurs successives que vont prendre les variables de boucle a, b, c.

1 2 3 4 5 6 7 8
for a in range(4): print(a) for b in range(10): print(b) for c in range(7): print(c)

...CORRECTION...

.. .. ..
for a in range(4): for b in range(10): for c in range(7):

a va prendre les valeurs 0, 1, 2 et 3.

b va prendre les valeurs 0, 1, 2, 3, 4, 5, 6, 7, 8 et 9.

b va prendre les valeurs 0, 1, 2, 3, 4, 5, 6.

13° 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(4): n = n + k n = n + 100

Notez bien qu'on incrémente la variable de k à chaque tour de boucle.

Solution à compléter :

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

...CORRECTION...

  • L1 (n = 10)
  • L2 (k = 0) - L3 (n = 10+0 = 10)
  • L2 (k = 1) - L3 (n = 10+1 = 11)
  • L2 (k = 2) - L3 (n = 11+2 = 13)
  • L2 (k = 3) - L3 (n = 13+3 = 16)
  • L4 : (gauche) on calcule 16+100=116 et (droite) n référence ensuite ce 116.

5 - Boucle TANT QUE

⇩ ⇧ ⤊

5.1 Boucle TANT QUE

A - Principe

Le mot-clé while réalise une boucle sans prévoir à l'avance combien de tours on va la réaliser exactement. 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 en L3, on réalise L4-L5-L6 puis on revient en ligne 3.
  • si poursuite est False en L3, on saute en L8.

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 une éparge initiale de 10 euros.
  • On double l'épargne tous les mois.
  • Tant que l'épargne est inférieure à 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
epargne = 10 nb_mois = 0 while epargne < 5000: epargne = epargne * 2 nb_mois = nb_mois + 1 print(epargne) print(nb_mois)

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 (epargne=10) - L2 (nb_mois=0)
  • L4 (condition 10<5000 vrai) - L5 (epargne=10*2=20) - L6 (nb_mois=0+1=1)
  • L4 (condition 20<5000 vrai) - L5 (epargne=20*2=40) - L6 (nb_mois=1+1=2)
  • ...
  • L4 (condition 1280<5000 vrai) - L5 (epargne=1280*2=2560) - L6 (nb_mois=8+1=9)
  • L4 (condition 2560<5000 vrai) - L5 (epargne=2560*2=5120) - L6 (nb_mois=9+1=10)
  • L4 (condition 5120<5000 faux) : FIN DU TANT QUE.
  • L8-L9 : affichage des variables

14° 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 :

  • L1 (x = 0)
  • L3 (condition 0<40 True) - L4 (affiche 0) - L5 (x=0+10 = 10)
  • L3 (condition 10<40 True) - L4 (affiche 10) - L5 (x=10+10 = 20)
  • ...

...CORRECTION...

  • L1 (x = 0)
  • L3 (condition 0<40 True) - L4 (affiche 0) - L5 (x=0+10 = 10)
  • L3 (condition 10<40 True) - L4 (affiche 10) - L5 (x=10+10 = 20)
  • L3 (condition 20<40 True) - L4 (affiche 20) - L5 (x=20+10 = 30)
  • L3 (condition 30<40 True) - L4 (affiche 30) - L5 (x=30+10 = 40)
  • L3 (condition 40<40 False) - L7 - fin

FIN

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


⏪

⏫

⏩