Die 20 wichtigsten NumPy-Interviewfragen: Von Grundlagen bis Fortgeschritten

NumPy-Interviewfragen für Fortgeschrittene (Intermediate)

Diese Fragen gehen tiefer in die praktische Arbeit mit NumPy. Sobald du die Grundlagen von Arrays verstanden hast, solltest du die weiterführenden Funktionen erkunden. Auf diesem Level werden Berechnungen mit NumPy vorausgesetzt.

6. Wie erstellst du ein Array aus lauter Nullen oder lauter Einsen?

Arrays aus Nullen oder Einsen sind oft gefragt – etwa zum Initialisieren von Matrizen, Erstellen von Masken oder als Platzhalterstrukturen. 

Dafür nutzt du in NumPy np.zeros() bzw. np.ones():

import numpy as np

# Create a 3x4 array of zeros
zeros_arr = np.zeros((3, 4))
print(zeros_arr)
# Output:
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

# Create a 2x2 array of ones
ones_arr = np.ones((2, 2))
print(ones_arr)
# Output:
# [[1. 1.]
#  [1. 1.]]

7. Was ist Broadcasting in NumPy?

Broadcasting ist ein zentrales Konzept in NumPy, das effiziente Operationen auf Arrays unterschiedlicher Größe ermöglicht. 

Kurz gesagt erlaubt es arithmetische Operationen zwischen Arrays mit verschiedenen Formen, indem kleinere Arrays automatisch über die größeren „ausgerollt“ werden, bis die Formen kompatibel sind. 

Sieh dir dieses Beispiel an:

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. Wie berechnest du Mittelwert, Median und Standardabweichung eines NumPy-Arrays?

Mittelwert, Median und Standardabweichung sind zentrale beschreibende Statistiken. NumPy bietet dafür eigene, sehr einfache Funktionen. 

Diese Berechnungen solltest du sicher beherrschen:

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. Wie können wir NumPy nutzen, um numerische Daten schnell per Abfrage zu prüfen und auf eine boolesche Bedingung hin zu verarbeiten?

Auch wenn NumPy primär als Rechenbibliothek gilt, bietet es starke Data-Wrangling-Funktionen. 

Über boolesches Indexing kannst du Daten selektieren und darauf basierend Operationen ausführen. Besonders hilfreich ist where(), wenn Werte abhängig von numerischen Bedingungen geändert werden sollen.

Angenommen, wir haben ein DataFrame mit Prüfungsergebnissen namens df und wollen die Schüler kategorisieren. Ein einfaches np.where() sähe so aus:

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

Beachte, dass where() bis zu drei Argumente erhält: 

• Erstens die beliebige boolesche Bedingung
• Zweitens das Ergebnis, falls wahr
• Drittens das Ergebnis, falls falsch

10. Wie lässt sich NumPy für etwas wie den Mean Squared Error nutzen?

NumPys Fähigkeit, auf ganzen Arrays zu operieren, macht die Implementierung von Mean Squared Error (MSE) sehr einfach. 

Durch elementweise Operationen wird die Berechnung vektorisiert und damit effizient. 

Ein Beispiel für die Implementierung in NumPy:

# 1. Wir haben zwei Arrays: unsere Vorhersagen und die echten Labels
# 2. Wir quadrieren die Differenzen und summieren sie
# 3. Anschließend teilen wir durch n, die Länge des Arrays

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

Fortgeschrittene NumPy-Interviewfragen

Jetzt wird’s anspruchsvoll. Auf diesem Niveau solltest du NumPy einsetzen, um komplexere Aufgaben zu lösen.

11. Wie berechnest du gleitende Statistiken in NumPy, z. B. den gleitenden Mittelwert?

Gleitende Kennzahlen wie der Moving Average sind in der Data Science sehr wichtig, etwa zum Glätten verrauschter – oft zeitbezogener – Daten. 

Eine weniger bekannte NumPy-Funktionalität sind „Strides“. Damit lässt sich z. B. eine gleitende Fensteransicht eines Arrays erzeugen. Mit lib.stride_tricks.sliding_window_view() generierst du bequem Teilarrays. 

Auf diesen Subsets kannst du dann beliebige Aggregationen wie den Mittelwert berechnen, um einen gleitenden Durchschnitt zu erhalten. Beispiel:

import numpy as np

