Perguntas para Entrevista de Cientista de Dados Júnior: Guia Completo

# Lista - mutável
minha_lista = [1, 2, 3]
minha_lista[0] = 10  # Funciona
minha_lista.append(4)  # Funciona
print(minha_lista)  # [10, 2, 3, 4]

# Tupla - imutável
minha_tupla = (1, 2, 3)
# minha_tupla[0] = 10  # Erro: tuplas são imutáveis
# minha_tupla.append(4)  # Erro: sem método append

# Desempacotamento de tupla
x, y, z = (1, 2, 3)
print(x, y, z)  # 1 2 3

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

# Compreensão de lista
quadrados = [i ** 2 for i in range(10)]
print(quadrados)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# Com condição
quadrados_pares = [i ** 2 for i in range(10) if i % 2 == 0]
print(quadrados_pares)  # [0, 4, 16, 36, 64]

# Compreensão aninhada
matriz = [[i * j for j in range(3)] for i in range(3)]
print(matriz)  # [[0, 0, 0], [0, 1, 2], [0, 2, 4]]

# Compreensão de dicionário
dicionario_quadrados = {i: i ** 2 for i in range(5)}
print(dicionario_quadrados)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Função regular
def quadrado(x):
    return x ** 2

# Função lambda
quadrado_lambda = lambda x: x ** 2
print(quadrado_lambda(5))  # 25

# Com map
numeros = [1, 2, 3, 4, 5]
quadrados = list(map(lambda x: x ** 2, numeros))
print(quadrados)  # [1, 4, 9, 16, 25]

# Com filter
pares = list(filter(lambda x: x % 2 == 0, numeros))
print(pares)  # [2, 4]

# Ordenando com chave
alunos = [('Alice', 85), ('Bob', 92), ('Charlie', 78)]
alunos_ordenados = sorted(alunos, key=lambda x: x[1], reverse=True)
print(alunos_ordenados)  # [('Bob', 92), ('Alice', 85), ('Charlie', 78)]

# append - adiciona um único elemento
lista1 = [1, 2, 3]
lista1.append(4)
print(lista1)  # [1, 2, 3, 4]

lista1.append([5, 6])
print(lista1)  # [1, 2, 3, 4, [5, 6]] - lista como um único elemento

# extend - adiciona múltiplos elementos
lista2 = [1, 2, 3]
lista2.extend([4, 5, 6])
print(lista2)  # [1, 2, 3, 4, 5, 6]

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

# *args - argumentos posicionais
def somar_tudo(*args):
    return sum(args)

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

# **kwargs - argumentos de palavra-chave
def imprimir_info(**kwargs):
    for chave, valor in kwargs.items():
        print(f"{chave}: {valor}")

imprimir_info(nome="Alice", idade=25, cidade="NYC")
# nome: Alice
# idade: 25
# cidade: NYC

# Combinado
def funcao_flexivel(*args, **kwargs):
    print("Posicional:", args)
    print("Palavra-chave:", kwargs)

funcao_flexivel(1, 2, 3, nome="Alice", idade=25)
# Posicional: (1, 2, 3)
# Palavra-chave: {'nome': 'Alice', 'idade': 25}

import numpy as np
from scipy import stats

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

# Média - afetada por outliers
media = np.mean(dados)
print(f"Média: {media}")  # 16.71

# Mediana - robusta a outliers
mediana = np.median(dados)
print(f"Mediana: {mediana}")  # 3

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

import numpy as np

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

# Variância
variancia = np.var(dados, ddof=1)  # ddof=1 para variância amostral
print(f"Variância: {variancia}")  # 4.57

# Desvio padrão
desvio_padrao = np.std(dados, ddof=1)
print(f"Desvio Padrão: {desvio_padrao}")  # 2.14

# Cálculo manual
media = np.mean(dados)
variancia_manual = sum((x - media) ** 2 for x in dados) / (len(dados) - 1)
print(f"Variância Manual: {variancia_manual}")

from scipy import stats

# Exemplo: Testando se uma moeda é justa
# Hipótese nula: a moeda é justa (p = 0,5)
# Obtivemos 65 caras em 100 lançamentos

caras_observadas = 65
n_lancamentos = 100
proporcao_esperada = 0.5

# Teste binomial
valor_p = stats.binom_test(caras_observadas, n_lancamentos, proporcao_esperada)
print(f"Valor P: {valor_p}")  # 0.0018

if valor_p < 0.05:
    print("Rejeitar a hipótese nula - a moeda provavelmente é tendenciosa")
else:
    print("Não rejeitar a hipótese nula - a moeda parece justa")

