QCM : Mémento Python 3 (21 questions)

Questions et réponses du QCM

1. Une séquence doit conserver l’ordre de ses éléments, permettre un accès par index et accepter des valeurs répétées. Quels conteneurs répondent à ces critères ?

Les tuples et les ensembles
Les listes et les tuples
Les dictionnaires et les ensembles
Les listes et les dictionnaires

Les listes et les tuples

Explication

Les listes et les tuples sont des séquences ordonnées accessibles par index qui peuvent contenir des valeurs répétées. Les ensembles ne sont pas des séquences ordonnées, les dictionnaires associent des clés à des valeurs, et l’idée d’interdire les doublons ne s’applique pas aux listes et aux tuples.

2. Pour représenter des étiquettes associées à leurs valeurs, puis une collection d’éléments distincts sans ordre particulier, quels conteneurs faut-il choisir, dans cet ordre ?

Un ensemble, puis un dictionnaire
Un dictionnaire, puis un ensemble
Un tuple, puis une liste
Une liste, puis un dictionnaire

Un dictionnaire, puis un ensemble

Explication

Un dictionnaire associe des clés à des valeurs, tandis qu’un ensemble contient des éléments sans ordre a priori et sans doublons. L’ensemble ne stocke pas les associations clé-valeur, et le dictionnaire n’est pas le conteneur décrit pour une collection d’éléments sans ordre.

3. Une personne crée les noms `score_total`, `2e_score` et `score2`. Lesquels respectent la règle de formation des identificateurs ?

Les trois noms
`score_total` et `score2`
`2e_score` et `score2`
`score_total` et `2e_score`

`score_total` et `score2`

Explication

Un identificateur commence par une lettre ou un souligné, puis peut contenir des lettres, des chiffres et des soulignés. `2e_score` commence par un chiffre, tandis que le chiffre de `score2` apparaît après la première lettre.

4. Dans l’instruction `prix = 12`, que réalise l’affectation ?

Elle associe le nom `prix` à la valeur 12
Elle transforme la valeur 12 en nom `prix`
Elle vérifie si `prix` est égal à 12
Elle compare deux valeurs nommées `prix` et 12

Elle associe le nom `prix` à la valeur 12

Explication

Une affectation associe un nom à une valeur : ici, le nom `prix` est associé à 12. La comparaison d’égalité teste une relation, et l’affectation ne transforme pas la valeur en nom.

5. En Python, si `a = 17` et `b = 5`, quelles valeurs renvoient respectivement `a / b`, `a // b` et `a % b` ?

3 ; 3,4 ; 2
17 ; 5 ; 2
3,4 ; 2 ; 3
3,4 ; 3 ; 2

3,4 ; 3 ; 2

Explication

`/` effectue une division réelle, `//` donne le quotient entier et `%` le reste : ici, ces résultats sont 3,4, 3 et 2. La confusion des deux divisions produit la réponse « 3 ; 3,4 ; 2 », tandis que prendre le quotient pour le reste mène à « 3,4 ; 2 ; 3 ».

6. Un programme calcule `sin(1)` en Python, où l’argument est fourni directement comme `1`. Comment faut-il interpréter cet argument et le résultat calculé ?

Un angle d’un radian, avec un résultat exact
Un angle d’un radian, avec un résultat flottant approché
Un angle d’un degré, avec un résultat exact
Un angle d’un degré, avec un résultat flottant approché

Un angle d’un radian, avec un résultat flottant approché

Explication

Les fonctions trigonométriques utilisent des radians et les nombres flottants représentent des valeurs approchées. « Un degré » confond radians et degrés, tandis que « résultat exact » néglige l’approximation des flottants.

7. Pour `nombres = [10, 20, 30, 40, 50]`, quels éléments désignent respectivement `nombres[0]` et `nombres[-1]` ?

20 et 50
0 et −1
10 et 40
10 et 50

10 et 50

Explication

L’indexation commence à 0 pour le premier élément et l’indice −1 désigne le dernier : les éléments sont donc 10 et 50. « 20 » résulte d’un comptage à partir de 1, et « 40 » correspond à l’indice −2.

8. Pour `s = [10, 20, 30, 40, 50]`, quel résultat produit `s[1:4]` ?

[10, 20, 30]
[20, 30, 40, 50]
[30, 40, 50]
[20, 30, 40]

[20, 30, 40]

Explication

Dans une tranche, la borne de fin est exclue : les indices 1, 2 et 3 donnent `[20, 30, 40]`. Inclure l’élément d’indice 4 produit `[20, 30, 40, 50]`, et décaler le début conduit à `[30, 40, 50]`.

