Aller au contenu principal
Physique, Chimie et Informatique

1ère Spécialité NSI

Programme

Documents

Les QCM

Chaque section d’une activité se termine par un QCM qui permet de vérifier ses acquis. Les questions défilent une à une et le score n’apparaît qu’à la fin. Si toutes les réponses ne sont pas justes, on peut recommencer le QCM (les choix sont alors mélangés) ou demander à voir les réponses, mais on ne peut alors plus le retenter.

16 nov. 2026

Sous-sections de 1ère Spécialité NSI

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.

Sous-sections de Premières structures de données : listes et tuples

Physique, Chimie et Informatique > 1ère Spécialité NSI > Premières structures de données : listes et tuples

Les tuples

Objectif

Regrouper plusieurs valeurs dans un seul objet, le tuple, pour qu’une fonction puisse renvoyer plusieurs résultats à la fois.

Une fonction peut-elle renvoyer deux valeurs ?

Dans le Doc. 2,4, la fonction plus_grand_plus_petit retournait une chaîne de caractères comme "max : 18.0, min : 7.5". Pour un humain, c’est très lisible. Mais imaginons qu’on veuille ensuite calculer l’écart entre le maximum et le minimum. Il faudrait fouiller dans le texte pour retrouver les chiffres, puis les convertir en nombres. On a fabriqué une phrase alors qu’on voulait deux nombres.

Le vrai problème est le suivant : une instruction return met fin à la fonction. On ne peut donc pas écrire deux return à la suite en espérant récupérer deux résultats. Faisons une expérience.

Q22.

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

def min_max(a: float, b: float):
    """Retourne le plus petit puis le plus grand des nombres a et b."""
    if a < b:
        return a, b
    return b, a
  1. Appeler min_max(9, 4) dans la console. Qu’affiche-t-elle ?
  2. Saisir ensuite resultat = min_max(9, 4), puis type(resultat). Combien d’objets la fonction a-t-elle retournés ?

On n’a donc pas contourné la règle : une fonction renvoie toujours une seule valeur. On a simplement rangé les deux nombres dans une même boîte, et c’est la boîte qu’on renvoie.

À retenir

Un tuple (le programme dit aussi p-uplet) est une suite ordonnée de valeurs. On l’écrit en séparant les valeurs par des virgules, le plus souvent entre parenthèses : (4, 9).

Le tuple est un type construit : il est fabriqué à partir de valeurs de types de base (int, float, str, bool).

Une fonction ne retourne qu’une seule valeur. Pour retourner plusieurs résultats, elle les regroupe dans un tuple : return a, b.

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

Créer un tuple et lire ses éléments

C’est la virgule qui fait le tuple

Q23.

Pour chacune des expressions suivantes, prévoir le type de la valeur obtenue, puis vérifier avec la fonction type dans la console :

>>> type((3, 7, 12))
>>> type(3, 7, 12)
>>> type((5))
>>> type((5,))
>>> type(())

Le deuxième essai provoque une erreur. Pourquoi, à votre avis ? Comment écrire un tuple qui ne contient qu’un seul élément ?

Les éléments d’un tuple ne sont pas forcément du même type. Une ville peut être décrite par son nom, sa latitude et sa longitude :

ville = ("Paris", 48.86, 2.35)

Ce tuple n’a de sens que parce qu’on s’est mis d’accord sur l’ordre : d’abord le nom, ensuite la latitude, enfin la longitude. Si on écrivait (48.86, "Paris", 2.35), Python ne protesterait pas, mais un programme qui attend le nom en premier serait trompé.

Repérer un élément par son indice

Chaque élément d’un tuple occupe une position, appelée indice. En Python, les indices commencent à 0. Cela paraît étrange au début. Une façon de s’en souvenir : l’indice indique combien de pas il faut faire depuis le début pour atteindre l’élément. Le premier élément est à zéro pas du début.

indice 0 1 2
élément de t 3 7 12

On lit l’élément d’indice i du tuple t en écrivant t[i]. La fonction len, déjà rencontrée avec les chaînes de caractères, donne le nombre d’éléments du tuple.

Q24.

Saisir t = (3, 7, 12) dans la console. Prévoir le résultat de chacune des instructions suivantes, puis vérifier :

>>> t[0]
>>> t[2]
>>> len(t)
>>> t[3]
>>> t[len(t) - 1]

Quel est l’indice du dernier élément d’un tuple qui contient n éléments ?

Indices négatifs

Python accepte aussi des indices négatifs, qui comptent à partir de la fin : t[-1] est le dernier élément, t[-2] l’avant-dernier. Avec t = (3, 7, 12), t[-1] vaut 12, exactement comme t[len(t) - 1].

Q25.

Avec ville = ("Paris", 48.86, 2.35), écrire une instruction qui affiche, à l’aide d’une f-string et des indices :

Paris : latitude 48.86, longitude 2.35
À retenir

Les éléments d’un tuple t sont repérés par leur indice, qui commence à 0. On lit l’élément d’indice i avec t[i].

len(t) donne le nombre d’éléments de t. Les indices valides vont donc de 0 à len(t) - 1. Un indice en dehors de ces limites provoque une erreur IndexError.

Un tuple d’un seul élément s’écrit avec une virgule : (5,). Le tuple vide s’écrit ().

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

Un tuple ne peut pas être modifié

Q26.

Toujours avec t = (3, 7, 12), essayer de remplacer le premier élément par 4 :

>>> t[0] = 4

Que se passe-t-il ?

Un tuple, une fois créé, ne change plus. On dit qu’il est non mutable (ou immuable). Est-ce gênant ? Pas vraiment, car on peut toujours fabriquer un nouveau tuple.

Q27.

Prévoir, puis vérifier, le contenu de t et de u après chacune des instructions suivantes :

>>> t = (3, 7, 12)
>>> u = t + (20,)
>>> u
>>> t
>>> t = (4, t[1], t[2])
>>> t

L’opérateur + a-t-il modifié t ? La dernière affectation a-t-elle modifié le tuple (3, 7, 12) ?

Q28.

Prévoir puis vérifier le résultat de 7 in t et de 8 in t, avec t = (4, 7, 12). De quel type est la valeur obtenue ?

Pourquoi Python propose-t-il un objet qu’on ne peut pas modifier ? Parce que c’est une garantie. Les coordonnées de Paris ne vont pas changer pendant l’exécution du programme. Si on les range dans un tuple et qu’on les confie à une fonction, on est certain de les retrouver intactes, quelle que soit la façon dont cette fonction a été écrite.

À retenir

Un tuple est non mutable : on ne peut pas modifier ses éléments. L’instruction t[0] = 4 provoque une erreur TypeError.

On peut en revanche construire un nouveau tuple, par exemple par concaténation avec l’opérateur + : (3, 7) + (12,) vaut (3, 7, 12).

valeur in t vaut True si valeur est un élément de t, False sinon.

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

Parcourir un tuple

Un tuple est un objet itérable, au même titre que ce que produit range (voir Doc. 2,4). On peut donc le parcourir avec une boucle for. Il y a deux façons de le faire.

Q29.

Recopier les deux fonctions suivantes dans l’éditeur :

def somme(valeurs: tuple[float, ...]) -> float:
    """Retourne la somme des éléments du tuple valeurs."""
    total = 0
    for v in valeurs:
        total += v
    return total

def somme_2(valeurs: tuple[float, ...]) -> float:
    """Retourne la somme des éléments du tuple valeurs."""
    total = 0
    for i in range(len(valeurs)):
        total += valeurs[i]
    return total
  1. Tester somme((3, 7, 12)) et somme_2((3, 7, 12)).
  2. Dans chaque fonction, quelles valeurs prend successivement la variable de boucle (v ou i) ?
  3. L’annotation tuple[float, ...] signifie « tuple de nombres flottants, de longueur quelconque ». Pourquoi ne pas avoir écrit tuple[float, float, float] ?

La première écriture est plus courte. La seconde n’est utile que lorsqu’on a besoin de connaître la position des éléments, comme dans la question suivante.

Q30.

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

