Chaque section d’une activité se termine par un QCM qui permet de vérifier ses acquis. Les questions défilent une à une et le score n’apparaît qu’à la fin. Si toutes les réponses ne sont pas justes, on peut recommencer le QCM (les choix sont alors mélangés) ou demander à voir les réponses, mais on ne peut alors plus le retenter.
Sous-sections de 1ère Spécialité NSI
Physique, Chimie et Informatique > 1ère Spécialité NSI
En manipulant Python dans la console et dans Thonny, vous allez chercher à répondre aux questions suivantes :
Comment un programme représente-t-il une information (un âge, un nom, une réponse par oui ou non) ?
Comment Python calcule-t-il le résultat d’une expression, et dans quel ordre ?
Que se passe-t-il quand on appelle une fonction, et comment savoir s’en servir ?
Comment fabriquer sa propre fonction et vérifier qu’elle fait ce qu’on attend d’elle ?
Comment représenter une information dans un programme ?
L’informatique consiste à automatiser le traitement d’informations. Pour effectuer ces traitements, un programme doit d’abord être capable de représenter les informations issues du monde réel.
Un âge, une température, un nom, une réponse à une question ou une distance ne sont pas des informations de même nature. Un langage de programmation utilise donc différents types pour modéliser ces différentes informations.
Q31.
Pour chacune des informations suivantes, proposer une manière simple de la représenter à l’aide de Python :
le nombre d’élèves d’une classe ;
une température de 18,5 °C ;
le nom d’un élève ;
la réponse à la question « l’élève est-il majeur ? ».
On utilise int pour représenter un entier relatif, float pour un nombre flottant, str pour du texte et bool pour une information logique.
Le choix d’un type constitue donc une première étape de modélisation d’une information réelle.
À retenir
Un programme manipule des représentations d’informations. Le type précise la nature des valeurs manipulées et détermine les opérations que Python pourra leur appliquer.
Type
Information représentée
Exemple
int
nombre entier relatif
12
float
nombre décimal approché
18.5
str
texte
"Alice"
bool
vrai ou faux
True
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Quel type Python convient pour représenter la réponse à la question « l’élève est-il majeur ? » ?
Une information qui ne peut être que vraie ou fausse se représente par un booléen : True ou False. Une chaîne "oui" fonctionnerait, mais Python ne pourrait pas l’utiliser directement comme une condition.
Question 2 / 3
Que retourne l’évaluation de type("32") ?
Les guillemets indiquent une chaîne de caractères, même si son contenu ressemble à un nombre : "32" est un str, 32 est un int.
Question 3 / 3
Une température de 18,5 °C s’écrit en Python :
Python utilise le point comme séparateur décimal : 18.5 est un float. Avec une virgule, 18,5 est interprété comme deux valeurs séparées (un tuple). Avec des guillemets, on obtient un texte, pas un nombre.
Écrire des expressions et comprendre leur évaluation
Q32.
Prévoir la valeur de chacune des expressions suivantes :
>>>3+4>>>2*5+1>>>"NS"+"I">>>-7/0
Vérifier ensuite vos réponses dans la console. Quel point commun possèdent ces quatre écritures ?
Réponse
Elles produisent respectivement 7, 11, 'NSI' et ZeroDivisionError.
Ces quatre écritures sont des expressions : Python les évalue pour obtenir une valeur.
À retenir
Une expression décrit un calcul permettant d’obtenir une valeur. L’action de déterminer cette valeur est appelée évaluation de l’expression.
Q33.
On souhaite calculer 3x2+2x+4 pour x=5.
Tester les expressions suivantes dans la console :
>>>3x^2+2x+4>>>3*5^2+2*5+4>>>3*5**2+2*5+4
Laquelle de ces expressions permet d’obtenir le résultat attendu ? Quelles différences importantes existe-t-il entre l’écriture mathématique et l’écriture Python ?
Réponse
L’expression correcte est :
>>>3*5**2+2*5+489
Python exige d’écrire explicitement les multiplications avec *. La puissance s’écrit ** et non ^.
Q34.
Prévoir les valeurs des expressions suivantes puis vérifier le résultat de l’évaluation par Python :
>>>7+3>>>7-3>>>7*3>>>7/3>>>7//3>>>7%3>>>7**3
Associer ensuite à chaque opérateur son rôle.
Réponse
+
addition
-
soustraction
*
multiplication
/
division
//
quotient de la division euclidienne
%
reste de la division euclidienne
**
puissance
Q35.
Déterminer les valeurs des deux expressions suivantes :
>>>17//5>>>17%5
Utiliser les résultats obtenus pour compléter l’expression mathématique : 17=⋯×5+….
Recommencer avec les valeurs 38 et 7. À quoi servent les opérateurs // et % ?
Réponse
On obtient 17=3×5+2 et 38=5×7+3.
// retourne le quotient de la division euclidienne et % son reste.
/ retourne ici 4.0, de type float, tandis que 8 // 2 retourne 4, de type int. Avec 8.0 // 2, le résultat est un float.
Dans quel ordre Python effectue-t-il les opérations ?
Q37.
Sans utiliser Python, prévoir la valeur des expressions suivantes :
>>>2+3*4>>>(2+3)*4>>>2*3**2>>>(2*3)**2
Vérifier ensuite dans la console. Python effectue-t-il simplement les opérations de gauche à droite ?
Réponse
Les résultats sont respectivement 14, 20, 18 et 36. Python applique des règles de priorité ; les parenthèses permettent de modifier l’ordre d’évaluation.
Observer pas à pas une évaluation avec Thonny
Dans la partie centrale de l’éditeur Thonny, écrire :
2*(3+4)**2+5*6//2
Lancer le programme en mode débogage puis utiliser la touche F7.
Q38.
À l’aide de Thonny, relever l’ordre dans lequel les sous-expressions sont évaluées. Comparer cet ordre avec celui utilisé pour effectuer le calcul à la main.
Réponse
On observe notamment : 3 + 4, l’élévation au carré, la multiplication par 2, 5 * 6, la division entière par 2, puis l’addition des deux résultats.
Une expression complexe est évaluée par réduction progressive de sous-expressions plus simples.
?Vérifier ses acquis4 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 4
Quelle expression Python calcule 3x2+2x+4 pour x=5 ?
En Python, la multiplication s’écrit toujours avec * et la puissance avec **. Le symbole ^ existe, mais il désigne une tout autre opération.
Question 2 / 4
Que valent 17 // 5 et 17 % 5 ?
17=3×5+2 : // donne le quotient de la division euclidienne (3) et % son reste (2).
Question 3 / 4
Quel est le type de la valeur de 8 / 2 ?
L’opérateur / retourne toujours un flottant : 8 / 2 vaut 4.0. Pour obtenir l’entier 4, on utilise la division entière 8 // 2.
Question 4 / 4
Que vaut 2 * 3**2 ?
La puissance est prioritaire sur la multiplication : Python calcule d’abord 3**2 = 9, puis 2 * 9 = 18. Pour obtenir 36, il faut écrire (2 * 3)**2.
Comment utiliser une fonction déjà écrite ?
En mathématiques, une fonction associe à une valeur d’entrée (l’antécédent) une valeur de sortie (l’image) : pour f(x)=x2, l’entrée 3 donne la sortie 9.
À retenir
En programmation, une fonction est un outil qui porte un nom, reçoit des données appelées arguments et retourne un résultat après avoir effectué un traitement. Utiliser une fonction, c’est l’appeler en écrivant son nom suivi de parenthèses.
Python fournit déjà de nombreuses fonctions prêtes à l’emploi : on apprend d’abord à s’en servir, avant d’apprendre à en écrire soi-même.
De quoi se compose l’appel d’une fonction ?
Q39.
Tester les appels de fonctions suivants :
>>>abs(-5)>>>round(3.14159,2)>>>max(4,9)
Pour chaque appel, identifier le nom de la fonction, le ou les arguments et la valeur retournée.
Réponse
Dans abs(-5), abs est le nom de la fonction, -5 l’argument et 5 la valeur retournée. Dans round(3.14159, 2), la fonction round reçoit deux arguments et retourne 3.14.
Comment savoir ce que fait une fonction ?
Q40.
Évaluer les expressions suivantes :
>>>help(abs)>>>help(round)
Quelles opérations réalisent ces fonctions ? Combien d’arguments peut-on leur fournir ? Pourquoi la fonction help est-elle importante pour un programmeur ?
Réponse
help permet de consulter la documentation d’une fonction. Un programmeur n’a pas à mémoriser toutes les fonctions : il doit savoir consulter leur documentation et comprendre comment les utiliser.
Q41.
Évaluer les expressions suivantes :
>>>sum(4,7)>>>help(sum)
Pourquoi le nom d’une fonction ne suffit-il pas pour savoir comment l’utiliser ?
Réponse
L’appel proposé ne correspond pas à l’utilisation attendue de sum. La documentation indique notamment que son premier argument doit être un objet itérable, notion qui sera étudiée ultérieurement.
À quoi servent les modules ?
De nombreuses fonctions fournies avec le langage Python sont regroupées dans des modules.
Q42.
Tester le code suivant dans la console :
>>>importmath>>>dir(math)
Repérer les noms des fonctions qui permettent de calculer : une racine carrée, un sinus, un cosinus et le nom de la variable qui référence la constante π.
Exécuter ensuite help(math.sqrt) et calculer la racine carrée de 81.
Réponse
On trouve notamment math.sqrt, math.sin, math.cos et math.pi.
>>>math.sqrt(81)9.0
Module
Un module regroupe des fonctions (et parfois des variables) consacrées à un même domaine : calculs mathématiques, tirages aléatoires, interfaces graphiques, etc. Après :
importmath
un élément (une fonction par exemple) du module math est accessible avec la syntaxe math.nom.
Q43.
À l’aide de la fonction help, découvrir comment et pourquoi utiliser la fonction random.randint, puis écrire un appel retournant un entier aléatoire compris entre 1 et 10. Les deux bornes peuvent-elles être obtenues ?
Travailler dans la console.
Que peut-on écrire comme argument d’une fonction ?
Q44.
Sans utiliser Python, prévoir ce que retournent ces appels de fonctions, puis les tester dans la console :
>>>abs(3-8)>>>math.sqrt(4+5)>>>abs(3+4/2+7//3)
Que devient une expression utilisée comme argument d’une fonction ?
Réponse
Python commence par évaluer l’expression utilisée comme argument. Ainsi abs(3 - 8) devient d’abord abs(-5), puis produit 5.
Q45.
Dans la partie principale de l’éditeur Thonny, écrire :
importmathmath.sqrt(abs(3-12))
Lancer le programme en mode débogage puis utiliser la touche F7. Décrire l’ordre des calculs.
Réponse
Python évalue d’abord 3−12=−9, puis abs(-9) qui vaut 9, puis math.sqrt(9) qui vaut 3.
La valeur retournée par une fonction peut donc être utilisée comme argument d’une autre fonction.
Q46.
Dans la partie principale de l’éditeur Thonny, écrire :
max(2+3,4*2)
Lancer le programme en mode débogage puis utiliser la touche F7. Relever les valeurs successives prises par chacun des deux arguments avant que la fonction max ne soit appliquée. Que peut-on en conclure sur la nature d’un argument ?
Réponse
Thonny évalue d’abord séparément chaque argument : 2 + 3 devient 5 et 4 * 2 devient 8. L’appel se ramène alors à max(5, 8), qui retourne 8.
Un argument est une expression : Python la réduit à une valeur avant d’effectuer l’appel de la fonction.
Q47.
Prévoir la valeur de chacune des expressions suivantes, puis les écrire dans la partie principale de l’éditeur Thonny :
round(math.sqrt(50),1)max(abs(-10),round(7.4))
Il sera peut être nécessaire de rechercher à l’aide de la fonction help l’action de chacune des fonctions qui doivent être utilisées.
Lancer le programme en mode débogage puis utiliser la touche F7. Pour chaque expression, indiquer quelle fonction est appelée en premier, quelle valeur elle retourne, et comment cette valeur est ensuite utilisée.
Réponse
Dans round(math.sqrt(50), 1), Python évalue d’abord math.sqrt(50), qui retourne environ 7.071. Cette valeur devient le premier argument de round : l’appel se ramène à round(7.071, 1), qui retourne 7.1.
Dans max(abs(-10), round(7.4)), les deux arguments sont d’abord évalués : abs(-10) retourne 10 et round(7.4) retourne 7. L’appel devient max(10, 7), qui retourne 10.
La valeur retournée par une fonction peut donc servir d’argument à une autre fonction : c’est la composition de fonctions.
À retenir
Appeler (ou utiliser) une fonction, c’est écrire son nom suivi de parenthèses contenant ses arguments, séparés par des virgules : round(3.14159, 2).
Une fonction reçoit zéro, un ou plusieurs arguments et retourne une valeur après avoir effectué un traitement.
Chaque argument est une expression : Python l’évalue d’abord, puis effectue l’appel.
La valeur retournée peut être réutilisée, en particulier comme argument d’une autre fonction : math.sqrt(abs(3 - 12)).
Le nom d’une fonction ne suffit pas pour savoir l’utiliser : on consulte sa documentation avec help.
Des fonctions supplémentaires sont regroupées dans des modules, chargés avec import puis utilisés avec la syntaxe module.nom.
?Vérifier ses acquis4 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 4
Dans l’appel round(3.14159, 2), quels sont les arguments ?
round est le nom de la fonction ; les arguments sont les valeurs placées entre les parenthèses ; 3.14 est la valeur retournée.
Question 2 / 4
Lors de l’appel abs(3 - 8), que se passe-t-il en premier ?
Un argument est une expression : Python l’évalue d’abord, puis appelle la fonction avec la valeur obtenue. Ici abs(-5) retourne 5.
Question 3 / 4
Après import math, comment calcule-t-on la racine carrée de 81 ?
Une fonction d’un module s’utilise avec la syntaxe module.nom : math.sqrt(81) retourne 9.0.
Question 4 / 4
On ne sait pas comment utiliser la fonction sum. Que faire ?
Le nom d’une fonction ne suffit pas pour savoir l’utiliser : sum(4, 7) provoque d’ailleurs une erreur. help affiche la documentation, qui indique les arguments attendus.
Comment définir une nouvelle fonction ?
Le langage Python fournit un très grand nombre de fonctions mais il est absolument nécessaire d’être capable d’en définir de nouvelles.
Écrire et tester sa première fonction
Q48.
Dans l’éditeur, recopier le code suivant :
defcarre(x:float)->float:returnx**2
Puis appeler la fonction depuis la console :
>>>carre(3)>>>carre(-2)>>>carre(1.5)
Identifier le nom de la fonction, son paramètre, le type de ce paramètre, le type de la valeur retournée, le rôle de return dans le corps de la fonction.
Quels sont les arguments utilisés lors de l’appel de la fonction ?
Réponse
La fonction se nomme carre et son paramètre est x. C’est un float. return indique la valeur que la fonction retourne ; ici c’est un float. Dans carre(3), 3 est un argument.
Paramètres, arguments
Dans la définition :
defcarre(x:float)->float:returnx**2
x est un paramètre. Dans carre(5), 5 est un argument.
Q49.
Tester puis corriger la définition de fonction suivante :
deftriple(x:float)->float:return3*x
Quelle règle de syntaxe met en évidence l’erreur ?
Réponse
deftriple(x:float)->float:return3*x
Le corps de la fonction doit être indenté.
Comment décrire une fonction sans montrer son code ?
Q50.
Soit la fonction surface_rectangle dont la définition est :
Combien possède-t-elle de paramètres ? Quels types sont annoncés pour les paramètres et la valeur retournée ?
Réponse
La fonction possède deux paramètres, longueur et largeur, annotés avec float. La valeur retournée est également annoncée de type float.
À retenir
Le type d’une fonction est constitué des types de ses paramètres et du type de sa valeur de retour. La signature associe le nom de la fonction à son type.
Q51.
On donne seulement le type de la fonction calcul :
defcalcul(x:float)->float:...
Peut-on savoir si cette fonction calcule le carré de x, son double ou son opposé ? Que manque-t-il ?
Réponse
Non. La signature ne suffit pas à déterminer le traitement réalisé. Il manque une description du rôle de la fonction : sa documentation.
Q52.
Observer la définition de la fonction carre :
defcarre(x:float)->float:""" Retourne le carré du nombre x. """returnx**2
Quelle partie explique ce que fait la fonction ? Quelle partie explique comment elle le fait ?
Réponse
La chaîne de documentation explique ce que fait la fonction ; le corps return x**2 indique comment le calcul est effectué.
À retenir
La spécification constitue le contrat entre le concepteur d’une fonction et son utilisateur.
Speˊcification=Signature+Documentation
Elle indique essentiellement ce que fait la fonction, pas comment elle le fait.
Une fonction sans erreur donne-t-elle toujours le bon résultat ?
Q53.
On souhaite définir une fonction dont la spécification est :
defretire_un(n:float)->float:"""Retourne la valeur de n diminuée de 1."""
Un élève propose :
defretire_un(n:float)->float:"""Retourne la valeur de n diminuée de 1."""return1-n
Python accepte-t-il cette définition ? Que retourne retire_un(5) ? Quelle valeur devrait-elle retourner ? Corriger la fonction.
Réponse
La fonction est syntaxiquement correcte mais retire_un(5) retourne -4 au lieu de 4.
defretire_un(n:float)->float:"""Retourne la valeur de n diminuée de 1."""returnn-1
Peut-on construire une fonction à partir d’une autre ?
Q54.
Définir :
defsomme(x:float,y:float,z:float)->float:"""Retourne la somme de x, y et z."""returnx+y+z
Puis compléter :
defmoyenne(a:float,b:float,c:float)->float:"""Retourne la moyenne de a, b et c."""return...
La fonction moyenne doit utiliser la fonction somme.
Réponse
defmoyenne(a:float,b:float,c:float)->float:"""Retourne la moyenne de a, b et c."""returnsomme(a,b,c)/3
À retenir
Définir une fonction, c’est décrire une fois pour toutes le traitement qu’elle réalise, pour pouvoir ensuite l’appeler autant de fois que nécessaire.
defmoyenne(a:float,b:float,c:float)->float:"""Retourne la moyenne de a, b et c."""return(a+b+c)/3
On commence par le mot-clé def, suivi du nom de la fonction.
Entre parenthèses, on liste les paramètres, chacun annoté par son type (a: float). Après ->, on annonce le type de la valeur retournée.
La ligne d’en-tête se termine par :. Le corps de la fonction est indenté.
La documentation (chaîne entre triples guillemets) décrit ce que fait la fonction.
return indique la valeur retournée par la fonction, puis met fin à son exécution.
Le corps d’une fonction peut appeler d’autres fonctions, déjà définies ou fournies par Python.
Tant qu’elle n’est pas appelée (moyenne(12, 15, 9)), une fonction définie n’exécute aucun calcul.
?Vérifier ses acquis5 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 5
Dans def carre(x: float) -> float:, puis l’appel carre(5), quel est le paramètre et quel est l’argument ?
Le paramètre est le nom utilisé dans la définition ; l’argument est la valeur fournie au moment de l’appel.
Question 2 / 5
Que manque-t-il à cette définition pour que Python l’accepte ? def triple(x: float) -> float: return 3 * x
Le corps d’une fonction doit être indenté (décalé vers la droite) après la ligne d’en-tête, qui se termine par :.
Question 3 / 5
Que contient la spécification d’une fonction ?
Spécification = signature + documentation. Elle dit ce que fait la fonction, pas comment elle le fait.
Question 4 / 5
La fonction retire_un retourne 1 - n au lieu de n - 1. Que se passe-t-il ?
Une fonction peut être syntaxiquement correcte et pourtant ne pas respecter sa spécification : il faut la tester.
Question 5 / 5
Que se passe-t-il quand Python lit la définition def moyenne(a, b, c): ... ?
Définir une fonction, c’est décrire un traitement une fois pour toutes. Il ne s’exécute qu’à l’appel, par exemple moyenne(12, 15, 9).
Exercices de synthèse
Consigne : pour chacune des fonctions définies ci-dessous, donner systématiquement leur spécification complète.
Exercice 1 : Programmer une fonction polynomiale
Q55.
Définir la fonction polynomiale qui reçoit les arguments a, b, c, d, x et qui retourne le résultat du calcul ax3+bx2+cx+d.
Tests :
Définir la fonction moyenne_ponderee qui reçoit les arguments x, y, z, a, b, c et qui calcule la moyenne pondérée des valeurs x,y,z par les coefficients a,b,c. La fonction doit utiliser la fonction somme.
Réponse
defmoyenne_ponderee(x:float,y:float,z:float,a:float,b:float,c:float)->float:"""Retourne la moyenne pondérée de x, y et z."""return(a*x+b*y+c*z)/somme(a,b,c)
Exercice 3 : Calculer des surfaces et des volumes
Q57.
Définir successivement les fonctions surface_rectangle, volume_parallelepipede en utilisant la fonction précédente, surface_disque avec math.pi, puis surface_couronne avec deux appels à surface_disque.
Réponse
defsurface_rectangle(longueur:float,largeur:float)->float:"""Retourne la surface d'un rectangle."""returnlongueur*largeurdefvolume_parallelepipede(longueur:float,largeur:float,hauteur:float)->float:"""Retourne le volume d'un parallélépipède rectangle."""returnsurface_rectangle(longueur,largeur)*hauteurdefsurface_disque(r:float)->float:"""Retourne la surface d'un disque de rayon r."""returnmath.pi*r**2defsurface_couronne(r1:float,r2:float)->float:"""Retourne la surface d'une couronne."""returnsurface_disque(r2)-surface_disque(r1)
Exercice 4 : Calculer la distance entre deux points
Q58.
Dans un repère orthonormé, on peut claculer la distance AB à partir des coordonnées des points A et B :
AB=(x2−x1)2+(y2−y1)2
Définir la fonction distance qui reçoit les arguments x1, y1, x2, y2 et retourne la valeur de la distance entre les deux points.
Tests :
defdistance(x1:float,y1:float,x2:float,y2:float)->float:"""Retourne la distance entre deux points du plan."""returnmath.sqrt((x2-x1)**2+(y2-y1)**2)
Exercice 5 : Reconstruire un tirage aléatoire
Q59.
Consulter la documentation de la fonction random.randint.
Définir la fonction tirage_entier qui reçoit comme argument un entier a et qui retourne un entier aléatoire compris entre 1 et a, bornes incluses. On suppose a entier strictement positif.
Réponse
deftirage_entier(a:int)->int:""" retourne un entier compris entre 1 et a.
return random.randint(1, a)
Q60.
Reprendre l’exercice précédent mais cette fois n’utiliser que la fonction random.random du module random, la multiplication, l’addition et la fonction int. Justifier l’expression avant de programmer. Cet exercice est beaucoup plus difficile !
Réponse
random.random() retourne un nombre x tel que 0≤x<1. Donc 0≤ax<a et int(random.random() * a) produit un entier de 0 à a−1. Il suffit ensuite d’ajouter 1 pour réaliser le traitement attendu.
deftirage_entier(a:int)->int:"""Retourne un entier aléatoire compris entre 1 et a."""returnint(random.random()*a)+1
Bilan : où en suis-je ?
Pour chaque ligne, cochez la colonne qui correspond. Toute case Pas encore indique une partie à reprendre.
Je sais…
Oui
Pas encore
À revoir
choisir un type (int, float, str, bool) pour représenter une information
Partie 1
prévoir la valeur d’une expression et l’ordre dans lequel Python effectue les calculs
Partie 2
appeler une fonction, puis repérer ses arguments et sa valeur de retour
Partie 3
trouver comment utiliser une fonction inconnue avec help, et importer un module
Partie 3
définir une fonction avec def et return, corps indenté
Partie 4
rédiger la spécification d’une fonction et vérifier qu’elle la respecte
Partie 4
Physique, Chimie et Informatique > 1ère Spécialité NSI > Premiers pas en programmation
Manipuler des variables et des chaînes de caractères dans la console Python pour découvrir comment nommer et mettre à jour une information, puis comment l’insérer proprement dans un message.
Comment nommer une information à l’aide d’une variable ?
Q25.
Tester dans la console les instructions suivantes :
>>>age=15>>>age
Puis tester chacune des instructions ci-dessous, une par une :
>>>1age=15>>>mon-age=15>>>for=15
Laquelle de ces trois dernières instructions fonctionne ? Pour les autres, à quel endroit Python signale-t-il une erreur ?
Q26.
Tester dans la console :
>>>help("keywords")
À quoi correspond la liste affichée ? Pourquoi est-il plus utile de retenir l’appel de la fonction help : help("keywords"), que la liste elle-même ?
Ces deux identificateurs désignent-ils la même variable ?
À retenir
Une variable est repérée par un identificateur, qui doit respecter certaines règles :
il commence par une lettre ou un blanc souligné (_) ;
il ne peut ensuite contenir que des lettres, des chiffres ou des blancs soulignés ;
Python distingue les majuscules des minuscules (age et Age sont deux identificateurs différents) ;
un mot réservé du langage (liste consultable avec help("keywords")) ne peut pas être choisi comme identificateur.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Lequel de ces identificateurs est valide en Python ?
Un identificateur commence par une lettre ou _, puis ne contient que des lettres, des chiffres ou _. 1age commence par un chiffre, mon-age contient un tiret (Python y voit une soustraction) et for est un mot réservé.
Question 2 / 3
Après ma_variable = 1 puis maVariable = 2, que vaut ma_variable ?
ma_variable et maVariable sont deux identificateurs différents : la seconde affectation crée une autre variable.
Question 3 / 3
Comment obtenir la liste des mots réservés de Python, interdits comme identificateurs ?
Inutile de retenir la liste par cœur : help("keywords") l’affiche à tout moment.
Que se passe-t-il lors d’une affectation ?
Q28.
Sans utiliser Python, prévoir le résultat de l’évaluation de a et de b après ces instructions, puis tester dans la console :
>>>a=3>>>b=a>>>a=5>>>a>>>b
La variable b a-t-elle changé de valeur lorsque a a été modifiée ?
Q29.
Prévoir le résultat de l’évaluation de x, y et z après ces instructions, puis tester dans la console :
>>>x=y=z=1>>>x>>>y>>>z
Dans quel sens faut-il lire la première instruction pour comprendre ce qu’elle fait : de la gauche vers la droite, ou de la droite vers la gauche ?
Q30.
Prévoir le résultat de l’évaluation de a, b et c après cette instruction, puis tester dans la console :
>>>a,b,c=1,2,3>>>a>>>b>>>c
Combien de valeurs sont affectées en une seule instruction ?
À retenir
Une affectation (opérateur =) donne une valeur à une variable ; elle se lit toujours de la droite vers la gauche.
Affectation simple : a = 3.
Affectation multiple : x = y = z = 1 affecte la même valeur à plusieurs variables.
Affectation groupée : a, b, c = 1, 2, 3 affecte plusieurs valeurs différentes en une instruction.
Python est un langage à typage dynamique : il n’est pas nécessaire de préciser le type d’une variable avant de lui affecter une valeur.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Après a = 3, b = a, puis a = 5, que vaut b ?
b = a donne à b la valeur de a à ce moment-là, soit 3. Modifier a ensuite ne change pas b.
Question 2 / 3
Dans quel sens se lit l’instruction x = y = z = 1 ?
Une affectation se lit toujours de la droite vers la gauche. Les trois variables valent finalement 1.
Question 3 / 3
Après a, b, c = 1, 2, 3, que vaut b ?
C’est une affectation groupée : les valeurs sont attribuées dans l’ordre, a reçoit 1, b reçoit 2, c reçoit 3.
Comment mettre à jour la valeur d’une variable ?
Q31.
Un article coûte 20 € hors taxe ; la TVA est de 18,6 %. Prévoir le résultat de l’évaluation de prix après ces instructions, puis tester dans la console :
Que représente l’expression à droite du signe = dans la troisième instruction ?
Q32.
On suit maintenant le score d’un jeu. Prévoir le résultat de l’évaluation de score pour chacune des deux séquences suivantes, puis tester dans la console :
>>>score=0>>>score=score+10>>>score
>>>score=0>>>score+=10>>>score
Que remarquez-vous ?
Q33.
Par analogie avec +=, prévoir le résultat de l’évaluation de x après chacune des instructions suivantes, puis tester dans la console :
Pour chaque opérateur d’affectation utilisé, réécrire l’instruction équivalente utilisant = et l’opérateur arithmétique correspondant.
À retenir
Un opérateur d’affectation met à jour la valeur d’une variable à partir de sa propre valeur, en une seule écriture (à lire de la droite vers la gauche) :
Opérateur
Équivalent
+=
variable = variable + expression
-=
variable = variable - expression
*=
variable = variable * expression
/=
variable = variable / expression
//=
variable = variable // expression
%=
variable = variable % expression
Peut-on échanger les valeurs de deux variables ?
Q34.
Dans la partie principale de l’éditeur Thonny, écrire :
a=605b=506a=bb=aprint(a,b)
Lancer le programme en mode débogage puis utiliser la touche F7.
Ce programme permute-t-il bien les valeurs de a et b ? Compléter le tableau d’état ci-dessous.
Instruction
a
b
a = 605
b = 506
a = b
b = a
Q35.
Essentiel pour l’épreuve écrite. Sans utiliser Python, compléter le tableau d’état ci-dessous en suivant, ligne par ligne, l’exécution de la séquence d’instructions suivante (la colonne c reste vide tant que cette variable n’existe pas encore). Vérifier ensuite en testant la séquence dans la console.
Corriger le programme précédent, dans la partie principale de l’éditeur, en utilisant une variable supplémentaire nommée tmp, de façon à obtenir a = 506 et b = 605 après exécution.
Q37.
Plus difficile. En utilisant uniquement les opérateurs += et -=, permuter dans la partie principale de l’éditeur les valeurs de a et bsans utiliser aucune variable supplémentaire. Lancer le programme en mode débogage (F7) pour vérifier votre proposition en complétant le tableau d’état ci-dessous, avec a = 605 et b = 506.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Après x = 10, puis x -= 3, puis x *= 2, que vaut x ?
x -= 3 équivaut à x = x - 3 (x vaut 7), puis x *= 2 équivaut à x = x * 2 (x vaut 14).
Question 2 / 3
Le programme a = 605, b = 506, a = b, b = a échange-t-il les valeurs de a et b ?
Après a = b, l’ancienne valeur de a (605) est perdue : b = a recopie donc 506. Pour échanger, il faut d’abord sauvegarder la valeur dans une variable supplémentaire (tmp = a).
Question 3 / 3
Après prix = 20, puis prix = prix + prix * 10 / 100, que vaut prix ?
Python évalue d’abord la partie droite avec l’ancienne valeur de prix (20), ce qui donne 22.0, puis affecte ce résultat à prix.
Comment insérer une valeur dans une chaîne de caractères ?
Q38.
Tester dans la console :
>>>type("abcd")>>>type('abcd')>>>type("Python, c'est top !")>>>type('Python, c'esttop!')
L’une de ces quatre instructions provoque une erreur. Laquelle, et pourquoi ?
Q39.
Prévoir le résultat de l’évaluation de chacune des expressions suivantes, puis tester dans la console :
>>>prenom="Alice">>>"Bonjour "+prenom>>>age=15>>>"Tu as "+age+" ans"
L’une de ces deux dernières instructions échoue. Laquelle, et que dit le message d’erreur ?
Q40.
Python propose une écriture appelée f-string pour éviter ce problème. Prévoir le résultat de l’évaluation de chacune des expressions suivantes, puis tester dans la console :
>>>prenom="Alice">>>age=15>>>f"Bonjour {prenom}, tu as {age} ans.">>>f"L'année prochaine, tu auras {age+1} ans."
Que remarquez-vous sur le contenu des accolades {} dans la seconde instruction ?
f-string
Une f-string s’écrit f"..." : la lettre f juste avant les guillemets indique à Python de rechercher des accolades {} dans le texte. Chaque expression entre accolades est évaluée, convertie en str, puis insérée à cet endroit.
Q41.
On souhaite afficher un prix avec exactement deux chiffres après la virgule. Prévoir le résultat de l’évaluation de chacune des expressions suivantes, puis tester dans la console :
À quoi correspond le nombre placé juste avant la lettre f, après les deux points : ?
Q42.
La méthode .format(), plus ancienne, permet d’obtenir le même résultat et se rencontre encore dans d’anciens programmes. Prévoir le résultat de l’évaluation de chacune des expressions suivantes, puis tester dans la console :
>>>prenom="Alice">>>age=15>>>"Bonjour {}, tu as {} ans.".format(prenom,age)>>>f"Bonjour {prenom}, tu as {age} ans."
Ces deux instructions produisent-elles le même résultat ?
À retenir
Pour insérer une valeur dans un texte, on préfère une f-string :
f"...{expression}...{expression:.Nf}..."
{expression} insère le résultat de l’évaluation de l’expression, converti en str ;
{expression:.Nf} affiche un nombre flottant arrondi à N chiffres après la virgule ;
la méthode "...{}...".format(...), plus ancienne, produit le même résultat mais reste moins lisible.
Exercices de synthèse
Consigne
Écrire chaque fonction dans la partie principale de l’éditeur, en respectant sa spécification et en utilisant une f-string pour construire le message retourné. Tester ensuite son appel dans la console.
Q43.
Écrire la fonction conversion_franc_euro dont la spécification est :
defconversion_franc_euro(francs:float)->str:"""Conversion d'une somme en francs en euros.
Le message retourné donne les deux valeurs.
>>> conversion_franc_euro(100)
'100 francs correspondent à 15.24 euros.'
"""
Le franc était la monnaie utilisée en France avant l’euro (jusqu’en 2002) ; 1 euro correspond à 6,55957 francs. Le montant en euros sera affiché avec deux chiffres après la virgule.
Q44.
Écrire la fonction salutation dont la spécification est :
defsalutation(nom:str,prenom:str,naissance:int)->str:"""À partir des nom, prénom et date de naissance, retourne un
message d'accueil indiquant l'âge de la personne en 2026.
>>> salutation("Dupond", "Patrick", 1961)
'Bonjour Patrick Dupond, vous avez 65 ans.'
"""
Q45.
Écrire la fonction age_aleatoire dont la spécification est :
defage_aleatoire(age_min:int,age_max:int)->str:"""À partir de deux ages limites, retourne un message contenant
un age déterminé aléatoirement entre age_min et age_max inclus.
>>> age_aleatoire(20, 100)
'Votre age est : 85 ans !'
"""
Remarque : utiliser la fonction randint du module random pour déterminer aléatoirement un nombre.
Q46.
Écrire la fonction ticket qui réutilise le principe de la section précédente (prix hors taxe et TVA), et dont la spécification est :
defticket(article:str,prix_ht:float,tva:float)->str:"""Retourne une ligne de ticket de caisse donnant le nom de
l'article et son prix TTC, arrondi à deux chiffres après la
virgule.
>>> ticket("Cahier", 2.5, 5.5)
'Cahier : 2.64 €'
"""
Exercices de synthèse (Doc. 2,1 et Doc. 2,2)
Consigne : réinvestir les fonctions du Doc. 2,1 (spécification, module math) avec les notions du Doc. 2,2 (opérateur d’affectation, f-string). Écrire chaque fonction dans la partie principale de l’éditeur, puis tester son appel dans la console.
Q47.
Écrire la fonction prix_ttc dont la spécification est :
defprix_ttc(prix_ht:float,tva:float)->float:"""Retourne le prix TTC d'un article, à partir de son prix HT
et du taux de TVA en pourcentage.
>>> prix_ttc(20, 18.6)
23.72
"""
Dans la partie principale de l’éditeur, à la suite de cette fonction, calculer le montant total TTC d’un panier contenant trois articles de prix HT 12 €, 8 € et 25 € (TVA à 20 % pour chacun), en partant de total = 0 et en ajoutant chaque article avec l’opérateur +=. Afficher enfin, avec une f-string affichée par print, un message de la forme Total du panier : 54.00 €.
Q48.
On reprend la fonction distance du Doc. 2,1 (à recopier dans la partie principale de l’éditeur si nécessaire) :
defdistance(x1:float,y1:float,x2:float,y2:float)->float:"""Retourne la distance entre deux points du plan."""returnmath.sqrt((x2-x1)**2+(y2-y1)**2)
Écrire, à la suite, la fonction message_distance dont la spécification est :
defmessage_distance(x1:float,y1:float,x2:float,y2:float)->str:"""Retourne un message donnant la distance entre les points
(x1, y1) et (x2, y2), arrondie à deux chiffres après la virgule.
>>> message_distance(0, 0, 3, 4)
'La distance entre les deux points est de 5.00 unités.'
"""
La fonction message_distance doit utiliser la fonction distance.
Bilan : où en suis-je ?
Pour chaque ligne, cochez la colonne qui correspond. Toute case Pas encore indique une partie à reprendre.
Je sais…
Oui
Pas encore
À revoir
choisir un identificateur valide pour une variable
Partie 1
prévoir l’effet d’une affectation simple, multiple ou groupée
Partie 2
utiliser un opérateur d’affectation (+=, -=, …) pour mettre à jour une variable
Partie 3
échanger les valeurs de deux variables à l’aide d’une variable supplémentaire
Partie 3
insérer une valeur ou une expression dans un texte avec une f-string
Partie 4
afficher un nombre flottant avec un nombre choisi de chiffres après la virgule
Partie 4
?Vérifier ses acquis4 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 4
Avec age = 15, que produit "Tu as " + age + " ans" ?
L’opérateur + entre chaînes exige deux str : il ne convertit pas l’entier. Avec une f-string, f"Tu as {age} ans" fonctionne.
Question 2 / 4
Avec prenom = "Alice" et age = 15, que vaut f"{prenom} aura {age + 1} ans" ?
Chaque expression entre accolades est évaluée, convertie en str, puis insérée : age + 1 vaut 16.
Question 3 / 4
Avec montant = 3333.3333, que vaut f"{montant:.2f} €" ?
:.2f affiche le flottant arrondi à 2 chiffres après la virgule.
Question 4 / 4
Laquelle de ces chaînes provoque une erreur ?
Dans 'Python, c'est top !', l’apostrophe de « c’est » referme la chaîne ouverte par '. Quand le texte contient une apostrophe, on le délimite avec des guillemets doubles.
Physique, Chimie et Informatique > 1ère Spécialité NSI > Premiers pas en programmation
Manipuler des expressions booléennes dans la console Python pour découvrir comment combiner des conditions, puis écrire des fonctions dont l’exécution dépend de ces conditions.
Quel est ce nouveau type ? Combien de valeurs différentes peut-il prendre ?
Réponse
Le type bool (booléen) ne peut prendre que deux valeurs : True (vrai) ou False (faux). Une comparaison comme 3 > 2 est une expression booléenne : son évaluation produit un bool.
Q35.
Une confusion fréquente oppose = et ==. Prévoir le résultat de l’évaluation de chacune des instructions suivantes, puis tester dans la console :
>>>a=5>>>a==5>>>a>>>a=(a==5)>>>a
Quelle instruction modifie la variable a ? Laquelle se contente de comparer sans rien modifier ?
Réponse
a = 5 et a = (a == 5) sont des affectations (opérateur =) : elles modifient a. a == 5 est une comparaison (opérateur ==) : elle renvoie True sans modifier a. À la fin, a vaut True, un booléen.
Q36.
Par analogie avec > et ==, prévoir le résultat de l’évaluation de chacune des expressions suivantes, puis tester dans la console :
>>>a,b=3,5>>>a<b>>>a>=b>>>a<=b>>>a!=b>>>a+2==b
Pour chaque opérateur utilisé, indiquer en une phrase ce qu’il teste.
Réponse
Opérateur
Teste si…
<
strictement inférieur
>
strictement supérieur
<=
inférieur ou égal
>=
supérieur ou égal
==
égal
!=
différent
On obtient successivement True, False, True, True, True.
Q37.
Les opérateurs de comparaison s’utilisent aussi sur des chaînes de caractères, comparées dans l’ordre alphabétique. Prévoir le résultat de l’évaluation de chacune des expressions suivantes, puis tester dans la console :
>>>lettre,car="i","j">>>lettre<=car>>>lettre=="w"
Réponse
On obtient True puis False : "i" précède "j" dans l’ordre alphabétique.
Q38.
Python peut convertir n’importe quelle valeur en booléen avec la fonction bool. Prévoir le résultat de l’évaluation de chacune des expressions suivantes, puis tester dans la console :
On obtient False, True, True, False, True, False. Une valeur nulle ou vide (0, "", [], …) est convertie en False ; toute autre valeur est convertie en True.
À retenir
Une grandeur booléenne ne prend que deux valeurs : True ou False. Une expression booléenne (comparaison, appel de bool, …) est une expression dont l’évaluation produit une grandeur booléenne.
Ne pas confondre = (affectation) et == (comparaison).
Q39.
Sans utiliser Python, indiquer si chacune des expressions suivantes vaut True ou False, en justifiant :
>>>7<=7>>>"abc"=="abd">>>3!=3.0>>>"Ana"<="ana"
Vérifier ensuite dans la console.
Réponse
7 <= 7 vaut True (l’égalité est incluse dans <=).
"abc" == "abd" vaut False (le troisième caractère diffère).
3 != 3.0 vaut False : Python considère 3 et 3.0 comme des valeurs numériquement égales, même si leurs types diffèrent.
"Ana" <= "ana" vaut True : dans l’ordre utilisé par Python, une majuscule est toujours considérée comme inférieure à une minuscule.
?Vérifier ses acquis4 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 4
Après a = 5, que fait l’instruction a == 5 ?
= est l’affectation (elle modifie la variable) ; == est la comparaison (elle produit un booléen et ne modifie rien).
Question 2 / 4
Que vaut l’expression 3 != 3.0 ?
!= signifie « différent de ». Les nombres 3 et 3.0 sont égaux pour Python : l’expression vaut donc False.
Question 3 / 4
Que vaut bool("") ?
La chaîne vide (comme 0) est convertie en False ; toute chaîne non vide, même "0", est convertie en True.
Question 4 / 4
Combien de valeurs différentes une grandeur booléenne peut-elle prendre ?
Le type bool ne possède que deux valeurs, True et False.
Comment combiner plusieurs conditions ?
Q40.
Prévoir le résultat de l’évaluation de chacune des expressions suivantes, puis tester dans la console :
>>>notTrue>>>notFalse
Que fait l’opérateur not ?
Réponse
not inverse une valeur booléenne : not True vaut False, not False vaut True.
Q41.
Tester dans la console les quatre combinaisons possibles de l’opérateur and, puis compléter le tableau ci-dessous.
L’une de ces quatre instructions ne provoque pas d’erreur alors qu’elle contient une division par zéro. Laquelle ? Pour chaque instruction, indiquer si Python a eu besoin d’évaluer 1 / 0 pour connaître le résultat.
Réponse
False and (1 / 0) : Python sait déjà que le résultat est False dès qu’il lit False ; il n’évalue pas1 / 0. Aucune erreur.
True or (1 / 0) : Python sait déjà que le résultat est True dès qu’il lit True ; il n’évalue pas1 / 0. Aucune erreur.
True and (1 / 0) : Python doit évaluer le second opérande pour connaître le résultat ; ZeroDivisionError.
(1 / 0) and True : Python évalue toujours le premier opérande en premier, quoi qu’il arrive ; ZeroDivisionError immédiate.
Évaluation en court-circuit
Python évalue toujours une expression de gauche à droite, mais s’arrête dès que le résultat est déterminé, sans évaluer le reste :
avec and, si le premier opérande vaut False, le second n’est pas évalué (le résultat est déjà False) ;
avec or, si le premier opérande vaut True, le second n’est pas évalué (le résultat est déjà True).
Q44.
Sans utiliser Python. On donne e = False, f = False ; les valeurs de d ne sont pas connues. Déterminer, en justifiant par l’évaluation en court-circuit, la valeur de l’expression suivante (et si d doit être connue pour y parvenir) :
>>>eor((note)andfandd)
Vérifier ensuite dans la console avec d = 1 / 0 (qui provoquerait une erreur si Python l’évaluait).
Réponse
e vaut False, donc le or doit évaluer le second opérande : (not e) vaut True, puis True and f vaut False (car f vaut False). Le and s’arrête alors : d n’est jamais évalué. L’expression complète vaut False, sans erreur même si d = 1 / 0.
?Vérifier ses acquis4 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 4
Que vaut True and False ?
A and B ne vaut True que si A et B valent toutes les deux True.
Question 2 / 4
Que vaut False or not False ?
not False vaut True, et False or True vaut True : il suffit qu’un des deux opérandes de or soit vrai.
Question 3 / 4
Laquelle de ces instructions ne provoque pas d’erreur ?
Évaluation en court-circuit : avec and, si le premier opérande vaut False, le résultat est déjà connu et le second (1 / 0) n’est jamais évalué.
Question 4 / 4
Avec or, dans quel cas le second opérande n’est-il pas évalué ?
Si le premier opérande de or vaut True, le résultat vaut forcément True : Python s’arrête là.
Comment exécuter des instructions sous condition ?
Q45.
Dans la partie principale de l’éditeur, écrire puis exécuter :
x=-5ifx<0:print("x est négatif")print("fin du programme")
Relever ce qui s’affiche. Remplacer -5 par 5, exécuter à nouveau et relever ce qui s’affiche. Quelle instruction n’est exécutée que dans certains cas ?
Réponse
Avec x = -5, les deux lignes s’affichent. Avec x = 5, seule "fin du programme" s’affiche. L’instruction print("x est négatif"), indentée sous le if, n’est exécutée que lorsque x < 0 est True.
Alternative simple
if <expression booléenne>: suivi d’un bloc indenté ne fait exécuter ce bloc que si l’expression booléenne vaut True. Si elle vaut False, le bloc est ignoré et le flot d’exécution se poursuit normalement après.
Q46.
Modifier le programme précédent pour qu’il affiche "x est négatif" si x < 0, et "x est positif ou nul" sinon. Tester avec x = -5 puis x = 5.
Réponse
x=-5ifx<0:print("x est négatif")else:print("x est positif ou nul")print("fin du programme")
À retenir
if <exprBool>:, suivi d’un bloc indenté, n’exécute ce bloc que si <exprBool> est True :
if<exprBool>:instructions
Avec else, on exécute le premier bloc si <exprBool> est True, le second sinon :
if<exprBool>:...else:...
Q47.
On veut comparer deux nombres i et j et afficher le plus grand, ou "égaux" s’ils sont identiques. Dans la partie principale de l’éditeur, écrire puis exécuter, pour plusieurs valeurs de i et j (par exemple 3, 7 puis 7, 3 puis 4, 4) :
Combien de blocs peuvent être exécutés au maximum pour une même exécution du programme ?
Réponse
Un seul bloc est exécuté : dès que Python trouve la première condition vraie (i < j ou i > j), il exécute le bloc correspondant et ignore les suivants. Si aucune des conditions n’est vraie, c’est le bloc else qui s’exécute.
Q48.
Réécrire le programme précédent sans utiliserelif, à l’aide de deux if/else imbriqués. Vérifier que les deux versions produisent le même résultat pour i, j = 3, 7, 7, 3 et 4, 4.
Une chaîne if / elif / … / else est équivalente à des if / else imbriqués, mais sa syntaxe est bien plus lisible dès que le nombre de cas augmente. La branche else finale n’est pas obligatoire.
Q49.
Sans utiliser Python. En reprenant le programme de comparaison de i et j, déterminer la valeur de message pour chacun des couples suivants, en indiquant à chaque fois quelle condition a été la première trouvée vraie :
i, j = 2, 9
i, j = 9, 2
i, j = -4, -4
Vérifier ensuite dans la console ou dans la partie principale de l’éditeur.
Réponse
i, j = 2, 9 : i < j est vraie en premier arrowmessage = "j".
i, j = 9, 2 : i < j est fausse, i > j est vraie arrowmessage = "i".
i, j = -4, -4 : i < j et i > j sont fausses toutes les deux arrow c’est le else qui s’exécute, message = "égaux".
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Avec x = 5, qu’affiche ce programme ? if x < 0: print("négatif") print("fin")
La condition x < 0 vaut False : le bloc indenté est ignoré. La dernière instruction, qui n’est pas indentée, est toujours exécutée.
Question 2 / 3
Dans une chaîne if / elif / else, combien de blocs sont exécutés ?
Python teste les conditions dans l’ordre et exécute uniquement le premier bloc dont la condition est vraie. Les conditions suivantes ne sont même pas testées.
Question 3 / 3
Le bloc else final d’une chaîne if / elif est-il obligatoire ?
Le else n’est pas obligatoire : s’il est absent et qu’aucune condition n’est vraie, aucun bloc n’est exécuté.
Qu’est-ce qu’un prédicat ?
Q50.
Écrire, dans la partie principale de l’éditeur, la fonction est_positif dont la spécification est :
defest_positif(x:int|float)->bool:"""Retourne True si x est positif ou nul, False sinon."""
Tester ensuite est_positif(3) et est_positif(-3) dans la console. Que remarquez-vous sur le type de la valeur retournée par cette fonction ?
Réponse
defest_positif(x:int|float)->bool:"""Retourne True si x est positif ou nul, False sinon."""returnx>=0
La fonction retourne directement le résultat d’une expression booléenne : son type de retour est bool.
Prédicat
On appelle prédicat une fonction qui retourne un booléen. Par convention, le nom d’un prédicat commence par est_.
Q51.
Tester dans la console :
>>>1==1>>>1/49*49==1
L’une des deux instructions ne donne pas le résultat attendu mathématiquement. Laquelle, et pourquoi (on pourra tester 1 / 49 * 49 seule) ?
Réponse
1 / 49 * 49 == 1 vaut False : le calcul 1 / 49 * 49 donne une valeur très proche de 1 mais pas exactement égale, à cause des arrondis inévitables du calcul flottant. Comparer deux float avec == est donc risqué.
À retenir
On ne compare jamais deux float avec == : les arrondis du calcul flottant peuvent rendre deux valeurs mathématiquement égales différentes en mémoire, et l’égalité échoue. On vérifie plutôt que leur écart est suffisamment petit (voir est_egal ci-dessous).
Q52.
Écrire le prédicat est_egal dont la spécification est :
Écrire le prédicat est_pair dont la spécification est :
defest_pair(n:int)->bool:"""Retourne True si n est un nombre pair, False sinon."""
Réponse
defest_pair(n:int)->bool:"""Retourne True si n est un nombre pair, False sinon."""returnn%2==0
Q54.
Écrire le prédicat est_entier dont la spécification est :
defest_entier(n:int)->bool:"""Retourne True si n ne possède pas de partie décimale, False sinon."""
Consulter help(int) dans la console : comment la fonction int peut-elle aider à écrire ce prédicat ?
Réponse
defest_entier(n:int)->bool:"""Retourne True si n ne possède pas de partie décimale, False sinon."""returnn==int(n)
int(n) tronque la partie décimale de n ; si le résultat est égal à n, c’est que n n’en avait pas.
Q55.
Écrire le prédicat est_naturel dont la spécification est :
defest_naturel(n:int)->bool:"""Détermine si n est un entier naturel (entier positif ou nul).
>>> est_naturel(5)
True
>>> est_naturel(-5)
False
>>> est_naturel(2.3)
False
"""
Cette fonction doit utiliser les fonctions est_positif et est_entier des exercices précédents, combinées avec and.
Réponse
defest_naturel(n:int)->bool:"""Détermine si n est un entier naturel (entier positif ou nul).
>>> est_naturel(5)
True
>>> est_naturel(-5)
False
>>> est_naturel(2.3)
False
"""returnest_positif(n)andest_entier(n)
Q56.
Sans utiliser Python. En réutilisant la définition est_naturel(n) = est_positif(n) and est_entier(n), déterminer à la main le résultat de est_naturel(-3.5), est_naturel(4.0) et est_naturel(7). Pour le premier cas, indiquer si est_entier a besoin d’être évaluée.
Vérifier ensuite dans la console.
Réponse
est_naturel(-3.5) : est_positif(-3.5) vaut déjà False ; grâce à l’évaluation en court-circuit du and, est_entier(-3.5) n’est pas évaluée. Résultat : False.
est_naturel(4.0) : est_positif(4.0) vaut True, donc est_entier(4.0) est évaluée et vaut aussi True. Résultat : True.
est_naturel(7) : les deux prédicats valent True. Résultat : True.
Q57.
Tester dans la console est_naturel("coucou"). Que se passe-t-il ? Écrire le prédicat est_naturel_2, qui reprend est_naturel mais vérifie d’abord, à l’aide d’une instruction assert et de la fonction isinstance, que l’argument est bien un nombre :
defest_naturel_2(n:int)->bool:"""Détermine si n est un entier naturel.
Erreur si n n'est pas un nombre.
>>> est_naturel_2(5)
True
>>> est_naturel_2(-5)
False
>>> est_naturel_2(2.3)
False
>>> est_naturel_2("coucou")
Traceback ...
AssertionError: n doit être un nombre
"""
Réponse
est_naturel("coucou") provoque une TypeErrorpeu explicite, quelque part dans le calcul, sans indiquer clairement quel argument est en cause.
defest_naturel_2(n:int)->bool:"""Détermine si n est un entier naturel.
Erreur si n n'est pas un nombre.
>>> est_naturel_2(5)
True
>>> est_naturel_2(-5)
False
>>> est_naturel_2(2.3)
False
>>> est_naturel_2("coucou")
Traceback ...
AssertionError: n doit être un nombre
"""assertisinstance(n,int)orisinstance(n,float),"n doit être un nombre"returnest_naturel(n)
Q58.
Écrire le prédicat est_plus_grand dont la spécification est :
defest_plus_grand(x:int|float,y:int|float)->bool:"""Retourne True si x > y, False sinon."""
Écrire ensuite la fonction le_plus_grand, qui doit utiliser est_plus_grand :
defle_plus_grand(x:int|float,y:int|float)->int|float:"""Retourne x si x > y, y sinon."""
Réponse
defest_plus_grand(x:int|float,y:int|float)->bool:"""Retourne True si x > y, False sinon."""returnx>ydefle_plus_grand(x:int|float,y:int|float)->int|float:"""Retourne x si x > y, y sinon."""ifest_plus_grand(x,y):returnxelse:returny
Q59.
Écrire la fonction valeur_absolue, qui doit utiliser le prédicat est_positif :
defvaleur_absolue(x:int|float)->int|float:"""Retourne la valeur absolue de x."""
Réponse
defvaleur_absolue(x:int|float)->int|float:"""Retourne la valeur absolue de x."""ifest_positif(x):returnxelse:return-x
Exercices de synthèse (Doc. 2,1 à Doc. 2,3)
Consigne
Écrire chaque fonction dans la partie principale de l’éditeur, en respectant sa spécification. Tester ensuite son appel dans la console.
Q60.
Écrire le prédicat est_majeur dont la spécification est :
defest_majeur(age:int)->bool:"""Retourne True si age >= 18, False sinon."""
Écrire ensuite, en réutilisant est_majeur et une f-string (Doc. 2,2), la fonction message_age dont la spécification est :
defmessage_age(age:int)->str:"""Retourne un message indiquant si la personne est majeure,
et sinon le nombre d'années avant sa majorité.
>>> message_age(20)
'Vous êtes majeur.'
>>> message_age(15)
'Vous êtes mineur, encore 3 an(s) avant la majorité.'
"""
Réponse
defest_majeur(age:int)->bool:"""Retourne True si age >= 18, False sinon."""returnage>=18defmessage_age(age:int)->str:"""Retourne un message indiquant si la personne est majeure,
et sinon le nombre d'années avant sa majorité.
>>> message_age(20)
'Vous êtes majeur.'
>>> message_age(15)
'Vous êtes mineur, encore 3 an(s) avant la majorité.'
"""ifest_majeur(age):returnf"Vous êtes majeur."else:returnf"Vous êtes mineur, encore {18-age} an(s) avant la majorité."
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Qu’est-ce qu’un prédicat ?
Un prédicat est une fonction qui retourne True ou False. Par convention, son nom commence par est_ : est_pair, est_majeur…
Question 2 / 3
Que vaut 1 / 49 * 49 == 1 ?
À cause des arrondis du calcul flottant, 1 / 49 * 49 vaut 0.9999999999999999. On ne compare jamais deux float avec == : on vérifie que leur écart est très petit, par exemple abs(x - y) < 1e-5.
Question 3 / 3
Quelle définition de est_pair est correcte ?
Un entier est pair si le reste de sa division par 2 est nul : n % 2 == 0. Cette expression est déjà un booléen, inutile d’écrire un if.
Applications
Q61.
Écrire la fonction (avec sa spécification !) synthese, qui attend une moyenne générale au BAC et retourne :
"Recalé" si elle est strictement inférieure à 8 ;
"Second tour" si elle est comprise entre 8 (inclus) et 10 (exclus) ;
"Admis" si elle est comprise entre 10 (inclus) et 12 (exclus) ;
"Admis, Mention Assez Bien" si elle est comprise entre 12 (inclus) et 14 (exclus) ;
"Admis, Mention Bien" si elle est comprise entre 14 (inclus) et 16 (exclus) ;
"Admis, Mention Très Bien" si elle est supérieure ou égale à 16.
Réponse
defsynthese(moyenne:int|float)->str:"""Retourne la mention obtenue au BAC à partir de la moyenne générale.
>>> synthese(7)
'Recalé'
>>> synthese(15)
'Admis, Mention Bien'
"""ifmoyenne<8:return"Recalé"elifmoyenne<10:return"Second tour"elifmoyenne<12:return"Admis"elifmoyenne<14:return"Admis, Mention Assez Bien"elifmoyenne<16:return"Admis, Mention Bien"else:return"Admis, Mention Très Bien"
Q62.
Pour l’équation du second degré ax2+bx+c=0 (avec a, b, c réels), l’arbre des cas possibles est le suivant :
a=0 :
b=0 :
c=0 : tout réel est solution ;
c=0 : pas de solution ;
b=0 : une seule solution x=−c/b ;
a=0, avec Δ=b2−4ac :
Δ>0 : deux solutions x1=(−b+Δ)/(2a) et x2=(−b−Δ)/(2a) ;
Δ=0 : une seule solution x=−b/(2a) ;
Δ<0 : pas de solution réelle.
Écrire la fonction (avec sa spécification !) racines, à l’aide d’instructions if/elif/else imbriquées, qui retourne un message décrivant les solutions réelles.
Réponse
importmathdefracines(a:int|float,b:int|float,c:int|float)->str:"""Retourne un message décrivant les solutions réelles de
a * x**2 + b * x + c = 0.
>>> racines(1, -3, 2)
'deux solutions : x1 = 2.0, x2 = 1.0'
>>> racines(1, 2, 1)
'solution unique : x = -1.0'
>>> racines(1, 0, 1)
'pas de solution réelle'
"""ifa==0:ifb==0:ifc==0:return"tout réel est solution"else:return"pas de solution"else:x=-c/breturnf"solution unique : x = {x}"else:delta=b**2-4*a*cifdelta>0:x1=(-b+math.sqrt(delta))/(2*a)x2=(-b-math.sqrt(delta))/(2*a)returnf"deux solutions : x1 = {x1}, x2 = {x2}"elifdelta==0:x=-b/(2*a)returnf"solution unique : x = {x}"else:return"pas de solution réelle"
Q63.
Écrire la fonction (avec sa spécification !) calcul_remise, qui retourne le taux de remise (en %) applicable à un prix TTC :
0 % pour un montant TTC inférieur à 1000 € ;
1 % pour un montant TTC compris entre 1000 € (inclus) et 2000 € (exclus) ;
2 % pour un montant TTC compris entre 2000 € (inclus) et 5000 € (exclus) ;
5 % pour un montant TTC supérieur ou égal à 5000 €.
Écrire ensuite la fonction (avec sa spécification !) calcul_prix, qui retourne le prix final TTC (après remise) à partir d’un prix hors taxe, avec une TVA à 20 %. Cette fonction doit utiliser calcul_remise.
Réponse
defcalcul_remise(prix_ttc:int|float)->int:"""Retourne le taux de remise (en %) applicable à un prix TTC.
>>> calcul_remise(500)
0
>>> calcul_remise(1200)
1
"""ifprix_ttc>=5000:return5elifprix_ttc>=2000:return2elifprix_ttc>=1000:return1else:return0defcalcul_prix(prix_ht:int|float)->float:"""Retourne le prix final TTC (après remise) à partir d'un prix HT,
avec une TVA à 20 %.
>>> calcul_prix(1000)
1188.0
"""prix_ttc=prix_ht*1.20remise=calcul_remise(prix_ttc)returnprix_ttc*(1-remise/100)
Q64.
Écrire le prédicat (avec sa spécification !) est_bissextile, qui détermine si une année est bissextile.
Indication : une année est bissextile si son millésime est multiple de 4 ; toutefois, un millésime multiple de 100 n’est bissextile que s’il est aussi multiple de 400 (1900 n’était pas bissextile, 2000 l’a été).
Réponse
defest_bissextile(n:int)->bool:"""Retourne True si l'année n est bissextile, False sinon.
>>> est_bissextile(2024)
True
>>> est_bissextile(1900)
False
>>> est_bissextile(2000)
True
"""returnn%4==0and(n%100!=0orn%400==0)
Q65.
On rappelle l’inégalité triangulaire : trois longueurs a, b, c peuvent former un triangle si et seulement si chaque côté est strictement inférieur à la somme des deux autres. Écrire le prédicat (avec sa spécification !) est_triangle, qui doit combiner trois conditions avec and :
defest_triangle(a:int|float,b:int|float,c:int|float)->bool:"""Retourne True si a, b, c peuvent être les longueurs des côtés
d'un triangle, False sinon.
>>> est_triangle(3, 4, 5)
True
>>> est_triangle(1, 2, 5)
False
"""
Réponse
defest_triangle(a:int|float,b:int|float,c:int|float)->bool:"""Retourne True si a, b, c peuvent être les longueurs des côtés
d'un triangle, False sinon.
>>> est_triangle(3, 4, 5)
True
>>> est_triangle(1, 2, 5)
False
"""returna<b+candb<a+candc<a+b
Q66.
Écrire la fonction (avec sa spécification !) type_triangle, qui doit utiliser est_triangle et retourner :
"pas un triangle" si a, b, c ne peuvent pas former un triangle ;
"équilatéral" si les trois côtés sont égaux ;
"isocèle" si exactement deux côtés sont égaux ;
"scalène" sinon (aucun côté égal à un autre).
>>>type_triangle(1,2,5)'pas un triangle'>>>type_triangle(3,3,3)'équilatéral'>>>type_triangle(3,3,5)'isocèle'>>>type_triangle(3,4,5)'scalène'
Réponse
deftype_triangle(a:int|float,b:int|float,c:int|float)->str:"""Retourne le type d'un triangle de côtés a, b, c.
>>> type_triangle(1, 2, 5)
'pas un triangle'
>>> type_triangle(3, 3, 3)
'équilatéral'
>>> type_triangle(3, 3, 5)
'isocèle'
>>> type_triangle(3, 4, 5)
'scalène'
"""ifnotest_triangle(a,b,c):return"pas un triangle"elifa==b==c:return"équilatéral"elifa==borb==cora==c:return"isocèle"else:return"scalène"
Bilan : où en suis-je ?
Pour chaque ligne, cochez la colonne qui correspond. Toute case Pas encore indique une partie à reprendre.
Je sais…
Oui
Pas encore
À revoir
distinguer une affectation (=) d’une comparaison (==)
Partie 1
utiliser les opérateurs de comparaison (<, >=, !=, …)
Partie 1
combiner des conditions avec and, or, not
Partie 2
expliquer pourquoi Python n’évalue pas toujours les deux opérandes d’un and ou d’un or
Partie 2
écrire une alternative (if, if/else, if/elif/else)
Partie 3
écrire un prédicat qui réutilise un autre prédicat déjà écrit
Partie 4
Physique, Chimie et Informatique > 1ère Spécialité NSI > Premiers pas en programmation
En manipulant les boucles for et while dans la console et dans Thonny, vous allez apprendre à répéter des instructions un nombre de fois connu ou inconnu à l’avance, et à choisir la structure itérative adaptée à chaque situation.
Combien de fois une instruction doit-elle être répétée ?
Un programme est souvent amené à répéter plusieurs fois les mêmes instructions : afficher les nombres de 1 à 1000, demander un mot de passe jusqu’à ce qu’il soit correct, ou additionner les notes d’une classe entière. Écrire autant de fois l’instruction à répéter serait absurde ; les langages de programmation proposent pour cela des structures itératives, plus couramment appelées boucles. Chaque passage dans une boucle est appelé une itération.
Q30.
Pour chacune des situations suivantes, indiquer si le nombre de répétitions est connu avant de commencer à répéter, ou s’il n’est découvert qu’au fur et à mesure de l’exécution :
afficher les nombres de 1 à 100 ;
demander un mot de passe jusqu’à ce qu’il soit correct ;
additionner les 12 notes d’un bulletin ;
lancer un dé jusqu’à l’obtention d’un 6.
À retenir
Une boucle déterministe (ou boucle Pour) répète un nombre d’itérations connu à l’avance ; elle utilise une variable, le compteur de boucle, pour compter les itérations effectuées.
Une boucle non déterministe (ou boucle conditionnelle) répète des itérations tant qu’une condition d’arrêt n’est pas vérifiée ; ce nombre n’est pas connu à l’avance.
Python ne fournit qu’une seule boucle non déterministe, la boucle while (Tant que). Une boucle non déterministe peut toujours remplacer une boucle déterministe ; l’inverse n’est pas vrai.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
On demande un mot de passe jusqu’à ce qu’il soit correct. Quel type de boucle convient ?
On ne sait pas combien d’essais seront nécessaires : on répète tant que la condition d’arrêt (mot de passe correct) n’est pas vérifiée.
Question 2 / 2
Quelle est la seule boucle non déterministe disponible en Python ?
La boucle while répète son bloc tant qu’une condition est vraie, sans connaître à l’avance le nombre d’itérations.
La boucle “Tant que” : l’instruction while
Syntaxe et fonctionnement
La syntaxe d’une boucle while est :
while<condition>:instructionsàrépéter
La condition est une expression booléenne, évaluée au début de chaque itération. Tant qu’elle vaut True, le bloc indenté est exécuté, puis la condition est évaluée à nouveau. Dès qu’elle vaut False, la boucle s’arrête et l’exécution reprend après le bloc. Il est même possible que le bloc ne soit exécuté aucune fois, si la condition est déjà fausse dès la première évaluation.
Q31.
Recopier la fonction suivante dans la partie principale de l’éditeur Thonny :
defaffiche_jusqua(n:int)->None:"""
Affiche les entiers de 1 à n, un par ligne, à l'aide d'une boucle Tant que.
"""i=1# (1)whilei<=n:# (2)print(i)# (3)i+=1# (4)
Remplacer chacun des numéros ci-dessus par une phrase qui décrit ce que l’instruction réalise.
Q32.
Appeler ensuite, dans la console, la fonction : affiche_jusqua(5) puis affiche_jusqua(0).
Combien de fois le bloc indenté est-il exécuté dans le premier appel ? Dans le second appel ?
Q33.
Quelle instruction fait progresser i vers la condition d’arrêt ?
Boucle infinie
Si aucune instruction du bloc ne fait progresser la condition vers sa fin (si, par exemple, i += 1 avait été oublié), la condition i <= n resterait indéfiniment vraie : la boucle s’exécuterait sans jamais s’arrêter. Ce défaut porte un nom : la boucle infinie.
À retenir
Écrire une boucle while suppose de réunir trois éléments :
une initialisation de la ou des variables testées par la condition ;
une condition d’arrêt, expression booléenne évaluée avant chaque itération ;
une instruction qui fait progresser cette condition à chaque itération, jusqu’à ce qu’elle devienne fausse.
Oublier ce troisième élément est la cause la plus fréquente de boucle infinie.
Faire tourner une boucle à la main
Vérifier qu’une boucle fait ce qu’on attend d’elle exige de savoir la « faire tourner à la main » : appliquer méthodiquement les instructions, itération après itération, en notant dans un tableau l’évolution du contenu de chaque variable.
Q34.
On donne la fonction suivante, dont il faut déterminer l’action :
definconnue(a:int,b:int)->int:""" Fonction dont il faut déterminer l'action. """r=a%bwhiler!=0:a=bb=rr=a%breturnb
Repérer les instructions répétées par la boucle et l’instruction qui teste la fin de la boucle.
Quelle instruction modifie le résultat de l’évaluation de ce test ?
Sans utiliser Python, compléter le tableau d’évolution ci-dessous pour l’appel inconnue(30, 42), puis vérifier en exécutant le programme.
Étape
a
b
r
avant la boucle
30
42
itération 1
itération 2
itération 3
Visualiser le fonctionnement de cette fonction à l’aide du débogueur intégré à Thonny.
Reprendre la question précédente pour l’appel inconnue(35, 6), sans reconstruire de tableau : donner uniquement la valeur retournée.
Quel calcul réalise cette fonction ?
Q35.
Voici une autre fonction, dont il faut également déterminer l’action :
definconnue_deux(a:int)->int:""" Fonction dont il faut déterminer l'action. """b=1i=2whilei<=a:b*=ii+=1returnb
Quelle est la valeur initiale de i ? Quelle est sa valeur lorsque la boucle s’arrête ?
Sans utiliser Python, compléter le tableau d’évolution ci-dessous pour l’appel inconnue_deux(6), puis vérifier en exécutant le programme.
Étape
i
b
avant la boucle
2
1
itération 1
itération 2
itération 3
itération 4
itération 5
Quel calcul réalise cette fonction ?
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Dans affiche_jusqua(n) (i = 1, puis while i <= n: avec print(i) et i += 1), combien de fois le bloc est-il exécuté pour affiche_jusqua(0) ?
La condition est évaluée avant chaque itération. Dès le départ, 1 <= 0 vaut False : le bloc n’est jamais exécuté.
Question 2 / 3
Dans cette même fonction, que se passe-t-il si on oublie l’instruction i += 1 ?
Rien ne fait progresser la condition vers sa fin : la boucle ne s’arrête jamais.
Question 3 / 3
Quels sont les trois éléments d’une boucle while bien écrite ?
Oublier le troisième élément est la cause la plus fréquente de boucle infinie.
La boucle “Pour chaque” : l’instruction for et l’itérateur range
Syntaxe de la boucle “Pour chaque”
En Python, l’instruction for implémente en réalité une boucle Pour chaque : elle parcourt, un par un, les éléments d’un objet itérable, et non un simple compteur comme dans d’autres langages.
forelementinitérable:instructionsàrépéter
À chaque itération, la variable element prend la valeur de l’élément courant de l’itérable, pour être utilisée dans le bloc indenté. Cette variable ne doit jamais être modifiée dans le corps de la boucle : dans le cas contraire, le comportement de la boucle devient imprévisible.
Q36.
Recopier la fonction suivante dans la partie principale de l’éditeur :
defaffiche_intervalle(n:int)->None:"""Affiche, séparés par un espace, les entiers produits par
range(1, n + 1).
"""fornbreinrange(1,n+1):print(nbre,end=' ')
Appeler affiche_intervalle(10) dans la console. Quels entiers sont produits par range(1, 11) ? Combien y en a-t-il ?
Q37.
Recopier la fonction suivante dans la partie principale de l’éditeur :
deftable_de(n:int)->str:""" Retourne la table de multiplication de n, de 1 à 10. """reponse=""fornbreinrange(1,11):calcul=n*nbrereponse+=str(calcul)+" "returnreponse
Cette fonction parcourt le même itérable que la précédente. Sans exécuter le programme, prévoir le résultat de table_de(4), puis vérifier dans la console.
Réécrire ensuite l’instruction reponse += str(calcul) + " " à l’aide d’une f-string (voir Doc. 2,2), et vérifier que table_de(4) retourne toujours le même résultat.
L’itérateur range
L’itérateur range
L’itérateur range génère, à la volée, des entiers compris entre une valeur de départ début et une valeur finale fin (exclue), par pas de pas. Trois écritures sont possibles :
range(fin)
entiers de 0 à fin (exclu), par pas de 1
range(début, fin)
entiers de début à fin (exclu), par pas de 1
range(début, fin, pas)
entiers de début à fin (exclu), par pas de pas
Comme pour les tranches, la valeur fin n’est jamais atteinte : Python considère systématiquement les intervalles sous la forme [deˊbut,fin[.
Q38.
Recopier la fonction suivante dans la partie principale de l’éditeur :
defdemo_range(debut:int,fin:int,pas:int)->None:"""Affiche, séparés par un espace, les entiers produits par
range(debut, fin, pas).
"""foriinrange(debut,fin,pas):print(i,end=' ')
Prévoir puis vérifier dans la console le résultat de chacun des appels suivants :
Le pas pas peut-il être négatif ? Que se passe-t-il alors ?
Q39.
Écrire, dans la partie principale de l’éditeur, deux fonctions demo_range_1arg et demo_range_2arg, qui affichent respectivement, séparés par un espace, les entiers produits par range(fin) et par range(debut, fin).
Tester demo_range_1arg(10) et demo_range_2arg(1, 10) dans la console.
À retenir
La boucle for element in itérable: parcourt un par un les éléments d’un itérable ; la variable element ne doit jamais être modifiée dans le corps de la boucle.
L’itérateur range(début, fin, pas) génère les entiers de début (inclus) à fin (exclu), par pas de pas. Avec un seul argument, range(fin) part de 0 avec un pas de 1 ; avec deux arguments, range(début, fin) utilise un pas de 1.
Une boucle for peut toujours être réécrite avec une boucle while, en gérant soi-même le compteur ; l’inverse n’est vrai que si le nombre d’itérations est connu à l’avance.
?Vérifier ses acquis4 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 4
Quels entiers sont produits par range(1, 5) ?
range(début, fin) produit les entiers de début (inclus) à fin (exclu).
Question 2 / 4
Quels entiers sont produits par range(4) ?
Avec un seul argument, range(fin) part de 0, avec un pas de 1, et fin est exclu.
Question 3 / 4
Quels entiers sont produits par range(10, 1, -3) ?
Avec un pas négatif, on descend : 10, 7, 4. La valeur suivante, 1, est la fin : elle est exclue.
Question 4 / 4
Dans une boucle for element in iterable:, peut-on modifier element dans le corps de la boucle ?
C’est la boucle for qui donne ses valeurs à element, une à une. Le modifier rend le programme difficile à comprendre.
Interrompre une boucle ou passer à l’itération suivante : break et continue
L’instruction break
breakmet fin immédiatement à la boucle en cours et poursuit l’exécution juste après elle. On l’utilise généralement lorsqu’une condition testée avec if doit provoquer une sortie immédiate de la boucle. break s’utilise aussi bien dans une boucle for que dans une boucle while ; elle est en particulier indispensable pour sortir d’une boucle délibérément infinie, écrite avec while True:.
Q40.
Les deux fonctions suivantes déterminent, par une méthode peu efficace, le plus grand diviseur d’un entier nbre (différent de nbre lui-même) : on teste, en partant de nbre - 1, tous les diviseurs possibles, jusqu’à en trouver un qui convient.
defplus_grand_diviseur(nbre:int)->str:"""Retourne un message donnant le plus grand diviseur de nbre,
différent de nbre lui-même.
"""diviseur=nbre-1whilediviseur>0:ifnbre%diviseur==0:breakdiviseur-=1returnf"Le plus grand diviseur de {nbre} est {diviseur}."defplus_grand_diviseur_2(nbre:int)->str:"""Retourne un message donnant le plus grand diviseur de nbre,
différent de nbre lui-même.
"""fordiviseurinrange(nbre-1,0,-1):ifnbre%diviseur==0:breakreturnf"Le plus grand diviseur de {nbre} est {diviseur}."
Tester les deux fonctions avec nbre = 18. Pourquoi est-il inutile de continuer la boucle une fois un diviseur trouvé ? Dans la seconde fonction, à quel endroit du programme la variable diviseur reste-t-elle accessible, alors qu’elle est définie par la boucle for ?
L’instruction continue
continueinterrompt seulement l’itération courante et reprend au début de l’itération suivante : nouvelle évaluation de la condition pour une boucle while, élément suivant pour une boucle for.
Q41.
Les deux fonctions suivantes retournent une chaîne de caractères formée des entiers, inférieurs à nbre, qui ne le divisent pas :
defnon_diviseur(nbre:int)->str:"""Retourne les entiers de 1 à nbre - 1 qui ne divisent pas nbre."""reponse=""diviseur=nbre-1whilediviseur>0:ifnbre%diviseur==0:diviseur-=1continuereponse+=str(diviseur)+" "diviseur-=1returnreponsedefnon_diviseur_2(nbre:int)->str:"""Retourne les entiers de 1 à nbre - 1 qui ne divisent pas nbre."""reponse=""fordiviseurinrange(nbre-1,0,-1):ifnbre%diviseur==0:continuereponse+=str(diviseur)+" "returnreponse
Tester les deux fonctions avec nbre = 18. Dans non_diviseur, pourquoi l’instruction diviseur -= 1 apparaît-elle à deux endroits différents ?
Q42.
Réécrire la fonction non_diviseur_2 sous la forme non_diviseur_3, sans utilisercontinue, à l’aide d’un simple if, et en construisant reponse à l’aide d’une f-string plutôt que de str(diviseur) + " ". Cette nouvelle version est-elle plus lisible ?
À retenir
breakarrête définitivement la boucle en cours ; l’exécution reprend juste après elle.
continuearrête seulement l’itération en cours ; l’exécution reprend au début de l’itération suivante.
Ces deux instructions s’utilisent aussi bien dans une boucle for que dans une boucle while.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Que fait l’instruction break ?
break sort de la boucle en cours. C’est continue qui passe à l’itération suivante.
Question 2 / 3
Que fait l’instruction continue ?
Les instructions qui suivent continue dans le bloc sont sautées pour cette itération seulement.
Question 3 / 3
break et continue s’utilisent :
Ces deux instructions fonctionnent aussi bien dans une boucle for que dans une boucle while.
Exercices de synthèse
Consigne
Écrire chaque fonction dans la partie principale de l’éditeur, avec sa spécification complète (signature + documentation), en utilisant des f-strings pour construire les chaînes de caractères (voir Doc. 2,2). Tester ensuite son appel dans la console.
Construire un résultat au fil des itérations
Q43.
Écrire la fonction triple_du_precedent dont la spécification est :
deftriple_du_precedent(a:int)->str:"""
Retourne une chaîne de caractères formée d'une suite de 12 entiers dont chaque terme est
le triple du précédent, à partir du premier entier a (positif) passé en argument.
>>> triple_du_precedent(1)
'1 3 9 27 81 243 729 2187 6561 19683 59049 177147 '
>>> triple_du_precedent(5)
'5 15 45 135 405 1215 3645 10935 32805 98415 295245 885735 '
"""
Utiliser une boucle while.
Q44.
Écrire la fonction multiplication_multiple_trois dont la spécification est :
defmultiplication_multiple_trois(a:int)->str:"""Retourne les 10 premiers termes de la table de multiplication
de a, en signalant par un astérisque ceux qui sont multiples de 3.
>>> multiplication_multiple_trois(2)
'2 4 6* 8 10 12* 14 16 18* 20 '
>>> multiplication_multiple_trois(7)
'7 14 21* 28 35 42* 49 56 63* 70 '
"""
Q45.
Écrire la fonction multiplication_multiple_sept dont la spécification est :
defmultiplication_multiple_sept(a:int)->str:"""Calcule les 50 premiers termes de la table de multiplication
de a et retourne une chaîne de caractères contenant uniquement
les multiples de 7.
>>> multiplication_multiple_sept(2)
'14 28 42 56 70 84 98 '
>>> multiplication_multiple_sept(9)
'63 126 189 252 315 378 441 '
"""
En quoi cette fonction diffère-t-elle de multiplication_multiple_trois : marque-t-elle simplement des valeurs, ou en sélectionne-t-elle certaines ?
Q46.
Écrire la fonction diviseurs dont la spécification est :
defdiviseurs(a:int)->str:"""Retourne une chaîne de caractères formée de la liste des
diviseurs de a, de a lui-même jusqu'à 1.
>>> diviseurs(18)
'18 9 6 3 2 1 '
"""
Q47.
Écrire et exécuter la fonction loto_naif dont la spécification est :
defloto_naif()->str:"""Retourne 6 entiers sélectionnés aléatoirement dans
l'intervalle [1, 49].
"""
Remarque. Normalement, un numéro déjà tiré ne peut pas réapparaître. On acceptera ici qu’un même numéro apparaisse plusieurs fois, faute de disposer encore d’une structure de données adaptée pour mémoriser les numéros déjà sortis.
Boucles imbriquées
Q48.
Écrire la fonction table_multiplication dont la spécification est :
deftable_multiplication()->str:"""Retourne les tables de multiplication de 1 à 10, chaque table
étant écrite sur une ligne distincte.
"""
Indication. Utiliser deux boucles while imbriquées, et le caractère "\n" pour passer à la ligne. Tester avec print(table_multiplication()) dans la console, pour visualiser le résultat sous forme de tableau.
Demander une information à l’utilisateur
La fonction input retourne toujours une chaîne de caractères ; une conversion est donc nécessaire pour récupérer un nombre :
valeur=float(input("Entrez votre valeur : "))
Q49.
Écrire la fonction plus_grand_plus_petit dont la spécification est :
defplus_grand_plus_petit(nbre_valeurs:int)->str:"""Demande à l'utilisateur nbre_valeurs valeurs et retourne une
chaîne de caractères donnant le maximum et le minimum obtenus.
"""
Q50.
Écrire la fonction moyenne dont la spécification est :
defmoyenne(nbre_notes:int)->float:"""Demande à l'utilisateur nbre_notes notes et retourne leur
moyenne.
"""
Boucles pilotées par un événement imprévisible
Dans les deux fonctions précédentes, le nombre de saisies est un paramètre fixé à l’avance : une boucle while n’était donc pas indispensable. Il existe des situations où ce nombre ne peut au contraire pas être connu avant l’exécution.
Q51.
On souhaite ne plus imposer le nombre de notes à saisir : l’utilisateur arrête la saisie en entrant une note négative. Écrire la fonction moyenne_ter dont la spécification est :
defmoyenne_ter()->str:"""Demande des notes à l'utilisateur et retourne un message
donnant leur nombre et leur moyenne. La saisie s'arrête dès
qu'une note négative est entrée.
"""
Indication. Écrire while True: et utiliser break pour sortir de la boucle. Pourquoi une boucle for ne convient-elle pas ici ?
Q52.
Écrire et exécuter la fonction devine dont la spécification est :
defdevine()->None:"""Détermine aléatoirement un entier compris entre 1 et 50 et
demande à l'utilisateur de le deviner. À chaque proposition,
affiche si elle est trop grande ou trop petite. S'arrête et
annonce le nombre de tentatives lorsque le nombre est deviné.
"""
Indication. Le module random et sa fonction randint ont été présentés dans le Doc. 2,1.
Manipuler le code ASCII
Q53.
Écrire et exécuter la fonction alphabet dont la spécification est :
defalphabet(sens:str)->str:"""Retourne les 26 lettres de l'alphabet dans l'ordre croissant
si sens vaut 'croissant', dans l'ordre décroissant si sens vaut
'decroissant'.
"""
Indication.ord(car) retourne le code ASCII du caractère car ; chr(code) retourne le caractère correspondant à code. Le code de 'a' est 97, celui de 'z' est 122.
Suites définies par récurrence
Q54.
On rappelle la suite de Fibonacci, définie par u1=1, u2=1 et, pour n>2, un=un−1+un−2.
Écrire la fonction fibo dont la spécification est :
deffibo(n:int)->str:"""Retourne les n premiers termes de la suite de Fibonacci,
sous forme d'une chaîne de caractères.
"""
Indication. Traiter séparément les cas n == 1 et n == 2, puis utiliser deux variables u et v qui mémorisent les deux derniers termes calculés.
Choisir entre for et while
Q55.
Reprendre les fonctions triple_du_precedent, multiplication_multiple_trois, multiplication_multiple_sept, diviseurs, table_multiplication, plus_grand_plus_petit, moyenne, loto_naif et alphabet, et les réécrire à l’aide de l’instruction for.
Pourquoi moyenne_ter et devine ne peuvent-elles pas, elles, être réécrites avec for ?
À retenir
Le choix entre for et while dépend de la nature du problème, pas des préférences du programmeur :
si le nombre d’itérations est connu avant l’exécution (un nombre de termes, une taille fixée), for est le choix naturel et le plus lisible ;
si ce nombre dépend du déroulement de l’exécution (une saisie jusqu’à une valeur correcte, une recherche jusqu’à un résultat), seule une boucle while convient.
Pour aller plus loin (difficile)
Q56.
Code ISBN. Le code ISBN (« International Standard Book Number ») identifie un livre à l’aide de dix chiffres. Le dernier chiffre est une somme de contrôle, calculée à partir des neuf premiers : si d1,…,d9 désignent ces neuf chiffres et d10 le dixième, la somme d1+2d2+3d3+⋯+10d10 doit être un multiple de 11.
Écrire une fonction qui demande à l’utilisateur les neuf premiers chiffres d’un code ISBN et retourne le code complet sous forme d’une chaîne de caractères.
Q57.
Calendrier. Écrire une fonction qui affiche un calendrier allant du 1ᵉʳ janvier 2001 au 31 décembre 3000, en indiquant pour chaque jour le nombre de jours écoulés depuis le 1ᵉʳ janvier 2001, le jour de la semaine, le quantième, le mois et l’année.
Indication. Une année est bissextile si son millésime est multiple de 4, sauf s’il est multiple de 100 sans être multiple de 400 (1900 n’était pas bissextile, 2000 l’a été).
Q58.
Le taxi de Ramanujan. Trouver tous les entiers inférieurs ou égaux à un nombre N choisi par l’utilisateur qui peuvent s’écrire comme somme de deux cubes, de deux façons différentes : trouver quatre entiers a, b, c, d, inférieurs à N, tels que a3+b3=c3+d3.
Indication. Quatre boucles imbriquées suffisent, même si le résultat n’est pas optimisé.
Bilan : où en suis-je ?
Bilan : où en suis-je ?
Pour chaque ligne, cochez la colonne qui correspond. Toute case Pas encore indique une partie à reprendre.
Je sais…
Oui
Pas encore
À revoir
distinguer une boucle déterministe (for) d’une boucle non déterministe (while)
Partie 1
écrire une boucle while (initialisation, condition d’arrêt, mise à jour) et prévoir si elle peut ne jamais s’exécuter
Partie 2
« faire tourner une boucle à la main » à l’aide d’un tableau d’évolution
Partie 2
écrire une boucle for en utilisant range avec un, deux ou trois arguments
Partie 3
utiliser break pour interrompre une boucle et continue pour passer à l’itération suivante
Partie 4
écrire une fonction qui accumule un résultat (chaîne, somme, maximum) au fil d’une boucle
Partie 5
choisir entre for et while selon que le nombre d’itérations est connu ou non à l’avance
Partie 5
Physique, Chimie et Informatique > 1ère Spécialité NSI > Premiers pas en programmation
En construisant pas à pas un petit jeu avec la bibliothèque Pyxel, vous allez réinvestir les fonctions, les instructions conditionnelles et les boucles dans un vrai programme, et découvrir la différence entre variables locales et variables globales.
Dans le jeu final, le joueur est un carré vert posé sur un sol. Il se déplace avec les flèches du clavier et doit attraper des cibles jaunes qui apparaissent au hasard. Chaque cible attrapée rapporte un point ; la partie est gagnée à 10 points.
Le programme de départ est fourni dans l’activité Capytale. Lorsqu’une question commence par « Sans exécuter le programme », il faut écrire sa réponse avant de lancer le programme, puis vérifier.
Découverte de Pyxel
Voici le programme de départ :
importpyxelLARGEUR=160HAUTEUR=120defupdate():passdefdraw():pyxel.cls(0)pyxel.text(50,60,"Bonjour NSI !",7)pyxel.init(LARGEUR,HAUTEUR,title="Mon premier jeu")pyxel.run(update,draw)
Un programme Pyxel contient deux fonctions particulières. La fonction update() fait évoluer l’état du jeu (position des personnages, score…) ; la fonction draw() dessine cet état à l’écran. L’instruction pyxel.run(update, draw) lance le jeu : à partir de ce moment, Pyxel appelle update() puis draw() à chaque nouvelle image, jusqu’à la fermeture de la fenêtre.
Q44.
Lancer le programme, puis modifier successivement les trois nombres de l’instruction pyxel.text(50, 60, "Bonjour NSI !", 7).
Que représente chacun de ces nombres ?
Où se trouve l’origine du repère ? Dans quel sens augmentent les coordonnées x et y ?
Q45.
Chaque caractère occupe 4 pixels de large et 6 pixels de haut. Calculer les coordonnées à donner à pyxel.text pour que le message « Bonjour NSI ! » apparaisse dans le coin inférieur droit de la fenêtre, puis vérifier.
Q46.
Le programme définit les fonctions update et draw, mais on ne trouve nulle part l’instruction draw(). Pourtant le texte s’affiche.
Qui appelle la fonction draw ?
Pourquoi écrit-on pyxel.run(update, draw) et non pyxel.run(update(), draw()) ?
Q47.
Remplacer l’instruction pyxel.text(...) par pyxel.text(50, 60, str(pyxel.frame_count), 7). La variable pyxel.frame_count contient le nombre d’images affichées depuis le lancement du programme.
À l’aide d’un chronomètre, estimer le nombre de fois où la fonction draw est appelée en une seconde.
Q48.
Sans exécuter le programme, prévoir ce qui se passe si l’on supprime l’instruction pyxel.cls(0). Vérifier, puis expliquer le rôle de pyxel.cls.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Dans la fenêtre Pyxel, où se trouve l’origine du repère, et dans quel sens augmente y ?
Comme pour la plupart des écrans, l’origine est le coin supérieur gauche : x augmente vers la droite et y vers le bas.
Question 2 / 3
Pourquoi écrit-on pyxel.run(update, draw) et non pyxel.run(update(), draw()) ?
Écrire draw désigne la fonction ; écrire draw() l’appelle. C’est Pyxel qui appelle update et draw, environ 30 fois par seconde.
Question 3 / 3
Quel est le rôle de pyxel.cls(0) au début de draw() ?
Sans effacement, chaque nouvelle image se superposerait aux précédentes : un objet qui se déplace laisserait une trace.
Le joueur
Pour que le programme reste lisible et facile à modifier, les valeurs numériques ne sont pas écrites directement dans les instructions. Elles sont rangées au début du programme dans des variables au nom explicite. Ajouter, sous HAUTEUR :
L’instruction pyxel.rect(x, y, l, h, col) dessine un rectangle plein de largeur l, de hauteur h et de couleur col, dont le coin supérieur gauche a pour coordonnées (x, y).
Q49.
Écrire une fonction dessiner_joueur(), sans paramètre, qui dessine le joueur : un carré de côté TAILLE_JOUEUR, de couleur COULEUR_JOUEUR, dont le coin supérieur gauche a pour coordonnées (x_joueur, y_joueur). Remplacer ensuite, dans draw(), l’affichage du texte par un appel à cette fonction.
Q50.
La valeur 76 place le joueur au milieu de l’écran, dans le sens horizontal.
Pourquoi n’a-t-on pas choisi 80, qui est la moitié de 160 ?
Remplacer 76 par une expression qui utilise LARGEUR et TAILLE_JOUEUR.
Pourquoi utiliser l’opérateur // plutôt que / dans cette expression ?
Q51.
Remplacer LARGEUR = 160 par LARGEUR = 200 et relancer le programme.
Qu’est-ce qui a changé sans qu’il soit nécessaire de modifier une autre ligne ?
Que faudrait-il faire si le nombre 160 avait été écrit partout dans le programme ?
Constantes
Une variable dont la valeur ne change pas pendant l’exécution du programme est appelée une constante. Par convention, en Python, son nom s’écrit en majuscules (LARGEUR, TAILLE_JOUEUR). Python n’interdit pas de la modifier : c’est une convention entre programmeurs. Regrouper les constantes au début du programme permet de changer une valeur en un seul endroit.
Q52.
Dans draw(), remplacer dessiner_joueur() par dessiner_joueur, sans les parenthèses. Que se passe-t-il ? Faire le lien avec l’instruction pyxel.run(update, draw) et formuler la différence entre désigner une fonction et appeler une fonction.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Que désigne, par convention, un nom écrit en majuscules comme LARGEUR ?
C’est une convention entre programmeurs : Python n’empêche pas de la modifier. Regrouper les constantes au début du programme permet de changer une valeur en un seul endroit.
Question 2 / 3
Avec LARGEUR = 160 et TAILLE_JOUEUR = 8, quelle expression centre horizontalement le joueur ?
L’abscisse est celle du coin supérieur gauche : on retire la taille du joueur avant de diviser par 2, ce qui donne 76. L’opérateur // garantit un résultat entier.
Question 3 / 3
Dans draw(), on écrit dessiner_joueur au lieu de dessiner_joueur(). Que se passe-t-il ?
Sans parenthèses, on désigne la fonction mais on ne l’exécute pas. Seul l’appel, avec parenthèses, exécute son corps.
Déplacer le joueur : variables locales et globales
L’instruction pyxel.btn(touche) renvoie True tant que la touche est enfoncée, False sinon. Les flèches du clavier sont désignées par pyxel.KEY_LEFT, pyxel.KEY_RIGHT, pyxel.KEY_UP et pyxel.KEY_DOWN.
Ajouter la constante VITESSE = 2 ainsi que la fonction suivante, qui contient volontairement une erreur, puis appeler cette fonction dans update() (à la place de pass).
Lancer le programme, attendre quelques secondes, puis appuyer sur ←.
Quel message d’erreur obtient-on ? Quelle ligne est en cause ?
Pourquoi l’erreur n’apparaît-elle pas dès le lancement du programme ?
Dans une fonction, une variable qui reçoit une valeur par une affectation est considérée par Python comme une variable locale : elle n’existe que pendant l’exécution de la fonction et n’a aucun lien avec la variable de même nom définie au début du programme. Ici, pour calculer x_joueur - VITESSE, Python cherche la variable locale x_joueur, qui n’a encore reçu aucune valeur : d’où l’erreur.
Pour modifier une variable définie au début du programme, appelée variable globale, il faut l’annoncer au début de la fonction avec le mot-clé global.
Variables locales et variables globales
Une variable définie en dehors de toute fonction est une variable globale. Toute fonction peut lire sa valeur.
Une variable qui reçoit une valeur à l’intérieur d’une fonction est une variable locale à cette fonction.
Pour qu’une fonction puisse modifier une variable globale, il faut écrire global nom_de_la_variable au début du corps de la fonction.
Q54.
Ajouter la ligne global x_joueur, y_joueur au début de deplacer_joueur(), puis compléter cette fonction pour que le joueur se déplace dans les quatre directions.
Q55.
La fonction dessiner_joueur() utilise x_joueur et y_joueur, et la fonction deplacer_joueur() utilise VITESSE, sans aucune déclaration global. Pourquoi cela ne provoque-t-il pas d’erreur ?
Q56.
Maintenir les touches → et ↑ enfoncées en même temps. Qu’observe-t-on ?
Un élève propose de remplacer les quatre if par une structure if … elif … elif … elif …. Sans exécuter le programme, prévoir ce qui se passerait avec les mêmes touches, puis vérifier.
Q57.
Sans exécuter le programme, calculer le nombre de pixels parcourus en une seconde lorsque la touche → reste enfoncée, puis le temps nécessaire pour traverser l’écran de gauche à droite. Vérifier avec un chronomètre.
Q58.
Pourquoi l’appel à deplacer_joueur() est-il placé dans update() et non dans draw() ?
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Une fonction contient x_joueur = x_joueur - VITESSE sans déclaration global. Que se passe-t-il à l’appel ?
Une variable qui reçoit une valeur dans une fonction est locale à cette fonction. Pour modifier la variable globale, il faut écrire global x_joueur au début du corps de la fonction.
Question 2 / 3
La fonction dessiner_joueur() lit x_joueur sans déclaration global. Est-ce une erreur ?
Lire une variable globale est toujours possible. La déclaration global ne sert qu’aux fonctions qui lui affectent une nouvelle valeur.
Question 3 / 3
Pourquoi l’appel à deplacer_joueur() est-il placé dans update() et non dans draw() ?
On sépare la logique du jeu (update) de son affichage (draw) : chaque fonction a une seule tâche.
Rester dans l’écran
Déplacer le joueur jusqu’au bord de l’écran : il peut en sortir. Il faut donc n’autoriser un déplacement que si le joueur reste entièrement visible.
Q59.
Compléter les conditions suivantes, en n’utilisant que des variables (aucun nombre sauf 0) :
Expliquer pourquoi la condition sur le bord droit doit tenir compte de la taille du joueur, alors que celle sur le bord gauche n’en tient pas compte.
Q60.
Remplacer VITESSE = 2 par VITESSE = 3.
Sans exécuter le programme, écrire les valeurs successives de x_joueur lorsque le joueur part de 76 et que la touche ← reste enfoncée. Le joueur reste-t-il dans l’écran ?
Modifier les quatre conditions pour que le joueur ne sorte jamais de l’écran, quelle que soit la valeur de VITESSE. Revenir ensuite à VITESSE = 2.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Le joueur va vers la gauche avec la touche ←. Quelle condition l’empêche de sortir de l’écran ?
On ne recule que si la touche est enfoncée et que le joueur n’est pas déjà au bord gauche (abscisse 0).
Question 2 / 2
Avec VITESSE = 3, le joueur part de x_joueur = 76 vers la gauche. La condition x_joueur > 0 suffit-elle à le garder dans l’écran ?
76, 73, …, 4, 1, puis −2 : la condition 1 > 0 est vraie, et le déplacement fait sortir le joueur. Il faut tester la position après le déplacement.
La cible : une fonction avec des paramètres
L’instruction pyxel.circ(x, y, r, col) dessine un disque de centre (x, y), de rayon r et de couleur col. Ajouter les constantes et les variables suivantes :
RAYON_CIBLE=4COULEUR_CIBLE=10x_cible=80y_cible=30
puis la fonction ci-dessous, et l’instruction dessiner_cible(x_cible, y_cible) dans draw().
Dans la définition def dessiner_cible(x, y): et dans l’appel dessiner_cible(x_cible, y_cible) :
identifier les paramètres et les arguments ;
indiquer la valeur de x et celle de y pendant l’exécution de cet appel.
Q62.
Sans exécuter le programme, prévoir le résultat de chacun des appels suivants, placés dans draw(), puis vérifier.
dessiner_cible(20, 20) suivi de dessiner_cible(140, 90) ;
dessiner_cible(y_cible, x_cible) ;
dessiner_cible(20).
Q63.
Ajouter à la fonction dessiner_cible un troisième paramètre couleur, puis modifier l’appel dans draw() pour que la cible soit toujours dessinée avec la couleur COULEUR_CIBLE. Vérifier en affichant une deuxième cible d’une autre couleur, puis la supprimer.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Pour la définition def dessiner_cible(x, y): et l’appel dessiner_cible(x_cible, y_cible), quels sont les paramètres ?
Les paramètres sont les noms de la définition ; x_cible et y_cible sont les arguments. Pendant l’appel, x reçoit la valeur de x_cible et y celle de y_cible.
Question 2 / 3
Que se passe-t-il avec l’appel dessiner_cible(20) ?
Une fonction attend autant d’arguments qu’elle a de paramètres : ici deux.
Question 3 / 3
Que dessine l’appel dessiner_cible(y_cible, x_cible) ?
Les arguments sont associés aux paramètres dans l’ordre : x reçoit ici la valeur de y_cible.
Le sol : une boucle for
Ajouter les constantes et la fonction suivantes, puis appeler dessiner_sol() dans draw().
quelles sont les abscisses de la première et de la dernière dalle ?
quelle est la largeur de l’espace entre deux dalles voisines ?
Q65.
Sans exécuter le programme, prévoir l’aspect du sol dans chacun des cas suivants, puis vérifier :
LARGEUR_DALLE = 8 ;
LARGEUR_DALLE = 6 et PAS_DALLES = 4.
Q66.
Réécrire la fonction dessiner_sol() avec une boucle while (voir Doc. 2,4). Laquelle des deux versions est la plus adaptée ? Pourquoi ?
Q67.
Dans draw(), placer l’appel à dessiner_sol() avant pyxel.cls(0). Qu’observe-t-on ? Pourquoi ?
Q68.
Le joueur peut descendre dans le sol. Modifier la condition sur la touche ↓ pour qu’il s’arrête au-dessus du sol, et la position de départ y_joueur pour qu’il soit posé sur le sol au lancement du jeu.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Avec LARGEUR = 160 et PAS_DALLES = 8, combien de dalles dessine la boucle for x in range(0, LARGEUR, PAS_DALLES): ?
x prend les valeurs 0, 8, 16, …, 152 : 160 est exclu, soit 160/8=20 valeurs, donc 20 dalles.
Question 2 / 3
Pour dessiner les dalles du sol, quelle boucle est la plus adaptée ?
Le nombre de répétitions est connu avant de commencer : la boucle for avec range est plus simple et ne risque pas d’être infinie.
Question 3 / 3
Dans draw(), on appelle dessiner_sol() avant pyxel.cls(0). Qu’observe-t-on ?
L’ordre des instructions compte : pyxel.cls efface tout ce qui a été dessiné avant lui.
Distance entre deux points : une fonction qui renvoie une valeur
Pour savoir si le joueur attrape la cible, il faut mesurer la distance qui les sépare. La distance entre les points de coordonnées (x1,y1) et (x2,y2) vaut :
d=(x2−x1)2+(y2−y1)2
La racine carrée s’obtient avec la fonction sqrt du module math, à importer au début du programme : from math import sqrt.
Q69.
Écrire une fonction distance(x1, y1, x2, y2) qui renvoie la distance entre les points (x1,y1) et (x2,y2).
Sans exécuter le programme, prévoir la valeur de distance(0, 0, 3, 4) et son type. Vérifier en ajoutant temporairement print(distance(0, 0, 3, 4)) juste après la définition de la fonction.
Q70.
Un élève a écrit une fonction qui affiche la distance au lieu de la renvoyer :
Sans exécuter le programme, prévoir le résultat de print(distance_affichee(0, 0, 3, 4) + 1), puis vérifier.
Pourquoi cette fonction ne peut-elle pas servir dans le jeu ?
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Que renvoie distance(0, 0, 3, 4) ?
32+42=25=5. La fonction sqrt renvoie toujours un float : 5.0.
Question 2 / 2
Une fonction distance_affichee contient print(...) mais pas de return. Que vaut distance_affichee(0, 0, 3, 4) ?
La fonction affiche 5.0, mais ne renvoie rien : sa valeur est None. On ne peut donc pas réutiliser le résultat dans un calcul ou une comparaison.
La cible est-elle attrapée ? Une fonction qui renvoie un booléen
Pourquoi ajoute-t-on 4 aux coordonnées du joueur ?
Justifier la valeur 8, en s’appuyant sur un schéma.
Réécrire la fonction en remplaçant les nombres 4 et 8 par des expressions qui utilisent les constantes TAILLE_JOUEUR et RAYON_CIBLE.
Q72.
Quelles valeurs la fonction cible_attrapee() peut-elle renvoyer ?
Un élève a écrit la fin de la fonction ainsi :
ifd<8:returnTrueelse:returnFalse
Les deux versions sont-elles équivalentes ? Laquelle préférer ?
Q73.
Dans draw(), afficher le texte « Touché ! » en haut de l’écran lorsque le joueur touche la cible. Tester.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
La fonction se termine par return d < 8. Que renvoie-t-elle ?
d < 8 est une expression booléenne : son évaluation donne directement True ou False.
Question 2 / 2
Les écritures return d < 8 et if d < 8: return True / else: return False sont-elles équivalentes ?
Inutile d’écrire un if pour renvoyer True ou False : on renvoie directement la valeur de la condition.
Faire apparaître une nouvelle cible
L’instruction pyxel.rndi(a, b) renvoie un entier choisi au hasard entre a et b, bornes comprises. Un disque de centre (x, y) et de rayon r occupe les pixels d’abscisse x - r à x + r ; les pixels de l’écran ont des abscisses comprises entre 0 et LARGEUR - 1.
Q74.
Déterminer les valeurs minimale et maximale de x_cible pour que la cible soit entièrement visible. Faire de même pour y_cible, en imposant que la cible reste au-dessus du sol.
Écrire une fonction nouvelle_cible() qui donne à la cible une position choisie au hasard, entièrement visible.
Dans update(), appeler nouvelle_cible() lorsque la cible est attrapée. Tester.
Q75.
Il peut arriver que la nouvelle cible apparaisse directement sur le joueur.
Que se passe-t-il dans ce cas ?
Pour l’éviter, il faut tirer une nouvelle position tant que la cible touche le joueur. Quelle boucle faut-il utiliser ? Pourquoi ?
Renommer la fonction de la question précédente en tirer_position_cible(), puis écrire une nouvelle fonction nouvelle_cible() qui l’utilise.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
On tire une nouvelle position de cible tant que la cible touche le joueur. Quelle boucle utiliser ?
Le nombre de tirages dépend du hasard : c’est une boucle non déterministe.
Question 2 / 2
Quelle instruction Pyxel donne un entier aléatoire entre a et b, bornes comprises ?
pyxel.rndi(a, b) renvoie un entier aléatoire entre a et b, les deux bornes étant incluses (comme random.randint). range(a, b) ne tire rien au hasard.
Le score
Ajouter la variable score = 0 au début du programme.
Q76.
Pourquoi le nom score est-il écrit en minuscules, alors que LARGEUR est écrit en majuscules ?
Modifier update() pour que le score augmente de 1 à chaque cible attrapée. Que faut-il ajouter au début de la fonction ?
Q77.
Remplacer l’affichage de « Touché ! » par celui du score, à l’aide de l’instruction pyxel.text(5, 5, "Score : " + str(score), 7).
Pourquoi faut-il écrire str(score) ?
Réécrire cette instruction à l’aide d’une f-string (voir Doc. 2,2).
Faut-il ajouter global score dans draw() ?
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Pourquoi score s’écrit-il en minuscules, alors que LARGEUR est en majuscules ?
Les majuscules signalent une constante. score est une variable globale modifiée au cours du jeu.
Question 2 / 3
Dans update(), l’instruction score += 1 provoque une erreur. Que faut-il ajouter au début de la fonction ?
Pour modifier une variable globale dans une fonction, il faut la déclarer avec global. Écrire score = 0 remettrait le score à zéro à chaque image.
Question 3 / 3
Pourquoi écrit-on "Score : " + str(score) ?
+ entre chaînes exige deux str. Une f-string fait la conversion automatiquement : f"Score : {score}".
Gagner la partie
Ajouter la constante SCORE_GAGNANT = 10 et modifier update() pour que le joueur ne puisse plus bouger une fois la partie gagnée :
Sans exécuter le programme, prévoir les deux défauts de l’affichage en fin de partie. Vérifier.
Corriger la fonction. Pour centrer le texte, utiliser les constantes pyxel.FONT_WIDTH et pyxel.FONT_HEIGHT, qui valent la largeur (4) et la hauteur (6) d’un caractère, ainsi que la fonction len.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Pour tester rapidement la fin de partie, que suffit-il de modifier ?
C’est tout l’intérêt d’une constante : une seule ligne à modifier.
Question 2 / 2
Une fois la partie gagnée, où doit-on empêcher le joueur de bouger ?
update() gère l’état du jeu ; draw() ne fait que l’afficher.
Quitter et rejouer
L’instruction pyxel.btnp(touche) renvoie True uniquement au moment où la touche vient d’être enfoncée, et non pendant tout le temps où elle reste enfoncée comme pyxel.btn. L’instruction pyxel.quit() ferme le jeu.
Q80.
Pourquoi utilise-t-on pyxel.btn pour déplacer le joueur, et non pyxel.btnp ?
Modifier update() pour que la touche Q ferme le jeu à tout moment, y compris après la victoire.
Q81.
Une fois la partie gagnée, un appui sur R doit lancer une nouvelle partie : le joueur revient à sa position de départ, le score revient à 0 et une nouvelle cible apparaît.
Pour ne pas écrire deux fois la position de départ, créer deux constantes X_DEPART et Y_DEPART, et les utiliser pour initialiser x_joueur et y_joueur.
Écrire une fonction nouvelle_partie(). Quelles variables doivent être déclarées global ?
Appeler cette fonction dans update() au bon endroit.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Quelle est la différence entre pyxel.btn et pyxel.btnp ?
Pour un déplacement continu, on utilise btn. Pour une action unique (quitter, rejouer), btnp évite de répéter l’action à chaque image.
Question 2 / 2
Pour rejouer, le joueur doit revenir à sa position de départ. Comment éviter d’écrire deux fois cette position ?
Une valeur écrite à un seul endroit ne peut pas devenir incohérente : on la modifie une fois, et tout le programme suit.
Le programme obtenu
Le programme complet est organisé ainsi :
constantes, puis variables décrivant l'état du jeu
Faire tourner des programmes à la main, en notant dans un tableau l’évolution du contenu des variables, pour prévoir ce que font un appel de fonction, une alternative et une boucle.
Chaque exercice se fait d’abord sur papier, sans ordinateur. Le programme est ensuite recopié dans Thonny et exécuté en mode débogage (touche F7) pour vérifier le tableau.
Méthode : remplir un tableau d’état
Une ligne du tableau correspond à une instruction exécutée, dans l’ordre où Python l’exécute (ou à une itération, quand le tableau le précise).
Sur chaque ligne, on écrit la valeur de chaque variable juste après l’exécution de l’instruction. Une case reste vide tant que la variable n’existe pas.
Pour une condition (if, elif, while), on la recopie en remplaçant les variables par leurs valeurs, puis on écrit sa valeur : True ou False.
Pour calculer une expression, on utilise les valeurs que les variables ont à ce moment-là, et non leurs valeurs du début.
Exercice 1 — Suivre un appel de fonction
On considère le programme suivant.
1
2
3
4
5
6
7
8
9
deftransforme(x:int)->int:"""Fonction à étudier."""y=2*xx=y+1returnx*ya=3b=transforme(a)c=transforme(b-40)
Q24.
Sans utiliser Python, compléter le tableau d’état ci-dessous. Les variables x et y n’existent que pendant l’exécution de la fonction : leurs cases restent vides en dehors d’un appel.
Ligne
a
b
c
x
y
7
8 : appel de transforme
3
4
5 : valeur retournée
8 : affectation de b
9 : appel de transforme
3
4
5 : valeur retournée
9 : affectation de c
Réponse
Ligne
a
b
c
x
y
7
3
8 : appel de transforme(3)
3
3
3
3
3
6
4
3
7
6
5 : retourne 42
3
7
6
8 : affectation de b
3
42
9 : appel de transforme(2)
3
42
2
3
3
42
2
4
4
3
42
5
4
5 : retourne 20
3
42
5
4
9 : affectation de c
3
42
20
À la ligne 9, l’argument b - 40 est évalué avant l’appel : il vaut 2. C’est cette valeur que reçoit le paramètre x. À la fin, a = 3, b = 42 et c = 20.
Q25.
À la ligne 4, la valeur de x change. Pourquoi a vaut-elle toujours 3 à la fin du programme ?
Réponse
Lors de l’appel transforme(a), le paramètre x reçoit la valeur de l’argument, c’est-à-dire 3. Ensuite, x et a sont deux variables différentes : affecter une nouvelle valeur à x ne modifie pas a.
Q26.
Sans utiliser Python, déterminer la valeur de transforme(transforme(1)) en détaillant les étapes. Vérifier ensuite dans la console.
Réponse
Python évalue d’abord l’argument transforme(1) : y prend la valeur 2, puis x la valeur 3 ; l’appel retourne 3 * 2, soit 6.
L’appel se ramène alors à transforme(6) : y vaut 12, x vaut 13 ; l’appel retourne 13 * 12, soit 156.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Avec la fonction transforme de l’exercice, que retourne transforme(1) ?
y = 2 * 1 = 2, puis x = y + 1 = 3, et la fonction retourne x * y = 3 * 2 = 6.
Question 2 / 3
Après a = 3 puis b = transforme(a), que vaut a ?
Le paramètre x reçoit la valeur de a, puis vit sa vie : modifier x dans la fonction ne modifie pas a.
Question 3 / 3
Que valent x et y après la fin de l’appel transforme(a), dans le programme principal ?
x et y n’existent que pendant l’exécution de la fonction.
Exercice 2 — Une fonction qui en appelle une autre
Dans le programme suivant, trois variables différentes portent le même nom n : celle du programme principal, le paramètre de f et le paramètre de double.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
defdouble(n:int)->int:"""Retourne le double de n."""n=2*nreturnndeff(n:int)->int:"""Fonction à étudier."""m=double(n)+1n=double(m)returnn-mn=3r=f(n)s=f(r)+n
Q27.
Sans utiliser Python, compléter le tableau d’état ci-dessous pour les lignes 12 et 13 du programme. La colonne « En cours » indique où se trouve l’exécution : programme principal, f ou double.
Ligne
En cours
n (programme)
r
n (dans f)
m
n (dans double)
12
programme
3
Réponse
Ligne
En cours
n (programme)
r
n (dans f)
m
n (dans double)
12
programme
3
13 : appel f(3)
f
3
3
8 : appel double(3)
double
3
3
3
3
double
3
3
6
4 : retourne 6
double
3
3
6
8 : affectation de m
f
3
3
7
9 : appel double(7)
double
3
3
7
7
3
double
3
3
7
14
4 : retourne 14
double
3
3
7
14
9 : affectation de n
f
3
14
7
10 : retourne 7
f
3
14
7
13 : affectation de r
programme
3
7
Le n de f passe de 3 à 14, celui de double de 3 à 6 : aucun des deux ne modifie le n du programme principal, qui vaut toujours 3.
Q28.
Sans construire de nouveau tableau, déterminer la valeur de s après la ligne 14. Quelle valeur de n est utilisée dans l’expression f(r) + n ?
Réponse
r vaut 7. Dans l’appel f(7) : double(7) retourne 14, donc m vaut 15 ; double(15) retourne 30, donc le n de f vaut 30 ; l’appel retourne 30 - 15, soit 15.
Dans f(r) + n, on est dans le programme principal : c’est son n qui est utilisé, et il vaut 3. Donc s = 15 + 3 = 18.
Q29.
Un élève remplace les lignes 3 et 4 par la seule instruction print(2 * n). Prévoir ce qui se passe lors de l’exécution de la ligne 13, puis vérifier.
Réponse
L’appel double(3) affiche 6 mais ne retourne aucune valeur : il retourne None. La ligne 8 doit alors calculer None + 1, ce qui provoque une erreur TypeError. Afficher une valeur n’est pas la retourner : seule une valeur retournée peut être réutilisée dans un calcul.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Avec les fonctions double et f de l’exercice, que retourne f(1) ?
m = double(1) + 1 = 3, puis n = double(3) = 6, et la fonction retourne n - m = 6 - 3 = 3.
Question 2 / 2
Après n = 3 puis r = f(n), que vaut le n du programme principal ?
Les paramètres n de f et de double sont des variables locales distinctes : aucun ne modifie le n du programme principal.
Exercice 3 — Quelle branche est exécutée ?
Un cinéma calcule le prix d’une place avec la fonction suivante.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
AGE_ENFANT=12AGE_SENIOR=65PRIX_ENFANT=5PRIX_REDUIT=7PRIX_NORMAL=10deftarif(age:int,etudiant:bool)->int:"""Retourne le prix de la place, en euros."""ifage<AGE_ENFANT:prix=PRIX_ENFANTelifage>=AGE_SENIORoretudiant:prix=PRIX_REDUITelse:prix=PRIX_NORMALreturnprix
Q30.
Sans utiliser Python, compléter le tableau ci-dessous. Dans la colonne du milieu, écrire chaque condition évaluée, dans l’ordre, avec les valeurs des variables et le résultat de l’évaluation. Une condition qui n’est pas évaluée ne doit pas apparaître.
Appel
Conditions évaluées
Valeur retournée
tarif(8, True)
tarif(70, False)
tarif(17, True)
tarif(30, False)
tarif(12, False)
Réponse
Appel
Conditions évaluées
Valeur retournée
tarif(8, True)
8 < 12 : True
5
tarif(70, False)
70 < 12 : False70 >= 65 or ... : True
7
tarif(17, True)
17 < 12 : False17 >= 65 or True : True
7
tarif(30, False)
30 < 12 : False30 >= 65 or False : False
10
tarif(12, False)
12 < 12 : False12 >= 65 or False : False
10
Pour tarif(70, False), 70 >= 65 vaut déjà True : grâce à l’évaluation en court-circuit, Python n’a pas besoin d’évaluer etudiant. Pour tarif(12, False), 12 < 12 est fausse : l’inégalité est stricte.
Q31.
Une personne de 8 ans est aussi étudiante dans une école de musique : tarif(8, True) retourne 5 et non 7. Expliquer pourquoi à partir de la structure if / elif / else.
Réponse
Dans une structure if / elif / else, un seul bloc est exécuté : celui de la première condition vraie. Ici, 8 < 12 est vraie, donc prix prend la valeur 5 et la condition du elif n’est même pas évaluée.
Q32.
Un élève remplace elif par if à la ligne 11. Le programme reste correct pour Python. Sans utiliser Python, déterminer ce que retournent alors tarif(8, True) et tarif(8, False). Vérifier ensuite.
Réponse
Le programme contient maintenant deux alternatives indépendantes, exécutées l’une après l’autre : un if seul (lignes 9 et 10), puis un if / else (lignes 11 à 14).
tarif(8, True) : 8 < 12 est vraie, prix vaut 5. Puis 8 >= 65 or True est vraie, prix vaut 7. L’appel retourne 7.
tarif(8, False) : prix vaut d’abord 5. Puis 8 >= 65 or False est fausse : c’est le bloc else qui s’exécute et prix vaut 10. L’appel retourne 10, le prix normal, pour un enfant.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Avec la fonction tarif de l’exercice, que retourne tarif(15, True) ?
15 < 12 est fausse ; 15 >= 65 or True est vraie grâce à etudiant : le prix réduit, 7 €, s’applique.
Question 2 / 3
Que retourne tarif(11, True) ?
11 < 12 est vraie : le premier bloc est exécuté et les conditions suivantes ne sont même pas évaluées.
Question 3 / 3
Lors de l’appel tarif(70, False), la variable etudiant est-elle évaluée dans la condition du elif ?
C’est l’évaluation en court-circuit : avec or, dès qu’un opérande vaut True, le résultat est connu.
Exercice 4 — Des if successifs ou un elif ?
On compare deux versions d’une fonction de calcul de score. En dehors de leur nom, elles ne diffèrent que par les mots-clés des lignes 5 et 7.
1
2
3
4
5
6
7
8
9
defajuste_a(score:int)->int:"""Calcule un nouveau score."""ifscore<10:score=score+3ifscore<15:score=score+2ifscore>14:score=score+1returnscore
1
2
3
4
5
6
7
8
9
defajuste_b(score:int)->int:"""Calcule un nouveau score."""ifscore<10:score=score+3elifscore<15:score=score+2elifscore>14:score=score+1returnscore
Q33.
Sans utiliser Python, suivre l’appel ajuste_a(9) en complétant le tableau ci-dessous. Chaque ligne du tableau correspond à une ligne exécutée de la fonction. Toutes les lignes du tableau ne seront pas forcément utilisées.
Ligne
Condition testée
score
1
9
Réponse
Ligne
Condition testée
score
1
9
3
9 < 10 : True
9
4
12
5
12 < 15 : True
12
6
14
7
14 > 14 : False
14
9
14
L’appel retourne 14. La condition de la ligne 5 utilise la valeur de score déjà modifiée à la ligne 4 (12), et non la valeur de départ (9).
Q34.
Faire de même pour ajuste_b(9), puis compléter le tableau des valeurs retournées ci-dessous.
score de départ
ajuste_a
ajuste_b
9
14
13
16
Réponse
Pour ajuste_b(9), les lignes exécutées sont 1, 3 (9 < 10 : True), 4 (score vaut 12) puis 9. Les deux elif ne sont pas évalués : l’appel retourne 12.
score de départ
ajuste_a
ajuste_b
9
14
12
13
16
15
16
17
17
Pour 13 : dans la version A, 13 < 15 est vraie et score devient 15 ; puis 15 > 14 est vraie et score devient 16. Dans la version B, seul le premier bloc dont la condition est vraie est exécuté : score devient 15.
Q35.
Plus difficile. Pour quelles valeurs entières de score, comprises entre 0 et 20, les deux versions retournent-elles des valeurs différentes ? Justifier, puis vérifier avec une boucle dans la console.
Réponse
Dans la version B, un seul bloc est exécuté. Dans la version A, un bloc peut être exécuté puis modifier score de façon qu’une condition suivante devienne vraie.
De 0 à 9 : la version A ajoute 3 puis 2 (le score obtenu est inférieur à 15), alors que la version B ajoute seulement 3. Les résultats diffèrent.
De 10 à 12 : les deux versions ajoutent 2. Dans la version A, le score obtenu (12 à 14) ne dépasse pas 14 : même résultat.
13 et 14 : les deux versions ajoutent 2, mais dans la version A le score obtenu (15 ou 16) dépasse 14 et on ajoute encore 1. Les résultats diffèrent.
De 15 à 20 : seule la condition score > 14 est vraie dans les deux versions : même résultat.
Les résultats diffèrent donc pour les scores de 0 à 9, 13 et 14. Vérification :
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Que retourne ajuste_a(13) (trois if successifs) ?
13 < 10 est fausse ; 13 < 15 est vraie, donc score devient 15 ; puis 15 > 14 est vraie, donc score devient 16. Chaque if teste la valeur déjà modifiée.
Question 2 / 2
Que retourne ajuste_b(13) (if / elif / elif) ?
Dès que 13 < 15 est vraie, le bloc correspondant est exécuté et les elif suivants sont ignorés : le score vaut 15.
Exercice 5 — Faire tourner une boucle à la main
On considère les deux fonctions suivantes.
defmystere(n:int)->int:"""Fonction à étudier."""s=0foriinrange(1,n+1,2):s=s+ireturns
defmystere_bis(n:int)->int:"""Fonction à étudier."""s=0i=1whilei<=n:s=s+ii=i+2returns
Q36.
Quels entiers sont produits par range(1, 8, 2) ? Combien d’itérations la boucle de mystere(7) effectue-t-elle ?
Réponse
range(1, 8, 2) produit 1, 3, 5 et 7 : on part de 1, on avance de 2, et 8 est exclu. La boucle effectue donc 4 itérations.
Q37.
Sans utiliser Python, compléter le tableau d’état de l’appel mystere(7). Chaque ligne donne les valeurs à la fin d’une itération.
Étape
i
s
avant la boucle
0
itération 1
itération 2
itération 3
itération 4
Réponse
Étape
i
s
avant la boucle
0
itération 1
1
1
itération 2
3
4
itération 3
5
9
itération 4
7
16
L’appel retourne 16. Avant la boucle, i n’existe pas encore : c’est la boucle for qui lui donne ses valeurs.
Q38.
Sans utiliser Python, compléter le tableau d’état de l’appel mystere_bis(7). La condition de la boucle est évaluée au début de chaque itération : la dernière ligne correspond au test qui arrête la boucle.
Étape
Condition testée
s
i
avant la boucle
0
1
itération 1
1 <= 7 : True
itération 2
itération 3
itération 4
fin
Réponse
Étape
Condition testée
s
i
avant la boucle
0
1
itération 1
1 <= 7 : True
1
3
itération 2
3 <= 7 : True
4
5
itération 3
5 <= 7 : True
9
7
itération 4
7 <= 7 : True
16
9
fin
9 <= 7 : False
16
9
L’appel retourne 16, comme mystere(7).
Q39.
À la fin de chaque appel, quelle est la dernière valeur prise par i : dans mystere(7) ? dans mystere_bis(7) ? Expliquer la différence.
Réponse
Dans mystere(7), i vaut 7 : c’est la dernière valeur produite par range. Dans mystere_bis(7), i vaut 9 : la boucle while ne s’arrête que lorsque la condition devient fausse, donc après que i a dépassé 7.
Q40.
Sans utiliser Python, prévoir les valeurs de mystere(8) et de mystere_bis(0). Combien d’itérations sont effectuées dans le second appel ?
Réponse
range(1, 9, 2) produit les mêmes entiers que range(1, 8, 2) : mystere(8) retourne aussi 16.
Pour mystere_bis(0), la condition 1 <= 0 est fausse dès le premier test : aucune itération n’est effectuée et l’appel retourne 0.
Q41.
Quel calcul réalisent ces deux fonctions ?
Réponse
Elles retournent la somme des entiers impairs compris entre 1 et n. On remarque que les valeurs successives de s (1, 4, 9, 16) sont des carrés.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Que retourne mystere(5) ?
range(1, 6, 2) produit 1, 3 et 5 : la fonction calcule 1+3+5=9, la somme des entiers impairs inférieurs ou égaux à n.
Question 2 / 2
Lors de l’appel mystere_bis(5), combien de fois la condition i <= n est-elle évaluée ?
Elle est vraie pour i = 1, 3 et 5, puis évaluée une dernière fois pour i = 7 : elle est alors fausse et la boucle s’arrête. Cela fait 4 évaluations pour 3 itérations.
Exercice 6 — Fonctions, alternative et boucles réunies
Une boucle non bornée qui appelle une fonction
On part d’un entier strictement positif n. S’il est pair, on le divise par 2 ; sinon, on le multiplie par 3 et on ajoute 1. On recommence jusqu’à obtenir 1. La fonction syracuse compte le nombre d’étapes et retient la plus grande valeur atteinte.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
defest_pair(n:int)->bool:"""Retourne True si n est pair, False sinon."""returnn%2==0defsyracuse(n:int)->str:"""Retourne le nombre d'étapes pour atteindre 1
et la plus grande valeur atteinte.
"""etapes=0maxi=nwhilen!=1:ifest_pair(n):n=n//2else:n=3*n+1ifn>maxi:maxi=netapes+=1returnf"{etapes} étapes, maximum {maxi}"
Q42.
Sans utiliser Python, compléter le tableau d’état de l’appel syracuse(6). Chaque ligne donne les valeurs à la fin d’une itération ; la colonne est_pair(n) contient la valeur retournée par cet appel, au début de l’itération. Toutes les lignes ne seront pas forcément utilisées. Quelle chaîne de caractères est retournée ?
Étape
est_pair(n)
n
maxi
etapes
avant la boucle
6
itération 1
itération 2
itération 3
itération 4
itération 5
itération 6
itération 7
itération 8
itération 9
itération 10
Réponse
Étape
est_pair(n)
n
maxi
etapes
avant la boucle
6
6
0
itération 1
True
3
6
1
itération 2
False
10
10
2
itération 3
True
5
10
3
itération 4
False
16
16
4
itération 5
True
8
16
5
itération 6
True
4
16
6
itération 7
True
2
16
7
itération 8
True
1
16
8
Après l’itération 8, la condition 1 != 1 est fausse : la boucle s’arrête. L’appel retourne '8 étapes, maximum 16'. À l’itération 1, 3 > 6 est fausse : maxi garde la valeur 6.
Q43.
Sans utiliser Python, prévoir la valeur retournée par syracuse(1). Combien de fois le bloc de la boucle est-il exécuté ?
Réponse
maxi prend la valeur 1 et etapes la valeur 0. La condition 1 != 1 est fausse dès le premier test : le bloc n’est exécuté aucune fois. L’appel retourne '0 étapes, maximum 1'.
Q44.
Un élève appelle syracuse(0), alors que la fonction attend un entier strictement positif. Faire tourner à la main les deux premières itérations. Que se passe-t-il ? Quelle modification de la ligne 11 éviterait ce problème ?
Réponse
0 != 1 est vraie ; est_pair(0) retourne True, donc n prend la valeur 0 // 2, soit 0. À l’itération suivante, la situation est exactement la même : n vaut toujours 0 et ne se rapproche jamais de 1. C’est une boucle infinie.
Avec while n > 1:, la condition 0 > 1 est fausse dès le premier test et la boucle n’est pas exécutée. Pour un entier strictement positif, les deux conditions donnent le même résultat.
Deux boucles imbriquées
defmotif(n:int)->str:"""Fonction à étudier."""texte=""foriinrange(1,n+1):forjinrange(i):texte+="*"texte+="-"returntexte
Q45.
Sans utiliser Python, compléter le tableau d’état de l’appel motif(3). Une ligne correspond à une instruction texte += ... exécutée ; la colonne j reste vide pour l’instruction texte += "-". Quelle chaîne est retournée ?
i
j
texte
Réponse
i
j
texte
1
0
"*"
1
"*-"
2
0
"*-*"
2
1
"*-**"
2
"*-**-"
3
0
"*-**-*"
3
1
"*-**-**"
3
2
"*-**-***"
3
"*-**-***-"
L’appel retourne '*-**-***-'. Pour chaque valeur de i, la boucle interne for j in range(i) effectue i itérations : elle ajoute i étoiles, puis l’instruction texte += "-", qui n’est pas dans la boucle interne, ajoute un tiret.
Q46.
Sans utiliser Python, déterminer le nombre de caractères de la chaîne retournée par motif(4). Vérifier avec len(motif(4)).
Réponse
motif(4) contient 1+2+3+4=10 étoiles et 4 tirets, soit 14 caractères.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Que retourne syracuse(3) ?
La suite est 3, 10, 5, 16, 8, 4, 2, 1 : 7 étapes, et la plus grande valeur atteinte est 16.
Question 2 / 2
Que retourne syracuse(1) ?
La condition 1 != 1 est fausse dès le départ : la boucle n’effectue aucune itération.
Bilan
À l’issue de cette activité, je sais…
remplir un tableau d’état en utilisant, pour chaque instruction, les valeurs des variables juste avant son exécution ;
suivre un appel de fonction : le paramètre reçoit la valeur de l’argument, les variables de la fonction disparaissent après le return ;
expliquer pourquoi modifier un paramètre ne modifie pas la variable passée en argument ;
distinguer une fonction qui retourne une valeur d’une fonction qui l’affiche ;
repérer le seul bloc exécuté dans une structure if / elif / else, et la différence avec des if successifs ;
compter les itérations d’une boucle for avec range et d’une boucle while, y compris lorsqu’il n’y en a aucune ;
repérer une boucle infinie en faisant tourner une boucle à la main ;
suivre deux boucles imbriquées.
Physique, Chimie et Informatique > 1ère Spécialité NSI
Premières structures de données : listes et tuples
Regrouper plusieurs valeurs dans un seul objet, le tuple, pour qu’une fonction puisse renvoyer plusieurs résultats à la fois.
Une fonction peut-elle renvoyer deux valeurs ?
Dans le Doc. 2,4, la fonction plus_grand_plus_petit retournait une chaîne de caractères comme "max : 18.0, min : 7.5". Pour un humain, c’est très lisible. Mais imaginons qu’on veuille ensuite calculer l’écart entre le maximum et le minimum. Il faudrait fouiller dans le texte pour retrouver les chiffres, puis les convertir en nombres. On a fabriqué une phrase alors qu’on voulait deux nombres.
Le vrai problème est le suivant : une instruction return met fin à la fonction. On ne peut donc pas écrire deux return à la suite en espérant récupérer deux résultats. Faisons une expérience.
Q22.
Recopier la fonction suivante dans la partie principale de l’éditeur Thonny :
defmin_max(a:float,b:float):"""Retourne le plus petit puis le plus grand des nombres a et b."""ifa<b:returna,breturnb,a
Appeler min_max(9, 4) dans la console. Qu’affiche-t-elle ?
Saisir ensuite resultat = min_max(9, 4), puis type(resultat). Combien d’objets la fonction a-t-elle retournés ?
On n’a donc pas contourné la règle : une fonction renvoie toujours une seule valeur. On a simplement rangé les deux nombres dans une même boîte, et c’est la boîte qu’on renvoie.
À retenir
Un tuple (le programme dit aussi p-uplet) est une suite ordonnée de valeurs. On l’écrit en séparant les valeurs par des virgules, le plus souvent entre parenthèses : (4, 9).
Le tuple est un type construit : il est fabriqué à partir de valeurs de types de base (int, float, str, bool).
Une fonction ne retourne qu’une seule valeur. Pour retourner plusieurs résultats, elle les regroupe dans un tuple : return a, b.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Avec la fonction min_max du cours, que vaut type(min_max(9, 4)) ?
return a, b regroupe les deux nombres dans un seul objet, un tuple.
Question 2 / 2
Combien d’objets une fonction qui exécute return a, b retourne-t-elle ?
Une fonction retourne toujours un seul objet ; pour transmettre plusieurs résultats, on les regroupe dans un tuple.
Créer un tuple et lire ses éléments
C’est la virgule qui fait le tuple
Q23.
Pour chacune des expressions suivantes, prévoir le type de la valeur obtenue, puis vérifier avec la fonction type dans la console :
Le deuxième essai provoque une erreur. Pourquoi, à votre avis ? Comment écrire un tuple qui ne contient qu’un seul élément ?
Les éléments d’un tuple ne sont pas forcément du même type. Une ville peut être décrite par son nom, sa latitude et sa longitude :
ville=("Paris",48.86,2.35)
Ce tuple n’a de sens que parce qu’on s’est mis d’accord sur l’ordre : d’abord le nom, ensuite la latitude, enfin la longitude. Si on écrivait (48.86, "Paris", 2.35), Python ne protesterait pas, mais un programme qui attend le nom en premier serait trompé.
Repérer un élément par son indice
Chaque élément d’un tuple occupe une position, appelée indice. En Python, les indices commencent à 0. Cela paraît étrange au début. Une façon de s’en souvenir : l’indice indique combien de pas il faut faire depuis le début pour atteindre l’élément. Le premier élément est à zéro pas du début.
indice
0
1
2
élément det
3
7
12
On lit l’élément d’indice i du tuple t en écrivant t[i]. La fonction len, déjà rencontrée avec les chaînes de caractères, donne le nombre d’éléments du tuple.
Q24.
Saisir t = (3, 7, 12) dans la console. Prévoir le résultat de chacune des instructions suivantes, puis vérifier :
>>>t[0]>>>t[2]>>>len(t)>>>t[3]>>>t[len(t)-1]
Quel est l’indice du dernier élément d’un tuple qui contient n éléments ?
Indices négatifs
Python accepte aussi des indices négatifs, qui comptent à partir de la fin : t[-1] est le dernier élément, t[-2] l’avant-dernier. Avec t = (3, 7, 12), t[-1] vaut 12, exactement comme t[len(t) - 1].
Q25.
Avec ville = ("Paris", 48.86, 2.35), écrire une instruction qui affiche, à l’aide d’une f-string et des indices :
Paris : latitude 48.86, longitude 2.35
À retenir
Les éléments d’un tuple t sont repérés par leur indice, qui commence à 0. On lit l’élément d’indice i avec t[i].
len(t) donne le nombre d’éléments de t. Les indices valides vont donc de 0 à len(t) - 1. Un indice en dehors de ces limites provoque une erreur IndexError.
Un tuple d’un seul élément s’écrit avec une virgule : (5,). Le tuple vide s’écrit ().
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Que vaut type((5)) ?
Les parenthèses seules ne font qu’entourer l’expression 5. Pour un tuple d’un seul élément, il faut une virgule : (5,).
Question 2 / 3
Avec t = (3, 7, 12), que produit t[3] ?
Le tuple contient 3 éléments, d’indices 0, 1 et 2 : l’indice 3 n’existe pas.
Question 3 / 3 (plusieurs réponses possibles)
Un tuple t contient n éléments. Quelles expressions donnent son dernier élément ?
Les indices vont de 0 à len(t) - 1. L’indice négatif -1 compte à partir de la fin. t[len(t)] et t[n] sont hors limites.
Un tuple ne peut pas être modifié
Q26.
Toujours avec t = (3, 7, 12), essayer de remplacer le premier élément par 4 :
>>>t[0]=4
Que se passe-t-il ?
Un tuple, une fois créé, ne change plus. On dit qu’il est non mutable (ou immuable). Est-ce gênant ? Pas vraiment, car on peut toujours fabriquer un nouveau tuple.
Q27.
Prévoir, puis vérifier, le contenu de t et de u après chacune des instructions suivantes :
L’opérateur + a-t-il modifié t ? La dernière affectation a-t-elle modifié le tuple (3, 7, 12) ?
Q28.
Prévoir puis vérifier le résultat de 7 in t et de 8 in t, avec t = (4, 7, 12). De quel type est la valeur obtenue ?
Pourquoi Python propose-t-il un objet qu’on ne peut pas modifier ? Parce que c’est une garantie. Les coordonnées de Paris ne vont pas changer pendant l’exécution du programme. Si on les range dans un tuple et qu’on les confie à une fonction, on est certain de les retrouver intactes, quelle que soit la façon dont cette fonction a été écrite.
À retenir
Un tuple est non mutable : on ne peut pas modifier ses éléments. L’instruction t[0] = 4 provoque une erreur TypeError.
On peut en revanche construire un nouveau tuple, par exemple par concaténation avec l’opérateur + : (3, 7) + (12,) vaut (3, 7, 12).
valeur in t vaut True si valeur est un élément de t, False sinon.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Avec t = (3, 7, 12), que produit l’instruction t[0] = 4 ?
Un tuple est non mutable : on ne peut pas affecter une nouvelle valeur à l’un de ses éléments.
Question 2 / 3
Après t = (3, 7, 12) puis u = t + (20,), que vaut t ?
La concaténation fabrique un nouveau tuple, rangé dans u. Le tuple t n’est pas modifié.
Question 3 / 3
Avec t = (4, 7, 12), que vaut 8 in t ?
in teste la présence d’une valeur et donne un booléen : 8 n’est pas un élément de t.
Parcourir un tuple
Un tuple est un objet itérable, au même titre que ce que produit range (voir Doc. 2,4). On peut donc le parcourir avec une boucle for. Il y a deux façons de le faire.
Q29.
Recopier les deux fonctions suivantes dans l’éditeur :
defsomme(valeurs:tuple[float,...])->float:"""Retourne la somme des éléments du tuple valeurs."""total=0forvinvaleurs:total+=vreturntotaldefsomme_2(valeurs:tuple[float,...])->float:"""Retourne la somme des éléments du tuple valeurs."""total=0foriinrange(len(valeurs)):total+=valeurs[i]returntotal
Tester somme((3, 7, 12)) et somme_2((3, 7, 12)).
Dans chaque fonction, quelles valeurs prend successivement la variable de boucle (v ou i) ?
L’annotation tuple[float, ...] signifie « tuple de nombres flottants, de longueur quelconque ». Pourquoi ne pas avoir écrit tuple[float, float, float] ?
La première écriture est plus courte. La seconde n’est utile que lorsqu’on a besoin de connaître la position des éléments, comme dans la question suivante.
Q30.
Écrire la fonction indice_max dont la spécification est :
defindice_max(valeurs:tuple[float,...])->int:"""Retourne l'indice du plus grand élément de valeurs.
valeurs ne doit pas être vide.
>>> indice_max((12, 5, 18, 7))
2
"""
Indication. On suppose d’abord que le plus grand élément est celui d’indice 0, puis on compare cet élément à chacun des suivants.
À retenir
On parcourt un tuple t de deux façons :
for element in t: donne directement les éléments, un par un ;
for i in range(len(t)): donne les indices, et on lit l’élément avec t[i]. On utilise cette écriture lorsque la position de l’élément compte.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Avec t = (3, 7, 12), quelles valeurs la variable v prend-elle dans for v in t: ?
Cette écriture parcourt directement les éléments du tuple.
Question 2 / 2
Pour écrire la fonction indice_max, quel parcours faut-il choisir ?
La fonction doit retourner un indice : il faut connaître la position de chaque élément, donc parcourir les indices.
Déballer un tuple
L’affectation multiple
Quand un tuple contient peu d’éléments, il est souvent plus clair de donner un nom à chacun d’eux. Python permet de le faire en une seule ligne.
Q31.
Saisir les instructions suivantes dans la console, en prévoyant le résultat avant chaque validation :
>>>point=(2,5)>>>x,y=point>>>x>>>y>>>a,b=(1,2,3)
Expliquer le message d’erreur obtenu à la dernière ligne.
Q32.
Reprendre la fonction min_max de la première partie. Écrire dans la console une instruction qui range le résultat de min_max(9, 4) dans deux variables petit et grand, puis calculer l’écart entre ces deux nombres.
Retour sur l’échange de deux variables
Dans le Doc. 2,2, on a vu que la séquence a = b puis b = a n’échange pas les valeurs de deux variables, et qu’il fallait passer par une variable tmp. Avec les tuples, Python propose une écriture bien plus courte.
Q33.
Saisir les instructions suivantes dans la console :
>>>a=605>>>b=506>>>a,b=b,a>>>a,b
Les valeurs ont-elles été échangées ?
La séquence a = b puis b = a échouait parce que la valeur de a était écrasée avant d’avoir été recopiée. Expliquer, en décrivant ce que fait Python dans l’ordre, pourquoi ce problème ne se pose pas ici.
Q34.
Pour l’épreuve écrite. Sans utiliser Python, compléter le tableau d’état de la séquence suivante, puis vérifier dans la console.
a,b=3,8a,b=b,a+ba,b=b-a,a
Instruction
a
b
a, b = 3, 8
a, b = b, a + b
a, b = b - a, a
Q35.
Dans le Doc. 2,4, la fonction fibo utilisait une troisième variable w pour calculer le terme suivant de la suite de Fibonacci. Réécrire cette fonction sans la variable w, à l’aide d’une affectation multiple. Vérifier que fibo(10) retourne '1 1 2 3 5 8 13 21 34 55 '.
À retenir
L’affectation multiplex, y = point déballe un tuple : chaque variable de gauche reçoit l’élément de même position. Il doit y avoir autant de variables que d’éléments, sinon Python signale une erreur ValueError.
Dans a, b = b, a, Python évalue d’abord tout le membre de droite, qui forme un tuple, puis affecte les variables. C’est pourquoi cette instruction échange les valeurs de a et de b.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Après point = (2, 5) puis x, y = point, que vaut y ?
Chaque variable de gauche reçoit l’élément de même position : x vaut 2 et y vaut 5.
Question 2 / 3
Que produit a, b = (1, 2, 3) ?
Il doit y avoir autant de variables que d’éléments dans le tuple.
Question 3 / 3
Que valent a et b après a, b = 2, 5 puis a, b = b, a + b ?
Le membre de droite est entièrement évalué avec les anciennes valeurs : il forme le tuple (5, 7), puis les deux variables sont affectées.
Écrire une fonction qui renvoie un tuple
Pour annoncer qu’une fonction retourne un tuple, on indique dans sa signature le type de chaque élément, dans l’ordre : -> tuple[int, int] signifie « retourne un tuple de deux entiers ». Pour un tuple de longueur quelconque dont tous les éléments ont le même type, on écrit tuple[float, ...].
Consigne
Écrire chaque fonction dans la partie principale de l’éditeur, avec sa spécification complète (signature et documentation). Tester ensuite chacun des exemples de la documentation dans la console.
Q36.
Division euclidienne. Écrire la fonction division_euclidienne dont la spécification est :
defdivision_euclidienne(a:int,b:int)->tuple[int,int]:"""Retourne le quotient et le reste de la division euclidienne
de a par b (b non nul).
>>> division_euclidienne(17, 5)
(3, 2)
>>> division_euclidienne(20, 4)
(5, 0)
"""
Comparer avec le résultat de la fonction divmod(17, 5), fournie par Python.
Q37.
Convertir une durée. Une course de fond a duré 3725 s. On veut exprimer cette durée en heures, minutes et secondes.
Sans ordinateur, effectuer la conversion à la main, en détaillant le calcul.
Écrire la fonction convertir_duree dont la spécification est :
defconvertir_duree(duree:int)->tuple[int,int,int]:"""Convertit une durée donnée en secondes en un tuple
(heures, minutes, secondes).
>>> convertir_duree(3725)
(1, 2, 5)
>>> convertir_duree(59)
(0, 0, 59)
"""
Q38.
Milieu d’un segment. Dans un repère, un point est représenté par le tuple (x, y) de ses coordonnées. Écrire la fonction milieu dont la spécification est :
defmilieu(a:tuple[float,float],b:tuple[float,float])->tuple[float,float]:"""Retourne les coordonnées du milieu du segment [AB].
>>> milieu((0, 0), (4, 2))
(2.0, 1.0)
>>> milieu((-1, 3), (1, 3))
(0.0, 3.0)
"""
Indication. Commencer par déballer chacun des deux tuples.
Q39.
Distance entre deux points. Dans le Doc. 2,1, la fonction distance recevait quatre arguments x1, y1, x2, y2. Avec des tuples, deux arguments suffisent. On veut de plus que la fonction marche aussi dans l’espace, avec des points à trois coordonnées. Dans un repère orthonormé de l’espace, la distance entre A(xA,yA,zA) et B(xB,yB,zB) est :
AB=(xB−xA)2+(yB−yA)2+(zB−zA)2
Écrire la fonction distance dont la spécification est :
defdistance(a:tuple[float,...],b:tuple[float,...])->float:"""Retourne la distance entre les points a et b, qui doivent
avoir le même nombre de coordonnées.
>>> distance((0, 0), (3, 4))
5.0
>>> distance((1, 2, 3), (1, 2, 3))
0.0
>>> distance((0, 0, 0), (1, 2, 2))
3.0
"""
Que devrait faire la fonction si on l’appelle avec distance((0, 0), (1, 1, 1)) ? Ajouter au début du corps de la fonction l’instruction :
assertlen(a)==len(b),"les deux points doivent avoir la même dimension"
puis tester à nouveau cet appel.
À retenir
L’instruction assert condition, "message" vérifie qu’une condition est vraie. Si elle est fausse, le programme s’arrête avec une erreur AssertionError et affiche le message.
On s’en sert pour vérifier une précondition, c’est-à-dire une condition que les arguments doivent respecter pour que la fonction ait un sens. Mieux vaut un programme qui s’arrête en expliquant pourquoi qu’un programme qui retourne un résultat faux sans prévenir.
Q40.
Plus petit et plus grand élément. Écrire la fonction min_max_tuple dont la spécification est :
defmin_max_tuple(valeurs:tuple[float,...])->tuple[float,float]:"""Retourne le plus petit et le plus grand élément de valeurs,
qui ne doit pas être vide.
>>> min_max_tuple((12, 5, 18, 7))
(5, 18)
>>> min_max_tuple((4,))
(4, 4)
"""
Les fonctions min et max de Python ne doivent pas être utilisées. Vérifier la précondition par une assertion.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Que retourne division_euclidienne(17, 5) ?
17=3×5+2 : le quotient vaut 3 et le reste 2, dans cet ordre.
Question 2 / 3
Que se passe-t-il à l’exécution de assert len(valeurs) > 0, "valeurs ne doit pas être vide" lorsque valeurs vaut () ?
La condition est fausse : assert arrête le programme en expliquant pourquoi, au lieu de laisser la fonction produire un résultat faux.
Question 3 / 3
Quelle annotation de type, écrite comme dans le cours, convient à une fonction qui retourne une durée sous la forme (heures, minutes, secondes), trois entiers ?
On indique le type de chacun des éléments du tuple retourné.
Exercices de synthèse
Q41.
Équation du second degré. On cherche les solutions réelles de l’équation ax2+bx+c=0, avec a=0. On note Δ=b2−4ac le discriminant.
Si Δ>0, il y a deux solutions : x1=(−b−Δ)/(2a) et x2=(−b+Δ)/(2a).
Si Δ=0, il y a une seule solution : x0=−b/(2a).
Si Δ<0, il n’y a pas de solution réelle.
Le nombre de solutions change d’une équation à l’autre. Un tuple convient bien : il peut contenir deux, un ou zéro élément. Écrire la fonction racines dont la spécification est :
defracines(a:float,b:float,c:float)->tuple[float,...]:"""Retourne le tuple des solutions réelles de a x² + b x + c = 0,
avec a non nul.
>>> racines(1, -3, 2)
(1.0, 2.0)
>>> racines(1, 2, 1)
(-1.0,)
>>> racines(1, 0, 1)
()
"""
Q42.
Comparer deux dates. Une date est représentée par un tuple (jour, mois, annee). Écrire la fonction est_avant dont la spécification est :
defest_avant(d1:tuple[int,int,int],d2:tuple[int,int,int])->bool:"""Retourne True si la date d1 est strictement antérieure
à la date d2, False sinon.
>>> est_avant((14, 7, 1789), (11, 11, 1918))
True
>>> est_avant((25, 12, 2025), (1, 1, 2025))
False
>>> est_avant((3, 5, 2026), (3, 5, 2026))
False
>>> est_avant((3, 5, 2026), (4, 5, 2026))
True
"""
Indication. Comparer d’abord les années. Si elles sont égales, comparer les mois, et ainsi de suite.
Bilan
À l’issue de cette activité, je sais…
créer un tuple, y compris un tuple d’un seul élément (5,) et le tuple vide () ;
lire un élément d’un tuple grâce à son indice, en sachant que les indices vont de 0 à len(t) - 1 ;
expliquer pourquoi t[0] = 4 provoque une erreur, et construire un nouveau tuple à la place ;
tester la présence d’une valeur dans un tuple avec in ;
parcourir un tuple par ses éléments ou par ses indices, et choisir l’écriture adaptée ;
déballer un tuple par une affectation multiple, et expliquer pourquoi a, b = b, a échange deux valeurs ;
écrire une fonction qui renvoie un tuple de valeurs, avec une signature du type -> tuple[int, int] ;
vérifier une précondition à l’aide d’une assertion.
Physique, Chimie et Informatique > 1ère Spécialité NSI > Premières structures de données : listes et tuples
Ranger des valeurs de même type dans une liste, modifier et parcourir ses éléments, puis construire des listes, y compris des listes de listes.
Quand un tuple ne suffit plus
Un professeur range les notes d’un devoir dans un tuple :
notes=(12,15,9,14)
En relisant les copies, il s’aperçoit que la troisième note est fausse : c’est 11 et non 9. Avec un tuple, l’instruction notes[2] = 11 provoque une erreur, puisqu’un tuple n’est pas mutable (Doc. 3,1). Il faudrait reconstruire un tuple complet, (notes[0], notes[1], 11, notes[3]), pour changer une seule valeur. Avec 35 élèves, ce serait pénible.
Python propose pour cela un autre type construit, la liste, qui s’écrit entre crochets.
Q1.
Saisir les instructions suivantes dans la console :
Une liste est une suite ordonnée de valeurs, écrite entre crochets et séparées par des virgules : [12, 15, 9, 14]. Son type est list.
Une liste est mutable : on peut modifier ses éléments après sa création, alors qu’un tuple ne le permet pas.
Dans cette activité, tous les éléments d’une même liste ont le même type.
Remarque
Il ne faut pas confondre une liste avec un tableau. Un tableau est un ensemble de valeurs de même type, rangées les unes à la suite des autres dans la mémoire : on dit qu’elles sont contiguës. Une liste Python ne répond pas à cette définition : ses éléments peuvent être de types différents, et ils ne sont pas rangés côte à côte dans la mémoire. Python se sert de tableaux pour fabriquer ses listes, mais une liste n’est pas un tableau.
?Vérifier ses acquis2 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 2
Après notes = [12, 15, 9, 14] puis notes[2] = 11, que vaut notes ?
Une liste est mutable : on peut remplacer l’élément d’indice 2, qui est le troisième.
Question 2 / 2 (plusieurs réponses possibles)
Quelles affirmations sont exactes ?
Une liste Python n’est pas un tableau : ses éléments ne sont pas rangés côte à côte en mémoire, et ils peuvent être de types différents.
Lire et modifier les éléments d’une liste
Bonne nouvelle : tout ce qu’on a appris sur les indices des tuples reste vrai pour les listes.
Q2.
Saisir notes = [12, 15, 11, 14] dans la console. Prévoir le résultat de chacune des instructions suivantes, puis vérifier :
Ce qui est nouveau, c’est qu’on peut écrire notes[i] à gauche du signe =. L’élément d’indice i est alors remplacé par une nouvelle valeur. Les opérateurs d’affectation du Doc. 2,2 fonctionnent aussi : notes[1] += 2 ajoute 2 à l’élément d’indice 1.
Q3.
Le professeur décide d’ajouter un point à chaque note. Un élève propose :
Exécuter les deux propositions et afficher notes après chacune d’elles. Laquelle fonctionne ?
Expliquer pourquoi l’autre ne modifie pas la liste.
À retenir
t[i] = valeur remplace l’élément d’indice i de la liste t.
Pour modifier les éléments d’une liste dans une boucle, on parcourt les indices : for i in range(len(t)):. La boucle for element in t: permet de lire les éléments, mais pas de les modifier.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Que vaut len([]) ?
La liste vide ne contient aucun élément.
Question 2 / 3
Après notes = [12, 15, 11, 14] puis la boucle for n in notes: n += 1, que vaut notes ?
À chaque tour, n reçoit la valeur d’un élément ; modifier n ne modifie pas la liste.
Question 3 / 3
Quelle boucle ajoute 1 à chaque élément de la liste t ?
Pour modifier les éléments, on parcourt les indices. Dans la troisième proposition, i prend les valeurs des éléments, qui ne sont pas des indices.
Construire une liste
Une liste de taille fixée à l’avance
L’opérateur * appliqué à une liste et à un entier répète la liste. Ainsi [0] * 6 vaut [0, 0, 0, 0, 0, 0]. On obtient une liste de 6 éléments, qu’on peut ensuite remplir par indice.
Q4.
Recopier et compléter la fonction suivante, qui doit construire la liste des carrés des entiers de 0 à n - 1 :
defcarres(n:int)->list[int]:"""Retourne la liste des carrés des entiers de 0 à n - 1.
>>> carres(5)
[0, 1, 4, 9, 16]
"""resultat=[0]*nforiinrange(n):...returnresultat
Une liste en compréhension
En mathématiques, on décrit parfois un ensemble par une règle plutôt qu’en écrivant tous ses éléments : k2∣k∈0,1,2,3,4 se lit « l’ensemble des k2 pour k appartenant à {0,1,2,3,4} ». Python permet d’écrire une liste de la même façon :
[k*kforkinrange(5)]
Cette expression se lit presque comme la phrase : « la liste des k * k pour k parcourant range(5) ». On dit que la liste est construite en compréhension. Elle remplace les quatre lignes du corps de la fonction carres.
Q5.
Prévoir la liste obtenue pour chacune des expressions suivantes, puis vérifier dans la console :
À quoi sert la partie if k % 3 == 0 dans la dernière expression ?
Q6.
Écrire une liste en compréhension qui donne :
les 10 premiers multiples de 7 : [7, 14, 21, ..., 70] ;
les notes de la liste notes = [12, 15, 8, 14, 6, 17] qui sont inférieures à 10 ;
la liste [True, False, True, False, True, False] qui indique, pour chaque entier de 0 à 5, s’il est pair.
À retenir
On peut construire une liste :
de taille fixée, avec [valeur] * n, puis la remplir par indice ;
en compréhension, avec [expression for element in iterable]. On peut ajouter un filtre : [expression for element in iterable if condition].
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Que vaut [0] * 4 ?
On obtient une liste de 4 éléments, tous égaux à 0, qu’on peut ensuite remplir par indice.
Question 2 / 3
Que vaut [2 * k + 1 for k in range(4)] ?
k prend les valeurs 0, 1, 2 et 3.
Question 3 / 3
Avec notes = [12, 15, 8, 14, 6], que vaut [n for n in notes if n >= 12] ?
Le filtre if ne garde que les éléments pour lesquels la condition est vraie.
Une liste, plusieurs noms
Une surprise
Q7.
Saisir les instructions suivantes dans la console, en prévoyant le résultat de la dernière ligne avant de la valider :
>>>n=[12,18,9]>>>m=n>>>m[0]=0>>>n
Le résultat est-il celui que vous attendiez ?
Ce résultat surprend presque tout le monde la première fois. Pour le comprendre, il faut revenir à ce que fait vraiment une affectation (Doc. 2,2) : une variable référence une valeur. Elle ne contient pas la liste, elle indique où elle se trouve, un peu comme une étiquette collée dessus.
L’instruction m = n ne fabrique donc pas une deuxième liste. Elle colle une deuxième étiquette, m, sur la même liste :
n→
arrow.lm
Quand on écrit m[0] = 0, on modifie cette liste unique. En la regardant par l’étiquette n, on voit forcément la modification. On dit que m et n sont des alias.
Avec les nombres et les tuples, ce phénomène existe aussi, mais il ne se voit jamais : comme on ne peut pas modifier un nombre ou un tuple, on ne peut pas constater que deux étiquettes désignent le même objet. C’est la mutabilité des listes qui le rend visible.
Q8.
Pour obtenir une vraie copie, on peut construire une nouvelle liste en compréhension. Prévoir puis vérifier le contenu de n et de c :
>>>n=[12,18,9]>>>c=[xforxinn]>>>c[0]=0>>>n>>>c
Une fonction peut modifier la liste qu’on lui donne
Lors d’un appel, le paramètre reçoit la valeur de l’argument, exactement comme dans une affectation. Si l’argument est une liste, le paramètre devient donc un alias de cette liste.
Q9.
Recopier les deux fonctions suivantes dans l’éditeur :
Expliquer la différence de comportement entre les deux fonctions.
Effet de bord
Une fonction qui modifie une liste reçue en argument agit sur la liste du programme appelant. On parle d’effet de bord. C’est parfois ce qu’on veut, mais il faut alors l’annoncer clairement dans la documentation de la fonction. Si on ne le veut pas, la fonction doit travailler sur une copie, ou construire et retourner une nouvelle liste.
À retenir
Après m = n, les variables m et n référencent la même liste : ce sont des alias. Toute modification faite par l’une est visible par l’autre.
Pour obtenir une copie indépendante, on construit une nouvelle liste, par exemple [x for x in n].
Une fonction qui reçoit une liste peut la modifier (effet de bord) avec t[i] = .... En revanche, une nouvelle affectation du paramètre (t = ...) ne change pas la liste de l’appelant.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Après n = [12, 18, 9], m = n puis m[0] = 0, que vaut n ?
m et n référencent la même liste : ce sont des alias.
Question 2 / 3
Après n = [12, 18, 9], c = [x for x in n] puis c[0] = 0, que vaut n ?
La compréhension fabrique une nouvelle liste : c est une copie indépendante.
Question 3 / 3
Laquelle de ces fonctions modifie la liste reçue en argument ?
t[0] = 0 modifie la liste partagée avec l’appelant : c’est un effet de bord. La nouvelle affectation t = ... fait seulement référencer une autre liste au paramètre.
Des listes de listes
Les éléments d’une liste peuvent eux-mêmes être des listes. C’est ainsi qu’on représente des valeurs rangées en lignes et en colonnes, comme les cases d’une grille de jeu. En mathématiques, des nombres rangés de cette façon forment une matrice.
m=[[1,2,3],[4,5,6]]
m est une liste de deux éléments : m[0] est la liste [1, 2, 3], qu’on voit comme la première ligne, et m[1] est la liste [4, 5, 6]. Pour atteindre un nombre, on applique deux indices l’un après l’autre : m[1] donne la ligne d’indice 1, puis m[1][2] donne l’élément d’indice 2 de cette ligne.
Q10.
Avec la liste m ci-dessus, prévoir puis vérifier :
Que représentent len(m) et len(m[0]) pour la matrice ?
Q11.
Écrire la fonction somme_matrice dont la spécification est :
defsomme_matrice(m:list[list[int]])->int:"""Retourne la somme de tous les éléments de la matrice m.
>>> somme_matrice([[1, 2, 3], [4, 5, 6]])
21
"""
Indication. Utiliser deux boucles imbriquées : l’une parcourt les indices des lignes, l’autre ceux des colonnes.
Q12.
Dans le Doc. 2,4, la fonction table_multiplication retournait une chaîne de caractères. On veut maintenant une matrice, pour pouvoir retrouver chaque produit par ses indices. Écrire la fonction table_multiplication dont la spécification est :
deftable_multiplication(n:int)->list[list[int]]:"""Retourne la table de multiplication des entiers de 1 à n,
sous forme d'une matrice de n lignes et n colonnes.
>>> table_multiplication(4)
[[1, 2, 3, 4], [2, 4, 6, 8], [3, 6, 9, 12], [4, 8, 12, 16]]
"""
Indication. Une ligne de la table est une liste en compréhension. La table entière est une liste de lignes, elle aussi en compréhension.
Avec t = table_multiplication(10), que vaut t[6][7] ? Quel produit cet élément représente-t-il ?
Un piège classique
Pour fabriquer une grille de 3 lignes et 3 colonnes remplie de zéros, l’écriture [[0] * 3] * 3 semble naturelle. Pourtant :
Le * 3 extérieur ne fabrique pas trois lignes : il place trois fois la même ligne dans la liste. Les trois lignes sont des alias. La bonne écriture fabrique une nouvelle ligne à chaque tour :
>>>g=[[0]*3foriinrange(3)]
À retenir
Une liste de listes permet de représenter une matrice, c’est-à-dire des valeurs rangées en lignes et en colonnes. m[i] est la ligne d’indice i, et m[i][j] l’élément de la ligne i et de la colonne j.
len(m) donne le nombre de lignes et len(m[0]) le nombre de colonnes. On parcourt une matrice avec deux boucles imbriquées.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Avec m = [[1, 2, 3], [4, 5, 6]], que vaut m[1][0] ?
m[1] est la ligne [4, 5, 6], et l’élément d’indice 0 de cette ligne vaut 4.
Question 2 / 3
Avec la même matrice m, que valent len(m) et len(m[0]) ?
len(m) est le nombre de lignes, len(m[0]) le nombre de colonnes.
Question 3 / 3
Après g = [[0] * 2] * 2 puis g[0][0] = 5, que vaut g ?
Le * 2 extérieur place deux fois la même ligne dans la liste. Il faut écrire [[0] * 2 for i in range(2)].
Exercices de synthèse
Consigne
Écrire chaque fonction dans la partie principale de l’éditeur, avec sa spécification complète (signature et documentation). Tester ensuite chacun des exemples de la documentation dans la console. Les fonctions sum, min, max et la méthode index de Python ne doivent pas être utilisées.
Q13.
Moyenne. Écrire la fonction moyenne dont la spécification est :
defmoyenne(notes:list[float])->float:"""Retourne la moyenne des éléments de notes, qui ne doit pas être vide.
>>> moyenne([12, 15, 9, 14])
12.5
"""
Vérifier la précondition à l’aide d’une assertion (voir Doc. 3,1).
Q14.
Recherche d’une valeur. Écrire la fonction indice dont la spécification est :
defindice(valeurs:list[int],cherchee:int)->int:"""Retourne l'indice de la première occurrence de cherchee dans
valeurs, ou -1 si cherchee n'est pas dans valeurs.
>>> indice([4, 8, 15, 16, 23, 42], 16)
3
>>> indice([4, 8, 15, 16, 23, 42], 7)
-1
>>> indice([5, 3, 5], 5)
0
"""
Dans le pire des cas, combien de comparaisons la fonction effectue-t-elle pour une liste de 1000 éléments ? Et pour une liste deux fois plus longue ?
Q15.
Statistiques d’un devoir. On veut écrire la fonction statistiques dont la spécification est :
defstatistiques(notes:list[float])->tuple[float,int,int,int]:"""Retourne un tuple (m, bas, milieu, haut) où m est la moyenne
des notes, bas le nombre de notes strictement inférieures à m - 3,
milieu le nombre de notes comprises entre m - 3 et m + 3 (bornes
incluses), haut le nombre de notes strictement supérieures à m + 3.
>>> statistiques([12, 15, 8, 14, 6, 17])
(12.0, 2, 3, 1)
>>> statistiques([10, 7, 13])
(10.0, 0, 3, 0)
"""
Vérifier à la main le premier exemple de la documentation.
Écrire la fonction, en utilisant la fonction moyenne de la question précédente.
Un élève propose de compter les notes de chaque groupe avec une fonction qui compte les valeurs comprises dans un intervalle [a;b], bornes incluses, appelée trois fois : sur [0;m−3], sur [m−3;m+3] et sur [m+3;20]. Le deuxième exemple de la documentation montre pourquoi cette idée donne un résultat faux. Expliquer.
Q16.
Tirage du Loto sans répétition. Dans le Doc. 2,4, la fonction loto_naif pouvait tirer deux fois le même numéro, faute de pouvoir mémoriser les numéros déjà sortis. Une liste résout ce problème. Écrire la fonction loto dont la spécification est :
defloto()->list[int]:"""Retourne une liste de 6 entiers différents, tirés au hasard
entre 1 et 49 (bornes incluses).
"""
Indication. Partir de la liste [0] * 6. Tirer un numéro avec random.randint(1, 49). S’il n’est pas déjà dans la liste, le ranger à la première place libre. Le nombre de tirages nécessaires n’est pas connu à l’avance : quelle boucle faut-il utiliser ?
Pour aller plus loin
Q17.
Transposée d’une matrice. La transposée d’une matrice s’obtient en échangeant ses lignes et ses colonnes : la première ligne devient la première colonne, et ainsi de suite. Écrire, en une seule ligne de code, la fonction transposee dont la spécification est :
deftransposee(m:list[list[int]])->list[list[int]]:"""Retourne la transposée de la matrice m.
>>> transposee([[1, 2, 3], [4, 5, 6]])
[[1, 4], [2, 5], [3, 6]]
"""
Bilan
À l’issue de cette activité, je sais…
expliquer la différence entre une liste, mutable, et un tuple, non mutable ;
lire et modifier un élément d’une liste grâce à son indice ;
parcourir une liste par ses éléments pour la lire, et par ses indices pour la modifier ;
construire une liste de taille fixée avec [valeur] * n ;
construire une liste en compréhension, avec ou sans filtre if ;
expliquer pourquoi, après m = n, une modification de m est visible dans n, et faire une vraie copie d’une liste ;
prévoir si une fonction modifie la liste qu’elle reçoit en argument ;
représenter une matrice par une liste de listes et utiliser la notation m[i][j] ;
écrire un algorithme de recherche d’une valeur, de calcul d’une moyenne, sur une liste.
Physique, Chimie et Informatique > 1ère Spécialité NSI > Premières structures de données : listes et tuples
Faire grandir et rétrécir une liste en lui envoyant des messages, en particulier append et pop, et savoir si un message modifie la liste ou renvoie une valeur.
Q14.
On veut noter la liste des courses au fur et à mesure qu’on y pense. Au départ, on n’a pensé à rien : la liste est vide. Prévoir ce qui se passe lorsqu’on saisit les deux instructions suivantes dans la console, puis vérifier :
>>>courses=[]>>>courses[0]="pain"
Dans le Doc. 3,2, on contournait la difficulté en fabriquant d’abord une liste de la bonne taille, par exemple [0] * 6, puis en la remplissant. Cela suppose de connaître la taille à l’avance. Pour une liste de courses, ce n’est pas le cas : on ne sait pas combien de choses on va y écrire. Il faut un moyen de dire à la liste « ajoute cet élément au bout ».
Envoyer un message à une liste
Objets, messages et méthodes
En Python, chaque valeur est un objet : un nombre, une chaîne de caractères, un tuple, une liste. Pour l’instant, retenons qu’un objet regroupe des données et des actions qu’il sait effectuer sur ces données. Les objets seront étudiés en détail en terminale. Ici, on apprend seulement à s’en servir : pour demander à un objet d’effectuer l’une de ses actions, on lui envoie un message. On écrit le nom de l’objet, un point, puis le message suivi de parenthèses :
courses.append("pain")
Cette instruction se lit : « on envoie à la liste courses le message append (ajouter, en anglais), avec l’argument "pain" ». La liste reçoit le message et réagit : elle place "pain" à sa fin. La façon dont un objet réagit à un message s’appelle une méthode. On dit indifféremment « envoyer le message append » ou « appeler la méthode append ».
Ce n’est pas la première fois que vous envoyez un message. Dans le Doc. 2,2, l’écriture "...{}...".format(...) envoyait le message format à une chaîne de caractères.
Comparons avec une fonction. Pour connaître la longueur d’une liste, on écrit len(courses) : on donne la liste à la fonction len, qui l’examine. Avec courses.append("pain"), on s’adresse à la liste elle-même, et c’est elle qui se modifie.
Q15.
Saisir les instructions suivantes dans la console, en prévoyant le résultat de chaque ligne avant de la valider :
À quel indice se trouve l’élément qu’on vient d’ajouter avec append ? Exprimer cet indice à l’aide de len(courses).
À retenir
En Python, une liste est un objet. On lui envoie un message avec la notation pointée : liste.message(arguments). La façon dont l’objet réagit au message s’appelle une méthode.
t.append(x) ajoute l’élément x à la fin de la liste t. La liste est modifiée, sa longueur augmente de 1. Cela fonctionne aussi à partir de la liste vide [].
Construire une liste en partant de la liste vide
La méthode append permet une façon de construire une liste qu’on utilisera très souvent : partir de la liste vide, puis ajouter les éléments un par un, au fil d’une boucle.
Exemple résolu
On veut la liste des multiples de k compris entre 1 et n.
defmultiples(n:int,k:int)->list[int]:"""Retourne la liste des multiples de k compris entre 1 et n.
>>> multiples(20, 3)
[3, 6, 9, 12, 15, 18]
"""resultat=[]# 1. on part de la liste videforiinrange(1,n+1):# 2. on examine chaque entier de 1 à nifi%k==0:# 3. s'il convient...resultat.append(i)# ... on l'ajoute au bout de la listereturnresultat# 4. on retourne la liste construite
Suivons l’appel multiples(20, 3). Au départ, resultat vaut []. Pour i égal à 1 et 2, le test est faux : rien ne se passe. Pour i égal à 3, le test est vrai : la liste devient [3]. Elle devient [3, 6] au tour où i vaut 6, et ainsi de suite. On n’a jamais eu besoin de savoir combien de multiples on allait trouver : la liste grandit d’elle-même.
Q16.
En suivant la même méthode, écrire la fonction diviseurs dont la spécification est :
defdiviseurs(n:int)->list[int]:"""Retourne la liste des diviseurs de l'entier n, avec n >= 1,
rangés dans l'ordre croissant.
>>> diviseurs(12)
[1, 2, 3, 4, 6, 12]
>>> diviseurs(7)
[1, 7]
"""
Pourquoi la méthode [0] * taille du Doc. 3,2 serait-elle mal adaptée ici ?
Q17.
Retour sur le Loto. Dans le Doc. 3,2, la fonction loto partait de [0] * 6 et utilisait une variable nbre_tirees pour savoir où ranger le prochain numéro. Réécrire cette fonction en partant de la liste vide et en utilisant append :
defloto()->list[int]:"""Retourne une liste de 6 entiers différents, tirés au hasard
entre 1 et 49 (bornes incluses).
"""
Quelle variable de l’ancienne version devient inutile ? Par quoi est-elle remplacée ?
Coups de pouce
On ne sait pas combien de tirages il faudra, puisqu’un numéro déjà sorti est rejeté. La boucle reste donc une boucle while.
La boucle doit s’arrêter quand la liste contient 6 numéros. Quelle expression donne le nombre de numéros déjà rangés ?
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Après t = [], t.append(4) puis t.append(9), que vaut t ?
append ajoute chaque élément à la fin de la liste.
Question 2 / 3
Que représente l’écriture t.append(x) ?
C’est la notation pointée : objet.message(arguments). La liste t elle-même est modifiée.
Question 3 / 3
Pour construire la liste des diviseurs de n en partant de [], quelle instruction faut-il placer dans la boucle, quand d divise n ?
On ajoute d à la fin de la liste. La deuxième proposition remplacerait la liste par None ; la troisième provoquerait une erreur IndexError, car la liste est trop courte.
Retirer un élément : le message pop
Le message pop fait l’inverse de append : il retire un élément de la liste. Mais il fait aussi autre chose, que l’on va découvrir.
Q18.
Saisir les instructions suivantes dans la console, en prévoyant le résultat de chaque ligne avant de la valider :
Quel élément pop() retire-t-il lorsqu’on ne lui donne pas d’argument ? Et pop(0) ?
Contrairement à append, la ligne pile.pop() affiche quelque chose. Que représente ce qui est affiché ?
Pourquoi la dernière ligne provoque-t-elle une erreur ?
À retenir
t.pop() retire le dernier élément de la liste t et le renvoie. t.pop(i) retire l’élément d’indice i et le renvoie. Dans les deux cas, la longueur de la liste diminue de 1.
Envoyer pop à une liste vide provoque l’erreur IndexError. Avant un pop, il faut donc s’assurer que la liste n’est pas vide, par exemple avec len(t) > 0.
Les deux messages append et pop() agissent sur la fin de la liste. Utilisés ensemble, ils font de la liste une pile d’assiettes : on pose une assiette sur le dessus, on reprend toujours celle du dessus. C’est exactement ce que fait la commande « Annuler » d’un traitement de texte. Chaque action est ajoutée au bout d’un historique. Annuler, c’est retirer la dernière action effectuée.
Q19.
Sans exécuter le programme, prévoir les affichages du programme suivant. Écrire le contenu de la liste historique après chaque ligne qui la modifie. Vérifier ensuite.
historique=[]historique.append("écrire Bonjour")historique.append("mettre en gras")historique.append("écrire Monde")derniere=historique.pop()print("Annulé :",derniere)historique.append("souligner")derniere=historique.pop()print("Annulé :",derniere)derniere=historique.pop()print("Annulé :",derniere)print(historique)
Q20.
Un élève veut écrire une fonction qui retourne les éléments d’une liste dans l’ordre inverse. Il a l’idée de vider la liste avec pop(), en ajoutant au fur et à mesure chaque élément retiré dans une nouvelle liste :
definverser(t:list[int])->list[int]:"""Retourne une nouvelle liste formée des éléments de t
pris dans l'ordre inverse.
>>> inverser([12, 15, 9, 14])
[14, 9, 15, 12]
"""resultat=[]whilelen(t)>0:resultat.append(t.pop())returnresultat
Recopier la fonction, puis saisir dans la console :
La fonction retourne-t-elle le bon résultat ? Quel autre effet a-t-elle ?
Expliquer cet effet à l’aide du Doc. 3,2.
Corriger la fonction pour que la liste reçue en argument ne soit pas modifiée, en conservant l’idée de l’élève.
Coups de pouce
Au moment de l’appel inverser(releve), combien de listes existent en mémoire ? Combien de noms les référencent ?
Le message pop modifie la liste qui le reçoit. Sur quelle liste faudrait-il l’envoyer pour que releve ne soit pas touchée ?
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Après pile = [3, 7, 12, 5] puis x = pile.pop(), que valent x et pile ?
Sans argument, pop retire le dernier élément et le renvoie.
Question 2 / 3
Après t = [3, 7, 12] puis t.pop(0), que vaut t ?
pop(0) retire l’élément d’indice 0, c’est-à-dire le premier.
Question 3 / 3
Que produit [].pop() ?
On ne peut rien retirer d’une liste vide : il faut le vérifier avant, par exemple avec len(t) > 0.
Un message qui modifie la liste ne renvoie rien
Q21.
Une élève veut ajouter le lait à sa liste de courses. Elle écrit :
Que renvoie le message append ? Et le message sort ?
Expliquer, étape par étape, ce qui s’est passé lors de l’instruction courses = courses.append("lait").
Comment fallait-il écrire cette instruction ?
Cette erreur est l’une des plus fréquentes chez les débutants, et chez les autres. Elle vient d’une confusion entre deux sortes de messages. Certains messages, comme append ou sort, modifient la liste et renvoient None. D’autres, comme pop, modifient la liste et renvoient une valeur utile. Il en existe enfin qui ne modifient rien et se contentent de renvoyer une information sur la liste, comme on va le voir dans la partie 4.
Puisque append modifie la liste elle-même, tous les alias de cette liste voient la modification. L’opérateur +, qui met deux listes bout à bout, se comporte autrement.
Q22.
Prévoir, puis vérifier, le contenu de n et de m à la fin de chacune des deux séquences :
>>>n=[1,2,3]>>>m=n>>>m.append(4)>>>n>>>m
>>>n=[1,2,3]>>>m=n>>>m=m+[4]>>>n>>>m
Expliquer la différence.
À retenir
Un message qui modifie la liste, comme append ou sort, renvoie None. On l’écrit seul sur sa ligne, sans affectation : t.append(x) et jamais t = t.append(x).
pop modifie la liste et renvoie l’élément retiré, qu’on peut ranger dans une variable : x = t.pop().
Un message envoyé à une liste agit sur la liste elle-même : tous ses alias voient la modification. L’expression t + [x], elle, fabrique une nouvelle liste.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Après courses = ["pain"] puis courses = courses.append("lait"), que vaut courses ?
append modifie la liste puis renvoie None, et c’est cette valeur qui est affectée à courses.
Question 2 / 3
Après n = [1, 2, 3], m = n puis m.append(4), que vaut n ?
m et n sont des alias : le message modifie la liste unique qu’ils référencent.
Question 3 / 3
Après n = [1, 2, 3], m = n puis m = m + [4], que vaut n ?
m + [4] fabrique une nouvelle liste, que l’on affecte à m. La liste référencée par n n’est pas touchée.
D’autres messages
Une liste comprend d’autres messages que append et pop. La commande help(list), dans la console, en donne la liste complète, en anglais. En voici quelques-uns, traduits :
Message
Effet
Renvoie
t.insert(i, x)
insère x juste avant l’élément d’indice i
None
t.remove(x)
retire la première occurrence de x ; erreur ValueError si x est absent
None
t.index(x)
ne modifie pas la liste ; erreur ValueError si x est absent
l’indice de la première occurrence de x
t.count(x)
ne modifie pas la liste
le nombre d’occurrences de x
t.reverse()
renverse l’ordre des éléments
None
t.sort()
range les éléments dans l’ordre croissant
None
t.copy()
ne modifie pas la liste
une nouvelle liste, copie de t
Q23.
À l’aide de ces descriptions, et sans exécuter les instructions, prévoir le résultat de chaque ligne. Indiquer pour chacune si la liste t est modifiée. Vérifier ensuite dans la console.
Dans la question sur la fonction inverser, on aurait pu écrire copie = t.copy() à la place de copie = [x for x in t]. Les deux instructions fabriquent une nouvelle liste contenant les mêmes éléments.
À retenir
Avant d’utiliser un message, il faut savoir répondre à deux questions : modifie-t-il la liste ? que renvoie-t-il ?
insert, remove, reverse et sort modifient la liste et renvoient None. pop la modifie et renvoie l’élément retiré. index, count et copy ne la modifient pas et renvoient une information ou une nouvelle liste.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Après t = [5, 8, 2, 8] puis t.remove(8), que vaut t ?
remove retire la première occurrence de la valeur.
Question 2 / 3 (plusieurs réponses possibles)
Quels messages modifient la liste qui les reçoit ?
insert et sort modifient la liste et renvoient None. index et count renvoient une information sans modifier la liste.
Question 3 / 3
Avec t = [5, 10, 2, 8], que vaut t.index(2) ?
index renvoie l’indice de la première occurrence de la valeur : 2 se trouve à l’indice 2.
Exercices de synthèse
Consigne
Écrire chaque fonction dans la partie principale de l’éditeur, avec sa spécification complète (signature et documentation). Tester ensuite chacun des exemples de la documentation dans la console. Aucune de ces fonctions ne doit modifier la liste qu’elle reçoit en argument.
Q24.
Sans doublons. Écrire la fonction sans_doublons dont la spécification est :
defsans_doublons(t:list[int])->list[int]:"""Retourne une nouvelle liste contenant les éléments de t,
chacun une seule fois, dans l'ordre de leur première apparition.
>>> sans_doublons([3, 1, 3, 2, 1])
[3, 1, 2]
>>> sans_doublons([])
[]
"""
Pourquoi ne peut-on pas obtenir ce résultat simplement avec une liste en compréhension filtrée par if x not in t ?
Q25.
Pairs et impairs. Écrire la fonction separer dont la spécification est :
defseparer(valeurs:list[int])->tuple[list[int],list[int]]:"""Retourne un tuple (pairs, impairs) : pairs est la liste des
éléments pairs de valeurs, impairs celle des éléments impairs,
dans l'ordre où ils apparaissent dans valeurs.
>>> separer([4, 7, 10, 3, 8])
([4, 10, 8], [7, 3])
"""
Tester ensuite, dans la console, l’affectation multiple p, i = separer([4, 7, 10, 3, 8]) (Doc. 3,1).
Pour aller plus loin
Q26.
Une file d’attente. À un guichet, les clients sont servis dans leur ordre d’arrivée : le premier arrivé est le premier servi. On décrit une matinée par une liste d’événements. Un prénom signale l’arrivée d’un client, qui se place au bout de la file. Le caractère "*" signale que le guichetier sert un client : celui qui attend depuis le plus longtemps.
defguichet(evenements:list[str])->tuple[list[str],list[str]]:"""Retourne un tuple (servis, en_attente) : servis est la liste
des clients servis, dans l'ordre où ils l'ont été, en_attente
celle des clients qui attendent encore à la fin.
On suppose que la file n'est jamais vide quand "*" survient.
>>> guichet(["Ana", "Bilal", "*", "Chloé", "Dylan", "*"])
(['Ana', 'Bilal'], ['Chloé', 'Dylan'])
"""
Écrire la fonction guichet.
Un élève a écrit pop() au lieu de pop(0). Sans exécuter son programme, prévoir ce que renvoie l’appel de la documentation. Pourquoi les clients ont-ils raison de se plaindre ?
Coups de pouce
La file est une liste qui part vide. Que faut-il lui envoyer quand un client arrive ?
Le client servi est celui qui est arrivé le premier. À quel indice de la file se trouve-t-il ?
Le client servi doit à la fois quitter la file et rejoindre la liste servis. Un seul message renvoie l’élément qu’il retire.
Bilan
À l’issue de cette activité, je sais…
expliquer la différence entre appeler une fonction, comme len(t), et envoyer un message à une liste, comme t.append(x) ;
construire une liste en partant de la liste vide et en ajoutant ses éléments avec append dans une boucle ;
retirer le dernier élément d’une liste, ou celui d’indice i, avec pop, et utiliser l’élément renvoyé ;
éviter d’envoyer pop à une liste vide ;
dire, pour un message donné, s’il modifie la liste et ce qu’il renvoie, et ne jamais écrire t = t.append(x) ;
prévoir l’effet d’un message envoyé à une liste qui a plusieurs alias, notamment lorsqu’elle est passée en argument à une fonction ;
utiliser une liste comme une pile (append et pop()) ou comme une file (append et pop(0)).
Physique, Chimie et Informatique > 1ère Spécialité NSI > Premières structures de données : listes et tuples
Construire pas à pas avec Pyxel la simulation d’un gaz : chaque particule est un tuple, le gaz est une liste de tuples passée en paramètre aux fonctions.
Q24.
Sur un billard, une bille frappe la bande de droite. Le schéma montre sa vitesse juste avant le choc.
Dessiner la flèche de sa vitesse juste après le choc. Lequel des deux mouvements, horizontal ou vertical, est modifié par le choc ?
Dans un gaz, les particules avancent en ligne droite et rebondissent sur les parois comme la bille sur la bande. Le programme de départ est fourni dans Capytale. Quand une question commence par « Sans exécuter le programme », on écrit sa réponse avant de vérifier.
Une particule décrite par un tuple
Une particule est décrite par cinq entiers, rangés dans un tuple, toujours dans le même ordre :
indice
0
1
2
3
4
élément
x
y
vx
vy
couleur
x et y sont les coordonnées du centre, en pixels. vx et vy sont les nombres de pixels parcourus horizontalement et verticalement à chaque image. Un écran n’a pas de demi-pixel : toutes ces valeurs sont des entiers.
importpyxel# ConstantesLARGEUR=160# largeur de la fenêtre, en pixelsHAUTEUR=120# hauteur de la fenêtre, en pixelsRAYON=3# rayon d'une particule, en pixels# Type d'une particule : (x, y, vx, vy, couleur)Particule=tuple[int,int,int,int,int]defdessiner_particule(p:Particule)->None:"""Dessine la particule p = (x, y, vx, vy, couleur)."""x,y,couleur=p[0],p[1],p[4]pyxel.circ(x,y,RAYON,couleur)defupdate(gaz:list[Particule])->None:"""Fait avancer le gaz d'une image."""passdefdraw(gaz:list[Particule])->None:"""Dessine les particules du gaz."""pyxel.cls(0)dessiner_particule(gaz[0])# Programme principalpyxel.init(LARGEUR,HAUTEUR,title="Gaz parfait")particules=[(36,60,2,-1,8)]# le gaz : une seule particule pour l'instantpyxel.run(lambda:update(particules),lambda:draw(particules))
La ligne Particule = tuple[...] donne un nom au type d’une particule, que l’on utilise dans les annotations des fonctions.
pyxel.run attend deux fonctions sans paramètre. lambda: update(particules) est justement une fonction sans paramètre, écrite sur une ligne : à chaque image, elle appelle update en lui passant la liste particules.
Règle de ce programme
Une fonction peut lire les constantes, écrites en majuscules (LARGEUR, RAYON…), car leur valeur ne change jamais. Elle ne lit aucune autre variable du programme principal : la liste des particules lui est toujours passée en paramètre.
Q25.
Lancer le programme. Avec particules = [(36, 60, 2, -1, 8)] :
que vaut particules[0][2] ? Quelle grandeur représente-t-il ?
que faut-il écrire pour obtenir la couleur de la particule ?
la particule va-t-elle monter ou descendre quand elle bougera ? Justifier à l’aide du repère de Pyxel (Doc. 2,5).
Q26.
Modifier particules pour obtenir une particule verte (couleur 11), au centre de l’écran, qui se déplacera vers la gauche de 1 pixel par image. Vérifier, puis revenir à la valeur de départ.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Une particule est décrite par le tuple (x, y, vx, vy, couleur). Avec particules = [(36, 60, 2, -1, 8)], que vaut particules[0][1] ?
particules[0] est le tuple de la particule, et son élément d’indice 1 est l’ordonnée y.
Question 2 / 3
Dans Pyxel, une particule a vy = -1. Comment se déplace-t-elle verticalement ?
Dans Pyxel, y augmente vers le bas : diminuer y fait monter la particule.
Question 3 / 3
D’après la règle du programme, quelles variables une fonction peut-elle lire sans les recevoir en paramètre ?
La valeur des constantes ne change jamais ; la liste des particules, elle, est toujours passée en paramètre.
Faire avancer la particule
Pyxel affiche 30 images par seconde et appelle update(particules) avant chaque image. À chaque appel, on ajoute vx à x et vy à y.
Q27.
Sans exécuter le programme. La particule part de x=36 avec vx = 2. Elle touche le bord droit quand son centre atteint x=159−3=156. Au bout de combien de temps ?
Sans exécuter le programme, prévoir ce qui se passe si on appelle deplacer(particules[0]). Expliquer.
La fonction doit donc fabriquer un nouveau tuple et le retourner. Pour récupérer d’un coup les cinq éléments de p, on le déballe :
x,y,vx,vy,couleur=p# x reçoit p[0], y reçoit p[1], etc.
Il faut autant de noms à gauche que d’éléments dans le tuple.
Q29.
Écrire la fonction deplacer :
defdeplacer(p:Particule)->Particule:"""Retourne la particule p après une image de déplacement."""
Tester dans la console : deplacer((36, 60, 2, -1, 8)) doit retourner (38, 59, 2, -1, 8).
Q30.
Dans update, remplacer pass par gaz[0] = deplacer(gaz[0]). Sans exécuter le programme, prévoir ce qui se passera au bout de 2 secondes, puis vérifier.
Q31.
Un autre élève écrit dans update : gaz = [deplacer(gaz[0])]. Il n’obtient aucune erreur, mais la particule reste immobile. Expliquer, en s’aidant des fonctions reinitialiser_1 et reinitialiser_2 du Doc. 3,2.
?Vérifier ses acquis4 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 4
Que produit deplacer(particules[0]) si la fonction contient l’instruction p[0] = p[0] + p[2] ?
On ne peut pas modifier un élément d’un tuple : la fonction doit fabriquer et retourner un nouveau tuple.
Question 2 / 4
Que retourne deplacer((36, 60, 2, -1, 8)) ?
On ajoute vx à x et vy à y : 36+2=38 et 60−1=59. La vitesse et la couleur sont inchangées.
Question 3 / 4
Dans update(gaz), laquelle de ces instructions fait réellement avancer la particule de la liste particules ?
gaz[0] = ... modifie un élément de la liste partagée avec le programme principal. gaz = [...] fait seulement référencer une nouvelle liste par la variable locale gaz.
Question 4 / 4
À 30 images par seconde, une particule avance de 2 pixels par image. Combien de temps met-elle à parcourir 120 pixels ?
Sa vitesse vaut 2×30=60 px/s, d’où t=60120=2 s.
Rebondir contre les murs
Comme sur le billard, quand la particule touche le mur de droite, vx devient -vx. On complète deplacer : elle change d’abord la vitesse si un mur est touché, puis fait avancer la particule. Première version, qui ne traite que le mur de droite :
defdeplacer(p:Particule)->Particule:"""Retourne la particule p après une image : sa vitesse change
si elle touche un mur, puis elle avance."""x,y,vx,vy,couleur=pifx+RAYON>=LARGEUR-1:# le bord droit du disque touche le murvx=-vxreturn(x+vx,y+vy,vx,vy,couleur)
Q32.
Compléter deplacer pour les murs de gauche, du haut et du bas, puis tester.
Coups de pouce
Pour les murs du haut et du bas, quelle composante de la vitesse change de signe ?
Le mur du haut est la ligne y=0. Quel point du disque l’atteint en premier ?
Q33.
Sans ordinateur. On part de particules = [(158, 60, 1, 0, 8)]. Compléter le tableau avec les valeurs de x et vx après chaque appel de update. Que fait la particule ? Vérifier à l’écran.
image
départ
1
2
3
4
x
158
vx
1
Q34.
Modifier les quatre conditions pour qu’une particule ne rebondisse que si elle se dirige vers le mur qu’elle touche. Refaire le tableau sans ordinateur, puis vérifier.
À retenir
Un tuple n’est pas mutable : une fonction qui « modifie » une particule fabrique et retourne un nouveau tuple. Le déballage x, y, vx, vy, couleur = p donne un nom à chaque élément.
Lors d’un rebond sur une paroi, la composante de la vitesse perpendiculaire à la paroi change de signe.
Une fonction qui reçoit une liste en paramètre peut modifier ses éléments (gaz[0] = ...). Si elle affecte une nouvelle valeur au paramètre (gaz = ...), la liste d’origine ne change pas.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Une particule touche le mur du haut. Quelle composante de sa vitesse change de signe ?
Lors d’un rebond, la composante de la vitesse perpendiculaire à la paroi change de signe. Le mur du haut est horizontal.
Question 2 / 3
Le disque a un rayon RAYON. Quelle condition indique qu’il touche le mur de gauche, d’abscisse 0 ?
Le point du disque le plus à gauche a pour abscisse x - RAYON : c’est lui qui atteint le mur en premier.
Question 3 / 3
Pourquoi ajoute-t-on la condition vx > 0 au test du mur de droite ?
Sans elle, une particule qui vient de rebondir et touche encore le mur voit sa vitesse inversée une seconde fois : elle reste coincée contre la paroi.
Un gaz : une liste de particules
On veut maintenant 30 particules, tirées au hasard. pyxel.rndi(a, b) retourne un entier au hasard entre a et b, bornes comprises. Ajouter ces constantes au début du programme (8, 11 et 12 sont le rouge, le vert et le bleu) :
NB_PARTICULES=30# nombre de particules du gazVITESSE_MAX=2# valeur maximale d'une composante de la vitesseCOULEURS=(8,11,12)# couleurs possibles
Q35.
Écrire la fonction nouvelle_particule, puis la tester plusieurs fois dans la console :
defnouvelle_particule()->Particule:"""Retourne une particule entièrement visible, tirée au hasard.
Chaque composante de la vitesse est comprise entre -VITESSE_MAX
et VITESSE_MAX. La couleur est l'un des éléments de COULEURS."""
Coups de pouce
Un disque est entièrement visible si son centre est à au moins RAYON pixels de chaque bord (Doc. 2,5).
Pour la couleur, tirer au hasard l’indice d’un élément de COULEURS.
Q36.
Dans le programme principal, remplacer particules = [(36, 60, 2, -1, 8)] par une liste de NB_PARTICULES particules construite en compréhension (Doc. 3,2). Pourquoi cette ligne doit-elle se trouver après la définition de nouvelle_particule ?
Q37.
Modifier draw pour dessiner toutes les particules de gaz.
Pour faire bouger toutes les particules, un élève écrit :
Sans exécuter le programme, prévoir ce qu’on observe. Expliquer, puis corriger.
À retenir
Le gaz est une liste de tuples, construite en compréhension. Pour lire ses éléments, on la parcourt par éléments. Pour les remplacer, on la parcourt par indices : gaz[i] = ....
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Quelle instruction construit une liste de NB_PARTICULES particules tirées au hasard ?
La compréhension appelle la fonction à chaque tour. La deuxième écriture répète NB_PARTICULES fois la même particule ; la troisième répète les éléments d’un seul tuple.
Question 2 / 3
Que se passe-t-il avec la boucle for p in gaz: p = deplacer(p) ?
p = ... fait référencer un nouveau tuple par la variable p, mais rien n’est rangé dans la liste. Il faut parcourir les indices : gaz[i] = deplacer(gaz[i]).
Question 3 / 3
Pour dessiner toutes les particules dans draw, quel parcours suffit ?
On ne modifie pas la liste : lire ses éléments un par un suffit.
Pour aller plus loin : des collisions entre particules
Dans un gaz réel, les particules se heurtent aussi entre elles. Deux particules se touchent si la distance entre leurs centres est inférieure ou égale à 2 * RAYON.
Q39.
Ajouter from math import sqrt au début du programme, puis écrire :
defdistance(p1:Particule,p2:Particule)->float:"""Retourne la distance entre les centres de p1 et p2."""defse_touchent(p1:Particule,p2:Particule)->bool:"""Retourne True si p1 et p2 se touchent, False sinon."""
Deux particules de même masse qui se heurtent de face échangent leurs vitesses. On adopte ce modèle pour toutes les collisions.
Q40.
Écrire la fonction choc :
defchoc(p1:Particule,p2:Particule)->tuple[Particule,Particule]:"""Retourne les particules p1 et p2 après leur collision :
elles ont échangé leurs vitesses."""
Voici la fonction qui teste toutes les paires de particules de la liste gaz. Sa dernière ligne déballe le tuple retourné par choc, comme a, b = b, a (Doc. 3,1).
defgerer_chocs(gaz:list[Particule])->None:"""Fait échanger leurs vitesses aux particules de gaz qui se touchent."""foriinrange(len(gaz)):forjinrange(i+1,len(gaz)):p1=gaz[i]p2=gaz[j]ifse_touchent(p1,p2):gaz[i],gaz[j]=choc(p1,p2)
Q41.
Avec 3 particules, écrire tous les couples (i, j) testés.
Pourquoi la boucle intérieure commence-t-elle à i + 1 et non à 0 ?
Q42.
Ajouter l’appel gerer_chocs(gaz) à la fin de update. Observer longuement : certaines particules restent collées. Pourquoi ? Corriger, en s’inspirant de la correction des rebonds sur les murs.
Coups de pouce
Que fait gerer_chocs à l’image qui suit un échange de vitesses ?
Sur le mur, on n’a fait rebondir que les particules qui s’en approchaient. Comment savoir si deux particules se rapprochent ? On peut utiliser deplacer et distance.
Il reste un défaut : des particules rapides se traversent parfois.
Q43.
Sans ordinateur. Deux particules arrivent de face, en diagonale : (50, 50, 2, 2, 8) et (56, 56, -2, -2, 12). À chaque image, update les déplace, puis appelle gerer_chocs. Compléter le tableau (distances arrondies au dixième), puis expliquer pourquoi les particules se traversent.
image
départ
1
2
3
particule 1
(50, 50)
particule 2
(56, 56)
distance
8,5
se_touchent
non
se_rapprochent
oui
Pour éviter ce chevauchement, il faut anticiper : avant de déplacer les particules, on regarde si elles vont se toucher à l’image suivante.
Q44.
Modifier la condition de gerer_chocs pour tester si les particules se toucheront après leur déplacement, puis placer l’appel gerer_chocs(gaz) au début de update. Refaire le tableau précédent, puis vérifier à l’écran que les particules ne se traversent presque plus.
?Vérifier ses acquis3 questions
Répondez aux questions une par une ; le résultat s'affiche à la fin. Recommencez jusqu'à obtenir 100 % : vous pouvez aussi afficher les réponses, mais vous ne pourrez alors plus retenter ce QCM.
Question 1 / 3
Avec 4 particules, combien de couples (i, j) la double boucle for i in range(n): for j in range(i + 1, n): teste-t-elle ?
(0, 1), (0, 2), (0, 3), (1, 2), (1, 3) et (2, 3) : chaque paire n’est testée qu’une fois.
Question 2 / 3
Pourquoi la boucle intérieure commence-t-elle à i + 1 et non à 0 ?
En partant de 0, on testerait (0, 1) puis (1, 0). Il faut aussi éviter de tester une particule avec elle-même.
Les particules échangent leurs vitesses ; elles gardent leur position et leur couleur.
Défis
Q45.
Défi A : le mélange de deux gaz. Au départ, les particules rouges sont dans la moitié gauche de la boîte, les bleues dans la moitié droite. Donner à nouvelle_particule les paramètres couleur, x_min et x_max, puis construire la liste. Comparer la vitesse du mélange avec et sans collisions.
Q46.
Défi B : chauffer le gaz. Chaque appui sur la touche ↑ double les deux composantes de la vitesse de toutes les particules. Que se passe-t-il après plusieurs appuis ?
Bilan
À l’issue de cette activité, je sais…
représenter un objet par un tuple et lire un élément par son indice ;
expliquer pourquoi on ne peut pas modifier un élément d’un tuple, et écrire une fonction qui retourne un nouveau tuple ;
déballer un tuple pour nommer ses éléments ;
construire une liste de tuples en compréhension ;
choisir entre un parcours par éléments, pour lire une liste, et un parcours par indices, pour la modifier ;
passer une liste en paramètre à une fonction, et expliquer pourquoi la fonction peut modifier ses éléments mais pas la remplacer ;
parcourir toutes les paires d’éléments d’une liste avec deux boucles imbriquées ;
faire tourner un programme à la main pour trouver l’origine d’un comportement inattendu.