Questions d'entretien pour Data Scientist Junior : Guide complet

# Liste - mutable
my_list = [1, 2, 3]
my_list[0] = 10  # Fonctionne
my_list.append(4)  # Fonctionne
print(my_list)  # [10, 2, 3, 4]

# Tuple - immuable
my_tuple = (1, 2, 3)
# my_tuple[0] = 10  # Erreur : les tuples sont immuables
# my_tuple.append(4)  # Erreur : pas de méthode append

# Déballage de tuple
x, y, z = (1, 2, 3)
print(x, y, z)  # 1 2 3

# Boucle traditionnelle
squares = []
for i in range(10):
    squares.append(i ** 2)

# Compréhension de liste
squares = [i ** 2 for i in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Avec condition
even_squares = [i ** 2 for i in range(10) if i % 2 == 0]
print(even_squares)  # [0, 4, 16, 36, 64]

# Compréhension imbriquée
matrix = [[i * j for j in range(3)] for i in range(3)]
print(matrix)  # [[0, 0, 0], [0, 1, 2], [0, 2, 4]]

# Compréhension de dictionnaire
squares_dict = {i: i ** 2 for i in range(5)}
print(squares_dict)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Fonction régulière
def square(x):
    return x ** 2

# Fonction Lambda
square_lambda = lambda x: x ** 2
print(square_lambda(5))  # 25

# Avec map
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)  # [1, 4, 9, 16, 25]

# Avec filter
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # [2, 4]

# Tri avec key
students = [('Alice', 85), ('Bob', 92), ('Charlie', 78)]
sorted_students = sorted(students, key=lambda x: x[1], reverse=True)
print(sorted_students)  # [('Bob', 92), ('Alice', 85), ('Charlie', 78)]

# append - ajoute un seul élément
list1 = [1, 2, 3]
list1.append(4)
print(list1)  # [1, 2, 3, 4]

list1.append([5, 6])
print(list1)  # [1, 2, 3, 4, [5, 6]] - liste comme un seul élément

# extend - ajoute plusieurs éléments
list2 = [1, 2, 3]
list2.extend([4, 5, 6])
print(list2)  # [1, 2, 3, 4, 5, 6]

# Alternative à extend
list3 = [1, 2, 3]
list3 += [4, 5, 6]
print(list3)  # [1, 2, 3, 4, 5, 6]

# *args - arguments positionnels
def sum_all(*args):
    return sum(args)

print(sum_all(1, 2, 3))  # 6
print(sum_all(1, 2, 3, 4, 5))  # 15

# **kwargs - arguments de mots-clés
def print_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="Alice", age=25, city="NYC")
# name: Alice
# age: 25
# city: NYC

# Combiné
def flexible_function(*args, **kwargs):
    print("Positional:", args)
    print("Keyword:", kwargs)

flexible_function(1, 2, 3, name="Alice", age=25)
# Positional: (1, 2, 3)
# Keyword: {'name': 'Alice', 'age': 25}

import numpy as np
from scipy import stats

data = [1, 2, 2, 3, 4, 5, 100]

# Moyenne - affectée par les valeurs aberrantes
mean = np.mean(data)
print(f"Mean: {mean}")  # 16.71

# Médiane - robuste aux valeurs aberrantes
median = np.median(data)
print(f"Median: {median}")  # 3

# Mode
mode = stats.mode(data, keepdims=True)
print(f"Mode: {mode.mode[0]}")  # 2

import numpy as np

data = [2, 4, 4, 4, 5, 5, 7, 9]

# Variance
variance = np.var(data, ddof=1)  # ddof=1 pour la variance de l'échantillon
print(f"Variance: {variance}")  # 4.57

# Écart type
std_dev = np.std(data, ddof=1)
print(f"Std Dev: {std_dev}")  # 2.14

# Calcul manuel
mean = np.mean(data)
variance_manual = sum((x - mean) ** 2 for x in data) / (len(data) - 1)
print(f"Manual Variance: {variance_manual}")

from scipy import stats

# Exemple : Tester si une pièce est équitable
# Hypothèse nulle : la pièce est équitable (p = 0,5)
# Nous avons obtenu 65 faces sur 100 lancers

observed_heads = 65
n_flips = 100
expected_proportion = 0.5

# Test binomial
p_value = stats.binom_test(observed_heads, n_flips, expected_proportion)
print(f"P-value: {p_value}")  # 0.0018

if p_value < 0.05:
    print("Reject null hypothesis - coin is likely biased")
else:
    print("Fail to reject null hypothesis - coin appears fair")

import numpy as np
import matplotlib.pyplot as plt

# Population avec distribution non normale (exponentielle)
population = np.random.exponential(scale=2, size=10000)

# Prendre de nombreux échantillons et calculer leurs moyennes
sample_means = []
for _ in range(1000):
    sample = np.random.choice(population, size=30)
    sample_means.append(np.mean(sample))

