Top 20 questions d'entretien sur NumPy : des bases à l'avancé

Questions d'entretien NumPy – niveau intermédiaire

Ces questions vont plus loin dans l’usage pratique de NumPy. Une fois les bases des tableaux acquises, explorez ses fonctionnalités. Au niveau intermédiaire, on attend de vous des calculs avec NumPy.

6. Comment créer un tableau rempli de zéros ou de uns ?

Des tableaux de zéros ou de uns servent souvent à initialiser des matrices, créer des masques ou préparer des structures temporaires.

Utilisez np.zeros() ou np.ones() :

import numpy as np

# Créer un tableau 3x4 de zéros
zeros_arr = np.zeros((3, 4))
print(zeros_arr)
# Output:
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

# Créer un tableau 2x2 de uns
ones_arr = np.ones((2, 2))
print(ones_arr)
# Output:
# [[1. 1.]
#  [1. 1.]]

7. Qu'est-ce que le broadcasting dans NumPy ?

Le broadcasting est un mécanisme clé de NumPy qui permet d’opérer efficacement sur des tableaux de tailles différentes.

Concrètement, il rend possible des opérations arithmétiques entre tableaux de formes compatibles en répliquant automatiquement les plus petits le long des dimensions nécessaires.

Exemple :

import numpy as np

a = np.array([1, 2, 3])b = np.array([[1], [2], [3]])
print(a + b)
# Output:
# [[2 3 4]
#  [3 4 5]
#  [4 5 6]]

8. Comment calculer la moyenne, la médiane et l'écart-type d'un tableau NumPy ?

La moyenne, la médiane et l’écart-type sont des statistiques descriptives essentielles pour comprendre les données. NumPy les calcule très facilement via des fonctions dédiées.

Voici comment s’y prendre :

import numpy as np

arr = np.array([1, 2, 3, 4, 5])

# Mean
mean_value = np.mean(arr)
print("Mean:", mean_value)  # Output: 3.0

# Median
median_value = np.median(arr)
print("Median:", median_value)  # Output: 3.0

# Standard deviation
std_value = np.std(arr)
print("Standard deviation:", std_value)  # Output: 1.4142135623730951

9. Comment interroger rapidement des données numériques avec NumPy et agir selon une condition booléenne ?

Si NumPy excelle dans le calcul, il propose aussi des fonctions puissantes de manipulation des données.

L’indexation booléenne permet de filtrer et d’appliquer des opérations selon des résultats. La méthode where() est particulièrement utile pour modifier des valeurs selon un critère numérique.

Supposons un DataFrame de notes d’examen nommé df et la volonté de catégoriser les étudiants. Un np.where() simple ressemblerait à :

df[‘student_cat’] = np.where(df[‘score’] > 80, ‘good’, ‘bad’)

La méthode where() accepte jusqu’à 3 arguments :

• La condition booléenne
• La valeur si vrai
• La valeur si faux

10. Comment utiliser NumPy pour calculer une erreur quadratique moyenne (MSE) ?

La capacité de NumPy à opérer sur un tableau entier facilite l’implémentation d’un Mean Squared Error (MSE).

Les opérations élément par élément permettent de vectoriser facilement le calcul et d'obtenir une MSE efficacement.

Exemple d’implémentation :

# 1. Deux tableaux : les prédictions et les étiquettes réelles
# 2. On calcule les différences au carré puis on les somme
# 3. On divise par n, la longueur du tableau

n= len(labels)
error = (1/n) * np.sum(np.square(predictions - labels))

Questions d'entretien NumPy – niveau avancé

Passons maintenant à un niveau avancé ! On attend de vous que vous résolviez des problèmes plus complexes avec NumPy.

11. Comment calculer des statistiques glissantes avec NumPy, par exemple une moyenne glissante ?

Les statistiques glissantes, comme la moyenne mobile, sont très utiles pour lisser des données bruitées, notamment temporelles.

Une fonctionnalité méconnue de NumPy est celle des « strides ». On peut créer une vue en fenêtre glissante du tableau via lib.stride_tricks.sliding_window_view() pour générer facilement des sous-tableaux.

On peut ensuite résumer chaque sous-ensemble (moyenne, etc.) pour obtenir une moyenne glissante. Exemple :

import numpy as np

from numpy.lib.stride_tricks import sliding_window_view
x = np.arange(6)
v = sliding_window_view(x, 3)
# v contient des sous-tableaux de longueur 3 correspondant à la taille de la fenêtre.

12. Comment réaliser un indexage avancé pour sélectionner des éléments d'un tableau multidimensionnel selon une condition ?

L’indexation est un fondamental de NumPy ; des techniques avancées permettent des extractions plus précises.

Avec l’indexation par tableaux d’entiers et l’indexation booléenne, il devient trivial de construire des ensembles répondant à des critères spécifiques.

