Perguntas de Entrevista para Data Analyst 2026: Guia Completo de SQL, Python e Analytics

As entrevistas para cargos de data analyst em 2026 avaliam três competências fundamentais: domínio de SQL, manipulação de dados com Python e resolução de problemas de negócio. Empresas como Google, Meta e Amazon padronizaram suas avaliações técnicas em torno dessas habilidades, com as funções window de SQL e operações pandas presentes em mais de 80% das entrevistas.

Funções Window SQL: O Tema de Entrevista Mais Comum

As funções window aparecem em praticamente todas as entrevistas técnicas para data analysts. Diferentemente das funções de agregação que colapsam linhas, as funções window realizam cálculos sobre um conjunto de linhas relacionadas à linha atual, preservando os dados individuais.

Pergunta: Calcular o salário de cada funcionário como porcentagem do salário total do seu departamento.

-- employee_salary_percentage.sql
SELECT 
    employee_id,
    department,
    salary,
    -- SUM as window function preserves each row
    ROUND(
        salary * 100.0 / SUM(salary) OVER (PARTITION BY department),
        2
    ) AS pct_of_dept_salary
FROM employees
ORDER BY department, pct_of_dept_salary DESC;

A cláusula PARTITION BY cria janelas separadas para cada departamento. O salário de cada funcionário é dividido pelo total do seu departamento, não pelo total da empresa. Essa distinção pega muitos candidatos que utilizam uma subconsulta ou join no lugar.

Pergunta: Calcular o acumulado de vendas por data, reiniciando a cada mês.

-- monthly_running_total.sql
SELECT
    sale_date,
    amount,
    SUM(amount) OVER (
        PARTITION BY DATE_TRUNC('month', sale_date)
        ORDER BY sale_date
        -- Default frame: RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
    ) AS monthly_running_total
FROM sales
ORDER BY sale_date;

Os recrutadores esperam que os candidatos conheçam o comportamento padrão do frame de janela. Sem uma cláusula ROWS ou RANGE explícita, o frame se estende do início da partição até a linha atual, produzindo um acumulado. Esses padrões podem ser praticados com o módulo de funções window SQL.

CTEs e Subconsultas: Organizando Consultas Complexas

As Common Table Expressions tornam as consultas legíveis e manuteníveis. Os recrutadores avaliam se os candidatos estruturam suas consultas de forma lógica em vez de escrever declarações monolíticas.

Pergunta: Encontrar clientes que realizaram compras em meses consecutivos.

-- consecutive_month_purchasers.sql
WITH monthly_purchases AS (
    -- Step 1: Get distinct customer-month combinations
    SELECT DISTINCT
        customer_id,
        DATE_TRUNC('month', purchase_date) AS purchase_month
    FROM orders
),
with_prev_month AS (
    -- Step 2: Add previous purchase month for each customer
    SELECT
        customer_id,
        purchase_month,
        LAG(purchase_month) OVER (
            PARTITION BY customer_id 
            ORDER BY purchase_month
        ) AS prev_purchase_month
    FROM monthly_purchases
)
-- Step 3: Filter to consecutive months only
SELECT DISTINCT customer_id
FROM with_prev_month
WHERE purchase_month = prev_purchase_month + INTERVAL '1 month';

Esse padrão combina CTEs com a função window LAG. Decompor a consulta em etapas nomeadas demonstra o processo de raciocínio, algo que os recrutadores valorizam tanto quanto a resposta correta.

Python Pandas: Fundamentos da Manipulação de Dados

As perguntas de pandas testam habilidades de limpeza, agregação e transformação de dados. Os recrutadores apresentam conjuntos de dados desordenados e pedem aos candidatos que extraiam insights.

Pergunta: Dado um DataFrame de sessões de usuário, calcular a duração média de sessão por segmento de usuário, excluindo sessões com menos de 10 segundos.

# session_analysis.py
import pandas as pd

def analyze_sessions(df: pd.DataFrame) -> pd.DataFrame:
    """Calculate average session duration by user segment.
    
    Args:
        df: DataFrame with columns [user_id, segment, session_start, session_end]
    
    Returns:
        DataFrame with average duration per segment
    """
    # Calculate duration in seconds
    df['duration_seconds'] = (
        df['session_end'] - df['session_start']
    ).dt.total_seconds()
    
    # Filter short sessions and aggregate
    return (
        df[df['duration_seconds'] >= 10]
        .groupby('segment')
        .agg(
            avg_duration=('duration_seconds', 'mean'),
            session_count=('user_id', 'count')
        )
        .round(2)
        .reset_index()
    )

