Cheatsheet Python Data Science: NumPy, Pandas, Matplotlib & Scikit-learn

import numpy as np

# Create array
arr = np.array([1, 2, 3, 4, 5])
zeros = np.zeros((3, 4))
ones = np.ones((2, 3))
rng = np.arange(0, 10, 2)
linspace = np.linspace(0, 1, 5)
random = np.random.randn(3, 3)

# Operations
arr.sum()         # 15
arr.mean()        # 3.0
arr.std()         # Std dev
arr.reshape(5, 1) # Reshape
arr[arr > 3]      # Boolean indexing
np.dot(a, b)      # Matrix multiply
np.concatenate([a, b])  # Join arrays

import pandas as pd

# Create
df = pd.DataFrame({"name": ["A","B"], "age": [25, 30]})
df = pd.read_csv("data.csv")
df = pd.read_json("data.json")

# Select
df["name"]              # Single column
df[["name", "age"]]     # Multiple columns
df.iloc[0:5]            # By index
df.loc[df["age"] > 25]  # By condition

# Transform
df["age"].mean()        # Average
df.groupby("city").agg({"salary": "mean", "age": "max"})
df.sort_values("age", ascending=False)
df.dropna()             # Remove NaN
df.fillna(0)            # Fill NaN with 0
df.drop_duplicates()
pd.merge(df1, df2, on="id")  # Join
pd.concat([df1, df2])         # Stack

import matplotlib.pyplot as plt

# Line plot
plt.plot(x, y, label="Data", color="blue", linewidth=2)
plt.xlabel("X Label")
plt.ylabel("Y Label")
plt.title("Chart Title")
plt.legend()
plt.grid(True)
plt.savefig("chart.png", dpi=150)
plt.show()

# Subplot
fig, axes = plt.subplots(2, 2, figsize=(10, 8))
axes[0, 0].plot(x, y1)
axes[0, 1].bar(categories, values)
axes[1, 0].hist(data, bins=20)
axes[1, 1].scatter(x, y2)

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Scale features
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Train model
model = LogisticRegression()
model.fit(X_train, y_train)

# Evaluate
y_pred = model.predict(X_test)
accuracy_score(y_test, y_pred)
print(classification_report(y_test, y_pred))

# Missing values
df.isnull().sum()
df.dropna(subset=["col1", "col2"])
df["col"].fillna(df["col"].median())

# Outliers
Q1 = df["col"].quantile(0.25)
Q3 = df["col"].quantile(0.75)
IQR = Q3 - Q1
df = df[(df["col"] >= Q1-1.5*IQR) & (df["col"] <= Q3+1.5*IQR)]

# Type conversion
df["date"] = pd.to_datetime(df["date"])
df["category"] = df["category"].astype("category")

import seaborn as sns

# Distribution plot
sns.histplot(df["age"], kde=True, bins=30)
sns.boxplot(x="category", y="price", data=df)

# Relationship plot
sns.scatterplot(x="age", y="salary", hue="gender", data=df)
sns.heatmap(df.corr(), annot=True, cmap="coolwarm", fmt=".2f")

# Categorical plot
sns.barplot(x="city", y="salary", data=df, estimator=np.mean)
sns.violinplot(x="category", y="score", data=df)
sns.pairplot(df, hue="species")  # All pairwise relationships

from sklearn.model_selection import cross_val_score, GridSearchCV
from sklearn.pipeline import Pipeline
from sklearn.ensemble import RandomForestClassifier

# Pipeline (preprocessing + model)
pipe = Pipeline([
    ("scaler", StandardScaler()),
    ("model", RandomForestClassifier())
])
pipe.fit(X_train, y_train)
pipe.score(X_test, y_test)

# Cross-validation
scores = cross_val_score(pipe, X, y, cv=5, scoring="accuracy")
print(f"Mean: {scores.mean():.3f} ± {scores.std():.3f}")

# Hyperparameter tuning
param_grid = {
    "model__n_estimators": [100, 200, 500],
    "model__max_depth": [5, 10, None],
    "model__min_samples_split": [2, 5]
}
grid = GridSearchCV(pipe, param_grid, cv=3, n_jobs=-1)
grid.fit(X_train, y_train)
print(f"Best params: {grid.best_params_}")
print(f"Best score: {grid.best_score_:.3f}")

from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.feature_selection import SelectKBest, f_classif

# Encoding categorical variables
le = LabelEncoder()
df["city_encoded"] = le.fit_transform(df["city"])

# One-hot encoding (untuk model linear)
df_encoded = pd.get_dummies(df, columns=["city", "gender"], drop_first=True)

# Feature selection
selector = SelectKBest(f_classif, k=10)
X_selected = selector.fit_transform(X, y)
selected_features = X.columns[selector.get_support()]

# Feature scaling comparison
from sklearn.preprocessing import MinMaxScaler, RobustScaler
minmax = MinMaxScaler()       # [0, 1] range, sensitive outliers
robust = RobustScaler()       # median-based, robust to outliers
standard = StandardScaler()   # mean=0, std=1, assumes normal