QCM : Types et fonctions Python — 40 questions

Explication

Un type détermine l’ensemble des valeurs représentables ainsi que les opérations qui peuvent leur être appliquées. Une valeur littérale décrit une manière d’écrire une valeur, mais ne définit pas à elle seule ces deux ensembles.

Explication

Le type `str` représente les chaînes de caractères en Python. `int` désigne les entiers, `float` les nombres à virgule flottante et `bool` les booléens.

Explication

Le type `int` représente les nombres entiers relatifs de manière exacte, y compris lorsqu’ils sont très grands. La représentation approximative concerne le type `float`, tandis que les chaînes et les booléens relèvent d’autres types.

Explication

Les séparateurs `_` sont autorisés dans les littéraux entiers, ce qui rend `10_000_000` valide. Un zéro initial comme dans `007` est interdit, la virgule ne sert pas de séparateur de milliers et l’espace entre l’opérateur et le nombre empêche cette écriture d’être un seul littéral.

Explication

L’opérateur `%` calcule le reste de la division euclidienne, tandis que `//` fournit le quotient entier. Les opérateurs `**` et `*` servent respectivement à la puissance et à la multiplication.

Explication

Le type `float` stocke une approximation, car la représentation flottante ne permet pas d’encoder exactement tous les nombres réels. Les conversions en chaîne et l’arrondissement systématique des entiers ne constituent pas le mécanisme en cause.

Explication

La notation simple d’un flottant utilise un point et peut omettre le zéro avant ce point, comme dans `.5`. L’écriture `2,5` forme une expression avec une virgule, `5` est un entier et `2e-1` relève de la notation scientifique.

Explication

L’opérateur `/` réalise une division flottante et produit une valeur de type `float`, même lorsque les deux opérandes sont des entiers. Pour obtenir un quotient entier, il faudrait utiliser l’opérateur `//`.

Explication

Les nombres flottants sont approximatifs, si bien que l’addition `0.1 + 0.2` peut produire `0.30000000000000004`. Cette différence vient de la représentation binaire des flottants, et non d’une multiplication implicite ou d’une interdiction des décimaux.

Explication

Les guillemets font de 314 une séquence de caractères, alors que la valeur non guillemetée 314 est interprétée comme un entier. La présence des mêmes chiffres ne suffit donc pas à donner le même type aux deux valeurs.

Explication

Deux apostrophes sans caractère entre elles représentent une chaîne dont la longueur est nulle. Un espace entre guillemets constitue au contraire une chaîne contenant un caractère.

Explication

Avec deux chaînes, l’opérateur + les concatène en plaçant la seconde à la suite de la première. Il n’ajoute ni espace ni valeur numérique entre les deux morceaux.

Explication

La fonction int() transforme une chaîne numérique acceptable en entier. str() conserve ici une chaîne, float() produit un flottant et la dernière expression convertit une valeur déjà numérique plutôt que la chaîne demandée.

Explication

Une expression, qu’elle soit littérale ou composée avec des opérateurs, est évaluée pour produire une valeur. Un opérateur isolé ne forme pas nécessairement une expression complète.

Explication

Les parenthèses imposent que 2 + 3 soit évalué avant la multiplication par 4. Sans ces parenthèses, la multiplication située dans 2 + 3 * 4 est prioritaire.

Explication

L’opérateur ** s’évalue de droite à gauche : l’expression devient donc $2 ** (2 ** 3)$, soit 256. L’écriture $(2 ** 2) ** 3$ donnerait 64, mais elle impose une autre association.

Explication

La multiplication d’une chaîne par un entier répète la chaîne ce nombre de fois, sans ajouter d’espace. Cette opération se distingue de la multiplication entre deux opérandes numériques.

Explication

La forme de l’expression respecte la syntaxe Python, mais l’opération est impossible parce que le diviseur vaut zéro : l’erreur survient donc à l’exécution. SyntaxError concerne plutôt un code qui ne respecte pas les règles d’écriture, comme 007 dans ce contexte.

Explication

Le nom et le message de l’erreur indiquent la nature du problème et orientent vers la portion de code à vérifier. Modifier le programme sans tenir compte de ces indications ne permet pas d’identifier méthodiquement la cause.

Explication

Une fonction regroupe un calcul, précise les données nécessaires et masque les détails de sa réalisation. Un calcul limité à un exemple particulier ne correspond pas au traitement général réalisé par une fonction paramétrée.