9. Dans ce code, quelle valeur est affectée à `etat` lorsque `age` vaut 70 ? ```python if age <= 18: etat = "Enfant" elif age > 65: etat = "Retraité" else: etat = "Actif" ```

Aucune valeur n’est affectée
« Actif »
« Enfant »
« Retraité »

« Retraité »

Explication

La première condition est fausse, mais `age > 65` est vraie : le bloc `elif` s’exécute. « Enfant » correspond à la première condition, « Actif » au cas où toutes les conditions sont fausses, et l’exécution de plusieurs blocs méconnaît la règle du premier bloc vrai.

10. Une expression Python utilise `and` avec une chaîne non vide à gauche et une autre valeur à droite. Quelle propriété faut-il retenir pour déterminer le résultat ?

Le résultat est nécessairement un booléen indiquant si les deux valeurs sont vraies.
Le résultat est une comparaison entre les deux valeurs, comme avec `==`.
Le résultat est toujours l’opérande situé à gauche de `and`.
Le résultat peut être une valeur opérande choisie par l’évaluation au plus court.

Le résultat peut être une valeur opérande choisie par l’évaluation au plus court.

Explication

`and` et `or` peuvent renvoyer une valeur opérande selon l’évaluation au plus court, plutôt qu’un booléen. L’idée d’un résultat nécessairement booléen confond ces opérateurs avec les comparaisons, tandis que les deux autres erreurs attribuent un résultat de comparaison ou une position fixe.

11. Dans cette boucle, comment éviter qu’elle se répète indéfiniment si `i` commence à 1 ? ```python while i <= 5: print(i) ```

Faire évoluer une autre variable sans modifier `i`.
Faire évoluer `i` dans le bloc pour qu’elle dépasse 5.
Remplacer `while` par `for` sans définir de séquence à parcourir.
Conserver `i` inchangé, puisque `print` la fait avancer.

Faire évoluer `i` dans le bloc pour qu’elle dépasse 5.

Explication

Une boucle `while` continue tant que sa condition est vraie ; ici, il faut donc faire évoluer `i` afin qu’elle dépasse 5. Modifier une autre variable ne change pas le résultat de la condition, et l’affichage ne fait pas avancer `i`.

12. Pour parcourir une liste en affichant à chaque étape l’indice et la valeur correspondante, quelle construction convient ?

`for indice in liste:`
`for indice, valeur in range(len(liste)):`
`for indice, valeur in enumerate(liste):`
`for valeur in enumerate(liste):`

`for indice, valeur in enumerate(liste):`

Explication

`enumerate(liste)` fournit des couples composés de l’indice et de la valeur, adaptés à ce parcours simultané. `range(len(liste))` fournit des indices, tandis qu’`enumerate` donne des couples et non des valeurs seules.

13. Une liste `notes` doit être triée sans créer une nouvelle liste et en conservant le même objet. Quelle opération convient ?

`notes.reverse()`
`notes.sort()`
`notes.extend(...)`
`sorted(notes)`

`notes.sort()`

Explication

La méthode `sort()` trie la liste sur place, tandis que `sorted()` produit une copie triée. `reverse()` inverse l’ordre existant et `extend()` ajoute une séquence d’éléments.

14. Un programme doit parcourir simultanément deux listes, en associant les éléments situés au même index. Quelle opération générique sur conteneurs convient ?

`enumerate(liste1)`
`zip(liste1, liste2)`
`élément in liste1`
`len(liste1)`

`zip(liste1, liste2)`

Explication

`zip` produit des tuples regroupant les éléments de même index dans les séquences fournies. `enumerate` associe un index aux éléments d’une seule séquence, `in` teste la présence et `len` compte les éléments.

15. Une chaîne contient des mots séparés par des virgules, et le programme doit obtenir une liste de ces mots. Quelle opération faut-il appliquer ?

`chaine.split(",")`
`list(chaine)`
`chaine.split()`
`",".join(chaine)`

`chaine.split(",")`

Explication

`split(",")` découpe la chaîne à chaque virgule et renvoie une liste de chaînes. `join` assemble une séquence de chaînes, `split()` découpe sur les blancs et `list` sépare la chaîne en caractères.

16. Pour insérer une valeur dans une chaîne de sortie et contrôler sa présentation, quelle forme de formatage faut-il utiliser ?

`sequence[valeur]`
`print("Valeur :", valeur)`
`str(valeur)`
`"Valeur : {}".format(valeur)`

`"Valeur : {}".format(valeur)`

Explication

`str.format` utilise des champs entre accolades et des directives de formatage pour insérer et présenter des valeurs. `str` convertit une valeur en chaîne, l’indexation accède à un élément et `print` affiche des valeurs.