# Les moyennes d'échantillon sont normalement distribuées (TCL)
print(f"Population mean: {np.mean(population):.2f}")
print(f"Mean of sample means: {np.mean(sample_means):.2f}")
print(f"Std of sample means: {np.std(sample_means):.2f}")

import numpy as np
import pandas as pd

# Exemple : Les ventes de glaces et les décès par noyade sont corrélés
# Mais la glace ne cause pas la noyade (variable confusionnelle : température)

# Coefficient de corrélation
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 5, 4, 5])

correlation = np.corrcoef(x, y)[0, 1]
print(f"Correlation: {correlation:.2f}")  # 0.82

# Corrélation de Pearson
from scipy.stats import pearsonr
corr, p_value = pearsonr(x, y)
print(f"Pearson r: {corr:.2f}, p-value: {p_value:.3f}")

import pandas as pd

# Lire CSV
df = pd.read_csv('data.csv')

# Informations de base
print(df.head())  # 5 premières lignes
print(df.tail())  # 5 dernières lignes
print(df.shape)   # (lignes, colonnes)
print(df.info())  # Types de données et nombres non nuls
print(df.describe())  # Résumé statistique

# Noms et types de colonnes
print(df.columns)
print(df.dtypes)

# Vérifier les valeurs manquantes
print(df.isnull().sum())

# Colonnes spécifiques
print(df[['column1', 'column2']].head())

import pandas as pd
import numpy as np

df = pd.DataFrame({
    'A': [1, 2, np.nan, 4],
    'B': [5, np.nan, np.nan, 8],
    'C': [9, 10, 11, 12]
})

# Vérifier les valeurs manquantes
print(df.isnull().sum())

# Supprimer les lignes avec des valeurs manquantes
df_dropped = df.dropna()

# Supprimer les colonnes avec des valeurs manquantes
df_dropped_cols = df.dropna(axis=1)

# Remplir avec une valeur spécifique
df_filled = df.fillna(0)

# Remplir avec la moyenne
df['A'] = df['A'].fillna(df['A'].mean())

# Remplir avec la médiane
df['B'] = df['B'].fillna(df['B'].median())

# Remplissage avant (utiliser la valeur précédente)
df_ffill = df.fillna(method='ffill')

# Remplissage arrière (utiliser la valeur suivante)
df_bfill = df.fillna(method='bfill')

# Interpoler
df_interpolated = df.interpolate()

import pandas as pd

df = pd.DataFrame({
    'name': ['Alice', 'Bob', 'Charlie', 'David'],
    'age': [25, 30, 35, 28],
    'salary': [50000, 60000, 75000, 55000],
    'department': ['IT', 'HR', 'IT', 'Finance']
})

# Sélectionner les colonnes
print(df['name'])  # Colonne unique (Série)
print(df[['name', 'age']])  # Colonnes multiples (DataFrame)

# Filtrer les lignes
high_salary = df[df['salary'] > 55000]
print(high_salary)

# Conditions multiples
it_high_salary = df[(df['department'] == 'IT') & (df['salary'] > 50000)]
print(it_high_salary)

# Utilisation de .loc (basé sur l'étiquette)
print(df.loc[0:2, ['name', 'age']])

# Utilisation de .iloc (basé sur la position)
print(df.iloc[0:2, 0:2])

# Méthode de requête
result = df.query('age > 28 and salary > 55000')
print(result)

# Méthode isin
it_or_hr = df[df['department'].isin(['IT', 'HR'])]
print(it_or_hr)

import pandas as pd

df = pd.DataFrame({
    'department': ['IT', 'HR', 'IT', 'Finance', 'HR', 'IT'],
    'employee': ['Alice', 'Bob', 'Charlie', 'David', 'Eve', 'Frank'],
    'salary': [50000, 45000, 60000, 55000, 48000, 65000],
    'age': [25, 30, 35, 28, 32, 40]
})

# Grouper par une seule colonne
dept_avg_salary = df.groupby('department')['salary'].mean()
print(dept_avg_salary)

# Agrégrations multiples
dept_stats = df.groupby('department').agg({
    'salary': ['mean', 'min', 'max'],
    'age': 'mean'
})
print(dept_stats)

# Agrégation personnalisée
dept_custom = df.groupby('department').agg({
    'salary': lambda x: x.max() - x.min(),
    'employee': 'count'
})
print(dept_custom)

# Grouper par plusieurs colonnes
result = df.groupby(['department', 'age'])['salary'].sum()
print(result)

import pandas as pd

# DataFrames d'exemple
df1 = pd.DataFrame({
    'employee_id': [1, 2, 3, 4],
    'name': ['Alice', 'Bob', 'Charlie', 'David']
})

