Domande per il Colloquio di Junior Data Scientist: Guida Completa

Introduzione

La scienza dei dati combina statistica, programmazione e conoscenza del settore per estrarre informazioni dai dati. Ci si aspetta che i data scientist junior abbiano una solida base in Python, statistica, basi del machine learning e strumenti di manipolazione dei dati.

Questa guida copre le domande essenziali per i colloqui per Data Scientist Junior. Esploreremo la programmazione Python, i fondamenti di statistica, la manipolazione dei dati con pandas, i concetti di machine learning, la visualizzazione dei dati e SQL per aiutarti a prepararti per il tuo primo ruolo nella scienza dei dati.

Fondamenti di Python (5 Domande)

1. Qual è la differenza tra una lista e una tupla in Python?

Risposta:

Lista: Mutabile (può essere modificata), definita con parentesi quadre []
Tupla: Immutabile (non può essere modificata), definita con parentesi tonde ()
Performance: Le tuple sono leggermente più veloci e usano meno memoria
Casi d'uso:
- Liste: Quando è necessario modificare i dati
- Tuple: Per raccolte fisse, chiavi di dizionario, ritorni di funzioni

# Lista - mutabile
my_list = [1, 2, 3]
my_list[0] = 10  # Funziona
my_list.append(4)  # Funziona
print(my_list)  # [10, 2, 3, 4]

# Tupla - immutabile
my_tuple = (1, 2, 3)
# my_tuple[0] = 10  # Errore: le tuple sono immutabili
# my_tuple.append(4)  # Errore: nessun metodo append

# Scomposizione di una tupla
x, y, z = (1, 2, 3)
print(x, y, z)  # 1 2 3

Rarità: Molto Comune Difficoltà: Facile

2. Spiega la list comprehension e fornisci un esempio.

Risposta: La list comprehension fornisce un modo conciso per creare liste basate su iterabili esistenti.

Sintassi: [espressione for item in iterable if condizione]
Vantaggi: Più leggibile, spesso più veloce dei cicli

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

# List comprehension
squares = [i ** 2 for i in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

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

# Nested comprehension
matrix = [[i * j for j in range(3)] for i in range(3)]
print(matrix)  # [[0, 0, 0], [0, 1, 2], [0, 2, 4]]

# Dictionary comprehension
squares_dict = {i: i ** 2 for i in range(5)}
print(squares_dict)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Rarità: Molto Comune Difficoltà: Facile

3. Cosa sono le funzioni lambda e quando le useresti?

Risposta: Le funzioni lambda sono funzioni anonime a espressione singola.

Sintassi: lambda argomenti: espressione
Casi d'uso: Funzioni brevi, callback, ordinamento, filtraggio

# Funzione regolare
def square(x):
    return x ** 2

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

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

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

# Ordinamento con 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)]

Rarità: Molto Comune Difficoltà: Facile

4. Spiega la differenza tra `append()` e `extend()` per le liste.

Risposta:

append(): Aggiunge un singolo elemento alla fine della lista
extend(): Aggiunge più elementi da un iterabile alla fine

# append - aggiunge un singolo elemento
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]] - lista come singolo elemento

# extend - aggiunge più elementi
list2 = [1, 2, 3]
list2.extend([4, 5, 6])
print(list2)  # [1, 2, 3, 4, 5, 6]

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

Rarità: Comune Difficoltà: Facile

5. Cosa sono `*args` e `**kwargs`?

Risposta: Permettono alle funzioni di accettare un numero variabile di argomenti.

*args: Numero variabile di argomenti posizionali (tupla)
**kwargs: Numero variabile di argomenti a parola chiave (dizionario)

# *args - argomenti posizionali
def sum_all(*args):
    return sum(args)

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

# **kwargs - argomenti a parola chiave
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

# Combinato
def flexible_function(*args, **kwargs):
    print("Posizionali:", args)
    print("Keyword:", kwargs)

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

Rarità: Comune Difficoltà: Media

Statistica e Probabilità (5 Domande)

6. Qual è la differenza tra media, mediana e moda?

Risposta:

Media: Media di tutti i valori (somma / conteggio)
Mediana: Valore centrale quando ordinato
Moda: Valore che si verifica più frequentemente
Quando usare:
- Media: Dati distribuiti normalmente
- Mediana: Dati asimmetrici o presenza di outlier
- Moda: Dati categorici

import numpy as np
from scipy import stats

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

