Premiers pas en programmation
Documents
-
Doc. 2,1 : Notions de type et de fonction
-
Doc. 2,3 : Booléens et alternative
-
Doc. 2,4 : Structures itératives
-
Doc. 2,5 : Un premier jeu avec Pyxel
-
Doc. 2,6 : Suivre l’évolution des variables
Doc. 2,1 : Notions de type et de fonction
Doc. 2,3 : Booléens et alternative
Doc. 2,4 : Structures itératives
Doc. 2,5 : Un premier jeu avec Pyxel
Doc. 2,6 : Suivre l’évolution des variables
En manipulant Python dans la console et dans Thonny, vous allez chercher à répondre aux questions suivantes :
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.
Pour chacune des informations suivantes, proposer une manière simple de la représenter à l’aide de Python :
Tester ensuite dans la console :
Quels sont les quatre réponses obtenus ?
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 |
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.
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.
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.
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.
Prévoir la valeur de chacune des expressions suivantes :
Vérifier ensuite vos réponses dans la console. Quel point commun possèdent ces quatre écritures ?
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.
On souhaite calculer pour . Tester les expressions suivantes dans la console :
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 ?
Prévoir les valeurs des expressions suivantes puis vérifier le résultat de l’évaluation par Python :
Associer ensuite à chaque opérateur son rôle.
Déterminer les valeurs des deux expressions suivantes :
Utiliser les résultats obtenus pour compléter l’expression mathématique : .
Recommencer avec les valeurs 38 et 7. À quoi servent les opérateurs // et % ?
Évaluer les expressions suivantes :
Que remarquez-vous ?
Sans utiliser Python, prévoir la valeur des expressions suivantes :
Vérifier ensuite dans la console. Python effectue-t-il simplement les opérations de gauche à droite ?
Dans la partie centrale de l’éditeur Thonny, écrire :
Lancer le programme en mode débogage puis utiliser la touche F7.
À 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é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.
Quelle expression Python calcule pour ?
En Python, la multiplication s’écrit toujours avec * et la puissance avec **. Le symbole ^ existe, mais il désigne une tout autre opération.
Que valent 17 // 5 et 17 % 5 ?
: // donne le quotient de la division euclidienne (3) et % son reste (2).
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.
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.
En mathématiques, une fonction associe à une valeur d’entrée (l’antécédent) une valeur de sortie (l’image) : pour , l’entrée donne la sortie .
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.
Tester les appels de fonctions suivants :
Pour chaque appel, identifier le nom de la fonction, le ou les arguments et la valeur retournée.
Évaluer les expressions suivantes :
Quelles opérations réalisent ces fonctions ? Combien d’arguments peut-on leur fournir ? Pourquoi la fonction help est-elle importante pour un programmeur ?
Évaluer les expressions suivantes :
Pourquoi le nom d’une fonction ne suffit-il pas pour savoir comment l’utiliser ?
De nombreuses fonctions fournies avec le langage Python sont regroupées dans des modules.
Tester le code suivant dans la console :
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.
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 :
un élément (une fonction par exemple) du module math est accessible avec la syntaxe math.nom.
À 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.
Sans utiliser Python, prévoir ce que retournent ces appels de fonctions, puis les tester dans la console :
Que devient une expression utilisée comme argument d’une fonction ?
Dans la partie principale de l’éditeur Thonny, écrire :
Lancer le programme en mode débogage puis utiliser la touche F7. Décrire l’ordre des calculs.
Dans la partie principale de l’éditeur Thonny, écrire :
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 ?
Prévoir la valeur de chacune des expressions suivantes, puis les écrire dans la partie principale de l’éditeur Thonny :
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.
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).
math.sqrt(abs(3 - 12)).help.import puis utilisés avec la syntaxe module.nom.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.
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.
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.
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.
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.
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.
Dans l’éditeur, recopier le code suivant :
Puis appeler la fonction depuis la console :
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 ?
Dans la définition :
x est un paramètre. Dans carre(5), 5 est un argument.
Tester puis corriger la définition de fonction suivante :
Quelle règle de syntaxe met en évidence l’erreur ?
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 ?
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.
On donne seulement le type de la fonction calcul :
Peut-on savoir si cette fonction calcule le carré de , son double ou son opposé ? Que manque-t-il ?
Observer la définition de la fonction carre :
Quelle partie explique ce que fait la fonction ? Quelle partie explique comment elle le fait ?
La spécification constitue le contrat entre le concepteur d’une fonction et son utilisateur.
Elle indique essentiellement ce que fait la fonction, pas comment elle le fait.
On souhaite définir une fonction dont la spécification est :
Un élève propose :
Python accepte-t-il cette définition ? Que retourne retire_un(5) ? Quelle valeur devrait-elle retourner ? Corriger la fonction.
Définir :
Puis compléter :
La fonction moyenne doit utiliser la fonction somme.
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.
def, suivi du nom de la fonction.a: float). Après ->, on annonce le type de la valeur retournée.:. Le corps de la fonction est indenté.return indique la valeur retournée par la fonction, puis met fin à son exécution.Tant qu’elle n’est pas appelée (moyenne(12, 15, 9)), une fonction définie n’exécute aucun calcul.
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.
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.
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 :.
Que contient la spécification d’une fonction ?
Spécification = signature + documentation. Elle dit ce que fait la fonction, pas comment elle le fait.
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.
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).
Consigne : pour chacune des fonctions définies ci-dessous, donner systématiquement leur spécification complète.
Définir la fonction polynomiale qui reçoit les arguments a, b, c, d, x et qui retourne le résultat du calcul .
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 par les coefficients . La fonction doit utiliser la fonction somme.
Dans un repère orthonormé, on peut claculer la distance à partir des coordonnées des points et :
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 :
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 , bornes incluses. On suppose entier strictement positif.
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 !
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 |
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.
Tester dans la console les instructions suivantes :
Puis tester chacune des instructions ci-dessous, une par une :
Laquelle de ces trois dernières instructions fonctionne ? Pour les autres, à quel endroit Python signale-t-il une erreur ?
Tester dans la console :
À 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 ?
Tester dans la console :
Ces deux identificateurs désignent-ils la même variable ?
Une variable est repérée par un identificateur, qui doit respecter certaines règles :
_) ;age et Age sont deux identificateurs différents) ;help("keywords")) ne peut pas être choisi comme identificateur.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.
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é.
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.
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.
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 :
La variable b a-t-elle changé de valeur lorsque a a été modifiée ?
Prévoir le résultat de l’évaluation de x, y et z après ces instructions, puis tester dans la console :
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 ?
Prévoir le résultat de l’évaluation de a, b et c après cette instruction, puis tester dans la console :
Combien de valeurs sont affectées en une seule instruction ?
Une affectation (opérateur =) donne une valeur à une variable ; elle se lit toujours de la droite vers la gauche.
a = 3.x = y = z = 1 affecte la même valeur à plusieurs variables.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.
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.
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.
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.
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.
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 ?
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 :
Que remarquez-vous ?
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.
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 |
Dans la partie principale de l’éditeur Thonny, écrire :
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 |
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.
| Instruction | a | b | c |
|---|---|---|---|
a = 7 |
|||
b = 4 |
|||
b = a + b |
|||
a = b - a |
|||
c = a * b |
|||
a += c |
|||
b -= 1 |
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.
Plus difficile. En utilisant uniquement les opérateurs += et -=, permuter dans la partie principale de l’éditeur les valeurs de a et b sans 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.
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.
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).
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).
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.
Tester dans la console :
L’une de ces quatre instructions provoque une erreur. Laquelle, et pourquoi ?
Prévoir le résultat de l’évaluation de chacune des expressions suivantes, puis tester dans la console :
L’une de ces deux dernières instructions échoue. Laquelle, et que dit le message d’erreur ?
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 :
Que remarquez-vous sur le contenu des accolades {} dans la seconde instruction ?
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.
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 : ?
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 :
Ces deux instructions produisent-elles le même résultat ?
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 ;"...{}...".format(...), plus ancienne, produit le même résultat mais reste moins lisible.É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.
Écrire la fonction conversion_franc_euro dont la spécification est :
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.
Écrire la fonction salutation dont la spécification est :
Écrire la fonction age_aleatoire dont la spécification est :
Remarque : utiliser la fonction randint du module random pour déterminer aléatoirement un nombre.
É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 :
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.
Écrire la fonction prix_ttc dont la spécification est :
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 €.
On reprend la fonction distance du Doc. 2,1 (à recopier dans la partie principale de l’éditeur si nécessaire) :
Écrire, à la suite, la fonction message_distance dont la spécification est :
La fonction message_distance doit utiliser la fonction distance.
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 |
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.
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.
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.
Avec montant = 3333.3333, que vaut f"{montant:.2f} €" ?
:.2f affiche le flottant arrondi à 2 chiffres après la virgule.
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.
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.
Tester dans la console :
Quel est ce nouveau type ? Combien de valeurs différentes peut-il prendre ?
Une confusion fréquente oppose = et ==. Prévoir le résultat de l’évaluation de chacune des instructions suivantes, puis tester dans la console :
Quelle instruction modifie la variable a ? Laquelle se contente de comparer sans rien modifier ?
Par analogie avec > et ==, prévoir le résultat de l’évaluation de chacune des expressions suivantes, puis tester dans la console :
Pour chaque opérateur utilisé, indiquer en une phrase ce qu’il teste.
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 :
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 :
Quelle règle générale peut-on énoncer ?
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).
Sans utiliser Python, indiquer si chacune des expressions suivantes vaut True ou False, en justifiant :
Vérifier ensuite dans la console.
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.
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).
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.
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.
Combien de valeurs différentes une grandeur booléenne peut-elle prendre ?
Le type bool ne possède que deux valeurs, True et False.
Prévoir le résultat de l’évaluation de chacune des expressions suivantes, puis tester dans la console :
Que fait l’opérateur not ?
Tester dans la console les quatre combinaisons possibles de l’opérateur and, puis compléter le tableau ci-dessous.
| A | B | A and B |
|---|---|---|
True |
True |
|
True |
False |
|
False |
True |
|
False |
False |
De la même façon, tester les quatre combinaisons de l’opérateur or, puis compléter le tableau ci-dessous.
| A | B | A or B |
|---|---|---|
True |
True |
|
True |
False |
|
False |
True |
|
False |
False |
Essentiel pour l’épreuve écrite. Tester dans la console, une instruction à la fois :
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.
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 :
and, si le premier opérande vaut False, le second n’est pas évalué (le résultat est déjà False) ;or, si le premier opérande vaut True, le second n’est pas évalué (le résultat est déjà True).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) :
Vérifier ensuite dans la console avec d = 1 / 0 (qui provoquerait une erreur si Python l’évaluait).
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.
Que vaut True and False ?
A and B ne vaut True que si A et B valent toutes les deux True.
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.
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é.
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à.
Dans la partie principale de l’éditeur, écrire puis exécuter :
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 ?
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.
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.
if <exprBool>:, suivi d’un bloc indenté, n’exécute ce bloc que si <exprBool> est True :
Avec else, on exécute le premier bloc si <exprBool> est True, le second sinon :
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éécrire le programme précédent sans utiliser elif, à 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.
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, 9i, j = 9, 2i, j = -4, -4Vérifier ensuite dans la console ou dans la partie principale de l’éditeur.
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.
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.
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.
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é.
Écrire, dans la partie principale de l’éditeur, la fonction est_positif dont la spécification est :
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 ?
On appelle prédicat une fonction qui retourne un booléen. Par convention, le nom d’un prédicat commence par est_.
Tester dans la console :
L’une des deux instructions ne donne pas le résultat attendu mathématiquement. Laquelle, et pourquoi (on pourra tester 1 / 49 * 49 seule) ?
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).
Écrire le prédicat est_egal dont la spécification est :
Tester ensuite son appel dans la console.
Écrire le prédicat est_pair dont la spécification est :
Écrire le prédicat est_entier dont la spécification est :
Consulter help(int) dans la console : comment la fonction int peut-elle aider à écrire ce prédicat ?
Écrire le prédicat est_naturel dont la spécification est :
Cette fonction doit utiliser les fonctions est_positif et est_entier des exercices précédents, combinées avec and.
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.
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 :
Écrire le prédicat est_plus_grand dont la spécification est :
Écrire ensuite la fonction le_plus_grand, qui doit utiliser est_plus_grand :
Écrire la fonction valeur_absolue, qui doit utiliser le prédicat est_positif :
Écrire chaque fonction dans la partie principale de l’éditeur, en respectant sa spécification. Tester ensuite son appel dans la console.
Écrire le prédicat est_majeur dont la spécification est :
Écrire ensuite, en réutilisant est_majeur et une f-string (Doc. 2,2), la fonction message_age dont la spécification est :
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.
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…
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.
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.
É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.Pour l’équation du second degré (avec , , réels), l’arbre des cas possibles est le suivant :
É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.
Écrire la fonction (avec sa spécification !) calcul_remise, qui retourne le taux de remise (en %) applicable à un prix TTC :
É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.
É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é).
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 :
É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).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 |
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.
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.
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 :
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.
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.
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.
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.
whileLa syntaxe d’une boucle while est :
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.
Recopier la fonction suivante dans la partie principale de l’éditeur Thonny :
Remplacer chacun des numéros ci-dessus par une phrase qui décrit ce que l’instruction réalise.
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 ?
Quelle instruction fait progresser i vers la condition d’arrêt ?
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.
Écrire une boucle while suppose de réunir trois éléments :
Oublier ce troisième élément est la cause la plus fréquente de boucle infinie.
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.
On donne la fonction suivante, dont il faut déterminer l’action :
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 |
inconnue(35, 6), sans reconstruire de tableau : donner uniquement la valeur retournée.Voici une autre fonction, dont il faut également déterminer l’action :
i ? Quelle est sa valeur lorsque la boucle s’arrête ?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 |
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.
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é.
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.
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.
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.
À 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.
Recopier la fonction suivante dans la partie principale de l’éditeur :
Appeler affiche_intervalle(10) dans la console. Quels entiers sont produits par range(1, 11) ? Combien y en a-t-il ?
Recopier la fonction suivante dans la partie principale de l’éditeur :
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 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 .
Recopier la fonction suivante dans la partie principale de l’éditeur :
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 ?
É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.
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.
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.
Quels entiers sont produits par range(1, 5) ?
range(début, fin) produit les entiers de début (inclus) à fin (exclu).
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.
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.
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.
break met 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:.
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.
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 ?
continue interrompt 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.
Les deux fonctions suivantes retournent une chaîne de caractères formée des entiers, inférieurs à nbre, qui ne le divisent pas :
Tester les deux fonctions avec nbre = 18. Dans non_diviseur, pourquoi l’instruction diviseur -= 1 apparaît-elle à deux endroits différents ?
Réécrire la fonction non_diviseur_2 sous la forme non_diviseur_3, sans utiliser continue, à 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 ?
break arrête définitivement la boucle en cours ; l’exécution reprend juste après elle.continue arrê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.
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.
Que fait l’instruction break ?
break sort de la boucle en cours. C’est continue qui passe à l’itération suivante.
Que fait l’instruction continue ?
Les instructions qui suivent continue dans le bloc sont sautées pour cette itération seulement.
break et continue s’utilisent :
Ces deux instructions fonctionnent aussi bien dans une boucle for que dans une boucle while.
É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.
Écrire la fonction triple_du_precedent dont la spécification est :
Utiliser une boucle while.
Écrire la fonction multiplication_multiple_trois dont la spécification est :
Écrire la fonction multiplication_multiple_sept dont la spécification est :
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 ?
Écrire la fonction diviseurs dont la spécification est :
Écrire et exécuter la fonction loto_naif dont la spécification est :
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.
Écrire la fonction table_multiplication dont la spécification est :
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.
La fonction input retourne toujours une chaîne de caractères ; une conversion est donc nécessaire pour récupérer un nombre :
Écrire la fonction plus_grand_plus_petit dont la spécification est :
Écrire la fonction moyenne dont la spécification est :
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.
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 :
Indication. Écrire while True: et utiliser break pour sortir de la boucle. Pourquoi une boucle for ne convient-elle pas ici ?
Écrire et exécuter la fonction devine dont la spécification est :
Indication. Le module random et sa fonction randint ont été présentés dans le Doc. 2,1.
Écrire et exécuter la fonction alphabet dont la spécification est :
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.
On rappelle la suite de Fibonacci, définie par , et, pour , .
Écrire la fonction fibo dont la spécification est :
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.
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 ?
Le choix entre for et while dépend de la nature du problème, pas des préférences du programmeur :
for est le choix naturel et le plus lisible ;while convient.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 désignent ces neuf chiffres et le dixième, la somme 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.
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é).
Le taxi de Ramanujan. Trouver tous les entiers inférieurs ou égaux à un nombre choisi par l’utilisateur qui peuvent s’écrire comme somme de deux cubes, de deux façons différentes : trouver quatre entiers , , , , inférieurs à , tels que .
Indication. Quatre boucles imbriquées suffisent, même si le résultat n’est pas optimisé.
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 |
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.
Voici le programme de départ :
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.
Lancer le programme, puis modifier successivement les trois nombres de l’instruction pyxel.text(50, 60, "Bonjour NSI !", 7).
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.
Le programme définit les fonctions update et draw, mais on ne trouve nulle part l’instruction draw(). Pourtant le texte s’affiche.
draw ?pyxel.run(update, draw) et non pyxel.run(update(), draw()) ?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.
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.
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.
Dans la fenêtre Pyxel, où se trouve l’origine du repère, et dans quel sens augmente ?
Comme pour la plupart des écrans, l’origine est le coin supérieur gauche : augmente vers la droite et vers le bas.
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.
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.
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).
É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.
La valeur 76 place le joueur au milieu de l’écran, dans le sens horizontal.
LARGEUR et TAILLE_JOUEUR.// plutôt que / dans cette expression ?Remplacer LARGEUR = 160 par LARGEUR = 200 et relancer le programme.
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.
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.
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.
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.
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.
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.
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 ←.
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.
global nom_de_la_variable au début du corps de la fonction.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.
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 ?
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.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.
Pourquoi l’appel à deplacer_joueur() est-il placé dans update() et non dans draw() ?
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.
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.
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.
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.
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.
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.
Remplacer VITESSE = 2 par VITESSE = 3.
x_joueur lorsque le joueur part de 76 et que la touche ← reste enfoncée. Le joueur reste-t-il dans l’écran ?VITESSE. Revenir ensuite à VITESSE = 2.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.
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).
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 : la condition 1 > 0 est vraie, et le déplacement fait sortir le joueur. Il faut tester la position après le déplacement.
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 :
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) :
x et celle de y pendant l’exécution de cet appel.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).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.
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.
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.
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.
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.
Ajouter les constantes et la fonction suivantes, puis appeler dessiner_sol() dans draw().
Sans exécuter le programme :
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.Réécrire la fonction dessiner_sol() avec une boucle while (voir Doc. 2,4). Laquelle des deux versions est la plus adaptée ? Pourquoi ?
Dans draw(), placer l’appel à dessiner_sol() avant pyxel.cls(0). Qu’observe-t-on ? Pourquoi ?
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.
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.
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 valeurs, donc 20 dalles.
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.
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.
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 et vaut :
La racine carrée s’obtient avec la fonction sqrt du module math, à importer au début du programme : from math import sqrt.
Écrire une fonction distance(x1, y1, x2, y2) qui renvoie la distance entre les points et .
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.
Un élève a écrit une fonction qui affiche la distance au lieu de la renvoyer :
print(distance_affichee(0, 0, 3, 4) + 1), puis vérifier.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.
Que renvoie distance(0, 0, 3, 4) ?
. La fonction sqrt renvoie toujours un float : 5.0.
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.
On considère la fonction suivante :
TAILLE_JOUEUR et RAYON_CIBLE.cible_attrapee() peut-elle renvoyer ?Dans draw(), afficher le texte « Touché ! » en haut de l’écran lorsque le joueur touche la cible. Tester.
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.
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.
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.
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.
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.nouvelle_cible() qui donne à la cible une position choisie au hasard, entièrement visible.update(), appeler nouvelle_cible() lorsque la cible est attrapée. Tester.Il peut arriver que la nouvelle cible apparaisse directement sur le joueur.
tirer_position_cible(), puis écrire une nouvelle fonction nouvelle_cible() qui l’utilise.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.
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.
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.
Ajouter la variable score = 0 au début du programme.
score est-il écrit en minuscules, alors que LARGEUR est écrit en majuscules ?update() pour que le score augmente de 1 à chaque cible attrapée. Que faut-il ajouter au début de la fonction ?Remplacer l’affichage de « Touché ! » par celui du score, à l’aide de l’instruction pyxel.text(5, 5, "Score : " + str(score), 7).
str(score) ?global score dans draw() ?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.
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.
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.
Pourquoi écrit-on "Score : " + str(score) ?
+ entre chaînes exige deux str. Une f-string fait la conversion automatiquement : f"Score : {score}".
Ajouter la constante SCORE_GAGNANT = 10 et modifier update() pour que le joueur ne puisse plus bouger une fois la partie gagnée :
Pour tester rapidement la fin de partie, quelle ligne suffit-il de modifier ?
Un élève a écrit la fonction draw() suivante pour afficher « BRAVO ! » au centre de l’écran en fin de partie :
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.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.
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.
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.
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.
pyxel.btn pour déplacer le joueur, et non pyxel.btnp ?update() pour que la touche Q ferme le jeu à tout moment, y compris après la victoire.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.
X_DEPART et Y_DEPART, et les utiliser pour initialiser x_joueur et y_joueur.nouvelle_partie(). Quelles variables doivent être déclarées global ?update() au bon endroit.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.
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.
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 complet est organisé ainsi :
dessiner_joueur(), dessiner_cible(...), dessiner_sol(), distance(...), cible_attrapee(), deplacer_joueur(), tirer_position_cible(), nouvelle_cible(), nouvelle_partie()update() : fait évoluer l'état du jeudraw() : dessine l'état du jeupyxel.init(...) puis pyxel.run(update, draw)Dans votre programme, trouver un exemple de chacune des notions suivantes et le recopier.
| Notion | Exemple dans votre programme |
|---|---|
| Constante | |
| Définition d’une fonction | |
| Appel d’une fonction | |
| Fonction avec paramètres | |
| Fonction renvoyant une valeur | |
| Fonction renvoyant un booléen | |
| Instruction conditionnelle | |
Boucle for |
|
Boucle while |
|
| Fonction qui modifie une variable globale |
Les défis sont classés par difficulté croissante.
Défi A : cible multicolore. La couleur de la cible change à chaque point marqué.
Défi B : difficulté croissante. À partir de 5 points, le joueur se déplace plus vite. VITESSE peut-elle rester une constante ?
Défi C : temps limité. La partie dure 30 secondes. Le temps restant est affiché à l’écran ; lorsqu’il atteint 0, la partie est perdue.
Défi D : deux cibles. Une deuxième cible, d’une autre couleur, rapporte 3 points.
global à bon escient ;for et une boucle while ;text, rect, circ, btn, btnp, rndi).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.
if, elif, while), on la recopie en remplaçant les variables par leurs valeurs, puis on écrit sa valeur : True ou False.On considère le programme suivant.
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 |
À la ligne 4, la valeur de x change. Pourquoi a vaut-elle toujours 3 à la fin du programme ?
Sans utiliser Python, déterminer la valeur de transforme(transforme(1)) en détaillant les étapes. Vérifier ensuite dans la console.
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.
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.
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.
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.
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.
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 | ||||
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 ?
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é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.
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.
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.
Un cinéma calcule le prix d’une place avec la fonction suivante.
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) |
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.
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é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.
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.
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.
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.
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.
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 | |
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 |
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é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.
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.
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.
On considère les deux fonctions suivantes.
Quels entiers sont produits par range(1, 8, 2) ? Combien d’itérations la boucle de mystere(7) effectue-t-elle ?
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 |
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 |
À 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.
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 ?
Quel calcul réalisent ces deux fonctions ?
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.
Que retourne mystere(5) ?
range(1, 6, 2) produit 1, 3 et 5 : la fonction calcule , la somme des entiers impairs inférieurs ou égaux à n.
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.
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.
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 |
Sans utiliser Python, prévoir la valeur retournée par syracuse(1). Combien de fois le bloc de la boucle est-il exécuté ?
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 ?
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 |
|---|---|---|
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é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.
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.
Que retourne syracuse(1) ?
La condition 1 != 1 est fausse dès le départ : la boucle n’effectue aucune itération.
return ;if / elif / else, et la différence avec des if successifs ;for avec range et d’une boucle while, y compris lorsqu’il n’y en a aucune ;