Топ‑20 вопросов по NumPy на собеседовании: от базовых до продвинутых

Вопросы среднего уровня по NumPy

Эти вопросы глубже затрагивают практическое использование NumPy. Освоив основы массивов, переходите к функциональности библиотеки. На среднем уровне ожидается умение выполнять вычисления с NumPy.

6. Как создать массив, заполненный нулями или единицами?

Создание массивов, заполненных нулями или единицами, — частая задача, например, при инициализации матриц, создании масок или заготовок структур данных. 

Для этого используйте функции np.zeros() или 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. Что такое broadcasting в NumPy?

Broadcasting — ключевой механизм NumPy, позволяющий эффективно выполнять операции над массивами разного размера. 

Проще говоря, это возможность выполнять арифметические операции между массивами разных размеров за счёт приведения их форм к совместимым. Для этого NumPy автоматически «распространяет» меньший массив по большему, чтобы их формы стали совместимыми. 

Пример:

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. Как найти среднее, медиану и стандартное отклонение массива NumPy?

Среднее, медиана и стандартное отклонение — ключевые описательные статистики для понимания данных. В NumPy они вычисляются очень просто с помощью специализированных функций. 

Знание этих вычислений важно для эффективного использования 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. Как быстро запрашивать числовые данные в NumPy и выполнять действия на основе булева выражения?

Хотя основная цель NumPy — вычисления, у него есть и мощные средства трансформации данных. 

NumPy позволяет просто запрашивать данные через булеву индексацию и выполнять операции в зависимости от результата. Метод where() особенно полезен, когда нужно модифицировать данные на основе числовых значений.

Предположим, у нас есть датафрейм с результатами экзамена df, и мы хотим категоризировать студентов. Пример np.where() может выглядеть так:

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

Обратите внимание, что метод where() принимает до трёх аргументов: 

• Первый — булево выражение любого вида
• Второй — результат, если условие истинно
• Третий — результат, если условие ложно

10. Как можно использовать NumPy для вычисления, например, среднеквадратичной ошибки?

Способность NumPy работать сразу с целыми массивами упрощает реализацию таких вычислений, как среднеквадратичная ошибка (MSE). 

Поскольку операции выполняются поэлементно, они легко векторизуются, и MSE вычисляется эффективно. 

Пример реализации MSE в 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))

Продвинутые вопросы по NumPy

Пора перейти к продвинутому уровню! Здесь ожидается, что вы будете использовать NumPy для решения более сложных задач.

11. Как вычислять скользящую статистику в NumPy, например скользящее среднее?

Скользящая статистика, например скользящее среднее, очень важна в анализе данных. Скользящее среднее часто применяют для сглаживания шумных данных, особенно временных. 

Малоизвестная возможность NumPy — «шагающие окна» (strides). Один из способов их использования — создание скользящего окна представления массива. С помощью lib.stride_tricks.sliding_window_view() можно легко генерировать подмассивы. 

Далее можно выполнять любую агрегацию, например вычислять среднее по каждому окну, чтобы получить скользящее среднее. Пример реализации:

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. Как выполнить продвинутую индексацию для выбора элементов из многомерного массива по условию?

Хотя индексация — базовый навык в NumPy, использование продвинутых приёмов позволяет точнее «нарезать» данные. 

Благодаря целочисленной и булевой индексации становится просто создавать выборки, удовлетворяющие заданным критериям.

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. Как использовать NumPy для операций линейной алгебры, таких как разложение матрицы или решение СЛАУ?

Разложение матрицы жизненно важно при работе с большими объёмами данных. Сведение данных к главным компонентам — критический шаг для снижения сложности и шума. 

Модуль linalg в NumPy позволяет легко выполнять линейную алгебру для получения главных компонентов. 

# 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. Как оптимизировать использование памяти при работе с большими массивами в NumPy?

Редко используемая возможность NumPy — memmap(). Она позволяет хранить массивы в виде файла и читать массивы большего размера, чем помещаются в память. Главная выгода — «ленивое» чтение данных, которое снижает общий объём потребляемой памяти и при этом даёт доступ ко всему набору данных. 

Грамотное применение этой функции упрощает и ускоряет работу с большими данными.

​​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. Как обрабатывать и изменять массивы с пропущенными или бесконечными значениями в NumPy?

Работа с пропущенными и бесконечными значениями — типичная задача для дата-сайентистов. Сначала можно воспользоваться isnan() или isinf() в NumPy, чтобы найти такие значения. 

Если есть системная проблема, стоит проверить конвейеры обработки; в противном случае можно заполнить эти значения.

Хотя для заполнения пропусков часто используется не сам NumPy, его функции нередко комбинируют с методами pandas, например fillna(). Например, можно применить функции NumPy mean() или median(), чтобы быстро заполнить некорректные значения.

Вопросы по NumPy для дата‑саентистов

До этого момента мы рассматривали общие вопросы по NumPy. Конечно, они применимы и к data science, но в этом разделе собраны вопросы, ориентированные именно на дата‑саентистов.

16. Можно ли быстро и просто применять функции к каждой строке и каждому столбцу 2D‑массива?

Иногда нужно выполнить пользовательские вычисления по строкам или столбцам массива. К счастью, метод NumPy apply_along_axis() позволяет применить произвольную функцию по оси массива. Функции применяются по всей выбранной оси каждого массива. 

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. Как использовать NumPy для масштабирования признаков и нормализации наборов данных для машинного обучения?

Нормализация данных помогает корректно обучать модели машинного обучения. Без нормализации масштаб признаков может искажать результаты, особенно в моделях на расстояниях. 

Функции NumPy позволяют легко выполнять масштабирование. Ниже пример мин‑макс нормализации по столбцам. Убедитесь, что вы выбираете правильное измерение при масштабировании признаков.

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. Какими способами можно легко сортировать и индексировать массивы NumPy?

Хотя в DataFrame есть метод sort_values(), иногда нам нужно найти позиции отсортированных значений. 

Функция NumPy argsort() возвращает позиции, упорядочивающие массив. Это полезно, когда нужно согласовать индексацию других наборов данных с нашим отсортированным массивом. Имея на руках позиции, мы можем использовать результат argsort() для обеспечения согласованности между датасетами.

19. Какая важная особенность генератора случайных чисел NumPy позволяет сделать его предсказуемым и зачем это нужно?

Генераторы случайных чисел в вычислениях не являются по-настоящему случайными: они зависят от начального зерна (seed). Поскольку нам часто нужно проводить эксперименты и воспроизводимо оценивать результаты, важно минимизировать долю случайности в конвейере. 

С помощью метода random.seed() в NumPy можно задать зерно для всего конвейера и получать сопоставимые результаты при каждом запуске. Фиксируя seed, мы понимаем, что улучшения связаны с настройкой модели, а не со случайностью.

20. Опишите, как вы бы реализовали K‑Means в NumPy.

На собеседовании вас могут попросить реализовать алгоритм. Важно показать фундаментальное понимание модели и библиотеки. 

Не обязательно заучивать каждый рядок кода ниже, но нужно уметь выделить ключевые шаги и используемые методы. Обязательно ознакомьтесь с K‑Means (и другими базовыми алгоритмами) и поймите, как он работает.

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)

Заключение

Расширение знаний по NumPy — один из критически важных шагов на пути к успеху в карьере в data science. 

Начните с практики и понимания основ, затем переходите к конкретным реализациям. Чем больше вы используете NumPy, тем лучше понимаете и запоминаете его функции. Попробуйте курсы и руководства на DataCamp, например:

• Руководство по массивам NumPy в Python
• Шпаргалка по NumPy
• Интенсив по NumPy