Explication

La signature décrit le nom de la fonction, les paramètres dans leur ordre avec leurs types, ainsi que le type de retour. La précondition concerne les valeurs autorisées avant l’appel et ne constitue pas le type de retour.

Explication

Lors d’un appel, les expressions fournies sont d’abord évaluées, puis leurs valeurs sont liées aux paramètres et l’expression suivant return est calculée. L’évaluation du retour ne précède donc pas l’association des valeurs aux paramètres.

Explication

La fonction renvoie le quotient entier $nb\_objets \mathbin{//} places\_par\_carton$, donc $11 \mathbin{//} 5 = 2$. Le résultat ne correspond pas à un arrondi supérieur ni à une suppression complète des objets restants.

Explication

Une docstring est une chaîne entre triples guillemets placée juste sous la signature afin de documenter le comportement de la fonction. Un commentaire externe ou une liste de tests ne remplit pas cette définition.

Explication

La précondition porte sur les paramètres avant l’appel et indique dans quelles conditions celui-ci est pertinent. Le type de retour décrit la valeur produite après l’exécution et ne constitue pas une précondition.

Explication

Un test automatisé exécute l’appel, utilise un oracle pour comparer la valeur obtenue à la valeur attendue, puis produit un verdict. L’oracle réalise la comparaison, tandis que le verdict indique l’issue du test.

Explication

L1test considère le test réussi lorsque la valeur calculée par l’appel est égale à la valeur attendue. Le respect de la précondition ou l’absence d’erreur ne suffit pas si les deux valeurs comparées diffèrent.

Explication

Un test automatisé exécute l’expression, compare les deux résultats et affiche un verdict. La vérification mentale d’un résultat correspond au contrôle manuel et ne fournit pas cette comparaison automatique.

Explication

La docstring présente les appels avec les résultats attendus $2$, $2$ et $0$ pour les arguments indiqués. Le cas de $11$ objets utilise le quotient entier et ne donne donc pas $3$ cartons.

Explication

L1Test suit le processus d’exécution de l’appel, de comparaison par oracle et de production d’un verdict. Il ne déduit pas nécessairement la valeur attendue du code et ne remplace pas l’exécution par une lecture de la docstring.

Explication

Un test unitaire isole une unité de programmation, ici une fonction, afin de la vérifier séparément. Un test portant sur plusieurs fonctions dépendantes ne correspond pas à cette définition.

Explication

Un test L1Test est formé de deux lignes consécutives : l’expression précédée de l’invite avec un espace, puis le résultat attendu. L’absence d’espace après l’invite ou l’écriture sur une seule ligne ne respecte pas cette syntaxe.

Explication

L1Test distingue le succès, l’échec et l’erreur selon la comparaison des résultats et l’exécution de l’expression. La durée, l’âge ou la longueur du code ne définissent pas ces verdicts.

Explication

L’écart vaut $|3{,}334-3{,}33|=0{,}004$, donc il est inférieur à $0{,}01$ et respecte la tolérance. Une différence numérique n’entraîne pas automatiquement un échec dans un test approché.

Explication

Cette écriture accepte un résultat proche de $3{,}33$, l’écart maximal autorisé étant $1\times10^{-2}$. Elle ne demande donc ni une égalité exacte ni une comparaison avec l’argument $10$.

Explication

Si le second argument ne peut pas être nul, l’appel viole une précondition et peut déclencher une division par zéro, donc une erreur. Un échec correspond plutôt à des résultats différents sans exception d’exécution.

Explication

Des tests réussis renforcent la confiance dans le code, mais ils ne couvrent pas nécessairement toutes les erreurs possibles. L’absence d’échec pendant les tests ne constitue donc pas une preuve de correction complète.

Explication

Un échec peut révéler un comportement incorrect de la fonction, mais aussi une valeur attendue ou une procédure de test mal définie. Il est donc nécessaire d’examiner le code et le test avant de conclure.

Explication

Un jeu de tests pertinent combine des valeurs représentatives des différents comportements avec des valeurs situées aux limites du domaine. Des valeurs aléatoires ou fréquentes peuvent compléter les tests, mais elles ne garantissent pas la couverture des cas limites.

Explication

Les tests automatisés constituent un filet de sécurité en signalant une régression, c’est-à-dire une erreur apparue à la suite d’une modification du code. Ils ne remplacent pas l’analyse du code et ne se limitent pas aux erreurs antérieures à la modification.