Las 20 mejores preguntas de entrevista sobre NumPy: de básico a avanzado

Preguntas intermedias sobre NumPy

Estas preguntas profundizan en el uso práctico de NumPy. Una vez que domines los arrays y su base, toca explorar su funcionalidad. En este nivel se espera que realices cálculos con NumPy.

6. ¿Cómo creas un array de ceros o de unos?

Crear arrays rellenos de ceros o de unos es habitual en muchas tareas de ciencia de datos: inicializar matrices, crear máscaras o estructurar datos temporales. 

Para ello en NumPy utiliza las funciones np.zeros() o np.ones():

import numpy as np

# Crear un array 3x4 de ceros
zeros_arr = np.zeros((3, 4))
print(zeros_arr)
# Output:
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

# Crear un array 2x2 de unos
ones_arr = np.ones((2, 2))
print(ones_arr)
# Output:
# [[1. 1.]
#  [1. 1.]]

7. ¿Qué es el broadcasting en NumPy?

El broadcasting es un comportamiento clave de NumPy que permite operar de forma eficiente con arrays de tamaños distintos. 

En pocas palabras, facilita operaciones aritméticas entre arrays de diferente tamaño garantizando que sus formas sean compatibles. NumPy replica automáticamente los arrays más pequeños sobre el más grande para que las formas encajen. 

Mira este ejemplo:

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. ¿Cómo calculas la media, la mediana y la desviación estándar de un array de NumPy?

La media, la mediana y la desviación estándar son estadísticas descriptivas clave para entender los datos. NumPy las calcula fácilmente con funciones específicas. 

Conocer estos cálculos mejora tu capacidad para aprovechar NumPy:

import numpy as np

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

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

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

# Desviación estándar
std_value = np.std(arr)
print("Standard deviation:", std_value)  # Output: 1.4142135623730951

9. ¿Cómo podemos usar NumPy para consultar rápidamente datos numéricos y actuar en función de una condición booleana?

Aunque solemos pensar en NumPy como una librería de cálculo, también tiene potentes capacidades para manipular datos. 

NumPy permite filtrar con indexación booleana y realizar operaciones según los resultados. El método where() es especialmente útil cuando queremos modificar datos en función de valores numéricos.

Imagina que tenemos un data frame de notas de examen llamado df y queremos categorizar al alumnado. Un np.where() sencillo sería:

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

Ten en cuenta que where() acepta hasta 3 entradas: 

• La primera es la condición booleana
• La segunda es el resultado si es verdadera
• La tercera es el resultado si es falsa

10. ¿Cómo usarías NumPy para algo como el error cuadrático medio (MSE)?

La capacidad de NumPy para operar sobre arrays completos facilita la implementación de cálculos como el Mean Squared Error (MSE). 

Como realiza operaciones sencillas elemento a elemento, vectoriza el cálculo y ofrece una forma eficiente de obtener el MSE. 

Aquí tienes un ejemplo de implementación en NumPy:

# 1. Tenemos dos arrays: predicciones y etiquetas reales
# 2. Calculamos las diferencias al cuadrado y las sumamos
# 3. Dividimos por n, que es la longitud del array

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

Preguntas avanzadas sobre NumPy

Ahora entramos en terreno avanzado. En este nivel se espera que utilices NumPy para resolver problemas más complejos.

11. ¿Cómo puedes calcular estadísticas móviles con NumPy, como una media móvil?

Las estadísticas móviles, como la media móvil, son muy importantes en ciencia de datos. La media móvil se usa a menudo para suavizar datos ruidosos, especialmente en series temporales. 

Una funcionalidad poco conocida de NumPy son los "strides". Una de sus aplicaciones es crear una vista de ventana deslizante del array. Con lib.stride_tricks.sliding_window_view() puedes generar subarrays fácilmente. 

Después, puedes resumir cada subarray —por ejemplo, calculando la media— para obtener una media móvil. Ejemplo:

import numpy as np

from numpy.lib.stride_tricks import sliding_window_view
x = np.arange(6)
v = sliding_window_view(x, 3)
# Esto crea v, un array con subarrays de longitud 3 que reflejan el tamaño de la ventana.

