Top 20 pytań z rozmów o pracę dotyczących NumPy: od podstaw do zaawansowanych

Średnio zaawansowane pytania dotyczące NumPy

Te pytania głębiej wchodzą w praktyczne użycie NumPy. Gdy zrozumiesz podstawy tablic NumPy, warto eksplorować jego funkcjonalności. Na poziomie średnio zaawansowanym możesz spodziewać się wykonywania obliczeń z NumPy.

6. Jak utworzyć tablicę samych zer lub samych jedynek?

Tworzenie tablic wypełnionych zerami lub jedynkami to częsty wymóg w wielu zadaniach data science, np. przy inicjalizacji macierzy, tworzeniu masek czy budowaniu struktur zastępczych. 

Aby utworzyć tablicę samych zer lub samych jedynek w NumPy, użyj funkcji np.zeros() lub 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. Czym jest broadcasting w NumPy?

Broadcasting to kluczowe zachowanie NumPy, które pozwala wydajnie wykonywać operacje na tablicach o różnych rozmiarach. 

Mówiąc prosto, umożliwia działania arytmetyczne między tablicami o różnych rozmiarach, doprowadzając ich kształty do zgodności. NumPy automatycznie replikuje mniejsze tablice względem większych, aby nadać im kompatybilne kształty. 

Zobacz przykład:

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. Jak obliczyć średnią, medianę i odchylenie standardowe tablicy NumPy?

Średnia, mediana i odchylenie standardowe to kluczowe statystyki opisowe służące do zrozumienia danych. NumPy bardzo łatwo je wylicza i ma do tego dedykowane funkcje. 

Znajomość tych obliczeń jest ważna, by w pełni wykorzystać 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. Jak wykorzystać NumPy do szybkiego odpytywania danych numerycznych i wykonywania działań na podstawie warunku logicznego?

Choć główne zastosowanie NumPy kojarzymy z obliczeniami, ma ono też potężne możliwości porządkowania danych. 

NumPy łatwo odpyta dane za pomocą indeksowania boolean i wykona operacje w zależności od wyników. Metoda where() jest szczególnie przydatna, gdy chcemy modyfikować dane na podstawie wartości liczbowych.

Załóżmy, że mamy ramkę danych z wynikami egzaminów o nazwie df i chcemy skategoryzować uczniów. Proste np.where() może wyglądać tak:

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

Zauważ, że metoda where() przyjmuje do 3 argumentów: 

• Pierwszy to dowolne wyrażenie logiczne
• Drugi to wynik, gdy warunek jest spełniony (true)
• Trzeci to wynik, gdy warunek nie jest spełniony (false)

10. W jaki sposób wykorzystać NumPy do obliczenia np. błędu średniokwadratowego (MSE)?

Zdolność NumPy do pracy na całej tablicy naraz sprawia, że implementacja obliczeń takich jak Mean Squared Error (MSE) jest prosta. 

Ponieważ wykonuje proste operacje element‑po‑elemencie, łatwo wektoryzuje działanie i zapewnia wydajny sposób wyliczania MSE. 

Przykładowa implementacja MSE w NumPy:

# 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))

Zaawansowane pytania dotyczące NumPy

Czas wejść na poziom zaawansowany! Na tym etapie oczekuje się, że wykorzystasz NumPy do rozwiązywania bardziej złożonych problemów.

11. Jak obliczyć statystyki kroczące w NumPy, np. średnią kroczącą?

Statystyki kroczące, takie jak średnia krocząca, są bardzo ważne w data science. Średnia krocząca jest często używana do wygładzania zaszumionych danych, szczególnie czasowych. 

Mniej znana funkcjonalność NumPy to „strides”. Jednym z jej zastosowań jest tworzenie widoku przesuwnego okna tablicy. Używając lib.stride_tricks.sliding_window_view(), możesz łatwo generować podzbiory tablicy. 

Następnie możesz wykonać dowolne podsumowania, np. obliczyć średnią dla każdego z tych podzbiorów, aby uzyskać średnią kroczącą. Oto przykładowa implementacja:

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. Jak wykonać zaawansowane indeksowanie, aby wybierać elementy z tablicy wielowymiarowej na podstawie warunku?

Choć indeksowanie jest podstawową umiejętnością w NumPy, wykorzystanie bardziej zaawansowanych technik pozwala precyzyjniej „kroić” dane. 

Korzystając z indeksowania tablicami liczb całkowitych i indeksowania boolean, tworzenie zbiorów spełniających konkretne kryteria staje się trywialne.

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. Jak użyć NumPy do wykonania operacji algebry liniowej, takich jak dekompozycja macierzy lub rozwiązanie układu równań liniowych?

Przeprowadzanie dekompozycji macierzy jest kluczowe dla data scientistów pracujących z dużymi wolumenami danych. Redukcja danych do głównych składowych to krytyczny pierwszy krok w redukcji złożoności i szumu. 

Moduł linalg w NumPy pozwala łatwo wykonywać algebrę liniową, aby uzyskać główne składowe. 

