QCM Python — Corrigé expliqué

Corrigé détaillé des 20 questions : bonne réponse et explication.

Q1. Quelle sera la sortie du code suivant ?

L=[1,2,3] ; L2=2*L ; print(L2)
Réponse — A. un message d'erreur
Bonne réponse — B. [1,2,3,1,2,3]
Réponse — C. [1,2,3,3,2,1]
Réponse — D. [2,4,6]
Explication

L=[1,2,3] est une liste. En Python, multiplier une liste par un entier ne multiplie pas les valeurs : cela répète la liste. Ainsi, 2*L donne [1,2,3,1,2,3].

Q2. Quelle sera la sortie du code suivant ?

def f(u): if len(u) > 5: m=2*u n=m.pop(7) return n else: m=u.pop(2) return m L3=[1,2,3,4,5,6] ; print(f(L3))
Bonne réponse — A. 2
Réponse — B. 3
Réponse — C. 4
Réponse — D. un message d'erreur
Explication

On a len(L3)=6, donc la condition len(u)>5 est vraie. On construit m=2*u : m=[1,2,3,4,5,6,1,2,3,4,5,6]. La méthode pop(7) supprime et retourne l’élément d’indice 7. Les indices commencent à 0 : l’élément d’indice 7 est donc 2.

Q3. Quelle sera la sortie du code suivant ?

import numpy ; L4=numpy.linspace(10,20,5) ; print(L4[1])
Réponse — A. 12
Réponse — B. un message d'erreur
Bonne réponse — C. 12.5
Réponse — D. 10
Explication

numpy.linspace(10,20,5) construit 5 valeurs régulièrement espacées entre 10 et 20, bornes comprises : [10, 12.5, 15, 17.5, 20]. L’indice 1 désigne la deuxième valeur, donc 12.5.

Q4. Quelle sera la sortie du code suivant ?

import numpy ; L5=numpy.arange(5,14,3) ; print(L5[-1])
Réponse — A. 14
Bonne réponse — B. 11
Réponse — C. un message d'erreur
Réponse — D. 8
Explication

numpy.arange(5,14,3) commence à 5 et ajoute 3 à chaque fois, sans atteindre 14 : [5,8,11]. L’indice -1 désigne le dernier élément : 11.

Q5. Quelle sera la sortie du code suivant ?

p=1 compteur=0 for i in range(4): p=p*i compteur=compteur+1 print(p,compteur)
Réponse — A. 6 3
Réponse — B. 0 5
Bonne réponse — C. 0 4
Réponse — D. 24 4
Explication

range(4) produit 0, 1, 2 et 3 : la boucle s’exécute donc 4 fois. Dès la première itération, p devient 1*0=0, puis reste égal à 0. Le compteur est augmenté une fois par itération : il vaut donc 4.

Q6. Quelle sera la sortie du code suivant ?

s=0 i=0 while s<= 9: s=s+i i=i+1 print(s,i)
Bonne réponse — A. 10 5
Réponse — B. 10 4
Réponse — C. 15 6
Réponse — D. 15 5
Explication

La boucle continue tant que s<=9. Les valeurs successives de s sont 0, 1, 3, 6 puis 10. Après s=10, la condition devient fausse et la boucle s’arrête. La variable i a alors été augmentée cinq fois : i=5.

Q7. Qu'est-il retourné si on tape dans la console : print('Python'[-2])

Réponse — A. t
Réponse — B. h
Bonne réponse — C. o
Réponse — D. n
Explication

Les caractères de 'Python' ont les indices 0:P, 1:y, 2:t, 3:h, 4:o, 5:n. Les indices négatifs comptent depuis la fin : -1 donne n et -2 donne o.

Q8. Qu'est-il retourné si on tape dans la console : print('Python'[1:3][-2])

Réponse — A. un message d'erreur
Réponse — B. P
Bonne réponse — C. y
Réponse — D. t
Explication

'Python'[1:3] sélectionne les indices 1 et 2, car la borne de fin 3 est exclue. On obtient donc 'yt'. Puis [-2] désigne l’avant-dernier caractère de cette nouvelle chaîne : 'y'.

Q9. Qu'est-il retourné si on tape dans la console : print(3*'BCPST1'[-1])

Réponse — A. un message d'erreur
Bonne réponse — B. 111
Réponse — C. 1
Réponse — D. BBB
Explication

Python effectue d’abord l’accès à [-1] sur la chaîne : 'BCPST1'[-1] vaut '1'. Ensuite 3*'1' répète le caractère trois fois : on obtient '111'.

Q10. Qu'est-il retourné si on tape dans la console : print((3*'BCPST1')[-1])

Réponse — A. un message d'erreur
Réponse — B. 111
Bonne réponse — C. 1
Réponse — D. BBB
Explication

Les parenthèses imposent d’abord le calcul de 3*'BCPST1'. On obtient 'BCPST1BCPST1BCPST1'. L’indice [-1] désigne ensuite le dernier caractère de cette chaîne : '1'.

Q11. On execute les 2 lignes suivantes :
a = [1,2,3,4,5]
print(a[2:4])
Qu'est renvoyé dans la console ?