def indice_max(valeurs: tuple[float, ...]) -> int:
    """Retourne l'indice du plus grand élément de valeurs.
    valeurs ne doit pas être vide.

    >>> indice_max((12, 5, 18, 7))
    2
    """

Indication. On suppose d’abord que le plus grand élément est celui d’indice 0, puis on compare cet élément à chacun des suivants.

À retenir

On parcourt un tuple t de deux façons :

  • for element in t: donne directement les éléments, un par un ;
  • for i in range(len(t)): donne les indices, et on lit l’élément avec t[i]. On utilise cette écriture lorsque la position de l’élément compte.
Vérifier ses 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.

Déballer un tuple

L’affectation multiple

Quand un tuple contient peu d’éléments, il est souvent plus clair de donner un nom à chacun d’eux. Python permet de le faire en une seule ligne.

Q31.

Saisir les instructions suivantes dans la console, en prévoyant le résultat avant chaque validation :

>>> point = (2, 5)
>>> x, y = point
>>> x
>>> y
>>> a, b = (1, 2, 3)

Expliquer le message d’erreur obtenu à la dernière ligne.

Q32.

Reprendre la fonction min_max de la première partie. Écrire dans la console une instruction qui range le résultat de min_max(9, 4) dans deux variables petit et grand, puis calculer l’écart entre ces deux nombres.

Retour sur l’échange de deux variables

Dans le Doc. 2,2, on a vu que la séquence a = b puis b = a n’échange pas les valeurs de deux variables, et qu’il fallait passer par une variable tmp. Avec les tuples, Python propose une écriture bien plus courte.

Q33.

Saisir les instructions suivantes dans la console :

>>> a = 605
>>> b = 506
>>> a, b = b, a
>>> a, b
  1. Les valeurs ont-elles été échangées ?
  2. La séquence a = b puis b = a échouait parce que la valeur de a était écrasée avant d’avoir été recopiée. Expliquer, en décrivant ce que fait Python dans l’ordre, pourquoi ce problème ne se pose pas ici.
Q34.

Pour l’épreuve écrite. Sans utiliser Python, compléter le tableau d’état de la séquence suivante, puis vérifier dans la console.

a, b = 3, 8
a, b = b, a + b
a, b = b - a, a
Instruction a b
a, b = 3, 8
a, b = b, a + b
a, b = b - a, a
Q35.

Dans le Doc. 2,4, la fonction fibo utilisait une troisième variable w pour calculer le terme suivant de la suite de Fibonacci. Réécrire cette fonction sans la variable w, à l’aide d’une affectation multiple. Vérifier que fibo(10) retourne '1 1 2 3 5 8 13 21 34 55 '.

À retenir

L’affectation multiple x, y = point déballe un tuple : chaque variable de gauche reçoit l’élément de même position. Il doit y avoir autant de variables que d’éléments, sinon Python signale une erreur ValueError.

Dans a, b = b, a, Python évalue d’abord tout le membre de droite, qui forme un tuple, puis affecte les variables. C’est pourquoi cette instruction échange les valeurs de a et de b.

Vérifier ses 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 une fonction qui renvoie un tuple

Pour annoncer qu’une fonction retourne un tuple, on indique dans sa signature le type de chaque élément, dans l’ordre : -> tuple[int, int] signifie « retourne un tuple de deux entiers ». Pour un tuple de longueur quelconque dont tous les éléments ont le même type, on écrit tuple[float, ...].

Consigne

Écrire chaque fonction dans la partie principale de l’éditeur, avec sa spécification complète (signature et documentation). Tester ensuite chacun des exemples de la documentation dans la console.

Q36.

Division euclidienne. Écrire la fonction division_euclidienne dont la spécification est :

def division_euclidienne(a: int, b: int) -> tuple[int, int]:
    """Retourne le quotient et le reste de la division euclidienne
    de a par b (b non nul).

    >>> division_euclidienne(17, 5)
    (3, 2)
    >>> division_euclidienne(20, 4)
    (5, 0)
    """

Comparer avec le résultat de la fonction divmod(17, 5), fournie par Python.

Q37.

Convertir une durée. Une course de fond a duré 3725 s. On veut exprimer cette durée en heures, minutes et secondes.

  1. Sans ordinateur, effectuer la conversion à la main, en détaillant le calcul.
  2. Écrire la fonction convertir_duree dont la spécification est :
def convertir_duree(duree: int) -> tuple[int, int, int]:
    """Convertit une durée donnée en secondes en un tuple
    (heures, minutes, secondes).

    >>> convertir_duree(3725)
    (1, 2, 5)
    >>> convertir_duree(59)
    (0, 0, 59)
    """
Q38.

Milieu d’un segment. Dans un repère, un point est représenté par le tuple (x, y) de ses coordonnées. Écrire la fonction milieu dont la spécification est :

def milieu(a: tuple[float, float], b: tuple[float, float]) -> tuple[float, float]:
    """Retourne les coordonnées du milieu du segment [AB].

    >>> milieu((0, 0), (4, 2))
    (2.0, 1.0)
    >>> milieu((-1, 3), (1, 3))
    (0.0, 3.0)
    """

Indication. Commencer par déballer chacun des deux tuples.

Q39.

Distance entre deux points. Dans le Doc. 2,1, la fonction distance recevait quatre arguments x1, y1, x2, y2. Avec des tuples, deux arguments suffisent. On veut de plus que la fonction marche aussi dans l’espace, avec des points à trois coordonnées. Dans un repère orthonormé de l’espace, la distance entre A(xA,yA,zA)A(x_A, y_A, z_A) et B(xB,yB,zB)B(x_B, y_B, z_B) est :

AB=(xB−xA)2+(yB−yA)2+(zB−zA)2A B = \sqrt{(x_B - x_A)^2 + (y_B - y_A)^2 + (z_B - z_A)^2}
  1. Écrire la fonction distance dont la spécification est :
def distance(a: tuple[float, ...], b: tuple[float, ...]) -> float:
    """Retourne la distance entre les points a et b, qui doivent
    avoir le même nombre de coordonnées.

    >>> distance((0, 0), (3, 4))
    5.0
    >>> distance((1, 2, 3), (1, 2, 3))
    0.0
    >>> distance((0, 0, 0), (1, 2, 2))
    3.0
    """
  1. Que devrait faire la fonction si on l’appelle avec distance((0, 0), (1, 1, 1)) ? Ajouter au début du corps de la fonction l’instruction :
assert len(a) == len(b), "les deux points doivent avoir la même dimension"

puis tester à nouveau cet appel.

À retenir

L’instruction assert condition, "message" vérifie qu’une condition est vraie. Si elle est fausse, le programme s’arrête avec une erreur AssertionError et affiche le message.

On s’en sert pour vérifier une précondition, c’est-à-dire une condition que les arguments doivent respecter pour que la fonction ait un sens. Mieux vaut un programme qui s’arrête en expliquant pourquoi qu’un programme qui retourne un résultat faux sans prévenir.

Q40.

Plus petit et plus grand élément. Écrire la fonction min_max_tuple dont la spécification est :

def min_max_tuple(valeurs: tuple[float, ...]) -> tuple[float, float]:
    """Retourne le plus petit et le plus grand élément de valeurs,
    qui ne doit pas être vide.

    >>> min_max_tuple((12, 5, 18, 7))
    (5, 18)
    >>> min_max_tuple((4,))
    (4, 4)
    """

Les fonctions min et max de Python ne doivent pas être utilisées. Vérifier la précondition par une assertion.

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

Q41.

Équation du second degré. On cherche les solutions réelles de l’équation ax2+bx+c=0a x^2 + b x + c = 0, avec a≠0a \neq 0. On note Δ=b2−4ac\Delta = b^2 - 4 a c le discriminant.

  • Si Δ>0\Delta > 0, il y a deux solutions : x1=(−b−Δ)/(2a)x_1 = (-b - \sqrt{\Delta}) / (2 a) et x2=(−b+Δ)/(2a)x_2 = (-b + \sqrt{\Delta}) / (2 a).
  • Si Δ=0\Delta = 0, il y a une seule solution : x0=−b/(2a)x_0 = -b / (2 a).
  • Si Δ<0\Delta < 0, il n’y a pas de solution réelle.

