Topp 20 intervjufrågor om NumPy: från grundläggande till avancerat

Intermediära intervjufrågor om NumPy

Dessa frågor går djupare in på att faktiskt använda NumPy. När du har etablerat en grundläggande förståelse för NumPys arrayer bör du utforska dess funktionalitet. Att utföra beräkningar med NumPy kan förväntas på mellannivå.

6. Hur skapar du en array med enbart nollor eller enbart ettor?

Att skapa arrayer fyllda med nollor eller ettor är ett vanligt krav i många data science-uppgifter, såsom initialisering av matriser, skapa maskarrayer eller sätta upp platshållarstrukturer. 

För att skapa en array med enbart nollor eller enbart ettor i NumPy använder du funktionerna np.zeros() eller 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. Vad är broadcasting i NumPy?

Broadcasting är ett centralt beteende i NumPy som möjliggör effektiva operationer på arrayer av olika storlek. 

Enkelt uttryckt tillåter det aritmetiska operationer mellan arrayer av olika storlek genom att säkerställa att båda arrayerna har kompatibla former. Detta sker när NumPy automatiskt replikerar mindre arrayer över den större arrayen så att de får kompatibla former. 

Se följande exempel:

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. Hur hittar du medelvärde, median och standardavvikelse för en NumPy-array?

Medelvärde, median och standardavvikelse är centrala beskrivande statistikmått som ofta används för att förstå våra data. NumPy beräknar dessa mycket enkelt och har särskilda funktioner för dem. 

Att kunna dessa beräkningar är viktigt för att förbättra vår förmåga att använda NumPy:

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. Hur kan vi utnyttja NumPy för att snabbt söka i vår numeriska data och utföra åtgärder baserat på ett booleskt villkor?

Även om vi tänker på NumPys huvudsakliga syfte som ett beräkningspaket har det också kraftfulla verktyg för datahantering. 

NumPy kan enkelt fråga data genom boolesk indexering och utföra operationer baserat på resultaten. Metoden where() är särskilt användbar när vi vill göra ändringar i våra data baserat på numeriska värden.

Anta att vi har en data frame med provresultat som heter df och vill kategorisera studenterna. En enkel np.where() kan se ut så här:

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

Observera att metoden where() tar upp till tre inparametrar: 

• Den första är det booleska uttrycket av valfritt slag
• Den andra är resultatet om sant
• Den tredje är resultatet om falskt

10. Hur kan vi utnyttja NumPy för något som Mean Squared Error?

NumPys förmåga att arbeta över en hel array på en gång gör det enkelt att implementera beräkningar som Mean Squared Error (MSE). 

Eftersom det utför enkla operationer element för element vektoriseras operationen enkelt och ger ett effektivt sätt att beräkna MSE. 

Ett exempel på en implementation av MSE i NumPy följer:

# 1. We have two arrays, our prediction, and actual labels
# 2. We take the squared differences and sum them
# 3. We then divide by n, which is the length of the array

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

Avancerade intervjufrågor om NumPy

Nu är det dags att gå in på avancerad mark! På den här nivån förväntas du använda NumPy för att lösa mer komplexa problem.

11. Hur kan du beräkna rullande statistik med NumPy, till exempel ett glidande medelvärde?

Rullande statistik som glidande medelvärde är mycket viktigt i data science. Det rullande medelvärdet används ofta för att jämna ut brusig data, särskilt om den är tidsbaserad. 

En mindre känd funktionalitet i NumPy är ”strides”. Ett sätt som stride implementeras på är att skapa en glidande fönstervy av din array. Med lib.stride_tricks.sliding_window_view() kan du enkelt generera delmängder av arrayer. 

Du kan sedan göra valfri summering, till exempel beräkna medelvärdet, på var och en av dessa delmängder för att få ett rullande medelvärde. Här är ett exempel på implementation:

import numpy as np

from numpy.lib.stride_tricks import sliding_window_view
x = np.arange(6)
v = sliding_window_view(x, 3)
# This creates v, an array that contains subarrays of length 3 which reflect the size of the window.

12. Hur utför du avancerad indexering för att välja element från en multidimensionell array baserat på ett villkor?

Även om indexering kan vara en grundläggande färdighet i NumPy kan mer avancerade indexeringstekniker låta data scientists skiva sin data mer precist. 

Genom att använda heltalsarray-indexering och boolesk indexering blir det trivialt att skapa dataset som uppfyller specifika kriterier.

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. Hur kan du använda NumPy för att utföra en linjäralgebraoperation som matrisdekomposition eller lösa ett linjärt ekvationssystem?

Att utföra matrisdekomposition är avgörande för data scientists som hanterar stora datavolymer. Att reducera data till dess huvudkomponenter är ett viktigt första steg för att minska komplexitet och brus. 

NumPys linalg-modul låter oss enkelt utföra linjär algebra för att få fram huvudkomponenter. 

# The underlying signal is a sinusoidally modulated image
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,...]

# We add some noise
noisy = real + np.random.randn(*true.shape)*255

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