17. Un programme demande un entier à l’utilisateur avec `input("Âge : ")`, puis doit effectuer un calcul numérique avec la réponse. Que doit-il faire ?

Convertir la réponse en chaîne avec `str(...)`.
Utiliser directement la réponse comme un entier.
Convertir la réponse en entier, par exemple avec `int(...)`.
Convertir la réponse en booléen avec `bool(...)`.

Convertir la réponse en entier, par exemple avec `int(...)`.

Explication

`input` renvoie une chaîne ; il faut donc la convertir, par exemple avec `int`, avant un calcul entier. L’utiliser directement ne la transforme pas en nombre, et `str` ou `bool` ne fournit pas la conversion attendue.

18. Une fonction doit recevoir deux valeurs, calculer leur somme et la fournir à l’appelant. Quelle définition et quelle structure d’appel conviennent ?

La définir avec `def`, puis appeler son nom sans parenthèses et renvoyer la somme avec `return`.
La définir avec `def`, puis appeler son nom avec des parenthèses et afficher la somme avec `print`.
La définir avec `def`, puis appeler son nom avec des parenthèses et renvoyer la somme avec `return`.
La définir avec `return`, puis appeler son nom avec des parenthèses et afficher la somme avec `def`.

La définir avec `def`, puis appeler son nom avec des parenthèses et renvoyer la somme avec `return`.

Explication

`def` définit la fonction, les parenthèses servent à l’appeler et `return` transmet le résultat à l’appelant. Appeler sans parenthèses ne lance pas la fonction, tandis que `print` affiche une valeur sans la renvoyer.

19. Dans un programme, un bloc `try` effectue un traitement susceptible de provoquer une exception précise, et une opération de nettoyage doit avoir lieu qu’une exception survienne ou non. Quel agencement convient ?

Mettre le traitement normal dans `finally`, la gestion de l’exception dans `except` et le nettoyage dans `try`.
Mettre le traitement normal dans `try`, le nettoyage dans `except` et la gestion de l’exception dans `finally`.
Mettre le traitement normal dans `try`, la gestion de l’exception dans `finally` et le nettoyage dans `except`.
Mettre le traitement normal dans `try`, la gestion de l’exception dans `except` et le nettoyage dans `finally`.

Mettre le traitement normal dans `try`, la gestion de l’exception dans `except` et le nettoyage dans `finally`.

Explication

`try` exécute le traitement normal, `except` traite l’exception indiquée et `finally` exécute les opérations finales dans tous les cas. Mettre le nettoyage dans `except` le limiterait aux erreurs; `finally` n’est pas le bloc qui traite l’exception.

20. Un programme doit ajouter du texte à la fin d’un fichier existant sans choisir le mode de lecture. Quel appel à `open` répond à ce besoin ?

`open(nom, "w", encoding="utf8")`
`open(nom, "a", encoding="utf8")`
`open(nom, encoding="utf8")`
`open(nom, "r", encoding="utf8")`

`open(nom, "a", encoding="utf8")`

Explication

Le mode `a` sert à ajouter du contenu au fichier, tandis que `w` sert à écrire et `r` à lire. Omettre le mode ne sélectionne pas explicitement l’ajout.

21. Un script parcourt les lignes d’un fichier texte et doit garantir que celui-ci est fermé lorsque le traitement du bloc se termine. Quelle forme faut-il employer ?

`with open(nom, "r", encoding="utf8") as f:` puis traiter les lignes dans le bloc
`with open(nom, "r", encoding="utf8"):` puis traiter les lignes avec une variable non liée
`f = open(nom, "r", encoding="utf8")` puis traiter les lignes sans fermer le fichier
`f = open(nom, "r", encoding="utf8"); f.close()` puis parcourir les lignes

`with open(nom, "r", encoding="utf8") as f:` puis traiter les lignes dans le bloc

Explication

La forme `with open(...) as f` gère la fermeture automatique du fichier à la fin du bloc. Une ouverture simple ne fournit pas cette gestion, et fermer le fichier avant la lecture empêche de parcourir ses lignes.

Révisez avec les flashcards

Mémorisez les réponses avec 77 flashcards sur Mémento Python 3.

Quelles propriétés partagent les listes et les tuples concernant l’ordre et l’accès ?

Ce sont des séquences ordonnées accessibles rapidement par index.

Que peuvent contenir les listes et les tuples ?

Des valeurs répétées.

Comment les dictionnaires associent-ils leurs données ?

Ils associent des clés à des valeurs.

Voir les flashcards →

Approfondir avec la fiche

Consultez la fiche de révision complète sur Mémento Python 3.

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