QCM : Types de variables en Python

[enonce]
Ce QCM porte sur les types de variables en Python : int, float, str, bool, affectation et règles de nommage. Choisissez la bonne réponse parmi les quatre propositions.
[/enonce]

[etape]
Quel est le type Python de la valeur $42$ ?
[qcm]
[option]float[/option]
[option correct="true"]int[/option]
[option]str[/option]
[option]bool[/option]
[reponse statut="correct"]Exact !
$42$ est un nombre entier, sans point décimal ni guillemets : son type est int (integer).[/reponse]
[reponse motif="float"]Non.
Le type float correspond aux nombres décimaux écrits avec un point, comme $42.0$ ou $3.14$. La valeur $42$ n'a pas de point décimal.[/reponse]
[reponse motif="str"]Non.
Le type str (string) est celui des chaînes de caractères, qui sont toujours écrites entre guillemets ou apostrophes. Ici $42$ n'est pas entre guillemets.[/reponse]
[reponse motif="bool"]Non.
Le type bool ne concerne que les deux valeurs True et False. Un nombre comme $42$ n'est pas un booléen.[/reponse]
[reponse statut="incorrect"]Non.
Observer la forme de la valeur : nombre entier sans point, donc entier (int).[/reponse]
[/qcm]
[/etape]

[etape]
Quel est le type Python de la valeur 'Bonjour' ?
[qcm]
[option]int[/option]
[option]float[/option]
[option correct="true"]str[/option]
[option]bool[/option]
[reponse statut="correct"]Bonne réponse !
Une valeur entre apostrophes (ou guillemets) est une chaîne de caractères : son type est str (string).[/reponse]
[reponse motif="int"]Non.
Le type int ne concerne que les nombres entiers. Ici, la présence d'apostrophes indique une chaîne de caractères.[/reponse]
[reponse motif="float"]Non.
Le type float concerne les nombres décimaux. Les apostrophes autour de Bonjour indiquent autre chose.[/reponse]
[reponse motif="bool"]Non.
Seules True et False (sans apostrophes, initiale majuscule) sont de type bool.[/reponse]
[reponse statut="incorrect"]Non.
Les apostrophes ou guillemets autour d'une valeur signalent toujours une chaîne de caractères.[/reponse]
[/qcm]
[/etape]

