Aller au contenu principal

Sous-sections de Premiers pas en programmation

Physique, Chimie et Informatique > 1ère Spécialité NSI > Premiers pas en programmation

Notions de type et de fonction

Objectif

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 ? ».

Tester ensuite dans la console :

>>> type(32)
>>> type(18.5)
>>> type("Alice")
>>> type(False)

Quels sont les quatre réponses obtenus ?

Réponse

On obtient :

>>> type(32)
<class 'int'>
>>> type(18.5)
<class 'float'>
>>> type("Alice")
<class 'str'>
>>> type(False)
<class 'bool'>

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 acquis 3 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.

É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+43 x^2 + 2 x + 4 pour x=5x = 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 + 4
89

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+…17 = \dots \times 5 + \dots.
Recommencer avec les valeurs 38 et 7. À quoi servent les opérateurs // et % ?

Réponse

On obtient 17=3×5+217 = 3 \times 5 + 2 et 38=5×7+338 = 5 \times 7 + 3.

// retourne le quotient de la division euclidienne et % son reste.

Q36.

Évaluer les expressions suivantes :

>>> 8 / 2
>>> 8 // 2
>>> type(8 / 2)
>>> type(8 // 2)
>>> type(8.0 // 2)

Que remarquez-vous ?

Réponse

/ 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 acquis 4 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.

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)=x2f(x) = x^2, l’entrée 33 donne la sortie 99.

À 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 :

>>> import math
>>> 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 π\pi. 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 :

import math

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.

Réponse
>>> import random
>>> help(random.randint)
>>> random.randint(1, 10)

Les deux bornes sont incluses.

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 :

import math

math.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=−93 - 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 acquis 4 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.

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 :

def carre(x: float) -> float:
    return x**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 :

def carre(x: float) -> float:
    return x**2

x est un paramètre. Dans carre(5), 5 est un argument.

Q49.

Tester puis corriger la définition de fonction suivante :

def triple(x: float) -> float:
return 3 * x

Quelle règle de syntaxe met en évidence l’erreur ?

Réponse
def triple(x: float) -> float:
    return 3 * 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 :

def surface_rectangle(longueur: float, largeur: float) -> float:
    return longueur * largeur

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 :

def calcul(x: float) -> float:
    ...

Peut-on savoir si cette fonction calcule le carré de xx, 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 :

def carre(x: float) -> float:
    """ Retourne le carré du nombre x. """
    return x**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\text{Spécification} = \text{Signature} + \text{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 :

def retire_un(n: float) -> float:
    """Retourne la valeur de n diminuée de 1."""

Un élève propose :

def retire_un(n: float) -> float:
    """Retourne la valeur de n diminuée de 1."""
    return 1 - 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.

def retire_un(n: float) -> float:
    """Retourne la valeur de n diminuée de 1."""
    return n - 1

Peut-on construire une fonction à partir d’une autre ?

Q54.

Définir :

def somme(x: float, y: float, z: float) -> float:
    """Retourne la somme de x, y et z."""
    return x + y + z

Puis compléter :

def moyenne(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
def moyenne(a: float, b: float, c: float) -> float:
    """Retourne la moyenne de a, b et c."""
    return somme(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.

def moyenne(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 acquis 5 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.

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+da x^3 + b x^2 + c x + d.
Tests :

>>> polynomiale(1, 1, 1, 1, 2)
15
>>> polynomiale(1, 1, 1, 1, 3)
40
Réponse
def polynomiale(a: float, b: float, c: float,
                d: float, x: float) -> float:
    """Retourne ax^3 + bx^2 + cx + d."""
    return a * x**3 + b * x**2 + c * x + d

Exercice 2 : Programmer une moyenne pondérée

Q56.

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,zx, y, z par les coefficients a,b,ca, b, c. La fonction doit utiliser la fonction somme.

Réponse
def moyenne_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.

Couronne Couronne

Réponse
def surface_rectangle(longueur: float, largeur: float) -> float:
    """Retourne la surface d'un rectangle."""
    return longueur * largeur

def volume_parallelepipede(longueur: float,
                           largeur: float,
                           hauteur: float) -> float:
    """Retourne le volume d'un parallélépipède rectangle."""
    return surface_rectangle(longueur, largeur) * hauteur

def surface_disque(r: float) -> float:
    """Retourne la surface d'un disque de rayon r."""
    return math.pi * r**2

def surface_couronne(r1: float, r2: float) -> float:
    """Retourne la surface d'une couronne."""
    return surface_disque(r2) - surface_disque(r1)

Exercice 4 : Calculer la distance entre deux points

Q58.

Dans un repère orthonormé, on peut claculer la distance ABA B à partir des coordonnées des points AA et BB :

AB=(x2−x1)2+(y2−y1)2A B = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^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 :

>>> distance(0, 0, 3, 4)
5.0
>>> distance(2, 3, 2, 3)
0.0
>>> distance(3, 4, 0, 0)
5.0
Réponse
def distance(x1: float, y1: float,
             x2: float, y2: float) -> float:
    """Retourne la distance entre deux points du plan."""
    return math.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 aa, bornes incluses. On suppose aa entier strictement positif.

Réponse
def tirage_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 xx tel que 0≤x<10 \leq x < 1. Donc 0≤ax<a0 \leq a x < a et int(random.random() * a) produit un entier de 0 à a−1a - 1. Il suffit ensuite d’ajouter 1 pour réaliser le traitement attendu.

def tirage_entier(a: int) -> int:
    """Retourne un entier aléatoire compris entre 1 et a."""
    return int(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

Opérateurs d'affectation, formatage des chaînes

Objectif

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 ?

Q27.

Tester dans la console :

>>> ma_variable = 1
>>> maVariable = 2
>>> ma_variable
>>> maVariable

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 acquis 3 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.

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 acquis 3 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.

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 :

>>> prix = 20
>>> tva = 18.6
>>> prix = prix + prix * tva / 100
>>> prix

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 :

>>> x = 10
>>> x -= 3
>>> x
>>> x *= 2
>>> x
>>> x //= 5
>>> x
>>> x %= 2
>>> x

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 = 605
b = 506
a = b
b = a
print(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.

>>> a = 7
>>> b = 4
>>> b = a + b
>>> a = b - a
>>> c = a * b
>>> a += c
>>> b -= 1
Instruction a b c
a = 7
b = 4
b = a + b
a = b - a
c = a * b
a += c
b -= 1
Q36.

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 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.

Vérifier ses acquis 3 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.

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'est top !')

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 :

>>> montant = 3333.3333
>>> f"{montant:.0f} €"
>>> f"{montant:.1f} €"
>>> f"{montant:.2f} €"

À 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 :

def conversion_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 :

def salutation(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 :

def age_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 :

def ticket(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 :

def prix_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) :

def distance(x1: float, y1: float, x2: float, y2: float) -> float:
    """Retourne la distance entre deux points du plan."""
    return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)

Écrire, à la suite, la fonction message_distance dont la spécification est :

def message_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 acquis 4 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.

Physique, Chimie et Informatique > 1ère Spécialité NSI > Premiers pas en programmation

Booléens et alternative

Objectif

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.

Comment exprimer une condition ?

Q34.

Tester dans la console :

>>> 3 > 2
>>> 3 == 2
>>> type(3 > 2)
>>> True
>>> False
>>> type(True)

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 :

>>> bool(0)
>>> bool(1)
>>> bool(-5)
>>> bool("")
>>> bool("a")
>>> bool([])

Quelle règle générale peut-on énoncer ?

Réponse

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 acquis 4 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.

Comment combiner plusieurs conditions ?

Q40.

Prévoir le résultat de l’évaluation de chacune des expressions suivantes, puis tester dans la console :

>>> not True
>>> not False

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.

>>> True and True
>>> True and False
>>> False and True
>>> False and False
A B A and B
True True
True False
False True
False False
Réponse
A B A and B
True True True
True False False
False True False
False False False

A and B ne vaut True que si A et B valent True.

Q42.

De la même façon, tester les quatre combinaisons de l’opérateur or, puis compléter le tableau ci-dessous.

>>> True or True
>>> True or False
>>> False or True
>>> False or False
A B A or B
True True
True False
False True
False False
Réponse
A B A or B
True True True
True False True
False True True
False False False

A or B ne vaut False que si A et B valent False.

Q43.

Essentiel pour l’épreuve écrite. Tester dans la console, une instruction à la fois :

>>> False and (1 / 0)
>>> True or (1 / 0)
>>> True and (1 / 0)
>>> (1 / 0) and True

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 pas 1 / 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 pas 1 / 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) :

>>> e or ((not e) and f and d)

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 acquis 4 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.

Comment exécuter des instructions sous condition ?

Q45.

Dans la partie principale de l’éditeur, écrire puis exécuter :

x = -5
if x < 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 = -5
if x < 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) :

i, j = 3, 7
if i < j:
    message = "j"
elif i > j:
    message = "i"
else:
    message = "égaux"
print(message)

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 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.

Réponse
i, j = 3, 7
if i < j:
    message = "j"
else:
    if i > j:
        message = "i"
    else:
        message = "égaux"
print(message)
elif

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 arrowarrow message = "j".
  • i, j = 9, 2 : i < j est fausse, i > j est vraie arrowarrow message = "i".
  • i, j = -4, -4 : i < j et i > j sont fausses toutes les deux arrowarrow c’est le else qui s’exécute, message = "égaux".
Vérifier ses acquis 3 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.

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 :

def est_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
def est_positif(x: int | float) -> bool:
    """Retourne True si x est positif ou nul, False sinon."""
    return x >= 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 :

def est_egal(x: int | float, y: int | float) -> bool:
    """Retourne True si abs(x - y) < epsilon, où epsilon = 1e-5.

    >>> est_egal(1 / 49 * 49, 1)
    True
    """

Tester ensuite son appel dans la console.

Réponse
def est_egal(x: int | float, y: int | float) -> bool:
    """Retourne True si abs(x - y) < epsilon, où epsilon = 1e-5.

    >>> est_egal(1 / 49 * 49, 1)
    True
    """
    epsilon = 1e-5
    return abs(x - y) < epsilon
Q53.

Écrire le prédicat est_pair dont la spécification est :

def est_pair(n: int) -> bool:
    """Retourne True si n est un nombre pair, False sinon."""
Réponse
def est_pair(n: int) -> bool:
    """Retourne True si n est un nombre pair, False sinon."""
    return n % 2 == 0
Q54.

Écrire le prédicat est_entier dont la spécification est :

def est_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
def est_entier(n: int) -> bool:
    """Retourne True si n ne possède pas de partie décimale, False sinon."""
    return n == 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 :

def est_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
def est_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
    """
    return est_positif(n) and est_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 :

def est_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 TypeError peu explicite, quelque part dans le calcul, sans indiquer clairement quel argument est en cause.

def est_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
    """
    assert isinstance(n, int) or isinstance(n, float), "n doit être un nombre"
    return est_naturel(n)
Q58.

Écrire le prédicat est_plus_grand dont la spécification est :

def est_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 :

def le_plus_grand(x: int | float, y: int | float) -> int | float:
    """Retourne x si x > y, y sinon."""
Réponse
def est_plus_grand(x: int | float, y: int | float) -> bool:
    """Retourne True si x > y, False sinon."""
    return x > y

def le_plus_grand(x: int | float, y: int | float) -> int | float:
    """Retourne x si x > y, y sinon."""
    if est_plus_grand(x, y):
        return x
    else:
        return y
Q59.

Écrire la fonction valeur_absolue, qui doit utiliser le prédicat est_positif :

def valeur_absolue(x: int | float) -> int | float:
    """Retourne la valeur absolue de x."""
Réponse
def valeur_absolue(x: int | float) -> int | float:
    """Retourne la valeur absolue de x."""
    if est_positif(x):
        return x
    else:
        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 :

def est_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 :

def message_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
def est_majeur(age: int) -> bool:
    """Retourne True si age >= 18, False sinon."""
    return age >= 18

def message_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é.'
    """
    if est_majeur(age):
        return f"Vous êtes majeur."
    else:
        return f"Vous êtes mineur, encore {18 - age} an(s) avant la majorité."
Vérifier ses acquis 3 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.

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
def synthese(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'
    """
    if moyenne < 8:
        return "Recalé"
    elif moyenne < 10:
        return "Second tour"
    elif moyenne < 12:
        return "Admis"
    elif moyenne < 14:
        return "Admis, Mention Assez Bien"
    elif moyenne < 16:
        return "Admis, Mention Bien"
    else:
        return "Admis, Mention Très Bien"
Q62.

Pour l’équation du second degré ax2+bx+c=0a x^2 + b x + c = 0 (avec aa, bb, cc réels), l’arbre des cas possibles est le suivant :

  • a=0a = 0 :
    • b=0b = 0 :
      • c=0c = 0 : tout réel est solution ;
      • c≠0c \neq 0 : pas de solution ;
    • b≠0b \neq 0 : une seule solution x=−c/bx = -c / b ;
  • a≠0a \neq 0, avec Δ=b2−4ac\Delta = b^2 - 4 a c :
    • Δ>0\Delta > 0 : deux solutions x1=(−b+Δ)/(2a)x_1 = (-b + \sqrt{\Delta}) / (2a) et x2=(−b−Δ)/(2a)x_2 = (-b - \sqrt{\Delta}) / (2a) ;
    • Δ=0\Delta = 0 : une seule solution x=−b/(2a)x = -b / (2a) ;
    • Δ<0\Delta < 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
import math

def racines(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'
    """
    if a == 0:
        if b == 0:
            if c == 0:
                return "tout réel est solution"
            else:
                return "pas de solution"
        else:
            x = -c / b
            return f"solution unique : x = {x}"
    else:
        delta = b**2 - 4 * a * c
        if delta > 0:
            x1 = (-b + math.sqrt(delta)) / (2 * a)
            x2 = (-b - math.sqrt(delta)) / (2 * a)
            return f"deux solutions : x1 = {x1}, x2 = {x2}"
        elif delta == 0:
            x = -b / (2 * a)
            return f"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
def calcul_remise(prix_ttc: int | float) -> int:
    """Retourne le taux de remise (en %) applicable à un prix TTC.

    >>> calcul_remise(500)
    0
    >>> calcul_remise(1200)
    1
    """
    if prix_ttc >= 5000:
        return 5
    elif prix_ttc >= 2000:
        return 2
    elif prix_ttc >= 1000:
        return 1
    else:
        return 0

def calcul_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.20
    remise = calcul_remise(prix_ttc)
    return prix_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
def est_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
    """
    return n % 4 == 0 and (n % 100 != 0 or n % 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 :

def est_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
def est_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
    """
    return a < b + c and b < a + c and c < 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
def type_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'
    """
    if not est_triangle(a, b, c):
        return "pas un triangle"
    elif a == b == c:
        return "équilatéral"
    elif a == b or b == c or a == 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

Structures itératives

Objectif

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 acquis 2 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.

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 :

def affiche_jusqua(n: int) -> None:
    """
    Affiche les entiers de 1 à n, un par ligne, à l'aide d'une boucle Tant que.
    """
    i = 1            # (1)
    while i <= 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 :

  1. une initialisation de la ou des variables testées par la condition ;
  2. une condition d’arrêt, expression booléenne évaluée avant chaque itération ;
  3. 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 :

def inconnue(a: int, b: int) -> int:
    """ Fonction dont il faut déterminer l'action. """
    r = a % b
    while r != 0:
        a = b
        b = r
        r = a % b
    return b
  1. Repérer les instructions répétées par la boucle et l’instruction qui teste la fin de la boucle.
  2. Quelle instruction modifie le résultat de l’évaluation de ce test ?
  3. 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
  1. Visualiser le fonctionnement de cette fonction à l’aide du débogueur intégré à Thonny.
  2. Reprendre la question précédente pour l’appel inconnue(35, 6), sans reconstruire de tableau : donner uniquement la valeur retournée.
  3. Quel calcul réalise cette fonction ?
Q35.

Voici une autre fonction, dont il faut également déterminer l’action :

def inconnue_deux(a: int) -> int:
    """ Fonction dont il faut déterminer l'action. """
    b = 1
    i = 2
    while i <= a:
        b *= i
        i += 1
    return b
  1. Quelle est la valeur initiale de i ? Quelle est sa valeur lorsque la boucle s’arrête ?
  2. 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
  1. Quel calcul réalise cette fonction ?
Vérifier ses acquis 3 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.

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.

for element in ité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 :

def affiche_intervalle(n: int) -> None:
    """Affiche, séparés par un espace, les entiers produits par
    range(1, n + 1).
    """
    for nbre in range(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 :

def table_de(n: int) -> str:
    """ Retourne la table de multiplication de n, de 1 à 10. """
    reponse = ""
    for nbre in range(1, 11):
        calcul = n * nbre
        reponse += str(calcul) + " "
    return reponse

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[[\text{début}, \text{fin}[.

Q38.

Recopier la fonction suivante dans la partie principale de l’éditeur :

def demo_range(debut: int, fin: int, pas: int) -> None:
    """Affiche, séparés par un espace, les entiers produits par
    range(debut, fin, pas).
    """
    for i in range(debut, fin, pas):
        print(i, end=' ')

Prévoir puis vérifier dans la console le résultat de chacun des appels suivants :

>>> demo_range(1, 10, 1)
>>> demo_range(1, 10, 3)
>>> demo_range(10, 1, -1)
>>> demo_range(10, -15, -3)

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 acquis 4 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.

Interrompre une boucle ou passer à l’itération suivante : break et continue

L’instruction break

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:.

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.

def plus_grand_diviseur(nbre: int) -> str:
    """Retourne un message donnant le plus grand diviseur de nbre,
    différent de nbre lui-même.
    """
    diviseur = nbre - 1
    while diviseur > 0:
        if nbre % diviseur == 0:
            break
        diviseur -= 1
    return f"Le plus grand diviseur de {nbre} est {diviseur}."

def plus_grand_diviseur_2(nbre: int) -> str:
    """Retourne un message donnant le plus grand diviseur de nbre,
    différent de nbre lui-même.
    """
    for diviseur in range(nbre - 1, 0, -1):
        if nbre % diviseur == 0:
            break
    return f"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

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.

Q41.

Les deux fonctions suivantes retournent une chaîne de caractères formée des entiers, inférieurs à nbre, qui ne le divisent pas :

def non_diviseur(nbre: int) -> str:
    """Retourne les entiers de 1 à nbre - 1 qui ne divisent pas nbre."""
    reponse = ""
    diviseur = nbre - 1
    while diviseur > 0:
        if nbre % diviseur == 0:
            diviseur -= 1
            continue
        reponse += str(diviseur) + " "
        diviseur -= 1
    return reponse

def non_diviseur_2(nbre: int) -> str:
    """Retourne les entiers de 1 à nbre - 1 qui ne divisent pas nbre."""
    reponse = ""
    for diviseur in range(nbre - 1, 0, -1):
        if nbre % diviseur == 0:
            continue
        reponse += str(diviseur) + " "
    return reponse

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 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 ?

À retenir
  • 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.

Vérifier ses acquis 3 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.

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 :

def triple_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 :

def multiplication_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 :

def multiplication_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 :

def diviseurs(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 :

def loto_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 :

def table_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 :

def plus_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 :

def moyenne(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 :

def moyenne_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 :

def devine() -> 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 :

def alphabet(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=1u_1 = 1, u2=1u_2 = 1 et, pour n>2n > 2, un=un−1+un−2u_n = u_{n-1} + u_{n-2}.

Écrire la fonction fibo dont la spécification est :

def fibo(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,…,d9d_1, \dots, d_9 désignent ces neuf chiffres et d10d_{10} le dixième, la somme d1+2d2+3d3+⋯+10d10d_1 + 2 d_2 + 3 d_3 + \dots + 10 d_{10} 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 NN choisi par l’utilisateur qui peuvent s’écrire comme somme de deux cubes, de deux façons différentes : trouver quatre entiers aa, bb, cc, dd, inférieurs à NN, tels que a3+b3=c3+d3a^3 + b^3 = c^3 + d^3.

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

Un premier jeu avec Pyxel

Objectif

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 :

import pyxel

LARGEUR = 160
HAUTEUR = 120

def update():
    pass

def draw():
    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).

  1. Que représente chacun de ces nombres ?
  2. Où se trouve l’origine du repère ? Dans quel sens augmentent les coordonnées xx et yy ?
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.

  1. Qui appelle la fonction draw ?
  2. 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 acquis 3 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.

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 :

TAILLE_JOUEUR = 8
COULEUR_JOUEUR = 11

x_joueur = 76
y_joueur = 100

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.

  1. Pourquoi n’a-t-on pas choisi 80, qui est la moitié de 160 ?
  2. Remplacer 76 par une expression qui utilise LARGEUR et TAILLE_JOUEUR.
  3. Pourquoi utiliser l’opérateur // plutôt que / dans cette expression ?
Q51.

Remplacer LARGEUR = 160 par LARGEUR = 200 et relancer le programme.

  1. Qu’est-ce qui a changé sans qu’il soit nécessaire de modifier une autre ligne ?
  2. 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 acquis 3 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.

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

def deplacer_joueur():
    if pyxel.btn(pyxel.KEY_LEFT):
        x_joueur = x_joueur - VITESSE
Q53.

Lancer le programme, attendre quelques secondes, puis appuyer sur ←.

  1. Quel message d’erreur obtient-on ? Quelle ligne est en cause ?
  2. 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.
  1. Maintenir les touches → et ↑ enfoncées en même temps. Qu’observe-t-on ?
  2. 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 acquis 3 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.

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

if pyxel.btn(pyxel.KEY_LEFT) and ................:
if pyxel.btn(pyxel.KEY_RIGHT) and ................:
if pyxel.btn(pyxel.KEY_UP) and ................:
if pyxel.btn(pyxel.KEY_DOWN) and ................:

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.

  1. 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 ?
  2. 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 acquis 2 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.

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 = 4
COULEUR_CIBLE = 10

x_cible = 80
y_cible = 30

puis la fonction ci-dessous, et l’instruction dessiner_cible(x_cible, y_cible) dans draw().

def dessiner_cible(x, y):
    pyxel.circ(x, y, RAYON_CIBLE, COULEUR_CIBLE)
Q61.

Dans la définition def dessiner_cible(x, y): et dans l’appel dessiner_cible(x_cible, y_cible) :

  1. identifier les paramètres et les arguments ;
  2. 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.

  1. dessiner_cible(20, 20) suivi de dessiner_cible(140, 90) ;
  2. dessiner_cible(y_cible, x_cible) ;
  3. 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 acquis 3 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.

Le sol : une boucle for

Ajouter les constantes et la fonction suivantes, puis appeler dessiner_sol() dans draw().

Y_SOL = HAUTEUR - 4
EPAISSEUR_SOL = 2
LARGEUR_DALLE = 6
PAS_DALLES = 8
COULEUR_SOL = 3

def dessiner_sol():
    for x in range(0, LARGEUR, PAS_DALLES):
        pyxel.rect(x, Y_SOL, LARGEUR_DALLE, EPAISSEUR_SOL, COULEUR_SOL)
Q64.

Sans exécuter le programme :

  1. combien de dalles sont dessinées ?
  2. quelles sont les abscisses de la première et de la dernière dalle ?
  3. 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 :

  1. LARGEUR_DALLE = 8 ;
  2. 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 acquis 3 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.

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)(x_1, y_1) et (x2,y2)(x_2, y_2) vaut :

d=(x2−x1)2+(y2−y1)2d = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^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)(x_1, y_1) et (x2,y2)(x_2, y_2).

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 :

def distance_affichee(x1, y1, x2, y2):
    print(sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2))
  1. Sans exécuter le programme, prévoir le résultat de print(distance_affichee(0, 0, 3, 4) + 1), puis vérifier.
  2. Pourquoi cette fonction ne peut-elle pas servir dans le jeu ?
Vérifier ses acquis 2 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.

La cible est-elle attrapée ? Une fonction qui renvoie un booléen

On considère la fonction suivante :

def cible_attrapee():
    d = distance(x_joueur + 4, y_joueur + 4, x_cible, y_cible)
    return d < 8
Q71.
  1. Pourquoi ajoute-t-on 4 aux coordonnées du joueur ?
  2. Justifier la valeur 8, en s’appuyant sur un schéma.
  3. 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.
  1. Quelles valeurs la fonction cible_attrapee() peut-elle renvoyer ?
  2. Un élève a écrit la fin de la fonction ainsi :
    if d < 8:
        return True
    else:
        return False
    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 acquis 2 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.

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.
  1. 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.
  2. Écrire une fonction nouvelle_cible() qui donne à la cible une position choisie au hasard, entièrement visible.
  3. 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.

  1. Que se passe-t-il dans ce cas ?
  2. Pour l’éviter, il faut tirer une nouvelle position tant que la cible touche le joueur. Quelle boucle faut-il utiliser ? Pourquoi ?
  3. 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 acquis 2 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.

Le score

Ajouter la variable score = 0 au début du programme.

Q76.
  1. Pourquoi le nom score est-il écrit en minuscules, alors que LARGEUR est écrit en majuscules ?
  2. 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).

  1. Pourquoi faut-il écrire str(score) ?
  2. Réécrire cette instruction à l’aide d’une f-string (voir Doc. 2,2).
  3. Faut-il ajouter global score dans draw() ?
Vérifier ses acquis 3 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.

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 :

def update():
    global score

    if score < SCORE_GAGNANT:
        deplacer_joueur()
        if cible_attrapee():
            score = score + 1
            nouvelle_cible()
Q78.

Pour tester rapidement la fin de partie, quelle ligne suffit-il de modifier ?

Q79.

Un élève a écrit la fonction draw() suivante pour afficher « BRAVO ! » au centre de l’écran en fin de partie :

def draw():
    if score < SCORE_GAGNANT:
        pyxel.cls(0)
        dessiner_sol()
        dessiner_cible(x_cible, y_cible, COULEUR_CIBLE)
        dessiner_joueur()
        pyxel.text(5, 5, f"Score : {score}", 7)
    else:
        pyxel.text(LARGEUR // 2, HAUTEUR // 2, "BRAVO !", 7)
  1. Sans exécuter le programme, prévoir les deux défauts de l’affichage en fin de partie. Vérifier.
  2. 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 acquis 2 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.

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.
  1. Pourquoi utilise-t-on pyxel.btn pour déplacer le joueur, et non pyxel.btnp ?
  2. 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.

  1. 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.
  2. Écrire une fonction nouvelle_partie(). Quelles variables doivent être déclarées global ?
  3. Appeler cette fonction dans update() au bon endroit.
Vérifier ses acquis 2 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.

Le programme obtenu

Le programme complet est organisé ainsi :

constantes, puis variables décrivant l'état du jeu
↓
fonctions réalisant chacune une tâche précise
dessiner_joueur(), dessiner_cible(...), dessiner_sol(), distance(...), cible_attrapee(), deplacer_joueur(), tirer_position_cible(), nouvelle_cible(), nouvelle_partie()
↓
update() : fait évoluer l'état du jeu
↓
draw() : dessine l'état du jeu
↓
pyxel.init(...) puis pyxel.run(update, draw)
Q82.

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

Défis

Les défis sont classés par difficulté croissante.

Q83.

Défi A : cible multicolore. La couleur de la cible change à chaque point marqué.

Q84.

Défi B : difficulté croissante. À partir de 5 points, le joueur se déplace plus vite. VITESSE peut-elle rester une constante ?

Q85.

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.

Q86.

Défi D : deux cibles. Une deuxième cible, d’une autre couleur, rapporte 3 points.

Bilan

À l’issue de cette activité, je sais…
  • distinguer la définition d’une fonction de son appel, et désigner une fonction sans l’appeler ;
  • utiliser des constantes plutôt que des valeurs numériques écrites dans les instructions ;
  • expliquer quand une variable est locale ou globale, et utiliser global à bon escient ;
  • écrire une condition qui tient compte des dimensions d’un objet ;
  • distinguer paramètres et arguments ;
  • choisir entre une boucle for et une boucle while ;
  • distinguer une fonction qui renvoie une valeur d’une fonction qui l’affiche ;
  • écrire une fonction qui renvoie un booléen et l’utiliser comme condition ;
  • utiliser quelques instructions de Pyxel (text, rect, circ, btn, btnp, rndi).
Physique, Chimie et Informatique > 1ère Spécialité NSI > Premiers pas en programmation

Suivre l'évolution des variables

Objectif

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
def transforme(x: int) -> int:
    """Fonction à étudier."""
    y = 2 * x
    x = y + 1
    return x * y

a = 3
b = 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 acquis 3 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.

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
def double(n: int) -> int:
    """Retourne le double de n."""
    n = 2 * n
    return n

def f(n: int) -> int:
    """Fonction à étudier."""
    m = double(n) + 1
    n = double(m)
    return n - m

n = 3
r = 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 acquis 2 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.

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 = 12
AGE_SENIOR = 65
PRIX_ENFANT = 5
PRIX_REDUIT = 7
PRIX_NORMAL = 10

def tarif(age: int, etudiant: bool) -> int:
    """Retourne le prix de la place, en euros."""
    if age < AGE_ENFANT:
        prix = PRIX_ENFANT
    elif age >= AGE_SENIOR or etudiant:
        prix = PRIX_REDUIT
    else:
        prix = PRIX_NORMAL
    return prix
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 : False 70 >= 65 or ... : True 7
tarif(17, True) 17 < 12 : False 17 >= 65 or True : True 7
tarif(30, False) 30 < 12 : False 30 >= 65 or False : False 10
tarif(12, False) 12 < 12 : False 12 >= 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 acquis 3 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.

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
def ajuste_a(score: int) -> int:
    """Calcule un nouveau score."""
    if score < 10:
        score = score + 3
    if score < 15:
        score = score + 2
    if score > 14:
        score = score + 1
    return score
1
2
3
4
5
6
7
8
9
def ajuste_b(score: int) -> int:
    """Calcule un nouveau score."""
    if score < 10:
        score = score + 3
    elif score < 15:
        score = score + 2
    elif score > 14:
        score = score + 1
    return score
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 :

>>> for score in range(21):
...     if ajuste_a(score) != ajuste_b(score):
...         print(score, end=" ")
0 1 2 3 4 5 6 7 8 9 13 14
Vérifier ses acquis 2 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.

Exercice 5 — Faire tourner une boucle à la main

On considère les deux fonctions suivantes.

def mystere(n: int) -> int:
    """Fonction à étudier."""
    s = 0
    for i in range(1, n + 1, 2):
        s = s + i
    return s
def mystere_bis(n: int) -> int:
    """Fonction à étudier."""
    s = 0
    i = 1
    while i <= n:
        s = s + i
        i = i + 2
    return s
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 acquis 2 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.

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
def est_pair(n: int) -> bool:
    """Retourne True si n est pair, False sinon."""
    return n % 2 == 0

def syracuse(n: int) -> str:
    """Retourne le nombre d'étapes pour atteindre 1
    et la plus grande valeur atteinte.
    """
    etapes = 0
    maxi = n
    while n != 1:
        if est_pair(n):
            n = n // 2
        else:
            n = 3 * n + 1
        if n > maxi:
            maxi = n
        etapes += 1
    return f"{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

def motif(n: int) -> str:
    """Fonction à étudier."""
    texte = ""
    for i in range(1, n + 1):
        for j in range(i):
            texte += "*"
        texte += "-"
    return texte
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=101 + 2 + 3 + 4 = 10 étoiles et 4 tirets, soit 14 caractères.

Vérifier ses acquis 2 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.

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.