QCM : Variables et conversions en Python (36 questions)

Questions et réponses du QCM

1. Une équipe part d’une idée pour automatiser la résolution d’un problème. En quoi consiste la programmation dans cette démarche ?

Assembler les composants d’un ordinateur pour augmenter sa capacité de calcul
Convertir un texte d’une langue humaine vers une autre langue humaine
Lancer un logiciel déjà écrit afin qu’il effectue une tâche donnée
Traduire des idées en instructions compréhensibles par la machine afin de résoudre le problème

Traduire des idées en instructions compréhensibles par la machine afin de résoudre le problème

Explication

La programmation consiste à formuler des instructions compréhensibles par la machine pour résoudre un problème. Assembler du matériel concerne la conception de l’ordinateur, lancer un logiciel est son exécution, et traduire entre langues humaines ne décrit pas cette démarche.

2. Pourquoi le langage binaire n’est-il pas un moyen pratique de communication directe entre une personne et un ordinateur ?

Il empêche l’ordinateur d’effectuer des calculs pourtant représentables en binaire
Il est difficile à écrire pour les humains et n’est pas compatible d’une machine ou d’un système à l’autre
Il est identique entre machines, mais ne peut représenter que des instructions simples
Il doit être réécrit dans la langue humaine utilisée par chaque personne

Il est difficile à écrire pour les humains et n’est pas compatible d’une machine ou d’un système à l’autre

Explication

Le binaire est difficile à écrire pour les humains et n’est pas compatible d’une machine ou d’un système d’exploitation à l’autre. L’ordinateur peut calculer en binaire, et les problèmes décrits ne sont ni la langue humaine de l’utilisateur ni une limitation aux instructions simples.

3. Une personne écrit un algorithme lisible en Python, puis le fait exécuter par un ordinateur qui traite le binaire. Quel rôle Python joue-t-il entre eux ?

Un mécanisme qui résout le problème sans instructions écrites
Un langage commun permettant à l’humain et à l’ordinateur de se comprendre
Un système d’exploitation qui rend les programmes compatibles
Le langage binaire directement compris par le processeur

Un langage commun permettant à l’humain et à l’ordinateur de se comprendre

Explication

Un langage de programmation comme Python sert de langage commun entre l’humain et l’ordinateur. Le binaire est le langage compris par l’ordinateur, tandis qu’un système d’exploitation et la résolution du problème sont des notions distinctes.

4. Une personne ouvre le même programme Python dans deux éditeurs qui affichent ses mots avec des couleurs différentes. Quelle interprétation est correcte ?

La coloration dépend de l’éditeur et aide à repérer la catégorie des éléments du code
La coloration change les instructions que l’interpréteur exécute
La coloration indique directement l’ordre dans lequel les instructions sont exécutées
La coloration est définie par Python et doit rester identique dans chaque éditeur

La coloration dépend de l’éditeur et aide à repérer la catégorie des éléments du code

Explication

La coloration syntaxique varie selon l’éditeur et rend le programme plus lisible en indiquant la catégorie des éléments du code. Elle ne modifie pas les instructions et ne fixe ni leur ordre d’exécution ni une apparence identique dans tous les éditeurs.

5. Dans un programme Python, une instruction prévue à l’intérieur d’un bloc conditionnel est décalée au même niveau que le mot-clé `if`. Quelle conséquence l’indentation peut-elle avoir ?

Elle renomme la condition et conserve la place de l’instruction dans le bloc
Elle peut changer la signification du code ou empêcher le programme de fonctionner
Elle change la couleur des instructions sans modifier leur structure
Elle modifie uniquement l’apparence du code sans effet sur son fonctionnement

Elle peut changer la signification du code ou empêcher le programme de fonctionner

Explication

En Python, l’indentation détermine la signification des lignes : la modifier peut changer le comportement du programme ou empêcher son fonctionnement. Elle ne se limite pas à l’apparence, ne renomme pas la condition et ne se confond pas avec la coloration syntaxique.

6. Une équipe veut que son code principal soit regroupé dans une fonction appelée au lancement du fichier. Quelle structure Python convient ?

Définir `main()`, puis l’appeler sous `if __name__ == "__main__":`
Placer le code dans `if __name__ == "__main__":` sans définir `main()`
Définir `main()`, puis l’appeler avant `if __name__ == "__main__":`
Définir `main()` sous `if __name__ == "__main__":` sans l’appeler

Définir `main()`, puis l’appeler sous `if __name__ == "__main__":`

Explication