import numpy as np
import matplotlib.pyplot as plt

# População com distribuição não normal (exponencial)
populacao = np.random.exponential(scale=2, size=10000)

# Pegue muitas amostras e calcule suas médias
medias_amostrais = []
for _ in range(1000):
    amostra = np.random.choice(populacao, size=30)
    medias_amostrais.append(np.mean(amostra))

# As médias amostrais são normalmente distribuídas (TLC)
print(f"Média da população: {np.mean(populacao):.2f}")
print(f"Média das médias amostrais: {np.mean(medias_amostrais):.2f}")
print(f"Desvio padrão das médias amostrais: {np.std(medias_amostrais):.2f}")

import numpy as np
import pandas as pd

# Exemplo: As vendas de sorvete e as mortes por afogamento estão correlacionadas
# Mas o sorvete não causa afogamento (variável de confusão: temperatura)

# Coeficiente de correlação
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 5, 4, 5])

correlacao = np.corrcoef(x, y)[0, 1]
print(f"Correlação: {correlacao:.2f}")  # 0.82

# Correlação de Pearson
from scipy.stats import pearsonr
corr, valor_p = pearsonr(x, y)
print(f"Pearson r: {corr:.2f}, valor-p: {valor_p:.3f}")

import pandas as pd

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

# Informações básicas
print(df.head())  # Primeiras 5 linhas
print(df.tail())  # Últimas 5 linhas
print(df.shape)   # (linhas, colunas)
print(df.info())  # Tipos de dados e contagens não nulas
print(df.describe())  # Resumo estatístico

# Nomes e tipos de colunas
print(df.columns)
print(df.dtypes)

# Verificar valores ausentes
print(df.isnull().sum())

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

# Verificar valores ausentes
print(df.isnull().sum())

# Remover linhas com quaisquer valores ausentes
df_removido = df.dropna()

# Remover colunas com quaisquer valores ausentes
df_colunas_removidas = df.dropna(axis=1)

# Preencher com um valor específico
df_preenchido = df.fillna(0)

# Preencher com a média
df['A'] = df['A'].fillna(df['A'].mean())

# Preencher com a mediana
df['B'] = df['B'].fillna(df['B'].median())

# Preenchimento para frente (usar o valor anterior)
df_ffill = df.fillna(method='ffill')

# Preenchimento para trás (usar o próximo valor)
df_bfill = df.fillna(method='bfill')

# Interpolar
df_interpolado = df.interpolate()

import pandas as pd

df = pd.DataFrame({
    'nome': ['Alice', 'Bob', 'Charlie', 'David'],
    'idade': [25, 30, 35, 28],
    'salario': [50000, 60000, 75000, 55000],
    'departamento': ['IT', 'HR', 'IT', 'Finance']
})

# Selecionar colunas
print(df['nome'])  # Coluna única (Series)
print(df[['nome', 'idade']])  # Múltiplas colunas (DataFrame)

# Filtrar linhas
salario_alto = df[df['salario'] > 55000]
print(salario_alto)

# Múltiplas condições
it_salario_alto = df[(df['departamento'] == 'IT') & (df['salario'] > 50000)]
print(it_salario_alto)

# Usando .loc (baseado em rótulos)
print(df.loc[0:2, ['nome', 'idade']])

# Usando .iloc (baseado em posição)
print(df.iloc[0:2, 0:2])

# Método de consulta
resultado = df.query('idade > 28 and salario > 55000')
print(resultado)

# Método isin
it_ou_rh = df[df['departamento'].isin(['IT', 'HR'])]
print(it_ou_rh)

import pandas as pd

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

# Agrupar por coluna única
media_salario_dept = df.groupby('departamento')['salario'].mean()
print(media_salario_dept)

# Múltiplas agregações
estatisticas_dept = df.groupby('departamento').agg({
    'salario': ['mean', 'min', 'max'],
    'idade': 'mean'
})
print(estatisticas_dept)

# Agregação personalizada
dept_personalizado = df.groupby('departamento').agg({
    'salario': lambda x: x.max() - x.min(),
    'funcionario': 'count'
})
print(dept_personalizado)

# Múltiplas colunas de agrupamento
resultado = df.groupby(['departamento', 'idade'])['salario'].sum()
print(resultado)

import pandas as pd

# DataFrames de amostra
df1 = pd.DataFrame({
    'id_funcionario': [1, 2, 3, 4],
    'nome': ['Alice', 'Bob', 'Charlie', 'David']
})

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

# Junção interna (apenas linhas correspondentes)
interna = pd.merge(df1, df2, on='id_funcionario', how='inner')
print(interna)

