Top 20 perguntas sobre NumPy em entrevistas: do básico ao avançado

Perguntas intermediárias sobre NumPy

Estas perguntas mergulham no uso prático do NumPy. Depois de entender os fundamentos dos arrays do NumPy, explore suas funcionalidades. Espera-se que, no nível intermediário, você consiga realizar cálculos com o NumPy.

6. Como criar um array só de zeros ou só de uns?

Criar arrays preenchidos com zeros ou uns é comum em várias tarefas, como inicializar matrizes, criar máscaras ou montar estruturas de dados temporárias.

Para isso, use as funções np.zeros() ou np.ones():

import numpy as np

# Cria um array 3x4 de zeros
zeros_arr = np.zeros((3, 4))
print(zeros_arr)
# Saída:
# [[0. 0. 0. 0.]
#  [0. 0. 0. 0.]
#  [0. 0. 0. 0.]]

# Cria um array 2x2 de uns
ones_arr = np.ones((2, 2))
print(ones_arr)
# Saída:
# [[1. 1.]
#  [1. 1.]]

7. O que é broadcasting no NumPy?

Broadcasting é um comportamento-chave do NumPy que permite operações eficientes em arrays de tamanhos diferentes.

Em termos simples, ele permite operações aritméticas entre arrays de tamanhos distintos, garantindo que ambos tenham shapes compatíveis. O NumPy replica automaticamente o array menor ao longo do maior para compatibilizar os shapes.

Veja o exemplo:

import numpy as np

a = np.array([1, 2, 3])
b = np.array([[1], [2], [3]])
print(a + b)
# Saída:
# [[2 3 4]
#  [3 4 5]
#  [4 5 6]]

8. Como calcular média, mediana e desvio padrão de um array NumPy?

Média, mediana e desvio padrão são estatísticas descritivas essenciais para entender os dados. O NumPy calcula tudo isso facilmente com funções dedicadas.

Veja como calcular:

import numpy as np

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

# Média
mean_value = np.mean(arr)
print("Mean:", mean_value)  # Saída: 3.0

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

# Desvio padrão
std_value = np.std(arr)
print("Standard deviation:", std_value)  # Saída: 1.4142135623730951

9. Como usar NumPy para consultar rapidamente dados numéricos e realizar ações com base em uma condição booleana?

Embora pensemos no NumPy principalmente como um pacote de cálculo, ele também tem recursos poderosos de manipulação de dados.

O NumPy consulta dados com facilidade por meio de indexação booleana e executa operações com base nos resultados. O método where() é especialmente útil quando queremos alterar dados com base em valores numéricos.

Suponha que temos um data frame de notas de prova chamado df e queremos categorizar os alunos. Um np.where() simples seria:

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

Note que o where() recebe até 3 entradas:

• A primeira é a expressão booleana
• A segunda é o resultado se verdadeiro
• A terceira é o resultado se falso

10. Como usar NumPy para algo como o erro quadrático médio (MSE)?

A capacidade do NumPy de operar sobre um array inteiro de uma vez torna simples implementar cálculos como o Mean Squared Error (MSE).

Como as operações são realizadas elemento a elemento, a vetorização é direta e eficiente para calcular o MSE.

Um exemplo de implementação em NumPy:

# 1. Temos dois arrays: previsões e rótulos verdadeiros
# 2. Calculamos as diferenças ao quadrado e somamos
# 3. Dividimos por n, o tamanho do array

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

Perguntas avançadas sobre NumPy

Agora é hora de avançar! Neste nível, espera-se que você use NumPy para resolver problemas mais complexos.

11. Como calcular estatísticas móveis (rolling), como a média móvel, usando NumPy?

Estatísticas móveis, como a média móvel, são muito importantes em ciência de dados. A média móvel é frequentemente usada para suavizar dados ruidosos, especialmente séries temporais.

Uma funcionalidade pouco conhecida do NumPy são os "strides". Uma forma de usá-los é criando uma janela deslizante do array. Com lib.stride_tricks.sliding_window_view(), você gera subconjuntos facilmente.

Depois, é só resumir cada subconjunto, por exemplo calculando a média, para obter a média móvel. Exemplo:

import numpy as np

from numpy.lib.stride_tricks import sliding_window_view
x = np.arange(6)
v = sliding_window_view(x, 3)
# Isso cria v, um array com subarrays de comprimento 3, refletindo o tamanho da janela.