Réponse — A. [2,4]
Réponse — B. 2,4
Réponse — C. [2,3,4]
Bonne réponse — D. [3,4]
Explication

Dans une tranche a[2:4], l’indice de début 2 est inclus et l’indice de fin 4 est exclu. On prend donc les éléments d’indices 2 et 3. Comme les indices commencent à 0, ce sont 3 et 4 : [3,4].

Q12. On execute les 2 lignes suivantes :
tableau=numpy.array([[1,2],[2,3],[3,4],[4,5]])
print(tableau[:,0])
Qu'est renvoyé dans la console ?

Bonne réponse — A. [1,2,3,4]
Réponse — B. [2,3,4,5]
Réponse — C. [1,2]
Réponse — D. un message d'erreur
Explication

Dans tableau[:,0], le symbole : signifie « toutes les lignes » et 0 désigne la première colonne. On récupère donc la première valeur de chacune des quatre lignes : [1,2,3,4].

Q13. Qu'est-il retourné si on tape dans la console : print(type([1,'abcd',2.5][1]))

Réponse — A. <class 'int'>
Réponse — B. <class 'float'>
Réponse — C. un message d'erreur
Bonne réponse — D. <class 'str'>
Explication

[1,'abcd',2.5][1] désigne l’élément d’indice 1 de la liste. C’est 'abcd'. Cette valeur est une chaîne de caractères, donc son type est str : .

Q14. Quelle sera la sortie du code suivant ?

def surprise(x): if x>=2 and x//10%2==0: return True else: return False print(surprise(152))
Réponse — A. un message d'erreur
Réponse — B. True
Bonne réponse — C. False
Réponse — D. Aucune réponse
Explication

Pour x=152, la première condition x>=2 est vraie. Mais x//10 vaut 15, puis 15%2 vaut 1. La deuxième condition est donc fausse. Avec and, les deux conditions doivent être vraies : la fonction retourne donc False.

Q15. On execute les 3 lignes suivantes :
ch1="123" ; ch2="123"
print(ch1==ch2)
print(ch1 is ch2)
Qu'est renvoyé dans la console ?

Bonne réponse — A. True True
Réponse — B. False False
Réponse — C. True False
Réponse — D. False True
Explication

L’opérateur == compare les valeurs : les deux chaînes valent '123', donc ch1==ch2 est True. Dans l’implémentation Python courante, ces deux littéraux peuvent désigner le même objet, ce qui donne ici True pour is. À retenir : pour comparer des valeurs, on utilise == ; is sert à tester l’identité de deux objets.

Q16. Quelle sera la sortie du code suivant ?

def f(ch1,ch2): res="" for i in range(1,len(ch1)): if ch1[i] != ch2: res=res+ch1[i] return res print(f("bcpst1","a"))
Réponse — A. un message d'erreur
Réponse — B. bcpst
Réponse — C. abcpst1
Bonne réponse — D. cpst1
Explication

La boucle utilise range(1,len(ch1)), donc elle commence à l’indice 1 et va jusqu’à 5 inclus. Le premier caractère 'b' (indice 0) est donc ignoré. Aucun des caractères suivants n’est 'a', donc ils sont tous ajoutés à res : 'cpst1'.

Q17. Quelle sera la sortie du code suivant ?

def g(L): i=len(L) ch="" while i > 0: ch=ch+str(L[i-1]) i=i-2 return ch print(g([1,2,3,4,5,6]))
Bonne réponse — A. 642
Réponse — B. 654
Réponse — C. 321
Réponse — D. rien car la boucle est infinie
Explication

i commence à len(L)=6. À chaque tour, on utilise L[i-1], puis on diminue i de 2. Les indices utilisés sont donc 5, 3 et 1, correspondant aux valeurs 6, 4 et 2. Elles sont concaténées : '642'.

Q18. On execute les lignes suivantes :

import numpy as np A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) print(A[:,1])
Réponse — A. [1,2,3]
Réponse — B. [7,8,9]
Bonne réponse — C. [2,5,8]
Réponse — D. [3,6,9]
Explication

Dans un tableau NumPy à deux dimensions, A[:,1] signifie « toutes les lignes, colonne d’indice 1 ». La colonne d’indice 1 est la deuxième colonne : 2, 5 et 8.

Q19. On execute les lignes suivantes :

import numpy as np A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) print(A[:2,1:])
Réponse — A. [[1, 2]
[4, 5]]
Bonne réponse — B. [[2, 3]
[5, 6]]
Réponse — C. [[4, 5]
[7, 8]]
Réponse — D. un message d'erreur
Explication

A[:2,1:] signifie : lignes d’indices 0 et 1 (la borne 2 est exclue) et colonnes à partir de l’indice 1 jusqu’à la fin. On obtient donc [[2,3],[5,6]].

Q20. On execute les lignes suivantes :

import numpy as np A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) print(A[:2,1:][0,0])
Réponse — A. [1, 2]
Réponse — B. [1, 4]
Bonne réponse — C. 2
Réponse — D. un message d'erreur
Explication

On commence par calculer A[:2,1:], qui vaut [[2,3],[5,6]]. Puis [0,0] sélectionne l’élément situé à la ligne 0 et à la colonne 0 de ce nouveau tableau : 2.