Junior Data Scientist: Fragen im Vorstellungsgespräch – Der komplette Leitfaden

# Liste - veränderlich
my_list = [1, 2, 3]
my_list[0] = 10  # Funktioniert
my_list.append(4)  # Funktioniert
print(my_list)  # [10, 2, 3, 4]

# Tupel - unveränderlich
my_tuple = (1, 2, 3)
# my_tuple[0] = 10  # Fehler: Tupel sind unveränderlich
# my_tuple.append(4)  # Fehler: keine append-Methode

# Tupel entpacken
x, y, z = (1, 2, 3)
print(x, y, z)  # 1 2 3

# Traditionelle Schleife
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]

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

# Verschachtelte 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}

# Reguläre Funktion
def square(x):
    return x ** 2

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

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

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

# Sortieren mit 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 - fügt ein einzelnes Element hinzu
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 als einzelnes Element

# extend - fügt mehrere Elemente hinzu
list2 = [1, 2, 3]
list2.extend([4, 5, 6])
print(list2)  # [1, 2, 3, 4, 5, 6]

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

# *args - Positionsargumente
def sum_all(*args):
    return sum(args)

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

# **kwargs - Schlüsselwortargumente
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

# Kombiniert
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]

# Mittelwert - beeinflusst von Ausreißern
mean = np.mean(data)
print(f"Mean: {mean}")  # 16.71

# Median - robust gegenüber Ausreißern
median = np.median(data)
print(f"Median: {median}")  # 3

# Modus
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]

# Varianz
variance = np.var(data, ddof=1)  # ddof=1 für Stichprobenvarianz
print(f"Variance: {variance}")  # 4.57

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

# Manuelle Berechnung
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

# Beispiel: Testen, ob eine Münze fair ist
# Nullhypothese: Münze ist fair (p = 0,5)
# Wir haben 65 Mal Kopf bei 100 Würfen erhalten

observed_heads = 65
n_flips = 100
expected_proportion = 0.5

# Binomialtest
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

# Grundgesamtheit mit nicht normaler Verteilung (exponentiell)
population = np.random.exponential(scale=2, size=10000)

# Nehmen Sie viele Stichproben und berechnen Sie deren Mittelwerte
sample_means = []
for _ in range(1000):
    sample = np.random.choice(population, size=30)
    sample_means.append(np.mean(sample))

# Stichprobenmittelwerte sind normalverteilt (CLT)
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

# Beispiel: Eisverkäufe und Todesfälle durch Ertrinken sind korreliert
# Aber Eis verursacht kein Ertrinken (Störvariable: Temperatur)

# Korrelationskoeffizient
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

# Pearson-Korrelation
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

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

# Grundlegende Informationen
print(df.head())  # Erste 5 Zeilen
print(df.tail())  # Letzte 5 Zeilen
print(df.shape)   # (Zeilen, Spalten)
print(df.info())  # Datentypen und Anzahl der Nicht-Null-Werte
print(df.describe())  # Statistische Zusammenfassung

# Spaltennamen und -typen
print(df.columns)
print(df.dtypes)

# Auf fehlende Werte prüfen
print(df.isnull().sum())

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

# Fehlende Werte prüfen
print(df.isnull().sum())

# Zeilen mit fehlenden Werten löschen
df_dropped = df.dropna()

# Spalten mit fehlenden Werten löschen
df_dropped_cols = df.dropna(axis=1)

# Mit spezifischem Wert füllen
df_filled = df.fillna(0)

# Mit Mittelwert füllen
df['A'] = df['A'].fillna(df['A'].mean())

# Mit Median füllen
df['B'] = df['B'].fillna(df['B'].median())

# Forward Fill (vorherigen Wert verwenden)
df_ffill = df.fillna(method='ffill')

# Backward Fill (nächsten Wert verwenden)
df_bfill = df.fillna(method='bfill')

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

# Spalten auswählen
print(df['name'])  # Einzelne Spalte (Series)
print(df[['name', 'age']])  # Mehrere Spalten (DataFrame)

# Zeilen filtern
high_salary = df[df['salary'] > 55000]
print(high_salary)

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

# Verwenden von .loc (labelbasiert)
print(df.loc[0:2, ['name', 'age']])

# Verwenden von .iloc (positionsbasiert)
print(df.iloc[0:2, 0:2])

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

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

# Nach einzelner Spalte gruppieren
dept_avg_salary = df.groupby('department')['salary'].mean()
print(dept_avg_salary)

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

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

# Mehrere Gruppierungsspalten
result = df.groupby(['department', 'age'])['salary'].sum()
print(result)

import pandas as pd

# Beispiel-DataFrames
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 (nur übereinstimmende Zeilen)
inner = pd.merge(df1, df2, on='employee_id', how='inner')
print(inner)

# Left Join (alle Zeilen von links)
left = pd.merge(df1, df2, on='employee_id', how='left')
print(left)

# Right Join (alle Zeilen von rechts)
right = pd.merge(df1, df2, on='employee_id', how='right')
print(right)

# Outer Join (alle Zeilen von beiden)
outer = pd.merge(df1, df2, on='employee_id', how='outer')
print(outer)

# Vertikal zusammenfügen
df3 = pd.concat([df1, df2], ignore_index=True)
print(df3)

# Horizontal zusammenfügen
df4 = pd.concat([df1, df2], axis=1)
print(df4)

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

# Überwachtes Lernen - Lineare Regression
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

# Unüberwachtes Lernen - K-Means-Clustering
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

# Daten generieren
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)

# Overfitting-Beispiel - Polynom hohen Grades
poly = PolynomialFeatures(degree=15)
X_poly = poly.fit_transform(X_train)

# Regularisierung zur Verhinderung von Overfitting
# Ridge (L2-Regularisierung)
ridge = Ridge(alpha=1.0)
ridge.fit(X_poly, y_train)

# Lasso (L1-Regularisierung)
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

# Daten laden
iris = load_iris()
X, y = iris.data, iris.target

# Train-Test-Aufteilung
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)}")

# Modell trainieren
model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)

# Bewerten
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}")

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

# Daten laden
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
)

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

# Metriken
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}")

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

# Klassifikationsbericht
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

# Regressionsbeispiel
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}")  # Kontinuierlicher Wert

# Klassifizierungsbeispiel
X_clf = np.array([[1], [2], [3], [4], [5]])
y_clf = np.array([0, 0, 1, 1, 1])  # Binäre Klassen

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]}")  # Klassenbezeichnung (0 oder 1)