Preguntas para Entrevistas de Data Scientist Junior: Guía Completa

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

# Tupla - inmutable
my_tuple = (1, 2, 3)
# my_tuple[0] = 10  # Error: las tuplas son inmutables
# my_tuple.append(4)  # Error: no hay método append

# Desempaquetado de tuplas
x, y, z = (1, 2, 3)
print(x, y, z)  # 1 2 3

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

# Comprensión de listas
squares = [i ** 2 for i in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

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

# Comprensión anidada
matrix = [[i * j for j in range(3)] for i in range(3)]
print(matrix)  # [[0, 0, 0], [0, 1, 2], [0, 2, 4]]

# Comprensión de diccionarios
squares_dict = {i: i ** 2 for i in range(5)}
print(squares_dict)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Función regular
def square(x):
    return x ** 2

# Función 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]

# Ordenando con clave
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 - agrega un solo 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 como un solo elemento

# extend - agrega múltiples elementos
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]

# *args - argumentos posicionales
def sum_all(*args):
    return sum(args)

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

# **kwargs - argumentos de palabra clave
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

# Combinado
def flexible_function(*args, **kwargs):
    print("Posicional:", args)
    print("Palabra clave:", kwargs)

flexible_function(1, 2, 3, name="Alice", age=25)
# Posicional: (1, 2, 3)
# Palabra clave: {'name': 'Alice', 'age': 25}

import numpy as np
from scipy import stats

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

# Media - afectada por valores atípicos
mean = np.mean(data)
print(f"Media: {mean}")  # 16.71

# Mediana - robusta a valores atípicos
median = np.median(data)
print(f"Mediana: {median}")  # 3

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

import numpy as np

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

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

# Desviación estándar
std_dev = np.std(data, ddof=1)
print(f"Desv. Estándar: {std_dev}")  # 2.14

# Cálculo manual
mean = np.mean(data)
variance_manual = sum((x - mean) ** 2 for x in data) / (len(data) - 1)
print(f"Varianza Manual: {variance_manual}")

from scipy import stats

# Ejemplo: Probar si una moneda es justa
# Hipótesis nula: la moneda es justa (p = 0.5)
# Obtuvimos 65 caras de 100 lanzamientos

observed_heads = 65
n_flips = 100
expected_proportion = 0.5

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

if p_value < 0.05:
    print("Rechazar la hipótesis nula: es probable que la moneda esté sesgada")
else:
    print("No se puede rechazar la hipótesis nula: la moneda parece justa")

import numpy as np
import matplotlib.pyplot as plt

# Población con distribución no normal (exponencial)
population = np.random.exponential(scale=2, size=10000)

# Tomar muchas muestras y calcular sus medias
sample_means = []
for _ in range(1000):
    sample = np.random.choice(population, size=30)
    sample_means.append(np.mean(sample))

# Las medias muestrales se distribuyen normalmente (TLC)
print(f"Media de la población: {np.mean(population):.2f}")
print(f"Media de las medias muestrales: {np.mean(sample_means):.2f}")
print(f"Desv. Estándar de las medias muestrales: {np.std(sample_means):.2f}")

import numpy as np
import pandas as pd

# Ejemplo: Las ventas de helados y las muertes por ahogamiento están correlacionadas
# Pero el helado no causa ahogamiento (variable de confusión: temperatura)

# Coeficiente de correlación
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"Correlación: {correlation:.2f}")  # 0.82

# Correlación de Pearson
from scipy.stats import pearsonr
corr, p_value = pearsonr(x, y)
print(f"r de Pearson: {corr:.2f}, valor p: {p_value:.3f}")

import pandas as pd

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

# Información básica
print(df.head())  # Primeras 5 filas
print(df.tail())  # Últimas 5 filas
print(df.shape)   # (filas, columnas)
print(df.info())  # Tipos de datos y conteos no nulos
print(df.describe())  # Resumen estadístico

# Nombres y tipos de columnas
print(df.columns)
print(df.dtypes)

# Comprobar valores faltantes
print(df.isnull().sum())

# Columnas específicas
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]
})

# Comprobar valores faltantes
print(df.isnull().sum())

# Eliminar filas con cualquier valor faltante
df_dropped = df.dropna()

# Eliminar columnas con cualquier valor faltante
df_dropped_cols = df.dropna(axis=1)

# Rellenar con un valor específico
df_filled = df.fillna(0)

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

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