# 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. Jak zoptymalizować użycie pamięci podczas pracy z dużymi tablicami w NumPy?

Rzadziej używana funkcjonalność NumPy to memmap(). Pozwala zapisać tablice jako plik, dzięki czemu możemy odczytywać większe tablice, niż zmieściłyby się w pamięci operacyjnej. Jej główną zaletą jest „leniwy” odczyt danych, który zmniejsza zapotrzebowanie na pamięć, a jednocześnie pozwala analizować cały zbiór danych. 

Sprytne użycie tej funkcji ułatwia i usprawnia pracę z dużymi danymi.

​​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. Jak obsługiwać i modyfikować tablice z brakującymi lub nieskończonymi wartościami w NumPy?

Radzenie sobie z brakami i wartościami nieskończonymi to codzienność data scientista. Najpierw możesz użyć isnan() lub isinf() w NumPy, aby znaleźć takie wartości. 

Jeśli problem jest systematyczny, warto ocenić nasze potoki przetwarzania; w przeciwnym razie możemy chcieć te wartości uzupełnić. 

Choć nie zawsze używamy bezpośrednio NumPy do wypełniania braków, często łączymy funkcje NumPy z metodami pandas, jak fillna(), aby uzupełnić brakujące dane. Na przykład możemy użyć funkcji mean() lub median() z NumPy, by szybko wypełnić błędne wartości.

Pytania o NumPy dla data scientistów

Do tej pory omawialiśmy ogólne pytania o NumPy. Oczywiście poprzednie pytania mogą dotyczyć data science, ale w tej sekcji zebrałem konkretne pytania o NumPy dla data scientistów.

16. Czy istnieje sposób, by szybko i łatwo zastosować funkcje do każdego wiersza i kolumny tablicy 2D?

Czasem musimy wykonać niestandardowe obliczenia na tablicy, aby uzyskać informacje dla każdego wiersza lub kolumny. Na szczęście metoda NumPy apply_along_axis() pozwala zastosować własną funkcję do całej tablicy NumPy. Funkcje te działają wzdłuż wskazanej osi w każdej tablicy. 

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. Jak wykorzystać NumPy do skalowania cech i normalizacji zbiorów danych na potrzeby uczenia maszynowego?

Normalizacja danych zapewnia poprawne trenowanie modeli uczenia maszynowego. Bez niej skala może wpływać na wyniki modelu, zwłaszcza w modelach opartych na odległościach. 

Możemy łatwo wykonać skalowanie, korzystając z funkcji NumPy. Oto przykład skalowania min‑max, które działa dla wszystkich wierszy. Upewnij się, że wybierasz właściwy wymiar podczas skalowania cech.

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. Jakie są sposoby na łatwe sortowanie i indeksowanie tablic NumPy?

Choć w DataFrame mamy np. sort_values(), bywają sytuacje, w których chcemy poznać położenie posortowanych wartości. 

Funkcja argsort() w NumPy zwraca pozycje, które posortowałyby daną tablicę. Przydaje się to, gdy musimy prawidłowo zaindeksować inne zbiory danych, aby dopasować je do naszych posortowanych tablic. Mając pozycje, możemy użyć wyniku argsort(), by zapewnić spójność między zbiorami danych.

19. Jaki ważny aspekt generatora liczb losowych w NumPy można wykorzystać, by uczynić go przewidywalnym i dlaczego?

Generatory liczb losowych w komputerach nie są naprawdę losowe. Opierają się na początkowym ziarnie (seed). Ponieważ często chcemy testować nasze dane i łatwo oceniać wyniki, musimy minimalizować losowość w potoku przetwarzania. 

Korzystając z metody random.seed() w NumPy, możemy ustawić ziarno dla całego potoku, aby za każdym razem otrzymywać podobne rezultaty. Ustawienie konkretnego ziarna pozwala ocenić, czy poprawa wyników wynika z modyfikacji modelu, a nie z losowości.

20. Opisz, jak mógłbyś zaimplementować K‑Means w NumPy.

W trakcie rozmowy możesz zostać poproszony o zaimplementowanie jakiegoś algorytmu. W tego typu pytaniach chodzi o pokazanie zrozumienia podstaw działania modelu i biblioteki. 

Nie musisz pamiętać każdej linijki kodu poniżej, ale bądź w stanie wskazać kluczowe kroki i potrzebne metody. Upewnij się, że znasz K‑Means (i inne podstawowe algorytmy) oraz rozumiesz, jak działa.

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)

Na zakończenie

Budowanie wiedzy z zakresu NumPy na potrzeby rozmów kwalifikacyjnych to jeden z kluczowych kroków do sukcesu w karierze w data science. 

Zacznij od ćwiczenia i zrozumienia podstaw, a następnie przechodź do konkretnych implementacji. Im więcej korzystasz z NumPy, tym lepiej zrozumiesz i utrwalisz jego funkcje. Wypróbuj kursy i tutoriale na DataCamp, takie jak:

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