Le nombre de solutions change d’une équation à l’autre. Un tuple convient bien : il peut contenir deux, un ou zéro élément. Écrire la fonction racines dont la spécification est :

def racines(a: float, b: float, c: float) -> tuple[float, ...]:
    """Retourne le tuple des solutions réelles de a x² + b x + c = 0,
    avec a non nul.

    >>> racines(1, -3, 2)
    (1.0, 2.0)
    >>> racines(1, 2, 1)
    (-1.0,)
    >>> racines(1, 0, 1)
    ()
    """
Q42.

Comparer deux dates. Une date est représentée par un tuple (jour, mois, annee). Écrire la fonction est_avant dont la spécification est :

def est_avant(d1: tuple[int, int, int], d2: tuple[int, int, int]) -> bool:
    """Retourne True si la date d1 est strictement antérieure
    à la date d2, False sinon.

    >>> est_avant((14, 7, 1789), (11, 11, 1918))
    True
    >>> est_avant((25, 12, 2025), (1, 1, 2025))
    False
    >>> est_avant((3, 5, 2026), (3, 5, 2026))
    False
    >>> est_avant((3, 5, 2026), (4, 5, 2026))
    True
    """

Indication. Comparer d’abord les années. Si elles sont égales, comparer les mois, et ainsi de suite.

Bilan

À l’issue de cette activité, je sais…
  • créer un tuple, y compris un tuple d’un seul élément (5,) et le tuple vide () ;
  • lire un élément d’un tuple grâce à son indice, en sachant que les indices vont de 0 à len(t) - 1 ;
  • expliquer pourquoi t[0] = 4 provoque une erreur, et construire un nouveau tuple à la place ;
  • tester la présence d’une valeur dans un tuple avec in ;
  • parcourir un tuple par ses éléments ou par ses indices, et choisir l’écriture adaptée ;
  • déballer un tuple par une affectation multiple, et expliquer pourquoi a, b = b, a échange deux valeurs ;
  • écrire une fonction qui renvoie un tuple de valeurs, avec une signature du type -> tuple[int, int] ;
  • vérifier une précondition à l’aide d’une assertion.
Physique, Chimie et Informatique > 1ère Spécialité NSI > Premières structures de données : listes et tuples

Les listes

Objectif

Ranger des valeurs de même type dans une liste, modifier et parcourir ses éléments, puis construire des listes, y compris des listes de listes.

Quand un tuple ne suffit plus

Un professeur range les notes d’un devoir dans un tuple :

notes = (12, 15, 9, 14)

En relisant les copies, il s’aperçoit que la troisième note est fausse : c’est 11 et non 9. Avec un tuple, l’instruction notes[2] = 11 provoque une erreur, puisqu’un tuple n’est pas mutable (Doc. 3,1). Il faudrait reconstruire un tuple complet, (notes[0], notes[1], 11, notes[3]), pour changer une seule valeur. Avec 35 élèves, ce serait pénible.

Python propose pour cela un autre type construit, la liste, qui s’écrit entre crochets.

Q1.

Saisir les instructions suivantes dans la console :

>>> notes = [12, 15, 9, 14]
>>> type(notes)
>>> notes[2] = 11
>>> notes

La modification a-t-elle été acceptée ?

À retenir

Une liste est une suite ordonnée de valeurs, écrite entre crochets et séparées par des virgules : [12, 15, 9, 14]. Son type est list.

Une liste est mutable : on peut modifier ses éléments après sa création, alors qu’un tuple ne le permet pas.

Dans cette activité, tous les éléments d’une même liste ont le même type.

Remarque

Il ne faut pas confondre une liste avec un tableau. Un tableau est un ensemble de valeurs de même type, rangées les unes à la suite des autres dans la mémoire : on dit qu’elles sont contiguës. Une liste Python ne répond pas à cette définition : ses éléments peuvent être de types différents, et ils ne sont pas rangés côte à côte dans la mémoire. Python se sert de tableaux pour fabriquer ses listes, mais une liste n’est pas un tableau.

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

Lire et modifier les éléments d’une liste

Bonne nouvelle : tout ce qu’on a appris sur les indices des tuples reste vrai pour les listes.

Q2.

Saisir notes = [12, 15, 11, 14] dans la console. Prévoir le résultat de chacune des instructions suivantes, puis vérifier :

>>> notes[0]
>>> len(notes)
>>> notes[len(notes) - 1]
>>> notes[4]
>>> 15 in notes
>>> []
>>> len([])

Ce qui est nouveau, c’est qu’on peut écrire notes[i] à gauche du signe =. L’élément d’indice i est alors remplacé par une nouvelle valeur. Les opérateurs d’affectation du Doc. 2,2 fonctionnent aussi : notes[1] += 2 ajoute 2 à l’élément d’indice 1.

Q3.

Le professeur décide d’ajouter un point à chaque note. Un élève propose :

notes = [12, 15, 11, 14]
for n in notes:
    n += 1

Un autre élève propose :

notes = [12, 15, 11, 14]
for i in range(len(notes)):
    notes[i] += 1
  1. Exécuter les deux propositions et afficher notes après chacune d’elles. Laquelle fonctionne ?
  2. Expliquer pourquoi l’autre ne modifie pas la liste.
À retenir

t[i] = valeur remplace l’élément d’indice i de la liste t.

Pour modifier les éléments d’une liste dans une boucle, on parcourt les indices : for i in range(len(t)):. La boucle for element in t: permet de lire les éléments, mais pas de les modifier.

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

Construire une liste

Une liste de taille fixée à l’avance

L’opérateur * appliqué à une liste et à un entier répète la liste. Ainsi [0] * 6 vaut [0, 0, 0, 0, 0, 0]. On obtient une liste de 6 éléments, qu’on peut ensuite remplir par indice.

Q4.

Recopier et compléter la fonction suivante, qui doit construire la liste des carrés des entiers de 0 à n - 1 :

def carres(n: int) -> list[int]:
    """Retourne la liste des carrés des entiers de 0 à n - 1.

    >>> carres(5)
    [0, 1, 4, 9, 16]
    """
    resultat = [0] * n
    for i in range(n):
        ...
    return resultat

Une liste en compréhension

En mathématiques, on décrit parfois un ensemble par une règle plutôt qu’en écrivant tous ses éléments : k2∣k∈0,1,2,3,4{k^2 | k \in {0, 1, 2, 3, 4}} se lit « l’ensemble des k2k^2 pour kk appartenant à {0,1,2,3,4}\{0, 1, 2, 3, 4\} ». Python permet d’écrire une liste de la même façon :

[k * k for k in range(5)]

Cette expression se lit presque comme la phrase : « la liste des k * k pour k parcourant range(5) ». On dit que la liste est construite en compréhension. Elle remplace les quatre lignes du corps de la fonction carres.

Q5.

Prévoir la liste obtenue pour chacune des expressions suivantes, puis vérifier dans la console :

>>> [2 * k + 1 for k in range(5)]
>>> [n / 2 for n in [12, 15, 11, 14]]
>>> [len(mot) for mot in ["tuple", "liste", "indice"]]
>>> [k for k in range(1, 21) if k % 3 == 0]

À quoi sert la partie if k % 3 == 0 dans la dernière expression ?

Q6.

Écrire une liste en compréhension qui donne :

  1. les 10 premiers multiples de 7 : [7, 14, 21, ..., 70] ;
  2. les notes de la liste notes = [12, 15, 8, 14, 6, 17] qui sont inférieures à 10 ;
  3. la liste [True, False, True, False, True, False] qui indique, pour chaque entier de 0 à 5, s’il est pair.
À retenir

On peut construire une liste :

  • de taille fixée, avec [valeur] * n, puis la remplir par indice ;
  • en compréhension, avec [expression for element in iterable]. On peut ajouter un filtre : [expression for element in iterable if condition].
Vérifier ses 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.

Une liste, plusieurs noms

Une surprise

Q7.