import numpy as np

array = np.array([[10, 15, 20, 25],
                  [30, 35, 40, 45],
                  [50, 55, 60, 65]])
print(array)  # Output: 
# [[10 15 20 25]
#  [30 35 40 45]
#  [50 55 60 65]]

# Indexation booléenne : sélectionner les éléments > 30
condition = array > 30
print(condition)  # Output:
# [[False False False False]
#  [False  True  True  True]
#  [ True  True  True  True]]

# Appliquer la condition pour récupérer les éléments correspondants
filtered_elements = array[condition]
print(filtered_elements)  # Output: [35 40 45 50 55 60 65]

# Indexation par tableaux d'entiers : sélectionner des éléments via indices de lignes et colonnes
row_indices = np.array([0, 1, 2])
col_indices = np.array([1, 2, 3])
selected_elements = array[row_indices, col_indices]
print(selected_elements)  # Output: [15 40 65]

# Combiner indexation booléenne et par entiers
# Sélectionner les éléments > 30 appartenant à des indices spécifiques
combined_condition = (array > 30) & ((row_indices[:, None] == np.arange(3)).any(axis=0))
filtered_selected_elements = array[combined_condition]
print(filtered_selected_elements)  # Output: [35 40 45 50 55 60 65]

13. Comment utiliser NumPy pour une opération d'algèbre linéaire comme une décomposition matricielle ou la résolution d'un système linéaire ?

Les décompositions matricielles sont cruciales avec des volumes de données importants. Réduire les données à leurs composantes principales est une étape clé pour diminuer la complexité et le bruit.

Le module linalg de NumPy permet d’effectuer simplement des opérations d’algèbre linéaire pour obtenir ces composantes.

# Le signal sous-jacent est une image modulée sinusoïdalement
img = lena() # This is from scipy.misc import lena
t = np.arange(100)
time = np.sin(0.1*t)
true= time[:,np.newaxis,np.newaxis] * img[np.newaxis,...]

# On ajoute du bruit
noisy = real + np.random.randn(*true.shape)*255

# Matrice (observations, variables)
M = noisy.reshape(noisy.shape[0],-1)

# La décomposition en valeurs singulières (SVD) factorise la matrice M :
#   M = U*S*V.T     (où '*' est une multiplication matricielle)
# * U et V contiennent des vecteurs orthogonaux de norme 1
# * S est diagonale et contient les valeurs singulières de M — on peut s'en servir pour calculer les PC

# Résultat de la SVD sur la matrice bruitée
U, s, Vt = np.linalg.svd(M, full_matrices=False)
# Transposer V pour obtenir les vecteurs des composantes principales
V = Vt.T

# Les PC sont déjà triées par ordre décroissant des valeurs singulières
# En utilisant toutes les PC, on reconstruit parfaitement le signal bruité
S = np.diag(s)
Mhat = np.dot(U, np.dot(S, V.T))
print(“Using all PCs, MSE = %.6G" %(np.mean((M - Mhat)**2)))

14. Comment optimiser l'usage mémoire avec de grands tableaux NumPy ?

Une fonctionnalité méconnue est memmap(). Elle permet de stocker des tableaux dans un fichier et de les lire paresseusement, afin de manipuler des tailles supérieures à la mémoire disponible. Le principal bénéfice est la lecture à la demande, réduisant l’empreinte mémoire tout en accédant à l’ensemble du jeu de données.

Bien l’exploiter facilite le travail sur de très grands volumes.

​​import numpy as np

# Créer un grand tableau et l'enregistrer dans un fichier avec memmap
filename = 'large_array.dat'
large_array_shape = (10000, 10000)
dtype = np.float32  # Type de données du tableau

# Créer un objet memmap avec la forme et le dtype souhaités
large_array = np.memmap(filename, dtype=dtype, mode='w+', shape=large_array_shape)

# Initialiser le tableau (ex. avec des valeurs aléatoires)
large_array[:] = np.random.rand(*large_array_shape)

# Accéder à une petite partie du tableau sans tout charger en mémoire
sub_array = large_array[5000:5010, 5000:5010]
print(sub_array)  # Output: un tableau 10x10 de floats aléatoires

# Nettoyage et écriture sur disque
del large_array

15. Comment gérer et manipuler des tableaux contenant des valeurs manquantes ou infinies dans NumPy ?

Traiter les valeurs manquantes ou infinies fait partie du quotidien des data scientists. Commencez par les détecter avec isnan() et isinf().

S’il s’agit d’un problème systématique, auditez vos pipelines ; sinon, envisagez l’imputation.

On combine souvent NumPy avec pandas fillna() pour remplir les valeurs manquantes, par exemple avec la mean() ou la median() de NumPy.

Questions NumPy pour data scientists

Jusqu’ici, nous avons couvert des questions générales sur NumPy. Elles s’appliquent bien sûr à la data science, mais voici des questions plus spécifiquement orientées data scientist.

16. Existe-t-il un moyen simple d'appliquer une fonction à chaque ligne ou colonne d'un tableau 2D ?

Il arrive qu’on doive appliquer des calculs personnalisés pour obtenir une information par ligne ou par colonne. La méthode apply_along_axis() permet d’appliquer une fonction personnalisée le long d’un axe d’un tableau NumPy.

import numpy as np

# Créer un tableau 2D
data = np.array([
    [1, 2, 3, 4, 5],
    [10, 15, 20, 25, 30],
    [100, 200, 300, 400, 500]
])

# Fonction pour calculer l'étendue d'un tableau 1D
def compute_range(arr):
    return np.max(arr) - np.min(arr)

# Appliquer compute_range à chaque ligne (axis=1)
ranges = np.apply_along_axis(compute_range, axis=1, arr=data)
print("Range of each row:", ranges)
# Output:
# Range of each row: [  4  20 400]

17. Comment utiliser NumPy pour le scaling et la normalisation des variables avant l'entraînement ?

La normalisation garantit un entraînement correct des modèles. Sans elle, l’échelle peut biaiser les résultats, notamment pour les modèles basés sur des distances.

Les fonctions NumPy facilitent ces transformations. Exemple de min-max scaling sur les colonnes : veillez à choisir la bonne dimension.

import numpy as np

data = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])