A resposta demonstra encadeamento de métodos, manipulação de datas e a função agg com saídas nomeadas. Os recrutadores verificam se os candidatos filtram antes de agregar, e não depois, o que distorceria as médias.

Pergunta: Mesclar dois DataFrames e tratar valores ausentes adequadamente.

# merge_and_clean.py
import pandas as pd
import numpy as np

def merge_user_data(
    users: pd.DataFrame,
    transactions: pd.DataFrame
) -> pd.DataFrame:
    """Merge user demographics with transaction history.
    
    Users without transactions get total_spent = 0.
    Transactions without user data are excluded.
    """
    merged = pd.merge(
        users,
        transactions.groupby('user_id')['amount'].sum().reset_index(),
        on='user_id',
        how='left'  # Keep all users, even without transactions
    )
    
    # Fill NaN for users with no transactions
    merged['amount'] = merged['amount'].fillna(0)
    merged.rename(columns={'amount': 'total_spent'}, inplace=True)
    
    return merged

O parâmetro how='left' e o tratamento explícito com fillna demonstram atenção aos casos limite. Candidatos que usam how='inner' perdem usuários sem transações, o que altera a população de análise.

Conceitos Estatísticos: O que os Analistas Devem Explicar com Clareza

As perguntas estatísticas avaliam se os candidatos conseguem aplicar conceitos a problemas reais de negócio e comunicar descobertas aos stakeholders.

Pergunta: Um product manager afirma que o novo fluxo de checkout aumentou a conversão em 5%. O teste durou uma semana com 10.000 usuários por variante. Esse resultado é estatisticamente significativo?

Uma resposta completa aborda o tamanho da amostra, o poder estatístico e a significância prática:

1. Calcular o erro padrão: Para taxas de conversão, SE = sqrt(p(1-p)/n). Com uma conversão base de 10% e n=10.000, SE equivale aproximadamente a 0,003.

2. Calcular o z-score: Um aumento relativo de 5% significa que a nova conversão é 10,5%. A diferença de 0,5 ponto percentual dividida pelo erro padrão combinado determina a significância.

3. Considerar a significância prática: Mesmo se p < 0,05, um aumento de 0,5 ponto percentual pode não justificar o custo de engenharia do novo fluxo.

4. Verificar fatores de confusão: Uma semana captura padrões de dia de semana versus fim de semana, mas pode não captar ciclos mensais ou efeitos sazonais.

Os recrutadores valorizam candidatos que questionam pressupostos em vez de calcular mecanicamente p-values. O módulo de princípios de visualização de dados cobre como apresentar essas descobertas.

Pergunta: Explicar a diferença entre correlação e causalidade com um exemplo de negócio.

Vendas de sorvete e mortes por afogamento estão positivamente correlacionadas. Ambas aumentam no verão devido à variável confundidora da temperatura. Recomendar redução na produção de sorvetes para prevenir afogamentos confunde correlação com causalidade.

Em analytics de negócio: gastos com publicidade e receita frequentemente estão correlacionados, mas essa relação pode refletir que as empresas aumentam gastos com publicidade quando as projeções de receita já são favoráveis, não que os anúncios gerem receita. Estabelecer causalidade requer experimentos controlados ou técnicas de inferência causal como diferença em diferenças.

Perguntas de Casos de Negócio: Traduzindo Problemas em Consultas

As perguntas de caso testam a capacidade de decompor problemas de negócio ambíguos em etapas analíticas concretas.

Pergunta: A retenção de usuários caiu 15% no mês passado. Como investigar?

Uma abordagem estruturada:

1. Validar a métrica: Confirmar que a definição de retenção corresponde aos cálculos históricos. Verificar problemas no pipeline de dados ou mudanças no tracking.

2. Segmentar a queda: Decompor a retenção por coorte de usuário, canal de aquisição, tipo de dispositivo e geografia. Uma queda global de 15% pode ser uma queda de 50% em um segmento mascarando estabilidade em outros.

3. Identificar o timing: A retenção caiu gradualmente ou de repente? Uma queda súbita sugere uma mudança de produto ou bug. Um declínio gradual aponta para fatores de mercado ou competitivos.

4. Correlacionar com eventos: Alinhar a linha do tempo com lançamentos de produto, campanhas de marketing, lançamentos de concorrentes e eventos externos.

5. Formar hipóteses: Com base nos padrões de segmentação, propor explicações testáveis e os dados necessários para confirmar ou rejeitar cada uma.