Saisir les instructions suivantes dans la console, en prévoyant le résultat de la dernière ligne avant de la valider :

>>> n = [12, 18, 9]
>>> m = n
>>> m[0] = 0
>>> n

Le résultat est-il celui que vous attendiez ?

Ce résultat surprend presque tout le monde la première fois. Pour le comprendre, il faut revenir à ce que fait vraiment une affectation (Doc. 2,2) : une variable référence une valeur. Elle ne contient pas la liste, elle indique où elle se trouve, un peu comme une étiquette collée dessus.

L’instruction m = n ne fabrique donc pas une deuxième liste. Elle colle une deuxième étiquette, m, sur la même liste :

n →\rightarrow
arrow.larrow.l m

Quand on écrit m[0] = 0, on modifie cette liste unique. En la regardant par l’étiquette n, on voit forcément la modification. On dit que m et n sont des alias.

Avec les nombres et les tuples, ce phénomène existe aussi, mais il ne se voit jamais : comme on ne peut pas modifier un nombre ou un tuple, on ne peut pas constater que deux étiquettes désignent le même objet. C’est la mutabilité des listes qui le rend visible.

Q8.

Pour obtenir une vraie copie, on peut construire une nouvelle liste en compréhension. Prévoir puis vérifier le contenu de n et de c :

>>> n = [12, 18, 9]
>>> c = [x for x in n]
>>> c[0] = 0
>>> n
>>> c

Une fonction peut modifier la liste qu’on lui donne

Lors d’un appel, le paramètre reçoit la valeur de l’argument, exactement comme dans une affectation. Si l’argument est une liste, le paramètre devient donc un alias de cette liste.

Q9.

Recopier les deux fonctions suivantes dans l’éditeur :

def reinitialiser_1(notes: list[float]) -> None:
    notes = [0] * len(notes)

def reinitialiser_2(notes: list[float]) -> None:
    for i in range(len(notes)):
        notes[i] = 0

Prévoir, puis vérifier, le contenu de releve après chaque appel :

>>> releve = [12, 15, 9, 14]
>>> reinitialiser_1(releve)
>>> releve
>>> reinitialiser_2(releve)
>>> releve

Expliquer la différence de comportement entre les deux fonctions.

Effet de bord

Une fonction qui modifie une liste reçue en argument agit sur la liste du programme appelant. On parle d’effet de bord. C’est parfois ce qu’on veut, mais il faut alors l’annoncer clairement dans la documentation de la fonction. Si on ne le veut pas, la fonction doit travailler sur une copie, ou construire et retourner une nouvelle liste.

À retenir

Après m = n, les variables m et n référencent la même liste : ce sont des alias. Toute modification faite par l’une est visible par l’autre.

Pour obtenir une copie indépendante, on construit une nouvelle liste, par exemple [x for x in n].

Une fonction qui reçoit une liste peut la modifier (effet de bord) avec t[i] = .... En revanche, une nouvelle affectation du paramètre (t = ...) ne change pas la liste de l’appelant.

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

Des listes de listes

Les éléments d’une liste peuvent eux-mêmes être des listes. C’est ainsi qu’on représente des valeurs rangées en lignes et en colonnes, comme les cases d’une grille de jeu. En mathématiques, des nombres rangés de cette façon forment une matrice.

m = [[1, 2, 3],
     [4, 5, 6]]

m est une liste de deux éléments : m[0] est la liste [1, 2, 3], qu’on voit comme la première ligne, et m[1] est la liste [4, 5, 6]. Pour atteindre un nombre, on applique deux indices l’un après l’autre : m[1] donne la ligne d’indice 1, puis m[1][2] donne l’élément d’indice 2 de cette ligne.

Q10.

Avec la liste m ci-dessus, prévoir puis vérifier :

>>> m[0]
>>> m[1][2]
>>> len(m)
>>> len(m[0])
>>> m[0][1] = 0
>>> m

Que représentent len(m) et len(m[0]) pour la matrice ?

Q11.

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

def somme_matrice(m: list[list[int]]) -> int:
    """Retourne la somme de tous les éléments de la matrice m.

    >>> somme_matrice([[1, 2, 3], [4, 5, 6]])
    21
    """

Indication. Utiliser deux boucles imbriquées : l’une parcourt les indices des lignes, l’autre ceux des colonnes.

Q12.

Dans le Doc. 2,4, la fonction table_multiplication retournait une chaîne de caractères. On veut maintenant une matrice, pour pouvoir retrouver chaque produit par ses indices. Écrire la fonction table_multiplication dont la spécification est :

def table_multiplication(n: int) -> list[list[int]]:
    """Retourne la table de multiplication des entiers de 1 à n,
    sous forme d'une matrice de n lignes et n colonnes.

    >>> table_multiplication(4)
    [[1, 2, 3, 4], [2, 4, 6, 8], [3, 6, 9, 12], [4, 8, 12, 16]]
    """

Indication. Une ligne de la table est une liste en compréhension. La table entière est une liste de lignes, elle aussi en compréhension.

Avec t = table_multiplication(10), que vaut t[6][7] ? Quel produit cet élément représente-t-il ?

Un piège classique

Pour fabriquer une grille de 3 lignes et 3 colonnes remplie de zéros, l’écriture [[0] * 3] * 3 semble naturelle. Pourtant :

>>> g = [[0] * 3] * 3
>>> g[0][0] = 5
>>> g
[[5, 0, 0], [5, 0, 0], [5, 0, 0]]

Le * 3 extérieur ne fabrique pas trois lignes : il place trois fois la même ligne dans la liste. Les trois lignes sont des alias. La bonne écriture fabrique une nouvelle ligne à chaque tour :

>>> g = [[0] * 3 for i in range(3)]
À retenir

Une liste de listes permet de représenter une matrice, c’est-à-dire des valeurs rangées en lignes et en colonnes. m[i] est la ligne d’indice i, et m[i][j] l’élément de la ligne i et de la colonne j.

len(m) donne le nombre de lignes et len(m[0]) le nombre de colonnes. On parcourt une matrice avec deux boucles imbriquées.

Vérifier ses 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 et documentation). Tester ensuite chacun des exemples de la documentation dans la console. Les fonctions sum, min, max et la méthode index de Python ne doivent pas être utilisées.

Q13.

Moyenne. Écrire la fonction moyenne dont la spécification est :

def moyenne(notes: list[float]) -> float:
    """Retourne la moyenne des éléments de notes, qui ne doit pas être vide.

    >>> moyenne([12, 15, 9, 14])
    12.5
    """

Vérifier la précondition à l’aide d’une assertion (voir Doc. 3,1).

Q14.

Recherche d’une valeur. Écrire la fonction indice dont la spécification est :

def indice(valeurs: list[int], cherchee: int) -> int:
    """Retourne l'indice de la première occurrence de cherchee dans
    valeurs, ou -1 si cherchee n'est pas dans valeurs.

    >>> indice([4, 8, 15, 16, 23, 42], 16)
    3
    >>> indice([4, 8, 15, 16, 23, 42], 7)
    -1
    >>> indice([5, 3, 5], 5)
    0
    """

Dans le pire des cas, combien de comparaisons la fonction effectue-t-elle pour une liste de 1000 éléments ? Et pour une liste deux fois plus longue ?

Q15.

Statistiques d’un devoir. On veut écrire la fonction statistiques dont la spécification est :

def statistiques(notes: list[float]) -> tuple[float, int, int, int]:
    """Retourne un tuple (m, bas, milieu, haut) où m est la moyenne
    des notes, bas le nombre de notes strictement inférieures à m - 3,
    milieu le nombre de notes comprises entre m - 3 et m + 3 (bornes
    incluses), haut le nombre de notes strictement supérieures à m + 3.

    >>> statistiques([12, 15, 8, 14, 6, 17])
    (12.0, 2, 3, 1)
    >>> statistiques([10, 7, 13])
    (10.0, 0, 3, 0)
    """
  1. Vérifier à la main le premier exemple de la documentation.
  2. Écrire la fonction, en utilisant la fonction moyenne de la question précédente.
  3. Un élève propose de compter les notes de chaque groupe avec une fonction qui compte les valeurs comprises dans un intervalle [a;b][a ; b], bornes incluses, appelée trois fois : sur [0;m−3][0 ; m - 3], sur [m−3;m+3][m - 3 ; m + 3] et sur [m+3;20][m + 3 ; 20]. Le deuxième exemple de la documentation montre pourquoi cette idée donne un résultat faux. Expliquer.
