Exo Python

Identification

Infoforall

10 - Exercices Python


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

une sorte de boite
Image issue de http://hcc-cs.weebly.com/variables.html
Affectation
L'affectation est le mécanisme créant une liaison entre un nom de variable et un contenu mémoire. Dans les algorithmes, on symbolise l'affectation du contenu 10 à la variable nommée a de cette façon :

a  10

On affecte le contenu de droite vers la variable à gauche. On va donc de la droite vers la gauche.

Représentation mentale de l'affectation

On peut représenter naïvement ce mécanisme comme une boite :

Boite a contenant 10 Néanmoins, une affectation est en réalité cette liaison entre un nom et une zone de la mémoire :

une sorte de liaison
L'opérateur d'affectation = en Python
L'opérateur = permet de réaliser une affectation.

La syntaxe est variable = expression.
On place donc toujours la variable à gauche.

Pour affecter la valeur 10 à la variable a, on tape ceci :

1
a = 10
Afficher le contenu d'une variable
En Python, la demande est différente en fonction de l'endroit où elle est formulée.

Pour obtenir le contenu d'une variable, il suffit

  • Dans la console interactive, il suffit de taper une ligne contenant uniquement le nom de la variable :
  • >>> a = 100 >>> a 100
  • Dans un programme, il faut utiliser la fonction native print() :
  • 1 2
    a = 100 print(a)
1.2 - VARIABLE - Incrémentation

Vocabulaire

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 de 1 d'ailleurs.

Conclusion

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

Incrémenter (sans autre information donnée) veut dire qu'on incrémente 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

Principe général

Une fonction est un bloc de code qui reçoit des données d'entrée et envoie une 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.

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

On fait appel à une fonction en notant son nom suivi de parenthèses contenant les entrées séparées par des virgules :

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

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 : définition d'une fonction personnelle
1 2 3 4
def double(x): # Déclaration return 2 * x # Déclaration n = double(12) # Appel

Définir une fonction revient à stocker ses instructions pour les utiliser plus tard.

On voit d'ailleurs que vous ne pourriez pas l'utiliser pour le moment car vous ne savez pas ce que contient réellement la variable x.

Par contre, si vous avez bien compris ce qu'est une variable, vous devriez comprendre qu'on va remplir le double de ce qu'on va recevoir un jour en entrée.

Pour définir une fonction, on utilise le mot-clé def puis

  1. le nom de la fonction
  2. des parenthèses contenant les entrées séparées par des virgules
  3. le caractère : pour finir cette première ligne
  4. le bloc tabulé contenant les instructions à réaliser un jour.
1 2
def double(x): return 2 * x

Le mot-clé return permet d'indiquer la sortie que la fonction devra renvoyer.

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.

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

Lancer un appel de fonction
Lancer un appel veut dire utiliser une fonction en lui fournissant des entrées puis attendre pour récupérer la réponse qu'elle fournira.

Sur le code d'exemple, on lance un appel en ligne 4.

Lors d'un appel, l'interpréteur Python transfère les données envoyées une à une dans les variables visibles sur la définition. Pour comprendre où sont stockées les entrées, il suffit de comparer la ligne de la définition et celle de l'appel.

Avec l'appel de la ligne 5, on a 10 qui est stocké dans a lors de cet appel :

définition appel
def fois2(a): x = fois2(10)
[Déroulé] Lors d'un appel, on part de la ligne d'appel vers la ligne de définition puis la réponse est renvoyée vers la ligne d'appel.

1 2 3 4
def double(x): # Définition return 2 * x # Définition n = double(12) # Appel
  • L1 (déclaration)
  • L4 (appel) - L1 - L2 (envoi de la réponse)
  • L4 (réception de la réponse) - fin car il n'y a rien ensuite

Explications complètes

  • 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.
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 affectation du 20 à a)
  • L5 (appel) - L1 - L2 (envoi de la réponse)
  • L5 (réception de la réponse et affectation du 60 à b) - fin
Bilan

Vous devez donc savoir distinguer ces deux étapes, sous peine de ne pas comprendre correctement ce qui est réalisé :

  1. La définition (mise en mémoire d'un bloc d'instructions pour l'utiliser plus tard)
  2. L'appel (utilisation de ce bloc d'instructions)

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.5 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 permet de réaliser une boucle sous condition. Le principe est le suivant :

Lorsqu’on tombe sur le début de la boucle, on évalue l’expression de poursuite.

Si elle est vraie, on réalise un tour de boucle et on revient au début.

Si elle est fausse, on arrête la boucle, en cherchant la première instruction hors boucle (non indentée).

Comme pour for et if, 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

On a donc deux possibilités d'exécution :

  • si poursuite est True en L3 : L3(True) - L4-L5-L6 puis L3 à nouveau.
  • si poursuite est False en L3 : L3(True) - L8.
B - Un classique : valeur de seuil

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

  • on considère une épargne initiale de 10 euros.
  • On double l'épargne tous les mois.
  • Tant que l'épargne est inférieure à 500 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 < 500: 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 640 euros au bout de 6 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<500 vrai) - L5 (epargne=10*2=20) - L6 (nb_mois=0+1=1)
  • L4 (condition 20<500 vrai) - L5 (epargne=20*2=40) - L6 (nb_mois=1+1=2)
  • L4 (condition 20<500 vrai) - L5 (epargne=40*2=80) - L6 (nb_mois=2+1=3)
  • L4 (condition 20<500 vrai) - L5 (epargne=160) - L6 (nb_mois=3+1=4)
  • L4 (condition 20<500 vrai) - L5 (epargne=320) - L6 (nb_mois=4+1=5)
  • L4 (condition 20<500 vrai) - L5 (epargne=640) - L6 (nb_mois=5+1=6)
  • L4 (condition 640<500 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.