La structure avancée définit le code dans une fonction `main()` et appelle cette fonction sous la condition `if __name__ == "__main__":`. Placer l’appel avant la définition ou omettre l’appel ne réalise pas cette structure.

7. Un script Python contient trois instructions successives, sans branchement ni appel qui change leur enchaînement. Dans quel ordre sont-elles exécutées ?

Dans l’ordre alphabétique des noms utilisés par les instructions
Dans l’ordre où les lignes apparaissent dans le programme
Dans l’ordre inverse, en commençant par la dernière ligne
Dans l’ordre associé aux couleurs affichées par l’éditeur

Dans l’ordre où les lignes apparaissent dans le programme

Explication

Les lignes d’un programme Python sont exécutées dans l’ordre où les instructions sont écrites. L’ordre inverse, l’ordre alphabétique et les couleurs de l’éditeur ne déterminent pas cette séquence.

8. Une même opération est appliquée à deux valeurs de types différents. Quel rôle joue le type de chaque valeur dans cette opération ?

Il modifie la valeur après l’exécution de l’opération.
Il indique l’emplacement mémoire où la valeur est stockée.
Il contribue à déterminer l’effet de l’opération sur la valeur.
Il détermine le nom que Python attribue à la valeur.

Il contribue à déterminer l’effet de l’opération sur la valeur.

Explication

Le type détermine notamment l’effet des opérations appliquées à une valeur. Le nom de la variable et son emplacement mémoire ne définissent pas cet effet, et le type ne sert pas à modifier la valeur après le calcul.

9. En Python, quel est le type du résultat de l’expression `9 / 3` ?

`float`
`bool`
`int`
`str`

`float`

Explication

En Python, l’opérateur `/` produit un résultat de type `float`, même lorsque la division tombe juste. `int` vient de la confusion avec une division entière, tandis que `bool` et `str` sont d’autres types sans rapport avec cette opération.

10. Si `p` vaut `False` et `q` vaut `True`, quelles sont les valeurs de `p and q` et de `p or q`, dans cet ordre ?

`False`, puis `False`
`True`, puis `True`
`True`, puis `False`
`False`, puis `True`

`False`, puis `True`

Explication

`and` vaut `True` seulement si ses deux opérandes sont `True`, tandis que `or` vaut `False` seulement si les deux sont `False`. Ici, `p and q` vaut donc `False` et `p or q` vaut `True`.

11. En Python, quelle valeur produit une comparaison comme `x <= y` ?

Une valeur booléenne
Un entier
Un nombre réel
Une chaîne de caractères

Une valeur booléenne

Explication

Les comparaisons, notamment `<=`, produisent des valeurs booléennes. Un entier, un réel ou une chaîne peut être comparé, mais ce n’est pas le type du résultat de la comparaison.

12. Dans une expression Python, que produit `'LAC' + 'BLEU'` ?

`'LACBLEU'`
`'LACLACBLEU'`
`'BLEULAC'`
`'LAC BLEU'`

`'LACBLEU'`

Explication

L’opérateur `+` concatène les chaînes en les plaçant l’une à la suite de l’autre. La répétition correspond à `*`, l’ajout d’un espace n’est pas implicite et l’ordre des opérandes est conservé.

13. Que produit l’expression `'ha' * 4` en Python ?

`'hahaha'`
`'hahahaha'`
une erreur, car une chaîne ne peut pas être répétée
`'ha4'`

`'hahahaha'`

Explication

L’opérateur `*` répète une chaîne le nombre de fois indiqué : quatre exemplaires de `'ha'` donnent `'hahahaha'`. Les autres réponses omettent une répétition, traitent les caractères comme des nombres ou écartent à tort cette opération.

14. Une élève compare deux chaînes avec l’opérateur `<` et constate que `'MONT' < 'LUNE'` vaut False. Quel principe explique ce résultat ?

La comparaison suit l’ordre alphabétique inverse, où M vient après L.
La comparaison porte sur le nombre de caractères, et les deux longueurs diffèrent.
La comparaison convertit les lettres en nombres et compare leurs valeurs numériques.
La comparaison suit l’ordre alphabétique, et M vient après L.

La comparaison suit l’ordre alphabétique, et M vient après L.

Explication

La comparaison lexicographique examine l’ordre alphabétique : dès la première lettre, M vient après L, donc `'MONT' < 'LUNE'` est faux. La longueur, une conversion numérique ou un ordre alphabétique inversé ne constituent pas la règle.

15. En programmation, que désigne une variable ?