Q16.

Tirage du Loto sans répétition. Dans le Doc. 2,4, la fonction loto_naif pouvait tirer deux fois le même numéro, faute de pouvoir mémoriser les numéros déjà sortis. Une liste résout ce problème. Écrire la fonction loto dont la spécification est :

def loto() -> list[int]:
    """Retourne une liste de 6 entiers différents, tirés au hasard
    entre 1 et 49 (bornes incluses).
    """

Indication. Partir de la liste [0] * 6. Tirer un numéro avec random.randint(1, 49). S’il n’est pas déjà dans la liste, le ranger à la première place libre. Le nombre de tirages nécessaires n’est pas connu à l’avance : quelle boucle faut-il utiliser ?

Pour aller plus loin

Q17.

Transposée d’une matrice. La transposée d’une matrice s’obtient en échangeant ses lignes et ses colonnes : la première ligne devient la première colonne, et ainsi de suite. Écrire, en une seule ligne de code, la fonction transposee dont la spécification est :

def transposee(m: list[list[int]]) -> list[list[int]]:
    """Retourne la transposée de la matrice m.

    >>> transposee([[1, 2, 3], [4, 5, 6]])
    [[1, 4], [2, 5], [3, 6]]
    """

Bilan

À l’issue de cette activité, je sais…
  • expliquer la différence entre une liste, mutable, et un tuple, non mutable ;
  • lire et modifier un élément d’une liste grâce à son indice ;
  • parcourir une liste par ses éléments pour la lire, et par ses indices pour la modifier ;
  • construire une liste de taille fixée avec [valeur] * n ;
  • construire une liste en compréhension, avec ou sans filtre if ;
  • expliquer pourquoi, après m = n, une modification de m est visible dans n, et faire une vraie copie d’une liste ;
  • prévoir si une fonction modifie la liste qu’elle reçoit en argument ;
  • représenter une matrice par une liste de listes et utiliser la notation m[i][j] ;
  • écrire un algorithme de recherche d’une valeur, de calcul d’une moyenne, sur une liste.
Physique, Chimie et Informatique > 1ère Spécialité NSI > Premières structures de données : listes et tuples

Une liste est un objet auquel on peut passer des messages

Objectif

Faire grandir et rétrécir une liste en lui envoyant des messages, en particulier append et pop, et savoir si un message modifie la liste ou renvoie une valeur.

Q14.

On veut noter la liste des courses au fur et à mesure qu’on y pense. Au départ, on n’a pensé à rien : la liste est vide. Prévoir ce qui se passe lorsqu’on saisit les deux instructions suivantes dans la console, puis vérifier :

>>> courses = []
>>> courses[0] = "pain"

Dans le Doc. 3,2, on contournait la difficulté en fabriquant d’abord une liste de la bonne taille, par exemple [0] * 6, puis en la remplissant. Cela suppose de connaître la taille à l’avance. Pour une liste de courses, ce n’est pas le cas : on ne sait pas combien de choses on va y écrire. Il faut un moyen de dire à la liste « ajoute cet élément au bout ».

Envoyer un message à une liste

Objets, messages et méthodes

En Python, chaque valeur est un objet : un nombre, une chaîne de caractères, un tuple, une liste. Pour l’instant, retenons qu’un objet regroupe des données et des actions qu’il sait effectuer sur ces données. Les objets seront étudiés en détail en terminale. Ici, on apprend seulement à s’en servir : pour demander à un objet d’effectuer l’une de ses actions, on lui envoie un message. On écrit le nom de l’objet, un point, puis le message suivi de parenthèses :

courses.append("pain")

Cette instruction se lit : « on envoie à la liste courses le message append (ajouter, en anglais), avec l’argument "pain" ». La liste reçoit le message et réagit : elle place "pain" à sa fin. La façon dont un objet réagit à un message s’appelle une méthode. On dit indifféremment « envoyer le message append » ou « appeler la méthode append ».

Ce n’est pas la première fois que vous envoyez un message. Dans le Doc. 2,2, l’écriture "...{}...".format(...) envoyait le message format à une chaîne de caractères.

Comparons avec une fonction. Pour connaître la longueur d’une liste, on écrit len(courses) : on donne la liste à la fonction len, qui l’examine. Avec courses.append("pain"), on s’adresse à la liste elle-même, et c’est elle qui se modifie.

Q15.

Saisir les instructions suivantes dans la console, en prévoyant le résultat de chaque ligne avant de la valider :

>>> courses = []
>>> courses.append("pain")
>>> courses
>>> len(courses)
>>> courses.append("lait")
>>> courses.append("œufs")
>>> courses
>>> courses[2]

À quel indice se trouve l’élément qu’on vient d’ajouter avec append ? Exprimer cet indice à l’aide de len(courses).

À retenir

En Python, une liste est un objet. On lui envoie un message avec la notation pointée : liste.message(arguments). La façon dont l’objet réagit au message s’appelle une méthode.

t.append(x) ajoute l’élément x à la fin de la liste t. La liste est modifiée, sa longueur augmente de 1. Cela fonctionne aussi à partir de la liste vide [].

Construire une liste en partant de la liste vide

La méthode append permet une façon de construire une liste qu’on utilisera très souvent : partir de la liste vide, puis ajouter les éléments un par un, au fil d’une boucle.

Exemple résolu

On veut la liste des multiples de k compris entre 1 et n.

def multiples(n: int, k: int) -> list[int]:
    """Retourne la liste des multiples de k compris entre 1 et n.

    >>> multiples(20, 3)
    [3, 6, 9, 12, 15, 18]
    """
    resultat = []                # 1. on part de la liste vide
    for i in range(1, n + 1):    # 2. on examine chaque entier de 1 à n
        if i % k == 0:           # 3. s'il convient...
            resultat.append(i)   #    ... on l'ajoute au bout de la liste
    return resultat              # 4. on retourne la liste construite

Suivons l’appel multiples(20, 3). Au départ, resultat vaut []. Pour i égal à 1 et 2, le test est faux : rien ne se passe. Pour i égal à 3, le test est vrai : la liste devient [3]. Elle devient [3, 6] au tour où i vaut 6, et ainsi de suite. On n’a jamais eu besoin de savoir combien de multiples on allait trouver : la liste grandit d’elle-même.

Q16.

En suivant la même méthode, écrire la fonction diviseurs dont la spécification est :

def diviseurs(n: int) -> list[int]:
    """Retourne la liste des diviseurs de l'entier n, avec n >= 1,
    rangés dans l'ordre croissant.

    >>> diviseurs(12)
    [1, 2, 3, 4, 6, 12]
    >>> diviseurs(7)
    [1, 7]
    """

Pourquoi la méthode [0] * taille du Doc. 3,2 serait-elle mal adaptée ici ?

Q17.

Retour sur le Loto. Dans le Doc. 3,2, la fonction loto partait de [0] * 6 et utilisait une variable nbre_tirees pour savoir où ranger le prochain numéro. Réécrire cette fonction en partant de la liste vide et en utilisant append :

def loto() -> list[int]:
    """Retourne une liste de 6 entiers différents, tirés au hasard
    entre 1 et 49 (bornes incluses).
    """

Quelle variable de l’ancienne version devient inutile ? Par quoi est-elle remplacée ?

Coups de pouce
  1. On ne sait pas combien de tirages il faudra, puisqu’un numéro déjà sorti est rejeté. La boucle reste donc une boucle while.
  2. La boucle doit s’arrêter quand la liste contient 6 numéros. Quelle expression donne le nombre de numéros déjà rangés ?
Vérifier ses 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.

Retirer un élément : le message pop

Le message pop fait l’inverse de append : il retire un élément de la liste. Mais il fait aussi autre chose, que l’on va découvrir.