12. ¿Cómo realizas indexación avanzada para seleccionar elementos de un array multidimensional según una condición?

Aunque la indexación es una habilidad básica, aprovechar técnicas avanzadas permite particionar los datos con más precisión. 

Usando indexación por arrays de enteros y booleana, crear subconjuntos que cumplan criterios específicos resulta trivial.

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

# Indexación booleana: seleccionar elementos mayores que 30
condition = array > 30
print(condition)  # Output:
# [[False False False False]
#  [False  True  True  True]
#  [ True  True  True  True]]

# Aplicar la condición para obtener los elementos que cumplen el criterio
filtered_elements = array[condition]
print(filtered_elements)  # Output: [35 40 45 50 55 60 65]

# Indexación por arrays de enteros: seleccionar elementos según índices de fila y columna
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]

# Combinando indexación booleana y por enteros
# Seleccionar elementos del array donde el valor sea mayor que 30 y pertenezca a índices específicos
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. ¿Cómo puedes usar NumPy para realizar álgebra lineal, como una descomposición matricial o resolver un sistema de ecuaciones lineales?

Realizar descomposición de matrices es vital cuando trabajas con grandes volúmenes de datos. Reducir los datos a sus componentes principales es un primer paso crítico para reducir la complejidad y el ruido. 

El módulo linalg de NumPy permite realizar álgebra lineal fácilmente para obtener los componentes principales. 

# La señal subyacente es una imagen modulada sinusoidalmente
img = lena() # Esto es de scipy.misc import lena
t = np.arange(100)
tiempo = np.sin(0.1*t)
true= tiempo[:,np.newaxis,np.newaxis] * img[np.newaxis,...]

# Añadimos algo de ruido
noisy = real + np.random.randn(*true.shape)*255

# Matriz (observaciones, características)
M = noisy.reshape(noisy.shape[0],-1)

# La descomposición en valores singulares (SVD) factoriza la matriz de datos de modo que:
#   M = U*S*V.T     (donde '*' es multiplicación matricial)
# * U y V son matrices singulares con vectores ortogonales de norma unitaria
# * S es una matriz diagonal con los valores singulares de M; con ellos podemos calcular los CP

# Obtener los resultados de la SVD de la matriz con ruido
U, s, Vt = np.linalg.svd(M, full_matrices=False)
# Transponemos V para obtener los vectores de CP
V = Vt.T

# Los CP ya están ordenados de mayor a menor según los valores singulares
# Si usamos todos los CP, podemos reconstruir la señal ruidosa perfectamente
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. ¿Cómo puedes optimizar el uso de memoria al trabajar con arrays grandes en NumPy?

Una funcionalidad poco utilizada de NumPy es memmap(). Permite almacenar arrays como un archivo y leer arrays más grandes de lo que cabría solo en memoria. Su principal ventaja es la lectura perezosa de datos, que reduce la memoria total necesaria y aun así permite evaluar todo el conjunto de datos. 

Usarla con cabeza facilita trabajar con datos grandes de forma más cómoda.

​​import numpy as np

# Crear un array grande y guardarlo en un archivo con memmap
filename = 'large_array.dat'
large_array_shape = (10000, 10000)
dtype = np.float32  # Especifica el tipo de datos del array

# Crear un objeto memmap con la forma y dtype deseados
large_array = np.memmap(filename, dtype=dtype, mode='w+', shape=large_array_shape)

# Inicializar el array con algunos valores (por ejemplo, números aleatorios)
large_array[:] = np.random.rand(*large_array_shape)

# Acceder a una parte pequeña del array sin cargarlo entero en memoria
sub_array = large_array[5000:5010, 5000:5010]
print(sub_array)  # Output: un array 10x10 con floats aleatorios

# Limpiar y asegurar que los cambios se escriben en disco
del large_array

15. ¿Cómo gestionas y manipulas arrays con valores faltantes o infinitos en NumPy?

Tratar con valores faltantes e infinitos es habitual. Primero, puedes usar isnan() o isinf() de NumPy para detectarlos. 