from numpy.lib.stride_tricks import sliding_window_view
x = np.arange(6)
v = sliding_window_view(x, 3)
# Dies erzeugt v: ein Array mit Teilarrays der Länge 3 entsprechend der Fenstergröße.

12. Wie führst du fortgeschrittenes Indexing durch, um Elemente aus einem mehrdimensionalen Array basierend auf einer Bedingung auszuwählen?

Indexing gehört zu den Grundlagen, aber mit fortgeschrittenen Techniken lassen sich Daten sehr präzise zuschneiden. 

Mit Integer-Array-Indexing und booleschem Indexing erstellst du mühelos Teilmengen, die bestimmten Kriterien entsprechen.

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]]

# Boolean indexing: Select elements greater than 30
condition = array > 30
print(condition)  # Output:
# [[False False False False]
#  [False  True  True  True]
#  [ True  True  True  True]]

# Apply the condition to get the elements that meet the criteria
filtered_elements = array[condition]
print(filtered_elements)  # Output: [35 40 45 50 55 60 65]

# Integer array indexing: Select specific elements based on row and column indices
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]

# Combining boolean and integer indexing
# Select elements from the array where the element is greater than 30 and belongs to specific indices
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. Wie nutzt du NumPy für Lineare Algebra, z. B. Matrixzerlegung oder zum Lösen linearer Gleichungssysteme?

Matrixzerlegungen sind essenziell, wenn große Datenvolumina vorliegen. Die Reduktion auf die Hauptkomponenten ist oft der erste Schritt, um Komplexität und Rauschen zu verringern. 

Mit NumPys linalg-Modul lassen sich die nötigen linearen Algebra-Operationen für Hauptkomponenten unkompliziert durchführen. 

# Das zugrunde liegende Signal ist ein sinusförmig moduliertes Bild
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,...]

# Wir fügen Rauschen hinzu
noisy = real + np.random.randn(*true.shape)*255

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

# Singulärwertzerlegung (SVD) faktorisiert die Datenmatrix:
#   M = U*S*V.T     ('*' ist Matrixmultiplikation)
# * U und V enthalten orthogonale Vektoren mit Norm 1
# * S ist diagonal und enthält die Singulärwerte von M – daraus lassen sich PCs berechnen

# SVD der verrauschten Matrix
U, s, Vt = np.linalg.svd(M, full_matrices=False)
# V transponieren für die PC-Vektoren
V = Vt.T

# PCs sind bereits nach absteigendem Anteil erklärter Varianz sortiert
# Mit allen PCs können wir das verrauschte Signal perfekt rekonstruieren
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. Wie optimierst du den Speicherverbrauch bei sehr großen Arrays in NumPy?

Eine seltener genutzte Funktion von NumPy ist memmap(). Damit speicherst du Arrays als Datei und kannst größerer Daten verarbeiten, als in den RAM passen. Der Hauptvorteil ist Lazy Loading, wodurch der Speicherbedarf sinkt und dennoch das Gesamtdataset zugänglich bleibt. 

Mit einem geschickten Einsatz dieser Funktion arbeitest du deutlich bequemer mit großen Daten.

​​import numpy as np

# Create a large array and save it to a file using memmap
filename = 'large_array.dat'
large_array_shape = (10000, 10000)
dtype = np.float32  # Specify the data type of the array

# Create a memmap object with the desired shape and dtype
large_array = np.memmap(filename, dtype=dtype, mode='w+', shape=large_array_shape)

# Initialize the array with some values (e.g., fill it with random numbers)
large_array[:] = np.random.rand(*large_array_shape)

# Access a small part of the array without loading the entire array into memory
sub_array = large_array[5000:5010, 5000:5010]
print(sub_array)  # Output: A 10x10 array with random float values

# Clean up and ensure that the changes are written to disk
del large_array

15. Wie gehst du in NumPy mit fehlenden oder unendlichen Werten um?

Mit fehlenden und unendlichen Werten umzugehen, gehört zum Alltag. Zunächst lassen sie sich mit isnan() bzw. isinf() erkennen. 

Liegt ein systematisches Problem vor, sollte die Pipeline überprüft werden; andernfalls können die Werte imputiert werden. 

Häufig kombinieren wir NumPy-Funktionen mit pandas, z. B. fillna(). So lassen sich Fehlwerte etwa mit mean() oder median() von NumPy schnell ersetzen.