# Min-Max Scaling
min_vals = np.min(data, axis=0)
max_vals = np.max(data, axis=0)
scaled_data = (data - min_vals) / (max_vals - min_vals)
print("Scaled Data:\n", scaled_data)
# Output:
# Scaled Data:
# [[0.   0.   0.  ]
#  [0.5  0.5  0.5 ]
#  [1.   1.   1.  ]]

18. Comment trier et indexer facilement des tableaux NumPy ?

Au-delà d’un sort_values() de DataFrame, on souhaite parfois connaître la position des valeurs triées.

argsort() renvoie les indices qui ordonneraient un tableau. Très utile pour réindexer d’autres jeux de données en cohérence avec un tri, et ainsi conserver l’alignement entre sources.

19. Quel aspect clé du générateur de nombres aléatoires de NumPy permet de le rendre prévisible, et pourquoi ?

Les générateurs pseudo-aléatoires reposent sur une graine initiale. Pour évaluer nos expériences et réduire l’aléa, il faut limiter le hasard dans la chaîne de traitement.

En utilisant random.seed() de NumPy, on fixe la graine pour reproduire les résultats. Cela aide à distinguer les progrès liés aux ajustements du modèle de ceux dus au hasard.

20. Comment décririez-vous une implémentation de K-Means avec NumPy ?

En entretien, on peut vous demander d’implémenter un algorithme. L’important est de montrer votre compréhension du modèle et des outils.

Inutile de mémoriser chaque ligne ci-dessous, mais sachez en expliquer les étapes clés et les méthodes utilisées. Lisez K-Means (et d’autres algorithmes de base) et comprenez leur fonctionnement.

import numpy as np

# Générer un jeu d'essai
np.random.seed(42)  # Pour la reproductibilité
data = np.vstack([
    np.random.normal(loc=[1, 1], scale=0.5, size=(50, 2)),
    np.random.normal(loc=[5, 5], scale=0.5, size=(50, 2)),
    np.random.normal(loc=[9, 1], scale=0.5, size=(50, 2))
])
def k_means(X, k, max_iters=100, tol=1e-4):
    # Étape 1 : initialiser aléatoirement les centroïdes
    num_samples, num_features = X.shape
    centroids = X[np.random.choice(num_samples, k, replace=False)]
    
    for i in range(max_iters):
        # Étape 2 : assigner les clusters
        distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
        cluster_assignments = np.argmin(distances, axis=1)
        
        # Étape 3 : mettre à jour les centroïdes
        new_centroids = np.array([X[cluster_assignments == j].mean(axis=0) for j in range(k)])
        
        # Critère de convergence
        if np.all(np.linalg.norm(new_centroids - centroids, axis=1) < tol):
            break
        
        centroids = new_centroids
    
    return centroids, cluster_assignments

# Appliquer k-means
k = 3
centroids, cluster_assignments = k_means(data, k)

Derniers conseils

Renforcer vos compétences NumPy est une étape déterminante pour réussir une carrière en data science.

Commencez par pratiquer et comprendre les fondamentaux, puis passez aux implémentations concrètes. Plus vous utilisez NumPy, mieux vous en saisirez les mécanismes. Testez des cours et tutoriels sur DataCamp, par exemple :

• Python Numpy Array Tutorial
• Numpy Cheat Sheet
• Numpy Crash Course