# Media - influenzata dagli outlier
mean = np.mean(data)
print(f"Media: {mean}")  # 16.71

# Mediana - robusta agli outlier
median = np.median(data)
print(f"Mediana: {median}")  # 3

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

Rarità: Molto Comune Difficoltà: Facile

7. Spiega varianza e deviazione standard.

Risposta:

Varianza: Deviazione quadratica media dalla media
Deviazione Standard: Radice quadrata della varianza (stesse unità dei dati)
Scopo: Misura la dispersione dei dati

import numpy as np

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

# Varianza
variance = np.var(data, ddof=1)  # ddof=1 per la varianza campionaria
print(f"Varianza: {variance}")  # 4.57

# Deviazione standard
std_dev = np.std(data, ddof=1)
print(f"Dev. Standard: {std_dev}")  # 2.14

# Calcolo manuale
mean = np.mean(data)
variance_manual = sum((x - mean) ** 2 for x in data) / (len(data) - 1)
print(f"Varianza Manuale: {variance_manual}")

Rarità: Molto Comune Difficoltà: Facile

8. Cos'è un p-value e come lo interpreti?

Risposta: Il p-value è la probabilità di ottenere risultati almeno altrettanto estremi di quelli osservati, assumendo che l'ipotesi nulla sia vera.

Interpretazione:
- p < 0.05: Rifiuta l'ipotesi nulla (statisticamente significativo)
- p ≥ 0.05: Non rifiuta l'ipotesi nulla
Nota: il p-value non misura la dimensione dell'effetto o l'importanza

from scipy import stats

# Esempio: Testare se una moneta è equa
# Ipotesi nulla: la moneta è equa (p = 0.5)
# Abbiamo ottenuto 65 teste su 100 lanci

observed_heads = 65
n_flips = 100
expected_proportion = 0.5

# Test binomiale
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("Rifiuta l'ipotesi nulla - la moneta è probabilmente truccata")
else:
    print("Non rifiuta l'ipotesi nulla - la moneta sembra equa")

Rarità: Molto Comune Difficoltà: Media

9. Cos'è il Teorema del Limite Centrale?

Risposta: Il Teorema del Limite Centrale afferma che la distribuzione campionaria della media campionaria si avvicina a una distribuzione normale all'aumentare della dimensione del campione, indipendentemente dalla distribuzione della popolazione.

Punti chiave:
- Funziona per qualsiasi distribuzione (se la dimensione del campione è abbastanza grande)
- Tipicamente n ≥ 30 è considerato sufficiente
- Permette test di ipotesi e intervalli di confidenza

import numpy as np
import matplotlib.pyplot as plt

# Popolazione con distribuzione non normale (esponenziale)
population = np.random.exponential(scale=2, size=10000)

# Prendi molti campioni e calcola le loro medie
sample_means = []
for _ in range(1000):
    sample = np.random.choice(population, size=30)
    sample_means.append(np.mean(sample))

# Le medie campionarie sono distribuite normalmente (CLT)
print(f"Media della popolazione: {np.mean(population):.2f}")
print(f"Media delle medie campionarie: {np.mean(sample_means):.2f}")
print(f"Dev. Standard delle medie campionarie: {np.std(sample_means):.2f}")

Rarità: Comune Difficoltà: Media

10. Cosa sono correlazione e causalità?

Risposta:

Correlazione: Relazione statistica tra due variabili
Causalità: Una variabile causa direttamente cambiamenti in un'altra
Punto chiave: La correlazione NON implica causalità
Ragioni:
- Variabili confondenti
- Causalità inversa
- Coincidenza

import numpy as np
import pandas as pd

# Esempio: Le vendite di gelato e le morti per annegamento sono correlate
# Ma il gelato non causa l'annegamento (variabile confondente: temperatura)

# Coefficiente di correlazione
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"Correlazione: {correlation:.2f}")  # 0.82

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

Rarità: Molto Comune Difficoltà: Facile

Manipolazione dei Dati con Pandas (5 Domande)

11. Come si legge un file CSV e si visualizzano le informazioni di base?

Risposta: Usa pandas per leggere ed esplorare i dati.

import pandas as pd

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

# Informazioni di base
print(df.head())  # Prime 5 righe
print(df.tail())  # Ultime 5 righe
print(df.shape)   # (righe, colonne)
print(df.info())  # Tipi di dati e conteggi non nulli
print(df.describe())  # Riepilogo statistico