Une valeur qui référence le nom du programme
Un nom qui référence une valeur en mémoire
Une opération qui transforme une valeur en nom
Un emplacement mémoire qui ne peut pas être désigné par un nom

Un nom qui référence une valeur en mémoire

Explication

Une variable est un nom qui référence une valeur en mémoire. La valeur n’est pas elle-même le nom, et une opération ou un emplacement sans nom ne correspond pas à cette définition.

16. Dans une instruction Python, que signifie `total = 12` ?

Le nom `total` est lié à la valeur 12.
Le programme additionne `total` et 12.
Le programme vérifie si `total` est égal à 12.
La valeur 12 est liée au nom `total` comme à une expression à calculer.

Le nom `total` est lié à la valeur 12.

Explication

Dans une affectation, `=` lie un nom à une valeur ; ici, `total` référence 12. Une comparaison d’égalité s’écrit `==`, et l’affectation ne réalise ni addition ni calcul du nom.

17. Lorsqu’un programme exécute `score = 17 + 5` et que `score` n’existe pas encore, quelle suite d’opérations décrit correctement l’affectation ?

Créer `score`, calculer 17 + 5, puis le relier à 22
Relier `score` à l’expression 17 + 5 sans la calculer
Calculer 17 + 5, créer `score`, puis le relier à 22
Calculer 17 + 5, puis comparer 22 au nom `score`

Calculer 17 + 5, créer `score`, puis le relier à 22

Explication

Python évalue d’abord le membre droit, obtient 22, crée le nom s’il n’existe pas, puis lie ce nom à la valeur calculée. Créer le nom en premier, conserver l’expression non évaluée ou effectuer une comparaison ne décrit pas ces étapes.

18. Une variable `n` vaut 8 avant l’exécution de `n = n + 1`. Quelle valeur référence-t-elle ensuite, et que signifie cette instruction ?

Vrai ou Faux, car l’instruction compare deux valeurs
9, car une nouvelle valeur est calculée à partir de l’ancienne
8, car l’égalité conserve la valeur initiale
10, car l’incrément est appliqué deux fois

9, car une nouvelle valeur est calculée à partir de l’ancienne

Explication

Le membre droit utilise l’ancienne valeur de `n` : 8 + 1 donne 9, puis l’affectation fait référencer cette nouvelle valeur à `n`. L’instruction n’est ni une égalité mathématique ni une comparaison, et l’incrément n’est pas appliqué deux fois.

19. Une développeuse veut nommer une variable contenant un numéro de dossier. Quel nom respecte la règle de position des chiffres ?

dossier-7
dossiér
7dossier
dossier7

dossier7

Explication

Les chiffres sont permis dans un nom de variable, mais pas en première position. « 7dossier » commence par un chiffre, « dossiér » contient une lettre accentuée et « dossier-7 » contient un trait d’union.

20. Dans un programme, une personne saisit la valeur « 8 » avec input et le résultat est stocké dans la variable n. Quel est le type de n avant toute conversion ?

Un nombre réel
Une chaîne de caractères
Une valeur booléenne
Un entier

Une chaîne de caractères

Explication

La fonction input renvoie du texte, même si la saisie ressemble à un nombre. La réponse « entier » confond input avec int, tandis que « nombre réel » et « valeur booléenne » attribuent d’autres types à la saisie.

21. Un programme lit deux saisies, « 6 » et « 2 », puis doit calculer leur somme numérique. Quelle opération faut-il appliquer à chaque saisie avant l’addition ?

Les conserver comme chaînes avec str
Les convertir en valeurs booléennes
Les relire avec input
Les convertir en entiers avec int

Les convertir en entiers avec int

Explication

int convertit les chaînes saisies en entiers, ce qui permet d’effectuer une addition numérique. Les conserver comme chaînes conduit à une concaténation, et str produit du texte plutôt qu’un entier.

22. Un programme doit afficher sous forme de texte la valeur booléenne `True`. Quelle conversion convient, et quel résultat produit-elle ?

`str(True)` produit `'True'`.
`float(True)` produit `'True'`.
`int(True)` produit `'True'`.
Aucune conversion ne peut produire ce texte.

`str(True)` produit `'True'`.

Explication

La fonction `str` convertit une valeur en chaîne, y compris une valeur booléenne. `int` et `float` convertissent vers des types numériques, tandis que l’idée d’une conversion impossible contredit le fonctionnement de `str`.

23. Un programme évalue `bool(0)`, `bool(None)` et `bool('IUT')`. Quelle suite de résultats obtient-il, dans cet ordre ?