[etape]
Parmi les noms suivants, lequel est un nom de variable valide en Python ?
[qcm]
[option]1an[/option]
[option]ma-note[/option]
[option correct="true"]age_eleve[/option]
[option]mon nom[/option]
[reponse statut="correct"]Bravo !
Ce nom ne contient que des lettres et le symbole underscore, et il ne commence pas par un chiffre : il est valide.[/reponse]
[reponse motif="1an"]Non.
Un nom de variable ne doit pas commencer par un chiffre. Relire la règle sur le nommage des variables.[/reponse]
[reponse motif="ma-note"]Non.
Le tiret « - » est interdit dans un nom de variable (Python l'interpréterait comme une soustraction). Seuls les lettres, chiffres et underscores sont autorisés.[/reponse]
[reponse motif="mon nom"]Non.
Un nom de variable ne peut pas contenir d'espace. Utiliser un underscore à la place.[/reponse]
[reponse statut="incorrect"]Non.
Règle : uniquement lettres, chiffres et underscores, et ne jamais commencer par un chiffre.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

a = 5
a = 'Bonjour'
print(type(a))

Que s'affiche-t-il ?
[qcm]
[option]class 'int'[/option]
[option correct="true"]class 'str'[/option]
[option]Une erreur est provoquée[/option]
[option]class 'bool'[/option]
[reponse statut="correct"]Exactement !
En Python, le type d'une variable change dynamiquement selon la valeur qu'elle contient. La dernière affectation met une chaîne dans a, donc son type final est str.[/reponse]
[reponse motif="class 'int'"]Non.
C'était le type de a après la première ligne, mais la seconde affectation a changé la valeur et le type de a.[/reponse]
[reponse motif="Une erreur est provoquée"]Non.
Python autorise sans problème de changer le type d'une variable en cours de programme. C'est une spécificité du langage.[/reponse]
[reponse motif="class 'bool'"]Non.
Aucune valeur booléenne n'a été affectée à a dans ce programme.[/reponse]
[reponse statut="incorrect"]Non.
Python prend en compte la dernière affectation. Ici, a contient la chaîne 'Bonjour' quand type(a) est appelé.[/reponse]
[/qcm]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

print(3 * 'hi')

Que s'affiche-t-il ?
[qcm]
[option]3hi[/option]
[option]hi hi hi[/option]
[option correct="true"]hihihi[/option]
[option]Une erreur est provoquée[/option]
[reponse statut="correct"]C'est bien ça !
L'opérateur * appliqué à une chaîne et un entier répète la chaîne : 3 * 'hi' donne la chaîne 'hi' répétée trois fois, soit 'hihihi'.[/reponse]
[reponse motif="3hi"]Non.
Le nombre n'est pas collé devant la chaîne : l'opérateur * répète la chaîne, il ne l'affiche pas préfixée du nombre.[/reponse]
[reponse motif="hi hi hi"]Non.
Les répétitions sont simplement concaténées, sans espace. Aucun séparateur n'est inséré par l'opérateur *.[/reponse]
[reponse motif="Une erreur est provoquée"]Non.
La multiplication entre un entier et une chaîne est parfaitement autorisée en Python et correspond à une répétition.[/reponse]
[reponse statut="incorrect"]Non.
* sur une chaîne répète simplement la chaîne, sans espace ni ajout du nombre.[/reponse]
[/qcm]
[/etape]

[etape]
Que renvoie l'instruction type(True) en Python ?
[qcm]
[option]class 'str'[/option]
[option]class 'int'[/option]
[option]True[/option]
[option correct="true"]class 'bool'[/option]
[reponse statut="correct"]Tu as raison !
True et False sont les deux valeurs du type booléen : leur type est bool.[/reponse]
[reponse motif="class 'str'"]Non.
Une chaîne de caractères aurait été écrite entre guillemets ou apostrophes (comme 'True'). Ici True n'est pas entre guillemets.[/reponse]
[reponse motif="class 'int'"]Non.
True n'est pas un nombre entier. C'est l'une des deux valeurs du type booléen.[/reponse]
[reponse motif="True"]Non.
L'instruction type(...) renvoie le type de la valeur, pas la valeur elle-même.[/reponse]
[reponse statut="incorrect"]Non.
True et False sont les deux valeurs du type bool.[/reponse]
[/qcm]
[/etape]

Vrai/Faux : Transtypage et saisie Python (niveau 3)

[enonce]
Pour chaque affirmation suivante sur le transtypage, la saisie et les types dynamiques en Python, indiquez si elle est Vraie ou Fausse.
[/enonce]

[etape]
On exécute le programme Python ci-dessous :

a = 1
a = 'Bonjour'

Affirmation : Ce programme provoque une erreur car on change le type de a.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Excellent !
En Python, le typage est dynamique : une variable peut changer de type au cours du programme.
Après la seconde ligne, a est de type str et vaut 'Bonjour', sans aucune erreur.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Contrairement à certains langages (C, Java), Python ne fige pas le type d'une variable.
Le typage est dynamique : réaffecter une variable avec une valeur d'un autre type est parfaitement valide.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. Python a un typage dynamique : a passe de int à str sans erreur.
[/solution]
[/etape]

[etape]
L'utilisateur exécute le programme Python suivant et saisit $42$ au clavier :

a = input("Saisir une valeur : ")

Affirmation : Après cette instruction, a contient le nombre entier $42$.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Bonne réponse !
La fonction input renvoie toujours une chaîne de caractères (type str), quelle que soit la saisie.
a contient donc la chaîne « 42 », pas l'entier $42$.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Attention : input renvoie toujours un str, même si l'utilisateur tape un nombre.
Pour obtenir un entier, il faut écrire a = int(input(...)).[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. input renvoie toujours une chaîne : a contient la chaîne « 42 », pas le nombre $42$.
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

print("Total :", 3 + 4)

Affirmation : Ce programme affiche Total : 7.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Bravo !
La fonction print affiche plusieurs valeurs séparées par des espaces (en présence de virgules).
$3+4$ est calculé avant l'affichage, donc le programme affiche bien Total : 7.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : les virgules dans print séparent des valeurs distinctes, chacune étant évaluée.
$3+4$ est calculé avant d'être affiché : le résultat affiché est Total : 7.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. print affiche les valeurs séparées par un espace et évalue les expressions : on obtient Total : 7.
[/solution]
[/etape]

[etape]
L'utilisateur exécute le programme Python suivant et saisit $3.5$ au clavier :

n = int(input("n = "))

Affirmation : Cette instruction permet à l'utilisateur de saisir le nombre décimal $3{,}5$.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Tu as raison !
La fonction int attend une chaîne représentant un entier.
Si l'utilisateur saisit 3.5, Python déclenche une erreur de conversion. Pour saisir un décimal, il faudrait utiliser float(input(...)).[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Le piège est de croire que int arrondit ou tronque automatiquement.
int(input(...)) n'accepte que des chaînes représentant un entier : « 3.5 » provoque une erreur. Pour un décimal, utiliser float(input(...)).[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. int(input(...)) accepte uniquement des entiers. Pour un décimal, il faut écrire float(input(...)).
[/solution]
[/etape]

[etape]
Affirmation : En Python, l'opérateur ** calcule la puissance d'un nombre.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Exactement !
En Python, la puissance s'écrit bien avec ** (deux étoiles). Par exemple : 2 ** 3 vaut $8$.
Le symbole ^ existe mais désigne un autre opérateur (le « ou exclusif » sur les entiers), rarement utilisé au lycée.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Le piège ici vient de la notation mathématique ($2^3$) ou de la calculatrice (touche ^).
En Python, la puissance s'écrit exclusivement avec **. Par exemple 2 ** 3 donne $8$.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. En Python, la puissance s'écrit ** (deux étoiles). C'est ^ qui désigne un opérateur logique, pas la puissance.
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

a = "ab"
print(3 * a)

Affirmation : Ce programme affiche ababab.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Correct !
Sur une chaîne de caractères, l'opérateur * (précédé d'un entier) répète la chaîne.
3 * « ab » donne donc « ababab ».[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Rappel : * appliqué à une chaîne et un entier effectue une répétition (pas un produit mathématique).
3 * « ab » répète trois fois la chaîne « ab », ce qui donne « ababab ».[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. L'opérateur * entre un entier et une chaîne répète la chaîne : 3 * « ab » donne « ababab ».
[/solution]
[/etape]

Vrai/Faux : Variables Python (niveau 1)

[enonce]
Pour chaque affirmation suivante sur les variables et leurs types en Python, indiquez si elle est Vraie ou Fausse.
[/enonce]

[etape]
On exécute l'instruction Python suivante :

a = 5

Affirmation : Cette instruction teste si a est égal à $5$.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Bonne réponse !
Le symbole = seul est l'opérateur d'affectation en Python : il range la valeur $5$ dans la variable a.
Pour tester l'égalité, on utilise == (double signe égal).[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Attention à ne pas confondre affectation et comparaison.
En Python, = range une valeur dans une variable (affectation), tandis que == teste si deux valeurs sont égales (comparaison).[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. a = 5 affecte la valeur $5$ à la variable a. Le test d'égalité s'écrit a == 5.
[/solution]
[/etape]

[etape]
Affirmation : L'instruction type(3.14) renvoie class 'float'.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Exactement !
Le nombre $3{,}14$ s'écrit 3.14 en Python (avec un point) : c'est un nombre décimal, donc de type float.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
En Python, un nombre avec un point décimal est de type float.
Ne pas confondre avec int (entier, sans point) ou str (chaîne, entre guillemets).[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. Tout nombre écrit avec un point décimal est de type float en Python.
[/solution]
[/etape]

[etape]
Affirmation : Le nom de variable 1variable est valide en Python.

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Bravo !
Un nom de variable ne peut pas commencer par un chiffre.
Il doit commencer par une lettre ou par le caractère _ (underscore).[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Rappel : un nom de variable doit commencer par une lettre ou un underscore.
1variable commence par un chiffre, il produit donc une erreur de syntaxe.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. Un nom de variable ne peut pas commencer par un chiffre. variable1 serait valide, 1variable ne l'est pas.
[/solution]
[/etape]

[etape]
On exécute le programme Python ci-dessous :

a = "7"

Affirmation : Après cette instruction, la variable a est de type int (entier).

[qcm]
[option]Vrai[/option]
[option correct="true"]Faux[/option]
[reponse statut="correct"]Tu as raison !
Les guillemets autour de $7$ indiquent une chaîne de caractères (type str), pas un entier.
La variable a est donc de type str.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est fausse.
Il ne faut pas confondre 7 (entier) et « 7 » (chaîne de caractères).
Dès qu'une valeur est entourée de guillemets ou d'apostrophes, son type est str, quel que soit son contenu.[/reponse]
[/qcm]

[solution]
Cette affirmation est fausse. « 7 » entre guillemets est une chaîne de caractères : a est de type str.
[/solution]
[/etape]

[etape]
Affirmation : Le nom de variable ma_variable est valide en Python.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]C'est bien ça !
Un nom de variable peut contenir des lettres, des chiffres et le caractère _ (underscore).
ma_variable respecte ces règles : il est valide.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Le caractère underscore _ est autorisé dans les noms de variables (contrairement au tiret -).
ma_variable commence par une lettre et n'utilise que des caractères autorisés.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. ma_variable respecte les règles : lettres, chiffres et underscore, sans commencer par un chiffre.
[/solution]
[/etape]

[etape]
Affirmation : En Python, MaVariable et mavariable désignent deux variables différentes.

[qcm]
[option correct="true"]Vrai[/option]
[option]Faux[/option]
[reponse statut="correct"]Correct !
Python est sensible à la casse : il distingue les majuscules des minuscules.
MaVariable et mavariable sont donc bien deux variables différentes.[/reponse]
[reponse statut="incorrect"]Non, cette affirmation est vraie.
Le piège ici est d'oublier que Python distingue majuscules et minuscules.
Deux noms identiques à la casse près désignent deux variables distinctes en Python.[/reponse]
[/qcm]

[solution]
Cette affirmation est vraie. Python est sensible à la casse : MaVariable et mavariable sont deux variables distinctes.
[/solution]
[/etape]

Python : Attention aux types de données !

Clara a saisi le programme suivant dans son éditeur Python :

a=input('Entrez la valeur de a : ')
b=input('Entrez la valeur de b : ')
c=5*a+3*b
print(c)

Elle exécute ensuite ce programme en entrant 10 comme valeur pour a et 5 comme valeur pour b.
Elle s'attend à obtenir 65 comme résultat.

Quel est, en réalité, le résultat affiché par le programme ?
Expliquez ce résultat.
Corrigez ce programme afin qu'il affiche le résultat 65 prévu par Clara.

Corrigé

Lorsque l'on exécute le programme de Clara on obtient '1010101010555' comme résultat.

En effet les valeurs entrées par Clara sont considérées comme étant des chaînes de caractères.

On a donc a='10' et 5*a='1010101010' (répétition de 10 cinq fois) ;
b='5' et 3*b='555' (répétition de 5 trois fois) ;
et 5*a+3*b='1010101010555' (concaténation).

Pour que le programme fonctionne comme Clara le souhaiterait, il faut convertir a et b en un type numérique : int ou float.

Par exemple :

a=input('Entrez la valeur de a : ')
b=input('Entrez la valeur de b : ')
a=int(a)
b=int(b)
c=5*a+3*b
print(c)

ou plus simplement :

a=int(input('Entrez la valeur de a : '))
b=int(input('Entrez la valeur de b : '))
c=5*a+3*b
print(c)

Python : Types et opérateurs

En mode interactif, on entre chacune des instructions suivantes dans une console Python :

>>> 3+3
>>> 3.0+3
>>> "3"+3
>>> "3"+"3"
>>> 3*3
>>> 3.0*3
>>> "3"*3
>>> "3"*"3"

Pour chacune des lignes ci-dessus, indiquer le résultat renvoyé par l'interpréteur Python.

Corrigé

```
>>> 3+3
```
Le résultat de cette instruction est : 6.
Python ajoute les deux entiers et renvoie un entier.
```
>>> 3.0+3
```
Le résultat de cette instruction est : 6.0.
Python ajoute les deux nombres. Comme l'un de ces nombres est un décimal (float), le résultat renvoyé est également un décimal (d'où la présence du « .0 » ).
```
>>> "3"+3
```
Cette instruction renvoie une erreur.
Python ne peut pas ajouter un entier et une chaine de caractères. Il faut noter que, contrairement à d'autres langages, Python n'effectue pas de conversion de types automatiquement. On dit que Python est fortement typé.
```
>>> "3"+"3"
```
Le résultat de cette instruction est : '33'.
Python concatène les chaînes de caractères. À cause des guillemets, « 3 » est considéré comme une chaîne de caractères. L'interpréteur Python n'additionne donc pas les valeurs numériques mais effectue une concaténation.
```
>>> 3*3
```
Le résultat de cette instruction est : 9.
Python effectue le produit des deux entiers et renvoie un entier.
```
>>> 3.0*3
```
Le résultat de cette instruction est : 9.0.
Python multiplie les deux nombres. Comme l'un de ces nombres est un décimal (float), le résultat renvoyé est un décimal.
```
>>> "3"*3
```
Le résultat de cette instruction est : '333'.
Python répète trois fois la chaîne de caractères « 3 ». L'opérateur *, suivi ou précédé d'un nombre entier, permet de répéter une chaîne de caractères.
```
>>> "3"*"3"
```
Cette instruction renvoie une erreur.
Python ne peut pas multiplier une chaîne de caractères par une autre chaîne de caractères.