Q18.

Saisir les instructions suivantes dans la console, en prévoyant le résultat de chaque ligne avant de la valider :

>>> pile = [3, 7, 12, 5]
>>> pile.pop()
>>> pile
>>> x = pile.pop(0)
>>> x
>>> pile
>>> pile.pop()
>>> pile.pop()
>>> pile.pop()
  1. Quel élément pop() retire-t-il lorsqu’on ne lui donne pas d’argument ? Et pop(0) ?
  2. Contrairement à append, la ligne pile.pop() affiche quelque chose. Que représente ce qui est affiché ?
  3. Pourquoi la dernière ligne provoque-t-elle une erreur ?
À retenir

t.pop() retire le dernier élément de la liste t et le renvoie. t.pop(i) retire l’élément d’indice i et le renvoie. Dans les deux cas, la longueur de la liste diminue de 1.

Envoyer pop à une liste vide provoque l’erreur IndexError. Avant un pop, il faut donc s’assurer que la liste n’est pas vide, par exemple avec len(t) > 0.

Les deux messages append et pop() agissent sur la fin de la liste. Utilisés ensemble, ils font de la liste une pile d’assiettes : on pose une assiette sur le dessus, on reprend toujours celle du dessus. C’est exactement ce que fait la commande « Annuler » d’un traitement de texte. Chaque action est ajoutée au bout d’un historique. Annuler, c’est retirer la dernière action effectuée.

Q19.

Sans exécuter le programme, prévoir les affichages du programme suivant. Écrire le contenu de la liste historique après chaque ligne qui la modifie. Vérifier ensuite.

historique = []
historique.append("écrire Bonjour")
historique.append("mettre en gras")
historique.append("écrire Monde")
derniere = historique.pop()
print("Annulé :", derniere)
historique.append("souligner")
derniere = historique.pop()
print("Annulé :", derniere)
derniere = historique.pop()
print("Annulé :", derniere)
print(historique)
Q20.

Un élève veut écrire une fonction qui retourne les éléments d’une liste dans l’ordre inverse. Il a l’idée de vider la liste avec pop(), en ajoutant au fur et à mesure chaque élément retiré dans une nouvelle liste :

def inverser(t: list[int]) -> list[int]:
    """Retourne une nouvelle liste formée des éléments de t
    pris dans l'ordre inverse.

    >>> inverser([12, 15, 9, 14])
    [14, 9, 15, 12]
    """
    resultat = []
    while len(t) > 0:
        resultat.append(t.pop())
    return resultat
  1. Recopier la fonction, puis saisir dans la console :
    >>> releve = [12, 15, 9, 14]
    >>> r = inverser(releve)
    >>> r
    >>> releve
    La fonction retourne-t-elle le bon résultat ? Quel autre effet a-t-elle ?
  2. Expliquer cet effet à l’aide du Doc. 3,2.
  3. Corriger la fonction pour que la liste reçue en argument ne soit pas modifiée, en conservant l’idée de l’élève.
Coups de pouce
  1. Au moment de l’appel inverser(releve), combien de listes existent en mémoire ? Combien de noms les référencent ?
  2. Le message pop modifie la liste qui le reçoit. Sur quelle liste faudrait-il l’envoyer pour que releve ne soit pas touchée ?
Vérifier ses 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.

Un message qui modifie la liste ne renvoie rien

Q21.

Une élève veut ajouter le lait à sa liste de courses. Elle écrit :

>>> courses = ["pain"]
>>> courses = courses.append("lait")
>>> print(courses)
None

Sa liste a disparu. Elle essaie alors de ranger des notes dans l’ordre croissant avec le message sort (trier) :

>>> notes = [12, 15, 9, 14]
>>> print(notes.sort())
None
>>> notes
[9, 12, 14, 15]
  1. Que renvoie le message append ? Et le message sort ?
  2. Expliquer, étape par étape, ce qui s’est passé lors de l’instruction courses = courses.append("lait").
  3. Comment fallait-il écrire cette instruction ?

Cette erreur est l’une des plus fréquentes chez les débutants, et chez les autres. Elle vient d’une confusion entre deux sortes de messages. Certains messages, comme append ou sort, modifient la liste et renvoient None. D’autres, comme pop, modifient la liste et renvoient une valeur utile. Il en existe enfin qui ne modifient rien et se contentent de renvoyer une information sur la liste, comme on va le voir dans la partie 4.

Puisque append modifie la liste elle-même, tous les alias de cette liste voient la modification. L’opérateur +, qui met deux listes bout à bout, se comporte autrement.

Q22.

Prévoir, puis vérifier, le contenu de n et de m à la fin de chacune des deux séquences :

>>> n = [1, 2, 3]
>>> m = n
>>> m.append(4)
>>> n
>>> m
>>> n = [1, 2, 3]
>>> m = n
>>> m = m + [4]
>>> n
>>> m

Expliquer la différence.

À retenir

Un message qui modifie la liste, comme append ou sort, renvoie None. On l’écrit seul sur sa ligne, sans affectation : t.append(x) et jamais t = t.append(x).

pop modifie la liste et renvoie l’élément retiré, qu’on peut ranger dans une variable : x = t.pop().

Un message envoyé à une liste agit sur la liste elle-même : tous ses alias voient la modification. L’expression t + [x], elle, fabrique une nouvelle liste.

Vérifier ses 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’autres messages

Une liste comprend d’autres messages que append et pop. La commande help(list), dans la console, en donne la liste complète, en anglais. En voici quelques-uns, traduits :

Message Effet Renvoie
t.insert(i, x) insère x juste avant l’élément d’indice i None
t.remove(x) retire la première occurrence de x ; erreur ValueError si x est absent None
t.index(x) ne modifie pas la liste ; erreur ValueError si x est absent l’indice de la première occurrence de x
t.count(x) ne modifie pas la liste le nombre d’occurrences de x
t.reverse() renverse l’ordre des éléments None
t.sort() range les éléments dans l’ordre croissant None
t.copy() ne modifie pas la liste une nouvelle liste, copie de t
Q23.

À l’aide de ces descriptions, et sans exécuter les instructions, prévoir le résultat de chaque ligne. Indiquer pour chacune si la liste t est modifiée. Vérifier ensuite dans la console.

>>> t = [5, 8, 2, 8]
>>> t.insert(1, 10)
>>> t
>>> t.remove(8)
>>> t
>>> t.index(2)
>>> t.count(8)
>>> t.remove(7)
>>> t.reverse()
>>> t
Remarque

Dans la question sur la fonction inverser, on aurait pu écrire copie = t.copy() à la place de copie = [x for x in t]. Les deux instructions fabriquent une nouvelle liste contenant les mêmes éléments.

À retenir

Avant d’utiliser un message, il faut savoir répondre à deux questions : modifie-t-il la liste ? que renvoie-t-il ?

insert, remove, reverse et sort modifient la liste et renvoient None. pop la modifie et renvoie l’élément retiré. index, count et copy ne la modifient pas et renvoient une information ou une nouvelle liste.

Vérifier ses 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 et documentation). Tester ensuite chacun des exemples de la documentation dans la console. Aucune de ces fonctions ne doit modifier la liste qu’elle reçoit en argument.

Q24.

Sans doublons. Écrire la fonction sans_doublons dont la spécification est :

def sans_doublons(t: list[int]) -> list[int]:
    """Retourne une nouvelle liste contenant les éléments de t,
    chacun une seule fois, dans l'ordre de leur première apparition.

    >>> sans_doublons([3, 1, 3, 2, 1])
    [3, 1, 2]
    >>> sans_doublons([])
    []
    """

Pourquoi ne peut-on pas obtenir ce résultat simplement avec une liste en compréhension filtrée par if x not in t ?

Q25.

Pairs et impairs. Écrire la fonction separer dont la spécification est :

def separer(valeurs: list[int]) -> tuple[list[int], list[int]]:
    """Retourne un tuple (pairs, impairs) : pairs est la liste des
    éléments pairs de valeurs, impairs celle des éléments impairs,
    dans l'ordre où ils apparaissent dans valeurs.

    >>> separer([4, 7, 10, 3, 8])
    ([4, 10, 8], [7, 3])
    """