Si hay un problema sistemático, conviene revisar los pipelines; si no, podemos imputar esos valores. 

Aunque quizá no uses NumPy directamente para imputar, a menudo se combina con pandas y su fillna(). Por ejemplo, puedes usar mean() o median() de NumPy para rellenar valores erróneos rápidamente.

Preguntas de entrevista sobre NumPy para data scientists

Hasta ahora hemos cubierto preguntas generales sobre NumPy. Aunque también aplican a ciencia de datos, en esta sección reunimos preguntas específicas para data scientists.

16. ¿Existe una forma rápida y sencilla de aplicar funciones a cada fila y columna de un array 2D?

A veces necesitamos realizar cálculos personalizados para obtener información por fila o columna. Por suerte, apply_along_axis() de NumPy permite aplicar una función personalizada a lo largo de un eje del array. 

import numpy as np

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

# Definir una función para calcular el rango de un array 1D
def compute_range(arr):
    return np.max(arr) - np.min(arr)

# Aplicar compute_range a cada fila (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. ¿Cómo puedes aprovechar NumPy para escalar y normalizar características de datasets para machine learning?

Normalizar los datos asegura un entrenamiento adecuado de los modelos. Sin normalización, la escala puede sesgar los resultados, especialmente en modelos basados en distancias. 

Podemos usar funciones de NumPy para escalar fácilmente. Aquí tienes un ejemplo de min-max scaling por columnas. Asegúrate de elegir el eje correcto al escalar.

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. ¿Qué formas hay de ordenar e indexar fácilmente nuestros arrays de NumPy?

Aunque en DataFrame usamos sort_values(), hay casos en los que queremos conocer la posición de los valores ordenados. 

argsort() de NumPy devuelve las posiciones que ordenarían un array. Es útil, por ejemplo, cuando necesitamos indexar otros conjuntos de datos para alinearlos con el orden. Con las posiciones, podemos usar la salida de argsort() y mantener la coherencia entre datasets.

19. ¿Qué aspecto importante del generador de números aleatorios de NumPy se puede usar para hacerlo predecible y por qué?

Los generadores de números aleatorios en computación no son realmente aleatorios: parten de una semilla inicial. Como a menudo queremos probar y evaluar resultados de forma reproducible, debemos minimizar la aleatoriedad en el pipeline. 

Con random.seed() de NumPy podemos fijar la semilla de toda la canalización y obtener resultados consistentes. Así, podremos atribuir mejoras a cambios en el modelo y no al azar.

20. Describe cómo implementarías K-Means en NumPy.

En una entrevista pueden pedirte implementar algún algoritmo. El objetivo es demostrar que entiendes los fundamentos del modelo y de la librería. 

No necesitas memorizar cada línea del siguiente código, pero sí identificar los pasos y métodos clave. Asegúrate de haber leído sobre K-Means (y otros algoritmos básicos) y comprender cómo funciona.

import numpy as np

# Generar un dataset de ejemplo
np.random.seed(42)  # Para reproducibilidad
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):
    # Paso 1: inicializar centroides aleatoriamente
    num_samples, num_features = X.shape
    centroids = X[np.random.choice(num_samples, k, replace=False)]
    
    for i in range(max_iters):
        # Paso 2: asignar clusters
        distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
        cluster_assignments = np.argmin(distances, axis=1)
        
        # Paso 3: actualizar centroides
        new_centroids = np.array([X[cluster_assignments == j].mean(axis=0) for j in range(k)])
        
        # Comprobar convergencia
        if np.all(np.linalg.norm(new_centroids - centroids, axis=1) < tol):
            break
        
        centroids = new_centroids
    
    return centroids, cluster_assignments

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

Conclusión

Reforzar tus conocimientos de entrevista con NumPy es un paso clave para triunfar en una carrera profesional en ciencia de datos. 

Empieza practicando y entendiendo los fundamentos y, después, pasa a implementaciones concretas. Cuanto más uses NumPy, mejor interiorizarás sus funciones. Prueba algunos cursos y tutoriales de DataCamp, como estos:

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