`True`, `False`, `True`.
`False`, `True`, `True`.
`False`, `False`, `False`.
`False`, `False`, `True`.

`False`, `False`, `True`.

Explication

`bool` renvoie `False` pour une valeur équivalente à zéro et pour `None`, mais une chaîne non vide comme `'IUT'` donne `True`. La suite contenant `True` pour `None` confond l’absence de valeur avec une valeur vraie, et les autres suites classent mal zéro ou la chaîne.

24. Une saisie fournit la chaîne `'4.5'` et le programme tente directement `int('4.5')`. Que se passe-t-il ?

La conversion réussit et renvoie le réel 4.5.
La conversion échoue, car la chaîne représente un réel et non un entier.
La conversion réussit et renvoie l’entier 4.
La conversion réussit et renvoie l’entier 5.

La conversion échoue, car la chaîne représente un réel et non un entier.

Explication

`int` échoue sur une chaîne qui représente un réel, telle que `'4.5'`; le cas d’une valeur numérique réelle convertie en entier est différent. Le résultat 4 transpose abusivement ce cas, le résultat 5 arrondit la valeur, et 4.5 correspond au type de résultat de `float`.

25. Une variable reçue d’un autre programme contient la valeur `1.5`. Quelle fonction permet d’inspecter son type et quel type indique-t-elle ?

`float` indique `int`.
`type` indique `int`.
`type` indique `float`.
`int` indique `float`.

`type` indique `float`.

Explication

La fonction `type` sert à connaître le type d’une valeur; `1.5` est de type `float`. `int` est une fonction de conversion, et classer cette valeur comme `int` confond nombre décimal et entier.

26. Dans un programme Python, l’expression `'3' + 2` tente d’additionner une chaîne et un entier incompatibles. Quelle conséquence faut-il prévoir ?

Python signale une erreur de syntaxe avant l’exécution.
Python concatène les valeurs et produit la chaîne `'32'`.
Python convertit l’entier en chaîne et produit `'32'`.
Python déclenche une exception `TypeError` et arrête le programme.

Python déclenche une exception `TypeError` et arrête le programme.

Explication

Le mélange de types incompatibles dans cette opération déclenche une exception `TypeError`, qui arrête le programme. La concaténation confond cette addition avec `'3' * 2`, la conversion implicite n’a pas lieu, et l’expression est syntaxiquement valide.

27. Un programme exécute successivement `a = 4`, puis `a = a + 3`, puis `print(a)`. Quelle valeur affiche-t-il ?

11
3
4
7

7

Explication

Python exécute ces instructions dans l’ordre : la deuxième affectation remplace la valeur de `a` par 7, qui est ensuite affichée. Répondre 4 revient à négliger la réaffectation, tandis que 3 ou 11 résultent d’un calcul erroné.

28. Un programme doit répéter l’affichage d’un message tant qu’une condition est vraie, puis arrêter la répétition lorsque celle-ci devient fausse. Quel mécanisme permet ce changement du flot d’instructions ?

Une condition `if` seule
Une boucle
Une séquence linéaire
Une affectation

Une boucle

Explication

Une boucle permet de répéter des instructions et de modifier ainsi le flot d’exécution. Une séquence linéaire ne répète pas le message, une condition `if` seule ne réalise pas la répétition, et une affectation ne dirige pas le flot.

29. Dans un programme Python, plusieurs instructions sont décalées sous une entête. Que décrit ce regroupement ?

Deux programmes séparés par un décalage
Un bloc d’instructions rattaché à l’entête
Une entête regroupant les instructions précédentes
Une séquence d’instructions hors bloc

Un bloc d’instructions rattaché à l’entête

Explication

Un bloc regroupe plusieurs instructions sous une entête, et ces instructions sont décalées par rapport à celles qui sont hors du bloc. Une suite au même niveau ne marque pas ce regroupement ; l’entête n’est pas le bloc entier, et le décalage ne sépare pas des programmes.

30. Une instruction est déplacée d’un bloc conditionnel vers le niveau extérieur en réduisant son indentation. Quelle conséquence faut-il envisager ?

L’instruction devient un commentaire
Le programme conserve nécessairement la même signification
Le nom de l’instruction est modifié
La signification du programme peut changer

La signification du programme peut changer

Explication

L’indentation fait partie du langage Python : déplacer une instruction hors d’un bloc peut donc changer la signification du programme. La traiter comme un choix visuel néglige son rôle syntaxique ; elle ne transforme ni l’instruction en commentaire ni son nom.