df2 = pd.DataFrame({
    'employee_id': [1, 2, 3, 5],
    'salary': [50000, 60000, 75000, 55000]
})

# Jointure interne (uniquement les lignes correspondantes)
inner = pd.merge(df1, df2, on='employee_id', how='inner')
print(inner)

# Jointure gauche (toutes les lignes de gauche)
left = pd.merge(df1, df2, on='employee_id', how='left')
print(left)

# Jointure droite (toutes les lignes de droite)
right = pd.merge(df1, df2, on='employee_id', how='right')
print(right)

# Jointure externe (toutes les lignes des deux)
outer = pd.merge(df1, df2, on='employee_id', how='outer')
print(outer)

# Concaténer verticalement
df3 = pd.concat([df1, df2], ignore_index=True)
print(df3)

# Concaténer horizontalement
df4 = pd.concat([df1, df2], axis=1)
print(df4)

from sklearn.linear_model import LinearRegression
from sklearn.cluster import KMeans
import numpy as np

# Apprentissage supervisé - Régression linéaire
X_train = np.array([[1], [2], [3], [4], [5]])
y_train = np.array([2, 4, 6, 8, 10])

model = LinearRegression()
model.fit(X_train, y_train)
prediction = model.predict([[6]])
print(f"Supervised prediction: {prediction[0]}")  # 12

# Apprentissage non supervisé - Clustering K-Means
X = np.array([[1, 2], [1.5, 1.8], [5, 8], [8, 8], [1, 0.6], [9, 11]])

kmeans = KMeans(n_clusters=2, random_state=42)
clusters = kmeans.fit_predict(X)
print(f"Cluster assignments: {clusters}")

from sklearn.model_selection import train_test_split
from sklearn.linear_model import Ridge, Lasso
from sklearn.preprocessing import PolynomialFeatures
import numpy as np

# Générer des données
X = np.random.rand(100, 1) * 10
y = 2 * X + 3 + np.random.randn(100, 1) * 2

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)

# Exemple de surapprentissage - polynôme de degré élevé
poly = PolynomialFeatures(degree=15)
X_poly = poly.fit_transform(X_train)

# Régularisation pour empêcher le surapprentissage
# Ridge (régularisation L2)
ridge = Ridge(alpha=1.0)
ridge.fit(X_poly, y_train)

# Lasso (régularisation L1)
lasso = Lasso(alpha=0.1)
lasso.fit(X_poly, y_train)

print(f"Ridge score: {ridge.score(X_poly, y_train)}")
print(f"Lasso score: {lasso.score(X_poly, y_train)}")

from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris

# Charger les données
iris = load_iris()
X, y = iris.data, iris.target

# Division train-test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

print(f"Training set size: {len(X_train)}")
print(f"Test set size: {len(X_test)}")

# Entraîner le modèle
model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)

# Évaluer
train_score = model.score(X_train, y_train)
test_score = model.score(X_test, y_test)

print(f"Training accuracy: {train_score:.2f}")
print(f"Test accuracy: {test_score:.2f}")

# Validation croisée (plus robuste)
cv_scores = cross_val_score(model, X, y, cv=5)
print(f"CV scores: {cv_scores}")
print(f"Mean CV score: {cv_scores.mean():.2f}")

from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
from sklearn.metrics import confusion_matrix, classification_report
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer

# Charger les données
data = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.3, random_state=42
)

# Entraîner le modèle
model = LogisticRegression(max_iter=10000)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# Mesures
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred)
recall = recall_score(y_test, y_pred)
f1 = f1_score(y_test, y_pred)

print(f"Accuracy: {accuracy:.2f}")
print(f"Precision: {precision:.2f}")
print(f"Recall: {recall:.2f}")
print(f"F1-Score: {f1:.2f}")

# Matrice de confusion
cm = confusion_matrix(y_test, y_pred)
print(f"\nConfusion Matrix:\n{cm}")

# Rapport de classification
print(f"\n{classification_report(y_test, y_pred)}")

from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn.metrics import mean_squared_error, r2_score
import numpy as np

# Exemple de régression
X_reg = np.array([[1], [2], [3], [4], [5]])
y_reg = np.array([2.1, 3.9, 6.2, 7.8, 10.1])

reg_model = LinearRegression()
reg_model.fit(X_reg, y_reg)
y_pred_reg = reg_model.predict([[6]])
print(f"Regression prediction: {y_pred_reg[0]:.2f}")  # Valeur continue

# Exemple de classification
X_clf = np.array([[1], [2], [3], [4], [5]])
y_clf = np.array([0, 0, 1, 1, 1])  # Classes binaires

clf_model = LogisticRegression()
clf_model.fit(X_clf, y_clf)
y_pred_clf = clf_model.predict([[3.5]])
print(f"Classification prediction: {y_pred_clf[0]}")  # Étiquette de classe (0 ou 1)