# Rellenado hacia adelante (usar el valor anterior)
df_ffill = df.fillna(method='ffill')

# Rellenado hacia atrás (usar el siguiente valor)
df_bfill = df.fillna(method='bfill')

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

# Seleccionar columnas
print(df['name'])  # Columna única (Serie)
print(df[['name', 'age']])  # Múltiples columnas (DataFrame)

# Filtrar filas
high_salary = df[df['salary'] > 55000]
print(high_salary)

# Múltiples condiciones
it_high_salary = df[(df['department'] == 'IT') & (df['salary'] > 50000)]
print(it_high_salary)

# Usando .loc (basado en etiquetas)
print(df.loc[0:2, ['name', 'age']])

# Usando .iloc (basado en la posición)
print(df.iloc[0:2, 0:2])

# Método de consulta
result = df.query('age > 28 and salary > 55000')
print(result)

# Método 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]
})

# Agrupar por una sola columna
dept_avg_salary = df.groupby('department')['salary'].mean()
print(dept_avg_salary)

# Múltiples agregaciones
dept_stats = df.groupby('department').agg({
    'salary': ['mean', 'min', 'max'],
    'age': 'mean'
})
print(dept_stats)

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

# Múltiples columnas de agrupación
result = df.groupby(['department', 'age'])['salary'].sum()
print(result)

import pandas as pd

# DataFrames de muestra
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]
})

# Unión interna (solo filas coincidentes)
inner = pd.merge(df1, df2, on='employee_id', how='inner')
print(inner)

# Unión izquierda (todas las filas de la izquierda)
left = pd.merge(df1, df2, on='employee_id', how='left')
print(left)

# Unión derecha (todas las filas de la derecha)
right = pd.merge(df1, df2, on='employee_id', how='right')
print(right)

# Unión externa (todas las filas de ambos)
outer = pd.merge(df1, df2, on='employee_id', how='outer')
print(outer)

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

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

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

# Aprendizaje Supervisado - Regresión Lineal
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"Predicción supervisada: {prediction[0]}")  # 12

# Aprendizaje No Supervisado - Agrupamiento 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"Asignaciones de clúster: {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

# Generar datos
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)

# Ejemplo de sobreajuste: polinomio de alto grado
poly = PolynomialFeatures(degree=15)
X_poly = poly.fit_transform(X_train)

# Regularización para prevenir el sobreajuste
# Ridge (regularización L2)
ridge = Ridge(alpha=1.0)
ridge.fit(X_poly, y_train)

# Lasso (regularización L1)
lasso = Lasso(alpha=0.1)
lasso.fit(X_poly, y_train)

print(f"Puntaje Ridge: {ridge.score(X_poly, y_train)}")
print(f"Puntaje Lasso: {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

# Cargar datos
iris = load_iris()
X, y = iris.data, iris.target

# División de entrenamiento-prueba
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

print(f"Tamaño del conjunto de entrenamiento: {len(X_train)}")
print(f"Tamaño del conjunto de prueba: {len(X_test)}")

# Entrenar modelo
model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)

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

print(f"Precisión del entrenamiento: {train_score:.2f}")
print(f"Precisión de la prueba: {test_score:.2f}")

# Validación cruzada (más robusta)
cv_scores = cross_val_score(model, X, y, cv=5)
print(f"Puntajes CV: {cv_scores}")
print(f"Puntaje CV medio: {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

# Cargar datos
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
)

# Entrenar modelo
model = LogisticRegression(max_iter=10000)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# Métricas
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"Precisión: {accuracy:.2f}")
print(f"Precisión: {precision:.2f}")
print(f"Recuperación: {recall:.2f}")
print(f"Puntaje F1: {f1:.2f}")

# Matriz de confusión
cm = confusion_matrix(y_test, y_pred)
print(f"\nMatriz de Confusión:\n{cm}")

# Informe de clasificación
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

# Ejemplo de regresión
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"Predicción de regresión: {y_pred_reg[0]:.2f}")  # Valor continuo

# Ejemplo de clasificación
X_clf = np.array([[1], [2], [3], [4], [5]])
y_clf = np.array([0, 0, 1, 1, 1])  # Clases binarias

clf_model = LogisticRegression()
clf_model.fit(X_clf, y_clf)
y_pred_clf = clf_model.predict([[3.5]])
print(f"Predicción de clasificación: {y_pred_clf[0]}")  # Etiqueta de clase (0 o 1)