12. Como fazer indexação avançada para selecionar elementos de um array multidimensional com base em uma condição?

Embora a indexação seja uma habilidade fundamental, técnicas mais avançadas permitem fatiar os dados com mais precisão.

Usando indexação por arrays de inteiros e indexação booleana, criar subconjuntos que atendem a critérios específicos fica trivial.

import numpy as np

array = np.array([[10, 15, 20, 25],
                  [30, 35, 40, 45],
                  [50, 55, 60, 65]])
print(array)  # Saída: 
# [[10 15 20 25]
#  [30 35 40 45]
#  [50 55 60 65]]

# Indexação booleana: selecionar elementos maiores que 30
condition = array > 30
print(condition)  # Saída:
# [[False False False False]
#  [False  True  True  True]
#  [ True  True  True  True]]

# Aplicar a condição para obter os elementos que atendem ao critério
filtered_elements = array[condition]
print(filtered_elements)  # Saída: [35 40 45 50 55 60 65]

# Indexação por arrays de inteiros: selecionar elementos específicos por índices de linha e coluna
row_indices = np.array([0, 1, 2])
col_indices = np.array([1, 2, 3])
selected_elements = array[row_indices, col_indices]
print(selected_elements)  # Saída: [15 40 65]

# Combinando booleana e inteiros
# Selecionar elementos > 30 pertencentes 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)  # Saída: [35 40 45 50 55 60 65]

13. Como usar NumPy para operações de álgebra linear, como decomposição de matrizes ou resolver sistemas lineares?

Realizar decomposição de matrizes é vital para quem lida com grandes volumes de dados. Reduzir os dados aos seus componentes principais é um primeiro passo crítico para reduzir complexidade e ruído.

O módulo linalg do NumPy permite executar álgebra linear facilmente para obter componentes principais.

# O sinal subjacente é uma imagem modulada por uma senóide
img = lena() # De scipy.misc import lena
t = np.arange(100)
time = np.sin(0.1*t)
true= time[:,np.newaxis,np.newaxis] * img[np.newaxis,...]

# Adicionamos ruído
noisy = real + np.random.randn(*true.shape)*255

# Matriz (observações, features)
M = noisy.reshape(noisy.shape[0],-1)

# Decomposição em valores singulares (SVD) fatora sua matriz de dados como:
#   M = U*S*V.T     (onde '*' é multiplicação de matrizes)
# * U e V são matrizes singulares com vetores ortogonais de norma 1
# * S é diagonal e contém os valores singulares de M — podemos usá-la para calcular os PCs

# Obter o SVD da matriz ruidosa
U, s, Vt = np.linalg.svd(M, full_matrices=False)
# Transpor V para obter os vetores de PC
V = Vt.T

# PCs já vêm ordenados por valor singular decrescente (proporção de variância explicada)
# Usando todos os PCs, reconstruímos o sinal ruidoso perfeitamente
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. Como otimizar o uso de memória ao trabalhar com arrays grandes no NumPy?

Uma funcionalidade pouco utilizada do NumPy é o memmap(). Ele permite armazenar arrays como arquivo, possibilitando ler arrays maiores do que caberiam apenas em memória. O principal benefício é a leitura preguiçosa (lazy) dos dados, reduzindo a necessidade total de memória enquanto acessamos todo o dataset.

Usar essa função com inteligência facilita o trabalho com dados muito grandes.

​​import numpy as np

# Criar um array grande e salvá-lo em arquivo com memmap
filename = 'large_array.dat'
large_array_shape = (10000, 10000)
dtype = np.float32  # Tipo dos dados no array

# Criar um memmap com shape e dtype desejados
large_array = np.memmap(filename, dtype=dtype, mode='w+', shape=large_array_shape)

# Inicializar o array com alguns valores (ex.: números aleatórios)
large_array[:] = np.random.rand(*large_array_shape)

# Acessar uma pequena parte sem carregar tudo em memória
sub_array = large_array[5000:5010, 5000:5010]
print(sub_array)  # Saída: um array 10x10 com floats aleatórios

# Limpar e garantir que as alterações sejam escritas em disco
del large_array

15. Como lidar e manipular arrays com valores ausentes ou infinitos no NumPy?

Lidar com valores ausentes e infinitos é comum. Primeiro, use isnan() ou isinf() do NumPy para identificar esses valores.