NumPy-Interviewfragen für Data Scientists

Bisher haben wir allgemeine NumPy-Themen abgedeckt. Natürlich gelten viele davon für Data Science. In diesem Abschnitt findest du speziell zusammengestellte NumPy-Fragen für Data Scientists.

16. Gibt es eine einfache Möglichkeit, Funktionen auf jede Zeile und Spalte eines 2D-Arrays anzuwenden?

Manchmal brauchen wir eigene Berechnungen je Zeile oder Spalte. Mit apply_along_axis() lässt sich eine benutzerdefinierte Funktion entlang einer Achse auf ein NumPy-Array anwenden – jeweils über die gesamte Achse hinweg. 

import numpy as np

# Create a 2D array
data = np.array([
    [1, 2, 3, 4, 5],
    [10, 15, 20, 25, 30],
    [100, 200, 300, 400, 500]
])

# Define a function to compute the range of a 1D array
def compute_range(arr):
    return np.max(arr) - np.min(arr)

# Apply the compute_range function to each row (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. Wie nutzt du NumPy für Feature Scaling und Normalisierung von Datensätzen im Machine Learning?

Normalisierung stellt sicher, dass ML-Modelle korrekt trainieren. Ohne sie kann die Skalierung – besonders bei distanzbasierten Modellen – die Ergebnisse verzerren. 

Mit NumPy lässt sich Skalierung leicht umsetzen. Hier ein Beispiel für Min-Max-Scaling spaltenweise. Achte darauf, die richtige Achse für dein Feature Scaling zu wählen.

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. Wie können wir NumPy-Arrays einfach sortieren und indizieren?

Während es bei DataFrames sort_values() gibt, wollen wir manchmal explizit die Positionen der sortierten Werte kennen. 

NumPys argsort() liefert die Indizes, die ein Array sortieren würden. Das ist nützlich, wenn andere Datensätze passend zum sortierten Array neu indiziert werden sollen. Mit den Positionen aus argsort() stellst du Konsistenz über Datensätze hinweg sicher.

19. Welchen wichtigen Aspekt des NumPy-Zufallszahlengenerators kannst du nutzen, um ihn vorhersagbar zu machen – und warum?

Zufallszahlengeneratoren in der Informatik sind pseudorandom und basieren auf einem Startwert (Seed). Um Experimente reproduzierbar zu halten, möchten wir die Zufälligkeit im Prozess minimieren. 

Mit random.seed() setzt du den Seed für die gesamte Pipeline und erhältst jedes Mal vergleichbare Ergebnisse. So erkennst du, ob Verbesserungen wirklich von Modellanpassungen kommen – und nicht vom Zufall.

20. Beschreibe, wie du K-Means in NumPy implementieren würdest.

Im Interview kann es vorkommen, dass du einen Algorithmus implementieren sollst. Es geht dabei vor allem um dein Verständnis des Modells und der Bibliothek. 

Du musst nicht jede Codezeile auswendig wissen, aber die Schlüsselschritte und Methoden benennen können. Lies dir K-Means (und andere Basis-Algorithmen) gut durch und verstehe, wie sie funktionieren.

import numpy as np

# Generate a sample dataset
np.random.seed(42)  # For reproducibility
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):
    # Step 1: Initialize centroids randomly
    num_samples, num_features = X.shape
    centroids = X[np.random.choice(num_samples, k, replace=False)]
    
    for i in range(max_iters):
        # Step 2: Assign clusters
        distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
        cluster_assignments = np.argmin(distances, axis=1)
        
        # Step 3: Update centroids
        new_centroids = np.array([X[cluster_assignments == j].mean(axis=0) for j in range(k)])
        
        # Check for convergence
        if np.all(np.linalg.norm(new_centroids - centroids, axis=1) < tol):
            break
        
        centroids = new_centroids
    
    return centroids, cluster_assignments

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

Abschließende Gedanken

Dein Interview-Wissen zu NumPy auszubauen, ist ein entscheidender Schritt für eine Karriere in der Data Science. 

Starte mit den Grundlagen und übe dann gezielte Implementierungen. Je mehr du mit NumPy arbeitest, desto besser verstehst und verinnerlichst du seine Funktionen. Probiere Kurse und Tutorials auf DataCamp, zum Beispiel:

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