# Nomi delle colonne e tipi
print(df.columns)
print(df.dtypes)

# Controlla i valori mancanti
print(df.isnull().sum())

# Colonne specifiche
print(df[['column1', 'column2']].head())

Rarità: Molto Comune Difficoltà: Facile

12. Come gestisci i valori mancanti in un DataFrame?

Risposta: Molteplici strategie per la gestione dei dati mancanti:

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

# Controlla i valori mancanti
print(df.isnull().sum())

# Elimina le righe con qualsiasi valore mancante
df_dropped = df.dropna()

# Elimina le colonne con qualsiasi valore mancante
df_dropped_cols = df.dropna(axis=1)

# Riempi con un valore specifico
df_filled = df.fillna(0)

# Riempi con la media
df['A'] = df['A'].fillna(df['A'].mean())

# Riempi con la mediana
df['B'] = df['B'].fillna(df['B'].median())

# Forward fill (usa il valore precedente)
df_ffill = df.fillna(method='ffill')

# Backward fill (usa il valore successivo)
df_bfill = df.fillna(method='bfill')

# Interpolazione
df_interpolated = df.interpolate()

Rarità: Molto Comune Difficoltà: Facile

13. Come filtri e selezioni i dati in pandas?

Risposta: Molti modi per filtrare e selezionare i dati:

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']
})

# Seleziona le colonne
print(df['name'])  # Singola colonna (Series)
print(df[['name', 'age']])  # Colonne multiple (DataFrame)

# Filtra le righe
high_salary = df[df['salary'] > 55000]
print(high_salary)

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

# Usando .loc (basato sull'etichetta)
print(df.loc[0:2, ['name', 'age']])

# Usando .iloc (basato sulla posizione)
print(df.iloc[0:2, 0:2])

# Metodo query
result = df.query('age > 28 and salary > 55000')
print(result)

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

Rarità: Molto Comune Difficoltà: Facile

14. Come si raggruppano e si aggregano i dati?

Risposta: Usa groupby() per le operazioni di aggregazione:

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

# Raggruppa per singola colonna
dept_avg_salary = df.groupby('department')['salary'].mean()
print(dept_avg_salary)

# Aggregazioni multiple
dept_stats = df.groupby('department').agg({
    'salary': ['mean', 'min', 'max'],
    'age': 'mean'
})
print(dept_stats)

# Aggregazione personalizzata
dept_custom = df.groupby('department').agg({
    'salary': lambda x: x.max() - x.min(),
    'employee': 'count'
})
print(dept_custom)

# Raggruppa per colonne multiple
result = df.groupby(['department', 'age'])['salary'].sum()
print(result)

Rarità: Molto Comune Difficoltà: Media

15. Come si uniscono o si collegano i DataFrame?

Risposta: Usa merge(), join() o concat():

import pandas as pd

# DataFrame di esempio
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]
})

# Inner join (solo righe corrispondenti)
inner = pd.merge(df1, df2, on='employee_id', how='inner')
print(inner)

# Left join (tutte le righe da sinistra)
left = pd.merge(df1, df2, on='employee_id', how='left')
print(left)

# Right join (tutte le righe da destra)
right = pd.merge(df1, df2, on='employee_id', how='right')
print(right)

# Outer join (tutte le righe da entrambi)
outer = pd.merge(df1, df2, on='employee_id', how='outer')
print(outer)

# Concatenazione verticale
df3 = pd.concat([df1, df2], ignore_index=True)
print(df3)

# Concatenazione orizzontale
df4 = pd.concat([df1, df2], axis=1)
print(df4)

Rarità: Molto Comune Difficoltà: Media

Basi del Machine Learning (5 Domande)

16. Qual è la differenza tra apprendimento supervisionato e non supervisionato?

Risposta:

Apprendimento Supervisionato:
- Ha dati di addestramento etichettati (coppie input-output)
- Obiettivo: Apprendere la mappatura dagli input agli output
- Esempi: Classificazione, Regressione
- Algoritmi: Regressione Lineare, Alberi Decisionali, SVM
Apprendimento Non Supervisionato:
- Nessun dato etichettato (solo input)
- Obiettivo: Trovare modelli o strutture nei dati
- Esempi: Clustering, Riduzione della Dimensionalità
- Algoritmi: K-Means, PCA, Clustering Gerarchico

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

# Apprendimento Supervisionato - Regressione Lineare
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"Predizione supervisionata: {prediction[0]}")  # 12