Tester ensuite, dans la console, l’affectation multiple p, i = separer([4, 7, 10, 3, 8]) (Doc. 3,1).

Pour aller plus loin

Q26.

Une file d’attente. À un guichet, les clients sont servis dans leur ordre d’arrivée : le premier arrivé est le premier servi. On décrit une matinée par une liste d’événements. Un prénom signale l’arrivée d’un client, qui se place au bout de la file. Le caractère "*" signale que le guichetier sert un client : celui qui attend depuis le plus longtemps.

def guichet(evenements: list[str]) -> tuple[list[str], list[str]]:
    """Retourne un tuple (servis, en_attente) : servis est la liste
    des clients servis, dans l'ordre où ils l'ont été, en_attente
    celle des clients qui attendent encore à la fin.
    On suppose que la file n'est jamais vide quand "*" survient.

    >>> guichet(["Ana", "Bilal", "*", "Chloé", "Dylan", "*"])
    (['Ana', 'Bilal'], ['Chloé', 'Dylan'])
    """
  1. Écrire la fonction guichet.
  2. Un élève a écrit pop() au lieu de pop(0). Sans exécuter son programme, prévoir ce que renvoie l’appel de la documentation. Pourquoi les clients ont-ils raison de se plaindre ?
Coups de pouce
  1. La file est une liste qui part vide. Que faut-il lui envoyer quand un client arrive ?
  2. Le client servi est celui qui est arrivé le premier. À quel indice de la file se trouve-t-il ?
  3. Le client servi doit à la fois quitter la file et rejoindre la liste servis. Un seul message renvoie l’élément qu’il retire.

Bilan

À l’issue de cette activité, je sais…
  • expliquer la différence entre appeler une fonction, comme len(t), et envoyer un message à une liste, comme t.append(x) ;
  • construire une liste en partant de la liste vide et en ajoutant ses éléments avec append dans une boucle ;
  • retirer le dernier élément d’une liste, ou celui d’indice i, avec pop, et utiliser l’élément renvoyé ;
  • éviter d’envoyer pop à une liste vide ;
  • dire, pour un message donné, s’il modifie la liste et ce qu’il renvoie, et ne jamais écrire t = t.append(x) ;
  • prévoir l’effet d’un message envoyé à une liste qui a plusieurs alias, notamment lorsqu’elle est passée en argument à une fonction ;
  • utiliser une liste comme une pile (append et pop()) ou comme une file (append et pop(0)).
Physique, Chimie et Informatique > 1ère Spécialité NSI > Premières structures de données : listes et tuples

Simuler un gaz avec Pyxel

Objectif

Construire pas à pas avec Pyxel la simulation d’un gaz : chaque particule est un tuple, le gaz est une liste de tuples passée en paramètre aux fonctions.

Q24.

Sur un billard, une bille frappe la bande de droite. Le schéma montre sa vitesse juste avant le choc.

Bille juste avant le choc Bille juste avant le choc

Dessiner la flèche de sa vitesse juste après le choc. Lequel des deux mouvements, horizontal ou vertical, est modifié par le choc ?

Dans un gaz, les particules avancent en ligne droite et rebondissent sur les parois comme la bille sur la bande. Le programme de départ est fourni dans Capytale. Quand une question commence par « Sans exécuter le programme », on écrit sa réponse avant de vérifier.

Une particule décrite par un tuple

Une particule est décrite par cinq entiers, rangés dans un tuple, toujours dans le même ordre :

indice 0 1 2 3 4
élément x y vx vy couleur

x et y sont les coordonnées du centre, en pixels. vx et vy sont les nombres de pixels parcourus horizontalement et verticalement à chaque image. Un écran n’a pas de demi-pixel : toutes ces valeurs sont des entiers.

import pyxel

# Constantes
LARGEUR = 160    # largeur de la fenêtre, en pixels
HAUTEUR = 120    # hauteur de la fenêtre, en pixels
RAYON = 3        # rayon d'une particule, en pixels

# Type d'une particule : (x, y, vx, vy, couleur)
Particule = tuple[int, int, int, int, int]

def dessiner_particule(p: Particule) -> None:
    """Dessine la particule p = (x, y, vx, vy, couleur)."""
    x, y, couleur = p[0], p[1], p[4]
    pyxel.circ(x, y, RAYON, couleur)

def update(gaz: list[Particule]) -> None:
    """Fait avancer le gaz d'une image."""
    pass

def draw(gaz: list[Particule]) -> None:
    """Dessine les particules du gaz."""
    pyxel.cls(0)
    dessiner_particule(gaz[0])

# Programme principal
pyxel.init(LARGEUR, HAUTEUR, title="Gaz parfait")
particules = [(36, 60, 2, -1, 8)]     # le gaz : une seule particule pour l'instant
pyxel.run(lambda: update(particules), lambda: draw(particules))

La ligne Particule = tuple[...] donne un nom au type d’une particule, que l’on utilise dans les annotations des fonctions.

pyxel.run attend deux fonctions sans paramètre. lambda: update(particules) est justement une fonction sans paramètre, écrite sur une ligne : à chaque image, elle appelle update en lui passant la liste particules.

Règle de ce programme

Une fonction peut lire les constantes, écrites en majuscules (LARGEUR, RAYON…), car leur valeur ne change jamais. Elle ne lit aucune autre variable du programme principal : la liste des particules lui est toujours passée en paramètre.

Q25.

Lancer le programme. Avec particules = [(36, 60, 2, -1, 8)] :

  1. que vaut particules[0][2] ? Quelle grandeur représente-t-il ?
  2. que faut-il écrire pour obtenir la couleur de la particule ?
  3. la particule va-t-elle monter ou descendre quand elle bougera ? Justifier à l’aide du repère de Pyxel (Doc. 2,5).
Q26.

Modifier particules pour obtenir une particule verte (couleur 11), au centre de l’écran, qui se déplacera vers la gauche de 1 pixel par image. Vérifier, puis revenir à la valeur de départ.

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

Faire avancer la particule

Pyxel affiche 30 images par seconde et appelle update(particules) avant chaque image. À chaque appel, on ajoute vx à x et vy à y.

Q27.

Sans exécuter le programme. La particule part de x=36x = 36 avec vx = 2. Elle touche le bord droit quand son centre atteint x=159−3=156x = 159 - 3 = 156. Au bout de combien de temps ?

Un élève propose :

def deplacer(p: Particule) -> None:
    p[0] = p[0] + p[2]
    p[1] = p[1] + p[3]
Q28.

Sans exécuter le programme, prévoir ce qui se passe si on appelle deplacer(particules[0]). Expliquer.

La fonction doit donc fabriquer un nouveau tuple et le retourner. Pour récupérer d’un coup les cinq éléments de p, on le déballe :

x, y, vx, vy, couleur = p      # x reçoit p[0], y reçoit p[1], etc.

Il faut autant de noms à gauche que d’éléments dans le tuple.

Q29.

Écrire la fonction deplacer :

def deplacer(p: Particule) -> Particule:
    """Retourne la particule p après une image de déplacement."""

Tester dans la console : deplacer((36, 60, 2, -1, 8)) doit retourner (38, 59, 2, -1, 8).

Q30.

Dans update, remplacer pass par gaz[0] = deplacer(gaz[0]). Sans exécuter le programme, prévoir ce qui se passera au bout de 2 secondes, puis vérifier.

Q31.

Un autre élève écrit dans update : gaz = [deplacer(gaz[0])]. Il n’obtient aucune erreur, mais la particule reste immobile. Expliquer, en s’aidant des fonctions reinitialiser_1 et reinitialiser_2 du Doc. 3,2.

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

Rebondir contre les murs

Comme sur le billard, quand la particule touche le mur de droite, vx devient -vx. On complète deplacer : elle change d’abord la vitesse si un mur est touché, puis fait avancer la particule. Première version, qui ne traite que le mur de droite :