# Singular value decomposition factorizes your data matrix such that:
#   M = U*S*V.T     (where '*' is matrix multiplication)
# * U and V are the singular matrices containing orthogonal vectors of unit length
# * S is a diagonal matrix containing the singular values of M - we can use this to calculate our PCs

# Obtain the results of SVD from our noisy matrix
U, s, Vt = np.linalg.svd(M, full_matrices=False)
# Transpose V to get our PC vectors
V = Vt.T

# PCs are already sorted by descending order of the singular values (i.e. by the proportion of total variance they explain)
# If we use all of the PCs we can reconstruct the noisy signal perfectly
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. Hur kan du optimera minnesanvändningen när du arbetar med stora arrayer i NumPy?

En sällan använd funktionalitet i NumPy är memmap(). Detta låter oss lagra arrayer som en fil, vilket gör att vi kan läsa in större arrayer än vad som ryms i minnet. Dess största fördel är lat inläsning av data, vilket minskar det totala minnesbehovet samtidigt som vi kan bedöma hela datasetet. 

Att använda denna funktion på ett smart sätt gör det enklare och smidigare för en data scientist att arbeta med stora datamängder.

​​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. Hur kan du hantera och manipulera arrayer med saknade eller oändliga värden i NumPy?

Att hantera saknade och oändliga värden är vanligt för data scientists. Först kan du vilja använda NumPys isnan() eller isinf() för att hitta dessa saknade och oändliga värden. 

Om det finns ett systematiskt problem kan vi vilja utvärdera våra pipelines; annars kan vi vilja fylla i dessa värden. 

Även om vi kanske inte använder NumPy direkt för att fylla i saknade värden använder vi ofta NumPy-funktioner i kombination med till exempel pandas fillna() för att fylla i saknade data. Till exempel kan vi vilja använda NumPys mean() eller median() för att snabbt fylla i felaktiga värden.

Intervjufrågor om NumPy för data scientists

Hittills har vi täckt allmänna NumPy-frågor. Självklart kan frågorna vi gick igenom tidigare gälla data science, men i det här avsnittet har jag sammanställt specifika NumPy-frågor för data scientists.

16. Finns det ett sätt att snabbt och enkelt tillämpa funktioner på varje rad och kolumn i en 2D-array?

Ibland behöver vi utföra anpassade beräkningar på vår array för att få information om varje rad eller kolumn. Som tur är kan NumPy-metoden apply_along_axis() användas för att tillämpa en anpassad funktion över en NumPy-array. Dessa funktioner tillämpas över hela en viss axel i varje array. 

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. Hur kan du använda NumPy för att utföra feature scaling och normalisering av dataset för maskininlärning?

Normalisering av data säkerställer att vi tränar våra maskininlärningsmodeller på rätt sätt. Utan normalisering kan skalan påverka modellernas resultat, särskilt för avståndsbaserade modeller. 

Vi kan använda NumPys funktioner för att enkelt utföra skalning. Här är ett exempel på min-max-skalning som körs för alla rader. Se till att du väljer rätt dimension när du skalar features.

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. Vilka är några sätt vi enkelt kan sortera och indexera våra NumPy-arrayer?

Även om vi har något som DataFrames sort_values() finns det vissa fall där vi vill hitta platsen för dessa sorterade värden. 

NumPys argsort() ger positionerna som skulle sortera en given array. Ett användbart scenario är när vi behöver indexera andra dataset korrekt för att matcha våra sorterade arrayer. Genom att ha positionerna redo kan vi använda utdata från argsort() för att säkerställa konsekvens mellan våra dataset.

19. Vad är en viktig aspekt av NumPys slumpgenerering som kan användas för att göra den förutsägbar, och varför?

Slumptalsgeneratorer i datorer är inte genuint slumpmässiga. De baseras på en initial seed. Eftersom vi ofta vill testa våra data och enkelt kunna utvärdera resultat måste vi minimera mängden slumpmässighet i vår pipeline. 

Genom att använda NumPys metod random.seed() kan vi sätta seed för en hel pipeline så att vi får liknande resultat varje gång. Genom att sätta ett specifikt seed kan vi bedöma om förbättringar av våra resultat beror på våra modelljusteringar och inte på slumpen.

20. Beskriv hur du kan implementera K-Means i NumPy.

Under en intervju kan du bli ombedd att implementera en algoritm av något slag. Fokus i dessa frågor är att svara med en grundläggande förståelse för modellen och paketet. 

Du behöver inte memorera varje kodrad nedan, men kunna peka ut de viktigaste stegen och metoderna som behövs. Se till att du har läst om K-Means (och andra grundläggande algoritmer) och också förstår hur algoritmen fungerar.

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)

Avslutande tankar

Att bygga upp dina intervjukunskaper med NumPy är ett av de avgörande stegen för framgång i en karriär inom data science. 

Börja med att öva och förstå grunderna följt av specifik implementation. Ju mer du använder Numpy desto bättre kommer du att förstå och internalisera dess funktioner. Testa några av DataCamps kurser och handledningar, till exempel följande:

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