# Apprendimento Non Supervisionato - 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"Assegnazioni dei cluster: {clusters}")

Rarità: Molto Comune Difficoltà: Facile

17. Cos'è l'overfitting e come lo previeni?

Risposta: L'overfitting si verifica quando un modello apprende troppo bene i dati di addestramento, incluso il rumore, e si comporta male su nuovi dati.

Segni:
- Alta accuratezza dell'addestramento, bassa accuratezza del test
- Modello troppo complesso per i dati
Prevenzione:
- Più dati di addestramento
- Cross-validation
- Regolarizzazione (L1, L2)
- Modelli più semplici
- Early stopping
- Dropout (reti neurali)

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

# Genera dati
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)

# Esempio di overfitting - polinomio di grado elevato
poly = PolynomialFeatures(degree=15)
X_poly = poly.fit_transform(X_train)

# Regolarizzazione per prevenire l'overfitting
# Ridge (regolarizzazione L2)
ridge = Ridge(alpha=1.0)
ridge.fit(X_poly, y_train)

# Lasso (regolarizzazione L1)
lasso = Lasso(alpha=0.1)
lasso.fit(X_poly, y_train)

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

Rarità: Molto Comune Difficoltà: Media

18. Spiega la divisione train-test e perché è importante.

Risposta: La divisione train-test divide i dati in set di addestramento e test per valutare le prestazioni del modello su dati non visti.

Scopo: Prevenire l'overfitting, stimare le prestazioni nel mondo reale
Divisione tipica: 70-30 o 80-20 (train-test)
Cross-Validation: Valutazione più robusta

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

# Carica dati
iris = load_iris()
X, y = iris.data, iris.target

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

print(f"Dimensione del set di addestramento: {len(X_train)}")
print(f"Dimensione del set di test: {len(X_test)}")

# Addestra il modello
model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)

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

print(f"Accuratezza dell'addestramento: {train_score:.2f}")
print(f"Accuratezza del test: {test_score:.2f}")

# Cross-validation (più robusta)
cv_scores = cross_val_score(model, X, y, cv=5)
print(f"Punteggi CV: {cv_scores}")
print(f"Punteggio CV medio: {cv_scores.mean():.2f}")

Rarità: Molto Comune Difficoltà: Facile

19. Quali metriche di valutazione usi per la classificazione?

Risposta: Diverse metriche per diversi scenari:

Accuratezza: Correttezza complessiva (buona per set di dati bilanciati)
Precisione: Dei positivi previsti, quanti sono corretti
Recall: Dei positivi effettivi, quanti sono stati trovati
F1-Score: Media armonica di precisione e recall
Matrice di Confusione: Ripartizione dettagliata delle previsioni

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

# Carica dati
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
)

# Addestra il modello
model = LogisticRegression(max_iter=10000)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# Metriche
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"Accuratezza: {accuracy:.2f}")
print(f"Precisione: {precision:.2f}")
print(f"Recall: {recall:.2f}")
print(f"F1-Score: {f1:.2f}")

# Matrice di confusione
cm = confusion_matrix(y_test, y_pred)
print(f"\nMatrice di Confusione:\n{cm}")

# Rapporto di classificazione
print(f"\n{classification_report(y_test, y_pred)}")

Rarità: Molto Comune Difficoltà: Media

20. Qual è la differenza tra classificazione e regressione?

Risposta:

Classificazione:
- Prevede categorie/classi discrete
- Output: Etichetta di classe
- Esempi: Rilevamento di spam, classificazione di immagini
- Algoritmi: Regressione Logistica, Alberi Decisionali, SVM
- Metriche: Accuratezza, Precisione, Recall, F1
Regressione:
- Prevede valori numerici continui
- Output: Numero
- Esempi: Previsione del prezzo delle case, previsione della temperatura
- Algoritmi: Regressione Lineare, Random Forest Regressor
- Metriche: MSE, RMSE, MAE, R²

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

# Esempio di regressione
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"Predizione di regressione: {y_pred_reg[0]:.2f}")  # Valore continuo

# Esempio di classificazione
X_clf = np.array([[1], [2], [3], [4], [5]])
y_clf = np.array([0, 0, 1, 1, 1])  # Classi binarie

clf_model = LogisticRegression()
clf_model.fit(X_clf, y_clf)
y_pred_clf = clf_model.predict([[3.5]])
print(f"Predizione di classificazione: {y_pred_clf[0]}")  # Etichetta di classe (0 o 1)