31. Dans ce programme, la condition est fausse : ```python if temperature < 0: alerte = True print("Fin") ``` Que se passe-t-il lors de l’exécution ?

Le bloc est exécuté, puis « Fin » est affiché.
Le bloc est ignoré, puis « Fin » est affiché.
Le bloc est ignoré et « Fin » n’est pas affiché.
Le programme s’arrête avant d’afficher « Fin ».

Le bloc est ignoré, puis « Fin » est affiché.

Explication

Le bloc d’un if n’est exécuté que si sa condition vaut True ; quelle que soit sa valeur, le programme reprend ensuite après le bloc. Exécuter le bloc malgré une condition fausse confond True et False, sauter « Fin » oublie la reprise après le bloc, et arrêter le programme confond condition fausse et erreur.

32. Une personne est née le 20 du mois en cours, alors que nous sommes le 14. Son âge initial a été calculé sans tenir compte du jour. Quelle correction le programme doit-il appliquer ?

Laisser l’âge inchangé.
Diminuer l’âge d’une unité.
Augmenter l’âge d’une unité.
Remplacer l’âge par le jour du mois.

Diminuer l’âge d’une unité.

Explication

Lorsque le mois de naissance est le mois actuel et que le jour de naissance est encore à venir, l’anniversaire n’a pas eu lieu : il faut donc retirer une unité à l’âge. Laisser l’âge inchangé néglige le jour, l’augmenter inverse la correction, et le remplacer par le jour confond deux valeurs différentes.

33. Dans une condition composée, l’évaluation d’un terme suffit déjà à déterminer le résultat global. Que fait alors Python aux termes suivants ?

Il reprend les tests depuis le début après chaque terme.
Il évalue tous les termes avant de calculer le résultat.
Il cesse les tests et conserve le résultat déterminé.
Il réordonne les termes pour commencer par le plus simple.

Il cesse les tests et conserve le résultat déterminé.

Explication

Python lit les conditions dans leur ordre et arrête les tests dès que le résultat de l’expression est connu. Évaluer tous les termes ignore cet arrêt anticipé, les réordonner contredit l’ordre de lecture, et recommencer les tests ne fait pas partie de ce mécanisme.

34. En Python, qu’arrive-t-il à l’évaluation de `x / 0 == 3 or 1 < 2` si `x` vaut un nombre ?

L’expression vaut True grâce au second terme.
Une erreur survient lors du premier terme évalué.
Python teste le terme droit avant le terme gauche.
Le premier terme vaut False, puis le second est testé.

Une erreur survient lors du premier terme évalué.

Explication

Python évalue les termes dans l’ordre de lecture : le calcul `x / 0` est donc tenté en premier et provoque une erreur avant que le terme droit puisse être testé. Croire que le terme vrai à droite évite le calcul oublie cet ordre, commencer par la droite l’inverse, et traiter l’erreur comme False confond exception et valeur booléenne.

35. Un programme stocke successivement `-4`, `3.5`, `False`, `None` et `'salut'`. Quel type Python correspond à la valeur `None` ?

`bool`
`NoneType`
`str`
`int`

`NoneType`

Explication

La valeur `None`, qui représente l’absence de valeur, est de type `NoneType`. `bool` correspond aux valeurs vrai ou faux, `int` aux entiers et `str` aux chaînes de caractères.

36. Vous devez choisir un nom de variable Python qui commence par une lettre et contient ensuite un chiffre et un tiret bas. Lequel respecte la règle de nommage ?

`donnee 2`
`2donnee`
`donnee_2`
`donnee-2`

`donnee_2`

Explication

Un nom de variable peut contenir des lettres, des chiffres et le caractère `_`, à condition de ne pas commencer par un chiffre. `2donnee` commence par un chiffre, tandis que le tiret et l’espace ne sont pas autorisés dans les autres noms proposés.

Révisez avec les flashcards

Mémorisez les réponses avec 74 flashcards sur Variables et conversions en Python.

Que consiste à faire la programmation pour résoudre un problème ?

Écrire des programmes qui traduisent des idées en instructions compréhensibles par la machine.

Quel langage un ordinateur comprend-il directement ?

Le langage binaire.

Qu’est-ce qui rend le langage binaire difficile à utiliser pour les humains ?

Il est difficile à écrire pour les humains.

Voir les flashcards →

Approfondir avec la fiche

Consultez la fiche de révision complète sur Variables et conversions en Python.

Voir la fiche →

Cours similaires

Crée tes propres QCM

Importe ton cours et l'IA génère des QCM avec corrections en 30 secondes.

Générateur de QCM