-- retention_by_cohort.sql
WITH user_cohorts AS (
    SELECT
        user_id,
        DATE_TRUNC('week', created_at) AS cohort_week
    FROM users
),
weekly_activity AS (
    SELECT
        user_id,
        DATE_TRUNC('week', activity_date) AS activity_week
    FROM user_events
)
SELECT
    c.cohort_week,
    a.activity_week,
    COUNT(DISTINCT a.user_id) AS active_users,
    COUNT(DISTINCT c.user_id) AS cohort_size,
    ROUND(
        COUNT(DISTINCT a.user_id) * 100.0 / COUNT(DISTINCT c.user_id),
        1
    ) AS retention_pct
FROM user_cohorts c
LEFT JOIN weekly_activity a 
    ON c.user_id = a.user_id 
    AND a.activity_week >= c.cohort_week
GROUP BY c.cohort_week, a.activity_week
ORDER BY c.cohort_week, a.activity_week;

Essa consulta de análise de coorte produz os dados necessários para a etapa 2. O módulo de retenção de coorte cobre variações desse padrão.

Exercícios para Casa: O que os Avaliadores Analisam

Muitas empresas incluem exercícios para casa de 2 a 4 horas. Os avaliadores pontuam as entregas pela qualidade do código, rigor analítico e comunicação.

Exercício comum: Dado um conjunto de dados de transações de e-commerce, identificar fatores que preveem o churn de clientes.

As entregas sólidas compartilham estas características:

• Análise exploratória primeiro: Estatísticas descritivas, gráficos de distribuição e avaliação de valores ausentes antes da modelagem
• Feature engineering: Criar variáveis relevantes como recência, frequência, valor monetário (RFM) e indicadores de tendência
• Justificativa da seleção do modelo: Explicar por que a regressão logística ou random forest se adequa ao problema, não apenas executar valores padrão
• Abordagem de validação: Usar splits baseados em tempo em vez de splits aleatórios para evitar vazamento de dados
• Comunicação clara: Resumo executivo no início, detalhes técnicos em apêndice, visualizações que apoiem as conclusões

# churn_analysis_structure.py
import pandas as pd
from sklearn.model_selection import TimeSeriesSplit
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import precision_recall_curve, auc

def create_rfm_features(df: pd.DataFrame, analysis_date: str) -> pd.DataFrame:
    """Create Recency, Frequency, Monetary features per customer."""
    analysis_dt = pd.to_datetime(analysis_date)
    
    rfm = df.groupby('customer_id').agg(
        recency=('order_date', lambda x: (analysis_dt - x.max()).days),
        frequency=('order_id', 'nunique'),
        monetary=('order_total', 'sum')
    ).reset_index()
    
    return rfm

def evaluate_with_time_split(
    X: pd.DataFrame, 
    y: pd.Series,
    n_splits: int = 5
) -> list:
    """Evaluate model using time-based cross-validation."""
    tscv = TimeSeriesSplit(n_splits=n_splits)
    scores = []
    
    for train_idx, val_idx in tscv.split(X):
        model = RandomForestClassifier(n_estimators=100, random_state=42)
        model.fit(X.iloc[train_idx], y.iloc[train_idx])
        
        y_pred_proba = model.predict_proba(X.iloc[val_idx])[:, 1]
        precision, recall, _ = precision_recall_curve(y.iloc[val_idx], y_pred_proba)
        scores.append(auc(recall, precision))
    
    return scores

O código demonstra feature engineering relevante ao domínio e metodologia de validação apropriada para dados temporais.

Pontos-Chave para Entrevistas de Data Analyst em 2026

• Funções window SQL com PARTITION BY e ORDER BY aparecem na maioria das entrevistas técnicas. Praticar o cálculo de acumulados, porcentagens e rankings.

• Perguntas de Python pandas enfatizam encadeamento de métodos, agregações groupby e operações de merge com tratamento adequado de valores ausentes.

• Perguntas estatísticas exigem explicar conceitos em termos de negócio. Os recrutadores avaliam a capacidade de comunicação, não apenas o conhecimento técnico.

• Perguntas de casos de negócio testam a decomposição estruturada de problemas. Começar validando a métrica, depois segmentar para isolar o problema.

• Exercícios para casa são pontuados pela qualidade do código e comunicação tanto quanto pela precisão analítica. Incluir um resumo executivo e explicar as escolhas feitas.

• O módulo avançado de BigQuery e o módulo básico de Python pandas fornecem perguntas de prática adicionais alinhadas com os padrões de entrevista atuais.