Questions Entretien Data Analyst 2026 : Guide Complet SQL, Python et Analytics

Les entretiens pour les postes de data analyst en 2026 évaluent trois compétences fondamentales : la maîtrise de SQL, la manipulation de données avec Python et la résolution de problèmes métier. Les grandes entreprises technologiques comme Google, Meta et Amazon ont standardisé leurs évaluations techniques autour de ces axes, avec les fonctions window SQL et les opérations pandas présentes dans plus de 80% des entretiens.

Fonctions Window SQL : Le Sujet d'Entretien le Plus Courant

Les fonctions window apparaissent dans pratiquement tous les entretiens techniques pour data analysts. Contrairement aux fonctions d'agrégation qui réduisent les lignes, les fonctions window effectuent des calculs sur un ensemble de lignes liées à la ligne courante tout en préservant les données individuelles.

Question : Calculer le salaire de chaque employé en pourcentage du salaire total de son département.

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

La clause PARTITION BY crée des fenêtres séparées pour chaque département. Le salaire de chaque employé est divisé par le total de son département, pas par le total de l'entreprise. Cette distinction piège de nombreux candidats qui utilisent une sous-requête ou une jointure à la place.

Question : Calculer le cumul des ventes par date, avec remise à zéro chaque mois.

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

Les recruteurs attendent des candidats qu'ils connaissent le comportement par défaut du cadre de fenêtre. Sans clause ROWS ou RANGE explicite, le cadre s'étend du début de la partition jusqu'à la ligne courante, produisant ainsi un cumul. Ces patterns se pratiquent avec le module fonctions window SQL.

CTEs et Sous-requêtes : Organiser les Requêtes Complexes

Les Common Table Expressions rendent les requêtes lisibles et maintenables. Les recruteurs évaluent si les candidats structurent leurs requêtes de manière logique plutôt que d'écrire des instructions monolithiques.

Question : Trouver les clients ayant effectué des achats pendant des mois consécutifs.

-- 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';

Ce pattern combine les CTEs avec la fonction window LAG. Décomposer la requête en étapes nommées démontre le processus de réflexion, ce que les recruteurs valorisent autant que la réponse correcte.

Python Pandas : Les Fondamentaux de la Manipulation de Données

Les questions pandas testent les compétences en nettoyage, agrégation et transformation de données. Les recruteurs présentent des jeux de données désordonnés et demandent aux candidats d'en extraire des insights.

Question : À partir d'un DataFrame de sessions utilisateur, calculer la durée moyenne de session par segment utilisateur, en excluant les sessions de moins de 10 secondes.

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

La réponse démontre le chaînage de méthodes, la gestion des dates et la fonction agg avec des sorties nommées. Les recruteurs vérifient que les candidats filtrent avant d'agréger plutôt qu'après, ce qui fausserait les moyennes.

Question : Fusionner deux DataFrames et gérer correctement les valeurs manquantes.

# 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

Le paramètre how='left' et la gestion explicite avec fillna montrent l'attention portée aux cas limites. Les candidats utilisant how='inner' perdent les utilisateurs sans transactions, ce qui modifie la population d'analyse.

Concepts Statistiques : Ce que les Analystes Doivent Expliquer Clairement

Les questions statistiques évaluent si les candidats peuvent appliquer les concepts à de vrais problèmes métier et communiquer leurs conclusions aux parties prenantes.

Question : Un product manager affirme que le nouveau flux de paiement a augmenté la conversion de 5%. Le test a duré une semaine avec 10 000 utilisateurs par variante. Ce résultat est-il statistiquement significatif ?

Une réponse complète aborde la taille d'échantillon, la puissance statistique et la significativité pratique :

1. Calculer l'erreur standard : Pour les taux de conversion, SE = sqrt(p(1-p)/n). Avec un taux de conversion de base de 10% et n=10 000, SE équivaut approximativement à 0,003.

2. Calculer le z-score : Une augmentation relative de 5% signifie que la nouvelle conversion est de 10,5%. La différence de 0,5 point de pourcentage divisée par l'erreur standard combinée détermine la significativité.

3. Considérer la significativité pratique : Même si p < 0,05, une augmentation de 0,5 point de pourcentage peut ne pas justifier le coût d'ingénierie du nouveau flux.

4. Vérifier les facteurs de confusion : Une semaine capture les variations semaine/week-end mais peut manquer les cycles mensuels ou les effets saisonniers.