# Junção esquerda (todas as linhas da esquerda)
esquerda = pd.merge(df1, df2, on='id_funcionario', how='left')
print(esquerda)

# Junção direita (todas as linhas da direita)
direita = pd.merge(df1, df2, on='id_funcionario', how='right')
print(direita)

# Junção externa (todas as linhas de ambos)
externa = pd.merge(df1, df2, on='id_funcionario', how='outer')
print(externa)

# 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

# Aprendizado Supervisionado - Regressão Linear
X_treino = np.array([[1], [2], [3], [4], [5]])
y_treino = np.array([2, 4, 6, 8, 10])

modelo = LinearRegression()
modelo.fit(X_treino, y_treino)
predicao = modelo.predict([[6]])
print(f"Predição supervisionada: {predicao[0]}")  # 12

# Aprendizado Não Supervisionado - Agrupamento 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"Atribuições de cluster: {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

# Gerar dados
X = np.random.rand(100, 1) * 10
y = 2 * X + 3 + np.random.randn(100, 1) * 2

X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0.2)

# Exemplo de overfitting - polinômio de alto grau
poli = PolynomialFeatures(degree=15)
X_poli = poli.fit_transform(X_treino)

# Regularização para prevenir overfitting
# Ridge (regularização L2)
ridge = Ridge(alpha=1.0)
ridge.fit(X_poli, y_treino)

# Lasso (regularização L1)
lasso = Lasso(alpha=0.1)
lasso.fit(X_poli, y_treino)

print(f"Pontuação Ridge: {ridge.score(X_poli, y_treino)}")
print(f"Pontuação Lasso: {lasso.score(X_poli, y_treino)}")

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

# Carregar dados
iris = load_iris()
X, y = iris.data, iris.target

# Divisão treino-teste
X_treino, X_teste, y_treino, y_teste = train_test_split(
    X, y, test_size=0.3, random_state=42
)

print(f"Tamanho do conjunto de treinamento: {len(X_treino)}")
print(f"Tamanho do conjunto de teste: {len(X_teste)}")

# Treinar modelo
modelo = LogisticRegression(max_iter=200)
modelo.fit(X_treino, y_treino)

# Avaliar
pontuacao_treino = modelo.score(X_treino, y_treino)
pontuacao_teste = modelo.score(X_teste, y_teste)

print(f"Precisão do treinamento: {pontuacao_treino:.2f}")
print(f"Precisão do teste: {pontuacao_teste:.2f}")

# Validação cruzada (mais robusta)
pontuacoes_cv = cross_val_score(modelo, X, y, cv=5)
print(f"Pontuações CV: {pontuacoes_cv}")
print(f"Pontuação CV média: {pontuacoes_cv.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

# Carregar dados
dados = load_breast_cancer()
X_treino, X_teste, y_treino, y_teste = train_test_split(
    dados.data, dados.target, test_size=0.3, random_state=42
)

# Treinar modelo
modelo = LogisticRegression(max_iter=10000)
modelo.fit(X_treino, y_treino)
y_pred = modelo.predict(X_teste)

# Métricas
precisao = accuracy_score(y_teste, y_pred)
precisao_modelo = precision_score(y_teste, y_pred)
revocacao = recall_score(y_teste, y_pred)
f1 = f1_score(y_teste, y_pred)

print(f"Precisão: {precisao:.2f}")
print(f"Precisão do Modelo: {precisao_modelo:.2f}")
print(f"Revocação: {revocacao:.2f}")
print(f"Pontuação F1: {f1:.2f}")

# Matriz de confusão
cm = confusion_matrix(y_teste, y_pred)
print(f"\nMatriz de Confusão:\n{cm}")

# Relatório de classificação
print(f"\n{classification_report(y_teste, y_pred)}")

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

# Exemplo de regressão
X_reg = np.array([[1], [2], [3], [4], [5]])
y_reg = np.array([2.1, 3.9, 6.2, 7.8, 10.1])

modelo_reg = LinearRegression()
modelo_reg.fit(X_reg, y_reg)
y_pred_reg = modelo_reg.predict([[6]])
print(f"Predição de regressão: {y_pred_reg[0]:.2f}")  # Valor contínuo

# Exemplo de classificação
X_clf = np.array([[1], [2], [3], [4], [5]])
y_clf = np.array([0, 0, 1, 1, 1])  # Classes binárias

modelo_clf = LogisticRegression()
modelo_clf.fit(X_clf, y_clf)
y_pred_clf = modelo_clf.predict([[3.5]])
print(f"Predição de classificação: {y_pred_clf[0]}")  # Rótulo de classe (0 ou 1)