def deplacer(p: Particule) -> Particule:
    """Retourne la particule p après une image : sa vitesse change
    si elle touche un mur, puis elle avance."""
    x, y, vx, vy, couleur = p
    if x + RAYON >= LARGEUR - 1:      # le bord droit du disque touche le mur
        vx = -vx
    return (x + vx, y + vy, vx, vy, couleur)
Q32.

Compléter deplacer pour les murs de gauche, du haut et du bas, puis tester.

Coups de pouce
  1. Pour les murs du haut et du bas, quelle composante de la vitesse change de signe ?
  2. Le mur du haut est la ligne y=0y = 0. Quel point du disque l’atteint en premier ?
Q33.

Sans ordinateur. On part de particules = [(158, 60, 1, 0, 8)]. Compléter le tableau avec les valeurs de x et vx après chaque appel de update. Que fait la particule ? Vérifier à l’écran.

image départ 1 2 3 4
x 158
vx 1
Q34.

Modifier les quatre conditions pour qu’une particule ne rebondisse que si elle se dirige vers le mur qu’elle touche. Refaire le tableau sans ordinateur, puis vérifier.

À retenir

Un tuple n’est pas mutable : une fonction qui « modifie » une particule fabrique et retourne un nouveau tuple. Le déballage x, y, vx, vy, couleur = p donne un nom à chaque élément.

Lors d’un rebond sur une paroi, la composante de la vitesse perpendiculaire à la paroi change de signe.

Une fonction qui reçoit une liste en paramètre peut modifier ses éléments (gaz[0] = ...). Si elle affecte une nouvelle valeur au paramètre (gaz = ...), la liste d’origine ne change pas.

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

Un gaz : une liste de particules

On veut maintenant 30 particules, tirées au hasard. pyxel.rndi(a, b) retourne un entier au hasard entre a et b, bornes comprises. Ajouter ces constantes au début du programme (8, 11 et 12 sont le rouge, le vert et le bleu) :

NB_PARTICULES = 30          # nombre de particules du gaz
VITESSE_MAX = 2             # valeur maximale d'une composante de la vitesse
COULEURS = (8, 11, 12)      # couleurs possibles
Q35.

Écrire la fonction nouvelle_particule, puis la tester plusieurs fois dans la console :

def nouvelle_particule() -> Particule:
    """Retourne une particule entièrement visible, tirée au hasard.
    Chaque composante de la vitesse est comprise entre -VITESSE_MAX
    et VITESSE_MAX. La couleur est l'un des éléments de COULEURS."""
Coups de pouce
  1. Un disque est entièrement visible si son centre est à au moins RAYON pixels de chaque bord (Doc. 2,5).
  2. Pour la couleur, tirer au hasard l’indice d’un élément de COULEURS.
Q36.

Dans le programme principal, remplacer particules = [(36, 60, 2, -1, 8)] par une liste de NB_PARTICULES particules construite en compréhension (Doc. 3,2). Pourquoi cette ligne doit-elle se trouver après la définition de nouvelle_particule ?

Q37.

Modifier draw pour dessiner toutes les particules de gaz.

Pour faire bouger toutes les particules, un élève écrit :

def update(gaz: list[Particule]) -> None:
    for p in gaz:
        p = deplacer(p)
Q38.

Sans exécuter le programme, prévoir ce qu’on observe. Expliquer, puis corriger.

À retenir

Le gaz est une liste de tuples, construite en compréhension. Pour lire ses éléments, on la parcourt par éléments. Pour les remplacer, on la parcourt par indices : gaz[i] = ....

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

Pour aller plus loin : des collisions entre particules

Dans un gaz réel, les particules se heurtent aussi entre elles. Deux particules se touchent si la distance entre leurs centres est inférieure ou égale à 2 * RAYON.

Q39.

Ajouter from math import sqrt au début du programme, puis écrire :

def distance(p1: Particule, p2: Particule) -> float:
    """Retourne la distance entre les centres de p1 et p2."""

def se_touchent(p1: Particule, p2: Particule) -> bool:
    """Retourne True si p1 et p2 se touchent, False sinon."""

Tester : distance((0, 0, 1, 1, 8), (3, 4, 0, 0, 12)) doit retourner 5.0.

Deux particules de même masse qui se heurtent de face échangent leurs vitesses. On adopte ce modèle pour toutes les collisions.

Q40.

Écrire la fonction choc :

def choc(p1: Particule, p2: Particule) -> tuple[Particule, Particule]:
    """Retourne les particules p1 et p2 après leur collision :
    elles ont échangé leurs vitesses."""

Tester : choc((50, 60, 1, 0, 8), (55, 60, -1, 0, 12)) doit retourner ((50, 60, -1, 0, 8), (55, 60, 1, 0, 12)).

Voici la fonction qui teste toutes les paires de particules de la liste gaz. Sa dernière ligne déballe le tuple retourné par choc, comme a, b = b, a (Doc. 3,1).

def gerer_chocs(gaz: list[Particule]) -> None:
    """Fait échanger leurs vitesses aux particules de gaz qui se touchent."""
    for i in range(len(gaz)):
        for j in range(i + 1, len(gaz)):
            p1 = gaz[i]
            p2 = gaz[j]
            if se_touchent(p1, p2):
                gaz[i], gaz[j] = choc(p1, p2)
Q41.
  1. Avec 3 particules, écrire tous les couples (i, j) testés.
  2. Pourquoi la boucle intérieure commence-t-elle à i + 1 et non à 0 ?
Q42.

Ajouter l’appel gerer_chocs(gaz) à la fin de update. Observer longuement : certaines particules restent collées. Pourquoi ? Corriger, en s’inspirant de la correction des rebonds sur les murs.

Coups de pouce
  1. Que fait gerer_chocs à l’image qui suit un échange de vitesses ?
  2. Sur le mur, on n’a fait rebondir que les particules qui s’en approchaient. Comment savoir si deux particules se rapprochent ? On peut utiliser deplacer et distance.

Il reste un défaut : des particules rapides se traversent parfois.

Q43.

Sans ordinateur. Deux particules arrivent de face, en diagonale : (50, 50, 2, 2, 8) et (56, 56, -2, -2, 12). À chaque image, update les déplace, puis appelle gerer_chocs. Compléter le tableau (distances arrondies au dixième), puis expliquer pourquoi les particules se traversent.

image départ 1 2 3
particule 1 (50, 50)
particule 2 (56, 56)
distance 8,5
se_touchent non
se_rapprochent oui

Pour éviter ce chevauchement, il faut anticiper : avant de déplacer les particules, on regarde si elles vont se toucher à l’image suivante.

Q44.

Modifier la condition de gerer_chocs pour tester si les particules se toucheront après leur déplacement, puis placer l’appel gerer_chocs(gaz) au début de update. Refaire le tableau précédent, puis vérifier à l’écran que les particules ne se traversent presque plus.

Vérifier ses 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éfis

Q45.

Défi A : le mélange de deux gaz. Au départ, les particules rouges sont dans la moitié gauche de la boîte, les bleues dans la moitié droite. Donner à nouvelle_particule les paramètres couleur, x_min et x_max, puis construire la liste. Comparer la vitesse du mélange avec et sans collisions.

Q46.

Défi B : chauffer le gaz. Chaque appui sur la touche ↑ double les deux composantes de la vitesse de toutes les particules. Que se passe-t-il après plusieurs appuis ?

Bilan

À l’issue de cette activité, je sais…
  • représenter un objet par un tuple et lire un élément par son indice ;
  • expliquer pourquoi on ne peut pas modifier un élément d’un tuple, et écrire une fonction qui retourne un nouveau tuple ;
  • déballer un tuple pour nommer ses éléments ;
  • construire une liste de tuples en compréhension ;
  • choisir entre un parcours par éléments, pour lire une liste, et un parcours par indices, pour la modifier ;
  • passer une liste en paramètre à une fonction, et expliquer pourquoi la fonction peut modifier ses éléments mais pas la remplacer ;
  • parcourir toutes les paires d’éléments d’une liste avec deux boucles imbriquées ;
  • faire tourner un programme à la main pour trouver l’origine d’un comportement inattendu.