Python — NumPy : tableaux & calcul vectoriel

Questions in this quiz

1. 1. Quelle est la principale différence entre une list Python et un numpy.ndarray ?
   1. Aucune, ce sont des synonymes
   2. Le ndarray est typé, contigu en mémoire, et permet le calcul vectoriel ; la liste est hétérogène et plus lente
   3. Les listes sont plus rapides pour le calcul numérique
   4. Le ndarray est une sous-classe de list
2. 2. Que vaut a.shape ?

   import numpy as np
   a = np.array([[1, 2, 3], [4, 5, 6]])
   print(a.shape)

   1. (2, 3)
   2. (3, 2)
   3. (6,)
   4. (2, 3, 1)
3. 3. Que produit ce code ?

   a = np.arange(6).reshape(2, 3)
   print(a.sum(axis=0))

   1. [3 5 7]
   2. [3 12]
   3. [0 1 2 3 4 5]
   4. 15
4. 4. Quelle est la sortie de ce broadcasting ?

   a = np.array([[1], [2], [3]])
   b = np.array([10, 20, 30])
   print((a + b).shape)

   1. (3,)
   2. (3, 3)
   3. (1, 3)
   4. ValueError
5. 5. Quel est le dtype par défaut de np.array([1, 2, 3]) sur un système 64 bits ?
   1. int8
   2. int32
   3. int64
   4. float64
6. 6. Que vaut a après cette opération ?

   a = np.array([1, 2, 3, 4, 5])
   b = a[1:4]
   b[0] = 99
   print(a)

   1. [1 2 3 4 5]
   2. [1 99 3 4 5]
   3. [1 99 99 99 5]
   4. Erreur
7. 7. Que produit cette indexation booléenne ?

   a = np.array([10, 20, 30, 40])
   print(a[a > 15])

   1. [10 20 30 40]
   2. [20 30 40]
   3. [False True True True]
   4. Erreur
8. 8. Quelle est la différence entre np.dot(a, b) et a * b pour deux matrices ?
   1. Aucune
   2. np.dot = produit matriciel ; * = produit élément par élément (Hadamard)
   3. * est plus rapide
   4. np.dot est obsolète
9. 9. Que renvoie ce code ?

   a = np.zeros((2, 3), dtype=np.int32)
   print(a.dtype, a.nbytes)

   1. int32 12
   2. int32 24
   3. int64 24
   4. float64 48
10. 10. Quelle fonction génère 100 valeurs régulièrement espacées entre 0 et 1 (bornes incluses) ?
    1. np.arange(0, 1, 100)
    2. np.linspace(0, 1, 100)
    3. np.range(0, 1, 100)
    4. np.logspace(0, 1, 100)
11. 11. Que renvoie cette opération ?

    a = np.array([1, 2, np.nan, 4])
    print(a.sum(), np.nansum(a))

    1. 7.0 7.0
    2. nan 7.0
    3. 7.0 nan
    4. Erreur
12. 12. Comment changer la forme d'un tableau de (12,) à (3, 4) sans copier les données ?
    1. a.reshape(3, 4)
    2. a.resize(3, 4) uniquement
    3. np.copy(a).reshape(3, 4)
    4. Impossible sans copie
13. 13. Quelle est la sortie ?

    a = np.array([[1, 2], [3, 4]])
    print(a.T)

    1. [[1 2] [3 4]]
    2. [[1 3] [2 4]]
    3. [[4 3] [2 1]]
    4. Erreur
14. 14. Quelle est la complexité asymptotique d'un produit matriciel (n, n) @ (n, n) dans NumPy standard ?
    1. O(n)
    2. O(n²)
    3. O(n³)
    4. O(n log n)
15. 15. Que produit ce code ?

    rng = np.random.default_rng(42)
    print(rng.integers(0, 10, size=3))

    1. Trois entiers aléatoires reproductibles dans [0, 10)
    2. Trois flottants entre 0 et 10
    3. Trois entiers reproductibles dans [0, 10] (borne incluse)
    4. Erreur : default_rng n'existe pas
16. 16. Quelle expression remplace les valeurs négatives d'un tableau par 0 ?
    1. a[a < 0] = 0
    2. a.replace(< 0, 0)
    3. a.zero_negatives()
    4. np.abs(a)
17. 17. Quelle est la différence entre a.flatten() et a.ravel() ?
    1. Aucune
    2. flatten renvoie toujours une copie ; ravel renvoie une vue quand possible
    3. ravel est plus lent
    4. flatten ne fonctionne qu'en 1D
18. 18. Que vaut r ?

    a = np.array([[1, 2, 3], [4, 5, 6]])
    r = a[:, [2, 0]]
    print(r)

    1. [[3 1] [6 4]]
    2. [[1 3] [4 6]]
    3. [[2 0] [5 3]]
    4. Erreur
19. 19. Quelle fonction lit/écrit efficacement un tableau au format binaire NumPy natif ?
    1. np.save / np.load
    2. pickle.dump / pickle.load
    3. json.dump
    4. open(..., "wb") + str(a)
20. 20. Pourquoi vectoriser plutôt que boucler en Python pour un calcul élément par élément ?
    1. Aucune raison
    2. Les opérations vectorisées s'exécutent en C/SIMD au lieu de la boucle Python interprétée, accélérant typiquement de 10× à 100×
    3. Les boucles Python sont plus rapides en NumPy
    4. Vectoriser consomme plus de mémoire et est toujours plus lent