Les recruteurs valorisent les candidats qui questionnent les hypothèses plutôt que de calculer mécaniquement les p-values. Le module principes de visualisation des données couvre la présentation de ces résultats.

Question : Expliquer la différence entre corrélation et causalité avec un exemple métier.

Les ventes de glaces et les noyades sont positivement corrélées. Les deux augmentent en été en raison de la variable confondante qu'est la température. Recommander de réduire la production de glaces pour prévenir les noyades confond corrélation et causalité.

En analytics métier : les dépenses publicitaires et le chiffre d'affaires sont souvent corrélés, mais cette relation peut refléter le fait que les entreprises augmentent leurs dépenses publicitaires lorsque les prévisions de revenus sont déjà bonnes, et non que les publicités génèrent du revenu. Établir la causalité nécessite des expériences contrôlées ou des techniques d'inférence causale comme la différence-en-différences.

Questions Études de Cas : Traduire les Problèmes en Requêtes

Les questions de cas testent la capacité à décomposer des problèmes métier ambigus en étapes analytiques concrètes.

Question : La rétention utilisateur a chuté de 15% le mois dernier. Comment investiguer ?

Une approche structurée :

1. Valider la métrique : Confirmer que la définition de la rétention correspond aux calculs historiques. Vérifier les problèmes de pipeline de données ou les changements de tracking.

2. Segmenter la baisse : Décomposer la rétention par cohorte utilisateur, canal d'acquisition, type d'appareil et géographie. Une baisse globale de 15% pourrait être une chute de 50% dans un segment masquant la stabilité ailleurs.

3. Identifier le timing : La rétention a-t-elle baissé progressivement ou soudainement ? Une baisse soudaine suggère un changement produit ou un bug. Un déclin progressif pointe vers des facteurs de marché ou concurrentiels.

4. Corréler avec les événements : Aligner la chronologie avec les releases produit, les campagnes marketing, les lancements concurrents et les événements externes.

5. Former des hypothèses : Sur la base des patterns de segmentation, proposer des explications testables et les données nécessaires pour confirmer ou rejeter chacune.

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

Cette requête d'analyse de cohorte produit les données nécessaires pour l'étape 2. Le module rétention de cohorte couvre les variations de ce pattern.

Exercices à Domicile : Ce que les Évaluateurs Examinent

De nombreuses entreprises incluent des exercices à domicile de 2 à 4 heures. Les évaluateurs notent les soumissions sur la qualité du code, la rigueur analytique et la communication.

Exercice courant : À partir d'un jeu de données de transactions e-commerce, identifier les facteurs qui prédisent le churn client.

Les soumissions solides partagent ces caractéristiques :

• Analyse exploratoire d'abord : Statistiques descriptives, graphiques de distribution et évaluation des valeurs manquantes avant la modélisation
• Feature engineering : Création de variables pertinentes comme récence, fréquence, valeur monétaire (RFM) et indicateurs de tendance
• Justification du choix de modèle : Expliquer pourquoi la régression logistique ou le random forest convient au problème, pas seulement exécuter les paramètres par défaut
• Approche de validation : Utiliser des splits temporels plutôt que des splits aléatoires pour éviter les fuites de données
• Communication claire : Résumé exécutif en haut, détails techniques en annexe, visualisations qui soutiennent les conclusions

# 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

Le code démontre un feature engineering pertinent au domaine et une méthodologie de validation appropriée pour les données temporelles.

Points Clés pour les Entretiens Data Analyst en 2026

• Les fonctions window SQL avec PARTITION BY et ORDER BY apparaissent dans la plupart des entretiens techniques. Pratiquer le calcul des cumuls, pourcentages et classements.

• Les questions Python pandas mettent l'accent sur le chaînage de méthodes, les agrégations groupby et les opérations de fusion avec une gestion appropriée des valeurs manquantes.

• Les questions statistiques nécessitent d'expliquer les concepts en termes métier. Les recruteurs évaluent la capacité de communication, pas seulement les connaissances techniques.

• Les questions études de cas testent la décomposition structurée des problèmes. Commencer par valider la métrique, puis segmenter pour isoler le problème.

• Les exercices à domicile sont notés sur la qualité du code et la communication autant que sur la précision analytique. Inclure un résumé exécutif et expliquer ses choix.

• Le module BigQuery avancé et le module bases Python pandas fournissent des questions de pratique supplémentaires alignées sur les patterns d'entretien actuels.