Se houver um problema sistemático, vale revisar o pipeline; caso contrário, podemos imputar tais valores.

Embora possamos não usar o NumPy diretamente para preencher ausências, é comum combiná-lo com o fillna() do pandas. Por exemplo, usar mean() ou median() do NumPy para imputar rapidamente valores errôneos.

Perguntas de entrevista sobre NumPy para cientistas de dados

Até aqui, cobrimos perguntas gerais sobre NumPy. Embora elas se apliquem à ciência de dados, nesta seção reunimos perguntas específicas para cientistas de dados.

16. Existe uma forma rápida e fácil de aplicar funções a cada linha e coluna de um array 2D?

Às vezes, precisamos executar cálculos personalizados para obter informações por linha ou coluna. O método apply_along_axis() do NumPy permite aplicar uma função personalizada ao longo de um eixo específico do array.

import numpy as np

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

# Função para calcular o range (máx - mín) de um array 1D
def compute_range(arr):
    return np.max(arr) - np.min(arr)

# Aplicar a função a cada linha (axis=1)
ranges = np.apply_along_axis(compute_range, axis=1, arr=data)
print("Range of each row:", ranges)
# Saída:
# Range of each row: [  4  20 400]

17. Como aproveitar o NumPy para fazer feature scaling e normalização de dados para machine learning?

Normalizar os dados garante que estamos treinando corretamente nossos modelos. Sem normalização, a escala pode afetar os resultados, especialmente em modelos baseados em distância.

Podemos usar funções do NumPy para escalonar com facilidade. Veja um exemplo de min-max scaling por coluna. Certifique-se de escolher o eixo certo ao aplicar o scaling.

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)
# Saída:
# Scaled Data:
# [[0.   0.   0.  ]
#  [0.5  0.5  0.5 ]
#  [1.   1.   1.  ]]

18. Quais são algumas formas de ordenar e indexar arrays NumPy com facilidade?

Embora o DataFrame tenha sort_values(), em certos casos queremos encontrar a posição dos valores ordenados.

O argsort() do NumPy fornece as posições que ordenariam um array. É útil quando precisamos indexar outros conjuntos de dados para corresponder à nossa ordenação. Com as posições em mãos, usamos a saída do argsort() para manter a consistência entre os datasets.

19. Qual é um aspecto importante do gerador de números aleatórios do NumPy que pode torná-lo previsível e por quê?

Geradores de números "aleatórios" em computação não são verdadeiramente aleatórios: eles partem de uma semente inicial. Como queremos testar e comparar resultados com facilidade, precisamos minimizar a aleatoriedade no pipeline.

Ao usar random.seed() do NumPy, definimos a semente para todo o pipeline para obter resultados reproduzíveis. Assim, avaliamos melhorias com base nos ajustes do modelo, e não por acaso.

20. Descreva como você implementaria K-Means em NumPy.

Em entrevistas, podem pedir para implementar algum algoritmo. O foco é demonstrar entendimento dos fundamentos do modelo e do pacote.

Você não precisa decorar cada linha do código abaixo, mas deve destacar as etapas e métodos-chave. Leia sobre K-Means (e outros algoritmos básicos) e entenda como o algoritmo funciona.

import numpy as np

# Gerar um dataset de exemplo
np.random.seed(42)  # Reprodutibilidade
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):
    # Etapa 1: inicializar centróides aleatoriamente
    num_samples, num_features = X.shape
    centroids = X[np.random.choice(num_samples, k, replace=False)]
    
    for i in range(max_iters):
        # Etapa 2: atribuir clusters
        distances = np.linalg.norm(X[:, np.newaxis] - centroids, axis=2)
        cluster_assignments = np.argmin(distances, axis=1)
        
        # Etapa 3: atualizar centróides
        new_centroids = np.array([X[cluster_assignments == j].mean(axis=0) for j in range(k)])
        
        # Verificar convergência
        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)

Considerações finais

Aprimorar seus conhecimentos de entrevista com NumPy é um passo decisivo para ter sucesso em uma carreira em ciência de dados.

Comece praticando e entendendo os fundamentos e, depois, parta para implementações específicas. Quanto mais você usar o NumPy, melhor vai entender e internalizar suas funções. Experimente cursos e tutoriais na DataCamp, como:

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