Rarità: Molto Comune Difficoltà: Facile

Indice

Domande per il Colloquio di Junior Data Scientist: Guida Completa

Introduzione

Fondamenti di Python (5 Domande)

1. Qual è la differenza tra una lista e una tupla in Python?

2. Spiega la list comprehension e fornisci un esempio.

3. Cosa sono le funzioni lambda e quando le useresti?

4. Spiega la differenza tra `append()` e `extend()` per le liste.

5. Cosa sono `*args` e `**kwargs`?

Statistica e Probabilità (5 Domande)

6. Qual è la differenza tra media, mediana e moda?

7. Spiega varianza e deviazione standard.

8. Cos'è un p-value e come lo interpreti?

9. Cos'è il Teorema del Limite Centrale?

10. Cosa sono correlazione e causalità?

Manipolazione dei Dati con Pandas (5 Domande)

11. Come si legge un file CSV e si visualizzano le informazioni di base?

12. Come gestisci i valori mancanti in un DataFrame?

13. Come filtri e selezioni i dati in pandas?

14. Come si raggruppano e si aggregano i dati?

15. Come si uniscono o si collegano i DataFrame?

Basi del Machine Learning (5 Domande)

16. Qual è la differenza tra apprendimento supervisionato e non supervisionato?

17. Cos'è l'overfitting e come lo previeni?

18. Spiega la divisione train-test e perché è importante.

19. Quali metriche di valutazione usi per la classificazione?

20. Qual è la differenza tra classificazione e regressione?

Distinguiti dai Reclutatori e Ottieni il Lavoro dei Tuoi Sogni

Condividi questo post

Consigli di carriera settimanali che funzionano davvero

Consigli di carriera settimanali che funzionano davvero

Post Correlati

Domande per il Colloquio di Junior Machine Learning Engineer: Guida Completa

Domande per il Colloquio di Sviluppatore Mobile Junior (iOS): Guida Completa

Domande per il Colloquio di Sviluppatore Mobile Junior (Android): Guida Completa

Distinguiti dai Reclutatori e Ottieni il Lavoro dei Tuoi Sogni

Condividi questo post

Riduci il Tempo di Scrittura del Curriculum del 90%

Indice

Introduzione

Fondamenti di Python (5 Domande)

1. Qual è la differenza tra una lista e una tupla in Python?

2. Spiega la list comprehension e fornisci un esempio.

3. Cosa sono le funzioni lambda e quando le useresti?

4. Spiega la differenza tra append() e extend() per le liste.

5. Cosa sono *args e **kwargs?

Statistica e Probabilità (5 Domande)

6. Qual è la differenza tra media, mediana e moda?

7. Spiega varianza e deviazione standard.

8. Cos'è un p-value e come lo interpreti?

9. Cos'è il Teorema del Limite Centrale?

10. Cosa sono correlazione e causalità?

Manipolazione dei Dati con Pandas (5 Domande)

11. Come si legge un file CSV e si visualizzano le informazioni di base?

12. Come gestisci i valori mancanti in un DataFrame?

13. Come filtri e selezioni i dati in pandas?

14. Come si raggruppano e si aggregano i dati?

15. Come si uniscono o si collegano i DataFrame?

Basi del Machine Learning (5 Domande)

16. Qual è la differenza tra apprendimento supervisionato e non supervisionato?

17. Cos'è l'overfitting e come lo previeni?

18. Spiega la divisione train-test e perché è importante.

19. Quali metriche di valutazione usi per la classificazione?

20. Qual è la differenza tra classificazione e regressione?

Distinguiti dai Reclutatori e Ottieni il Lavoro dei Tuoi Sogni

Condividi questo post

Consigli di carriera settimanali che funzionano davvero

Consigli di carriera settimanali che funzionano davvero

Post Correlati

Domande per il Colloquio di Junior Machine Learning Engineer: Guida Completa

Domande per il Colloquio di Sviluppatore Mobile Junior (iOS): Guida Completa

Domande per il Colloquio di Sviluppatore Mobile Junior (Android): Guida Completa

Distinguiti dai Reclutatori e Ottieni il Lavoro dei Tuoi Sogni

Condividi questo post

Riduci il Tempo di Scrittura del Curriculum del 90%

4. Spiega la differenza tra `append()` e `extend()` per le liste.

5. Cosa sono `*args` e `**kwargs`?