# Python untuk Data Science: NumPy, Pandas, dan Scikit-Learn di Tahun 2026

> Panduan praktis menggunakan NumPy 2.1, Pandas 2.2, dan Scikit-Learn 1.6 dengan Python 3.12. Dari pembersihan data dan feature engineering hingga pipeline ML siap produksi -- lengkap dengan contoh kode.

- Published: 2026-04-07
- Updated: 2026-04-07
- Author: Anthony Fillion-Maillet
- Tags: data-science, python, numpy, pandas, scikit-learn, machine-learning, tutorial
- Reading time: 10 min

---

Python tetap menjadi bahasa pemrograman utama di bidang data science pada tahun 2026 -- bukan karena sekadar tren, melainkan karena ekosistemnya yang matang dan teruji. Tiga pustaka inti menjadi fondasi dari hampir seluruh pipeline data modern: NumPy menyediakan operasi matriks dan array berkinerja tinggi, Pandas memungkinkan manipulasi data tabular secara fleksibel, dan Scikit-Learn menghadirkan algoritma machine learning siap pakai. Dengan menguasai ketiga pustaka ini, seorang praktisi data science dapat menangani seluruh alur kerja -- mulai dari pembersihan data mentah hingga deployment model -- sepenuhnya dalam Python. Artikel ini menyajikan contoh praktis yang saling berkesinambungan, yaitu analisis dan prediksi promosi karyawan, untuk mendemonstrasikan penggunaan efektif ketiga pustaka tersebut.

> **Versi yang Digunakan**
>
> Seluruh contoh kode dalam artikel ini dikembangkan dan diuji menggunakan Python 3.12+, NumPy 2.1, Pandas 2.2, dan Scikit-Learn 1.6. Versi yang lebih lama mungkin memiliki perbedaan pada beberapa detail API, khususnya perilaku Copy-on-Write pada Pandas 2.2 dan kompatibilitas Array API baru pada NumPy 2.1.

## Operasi Array NumPy: Dasar-Dasar dan Boolean Indexing

NumPy menggantikan list Python dan loop konvensional dengan operasi tervektorisasi yang secara internal dijalankan pada kode C yang telah dioptimasi. Alih-alih mengiterasi elemen satu per satu menggunakan `for` loop, fungsi-fungsi NumPy beroperasi pada seluruh array secara serentak -- menghasilkan peningkatan kecepatan 10 hingga 100 kali lipat pada beban kerja data science yang umum.

Contoh berikut menampilkan operasi array fundamental: pembuatan array dari berbagai sumber, aritmetika tervektorisasi, serta Boolean Indexing yang memungkinkan pemfilteran data tanpa loop.

```python
# numpy_basics.py
import numpy as np

# Create arrays from different sources
prices = np.array([29.99, 49.99, 19.99, 99.99, 39.99])
quantities = np.arange(1, 6)  # [1, 2, 3, 4, 5]

# Vectorized arithmetic — no loops needed
revenue = prices * quantities
print(revenue)  # [29.99, 99.98, 59.97, 399.96, 199.95]

# Statistical aggregations
print(f"Total revenue: ${revenue.sum():.2f}")   # $789.85
print(f"Mean price: ${prices.mean():.2f}")       # $47.99
print(f"Std deviation: ${prices.std():.2f}")     # $27.64

# Boolean indexing — filter without loops
premium_mask = prices > 40
premium_items = prices[premium_mask]  # [49.99, 99.99]
```

Boolean Indexing merupakan pola sentral dalam NumPy: ekspresi `prices > 40` menghasilkan array berisi nilai `True`/`False` yang langsung berfungsi sebagai masker filter. Konsep ini akan ditemui kembali pada Pandas DataFrame, karena Pandas secara internal dibangun di atas NumPy. Fungsi-fungsi agregasi statistik -- `sum()`, `mean()`, `std()` -- secara default beroperasi pada seluruh elemen array. Untuk array multidimensi, parameter `axis` memungkinkan agregasi dilakukan pada sumbu tertentu.

## Reshaping dan Broadcasting pada NumPy

Array multidimensi sangat lazim dijumpai dalam praktik sehari-hari: data penjualan berdasarkan produk dan bulan, nilai piksel pada citra, maupun matriks fitur untuk model machine learning. NumPy menyediakan kemampuan untuk mengubah bentuk struktur data ini secara fleksibel melalui `reshape()`, serta broadcasting otomatis saat melakukan operasi aritmetika pada array dengan dimensi yang berbeda.

```python
# numpy_reshape.py
import numpy as np

# Monthly sales data: 4 products x 3 months
sales = np.array([
    [120, 150, 130],  # Product A
    [200, 180, 220],  # Product B
    [90, 110, 95],    # Product C
    [300, 280, 310],  # Product D
])

# Column-wise mean (average per month)
monthly_avg = sales.mean(axis=0)  # [177.5, 180.0, 188.75]

# Row-wise sum (total per product)
product_totals = sales.sum(axis=1)  # [400, 600, 295, 890]

# Normalize each product relative to its own max
normalized = sales / sales.max(axis=1, keepdims=True)
# keepdims=True preserves the shape for broadcasting
print(normalized[0])  # [0.8, 1.0, 0.867] — Product A relative to its peak

# Reshape for Scikit-Learn (requires 2D input)
flat_sales = sales.flatten()  # 1D array of 12 values
reshaped = flat_sales.reshape(-1, 1)  # 12x1 column vector
```

Parameter `axis` berperan krusial dalam menentukan arah agregasi: `axis=0` melakukan agregasi per kolom (melintasi baris), sedangkan `axis=1` melakukan agregasi per baris (melintasi kolom). Pada proses normalisasi, `keepdims=True` mempertahankan shape `(4, 1)` sehingga broadcasting pada operasi pembagian berjalan dengan benar. Pola `reshape(-1, 1)` di bagian akhir merupakan teknik yang sangat umum digunakan, karena Scikit-Learn mensyaratkan input berupa array minimal dua dimensi.

## Manipulasi dan Pembersihan Data dengan Pandas DataFrame

Pandas merupakan alat utama untuk menangani data tabular dalam Python. Sebuah DataFrame berperilaku serupa dengan tabel database atau spreadsheet Excel, namun menawarkan kemampuan transformasi yang jauh lebih kuat. Dalam praktik nyata, pembersihan data merupakan tahap yang paling memakan waktu di setiap proyek data science -- nilai yang hilang, outlier, duplikat, serta tipe data yang tidak konsisten harus ditangani secara sistematis.

Pendekatan yang direkomendasikan adalah rangkaian transformasi yang reprodusibel, yaitu menjaga DataFrame asli tetap utuh dan menyimpan hasilnya ke dalam variabel baru. Contoh berikut menggunakan dataset berisi 1.500 profil kandidat.

```python
# pandas_cleaning.py
import pandas as pd
import numpy as np

# Load and inspect raw data
df = pd.read_csv("candidates.csv")
print(df.shape)       # (1500, 8)
print(df.dtypes)      # Check column types
print(df.isna().sum()) # Count missing values per column

# Clean in a reproducible chain
df_clean = (
    df
    .dropna(subset=["salary", "experience_years"])      # Drop rows missing critical fields
    .assign(
        salary=lambda x: x["salary"].clip(lower=20000, upper=500000),  # Cap outliers
        experience_years=lambda x: x["experience_years"].astype(int),
        hired_date=lambda x: pd.to_datetime(x["hired_date"], errors="coerce"),
    )
    .drop_duplicates(subset=["email"])                  # Remove duplicate candidates
    .query("experience_years >= 0")                     # Filter invalid entries
    .reset_index(drop=True)
)

print(f"Cleaned: {len(df)} -> {len(df_clean)} rows")
```

Metode `.assign()` menambahkan kolom baru atau menimpa kolom yang sudah ada tanpa mengubah DataFrame asli. Argumen `clip()` membatasi rentang gaji pada batas yang masuk akal, mencegah nilai ekstrem mendistorsi model yang akan dibangun. Pola `pd.to_datetime(..., errors="coerce")` mengonversi format tanggal yang tidak valid menjadi `NaT` (Not a Time) alih-alih memunculkan error -- pendekatan yang robust untuk menangani data dunia nyata.

> **Pandas 2.2: Copy-on-Write Aktif Secara Default**
>
> Mulai Pandas 2.2, fitur Copy-on-Write (CoW) diaktifkan secara default. Artinya, operasi pada subset DataFrame (slice) selalu menghasilkan salinan, bukan view. Dengan demikian, peringatan `SettingWithCopyWarning` yang selama ini kerap membingungkan tidak lagi muncul. Bagi yang memerlukan akses in-place secara langsung, disarankan untuk memanggil `.copy()` secara eksplisit atau menggunakan pola-pola baru yang kompatibel dengan CoW.

## Agregasi GroupBy dan Feature Engineering dengan Pandas

Memasukkan data mentah langsung ke dalam model jarang menghasilkan performa yang baik. Feature engineering -- proses transformasi dan penggabungan data mentah menjadi fitur-fitur yang lebih informatif -- seringkali menjadi faktor terbesar dalam meningkatkan kualitas model. Operasi GroupBy pada Pandas sangat penting dalam proses ini: memungkinkan perhitungan statistik agregat per kelompok, yang kemudian dijadikan fitur baru.

Contoh berikut menghitung statistik per departemen dan menurunkan fitur-fitur baru yang membantu model memahami posisi seorang kandidat relatif terhadap departemennya. Pembahasan lebih mendalam tentang strategi feature engineering tersedia di halaman [Feature Engineering untuk Interview Data Science](/technologies/data-science/interview-questions/feature-engineering).

```python
# pandas_groupby.py
import pandas as pd

# Aggregate candidate stats by department
dept_stats = (
    df_clean
    .groupby("department")
    .agg(
        avg_salary=("salary", "mean"),
        median_experience=("experience_years", "median"),
        headcount=("email", "count"),
        max_salary=("salary", "max"),
    )
    .sort_values("avg_salary", ascending=False)
)
print(dept_stats.head())

# Create features for ML: encode categorical + add aggregated stats
df_features = (
    df_clean
    .assign(
        # Ratio of individual salary to department average
        salary_ratio=lambda x: x["salary"] / x.groupby("department")["salary"].transform("mean"),
        # Time since hire in days
        tenure_days=lambda x: (pd.Timestamp.now() - x["hired_date"]).dt.days,
        # Binary encoding
        is_senior=lambda x: (x["experience_years"] >= 5).astype(int),
    )
)
```

Pola `transform("mean")` memiliki keunggulan tersendiri: berbeda dengan `agg()` yang mengembalikan tabel agregat, `transform()` mempertahankan jumlah baris asli dan mengembalikan nilai kelompok yang bersesuaian untuk setiap baris -- sangat ideal untuk menghitung rasio seperti `salary_ratio`. Fitur `tenure_days` mengkonversi data tanggal menjadi nilai numerik yang dapat langsung diproses oleh model.

## Membangun Pipeline Scikit-Learn

Pipeline Scikit-Learn merupakan konsep sentral untuk membangun alur kerja machine learning yang reprodusibel dan siap produksi. Sebuah pipeline merangkai langkah-langkah preprocessing dan model ke dalam satu objek tunggal -- hal ini mencegah data leakage, menyederhanakan proses hyperparameter tuning, dan memungkinkan serialisasi yang bersih untuk deployment ke lingkungan produksi.

Hal kritis yang perlu diperhatikan: pemisahan data train-test harus dilakukan sebelum preprocessing apa pun. Parameter skalasi (mean, standard deviation) hanya boleh dihitung pada data training, tidak pernah pada data test. Pipeline menegakkan pemisahan ini secara otomatis. Pemahaman lebih lanjut tentang [supervised learning dan klasifikasi](/technologies/data-science/interview-questions/ml-supervised-classification) dapat membantu dalam memahami algoritma GradientBoosting yang digunakan.

```python
# sklearn_pipeline.py
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import classification_report
import pandas as pd

# Define column groups
numeric_features = ["salary", "experience_years", "salary_ratio", "tenure_days"]
categorical_features = ["department", "role_level"]
target = "promoted"

# Split before any preprocessing
X = df_features[numeric_features + categorical_features]
y = df_features[target]
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# Build the preprocessing + model pipeline
preprocessor = ColumnTransformer(
    transformers=[
        ("num", StandardScaler(), numeric_features),           # Scale numeric columns
        ("cat", OneHotEncoder(handle_unknown="ignore"), categorical_features),  # Encode categories
    ]
)

pipeline = Pipeline([
    ("preprocessor", preprocessor),
    ("classifier", GradientBoostingClassifier(
        n_estimators=200,
        learning_rate=0.1,
        max_depth=4,
        random_state=42,
    )),
])

# Train and evaluate
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
print(classification_report(y_test, y_pred))
```

`ColumnTransformer` memungkinkan pendefinisian langkah-langkah preprocessing yang berbeda untuk kolom numerik dan kategoris. `StandardScaler` menormalisasi fitur numerik ke mean 0 dan standard deviation 1. `OneHotEncoder(handle_unknown="ignore")` mengubah nilai kategoris menjadi kolom biner dan menangani kategori baru yang muncul di data test secara aman. Meskipun `GradientBoostingClassifier` cukup robust terhadap fitur yang belum diskalasi, keberadaan `StandardScaler` dalam pipeline memudahkan penggantian model ke model linear atau SVM di kemudian hari tanpa perubahan signifikan.

## Cross-Validation dan Hyperparameter Tuning

Satu kali pembagian train-test saja memberikan estimasi kualitas model yang terlalu bervariasi. Cross-validation membagi data ke dalam beberapa fold dan merata-ratakan hasilnya -- sehingga menghasilkan estimasi yang lebih stabil terhadap kemampuan generalisasi model. Selanjutnya, `GridSearchCV` mengoptimasi hyperparameter model secara sistematis menggunakan mekanisme cross-validation yang sama. Pembahasan lebih komprehensif tentang algoritma machine learning dapat ditemukan di artikel [Algoritma Machine Learning Dijelaskan](/blog/data-science/machine-learning-algorithms-explained).

```python
# sklearn_tuning.py
from sklearn.model_selection import cross_val_score, GridSearchCV
import numpy as np

# 5-fold cross-validation on the full pipeline
scores = cross_val_score(pipeline, X_train, y_train, cv=5, scoring="f1")
print(f"F1 scores: {scores}")
print(f"Mean F1: {scores.mean():.3f} (+/- {scores.std() * 2:.3f})")

# Grid search over hyperparameters
param_grid = {
    "classifier__n_estimators": [100, 200, 300],
    "classifier__max_depth": [3, 4, 5],
    "classifier__learning_rate": [0.05, 0.1, 0.2],
}

grid_search = GridSearchCV(
    pipeline,
    param_grid,
    cv=5,
    scoring="f1",
    n_jobs=-1,      # Use all CPU cores
    verbose=1,
)

grid_search.fit(X_train, y_train)
print(f"Best params: {grid_search.best_params_}")
print(f"Best F1: {grid_search.best_score_:.3f}")

# Evaluate the best model on held-out test set
best_model = grid_search.best_estimator_
print(classification_report(y_test, best_model.predict(X_test)))
```

Notasi garis bawah ganda pada `"classifier__n_estimators"` merupakan konvensi Scikit-Learn untuk mengakses parameter pada langkah pipeline yang bersarang: `classifier` adalah nama langkah pipeline, sedangkan `n_estimators` adalah parameter dari estimator di dalamnya. Pengaturan `n_jobs=-1` memanfaatkan seluruh inti CPU yang tersedia dan mempercepat proses pencarian secara signifikan -- pada grid berukuran 3x3x3 kombinasi dengan 5-fold CV, total 135 model akan dilatih.

> **Menghindari Data Leakage pada Cross-Validation**
>
> Kesalahan paling umum saat melakukan cross-validation dengan preprocessing adalah menghitung parameter skalasi pada seluruh dataset training sebelum pembagian fold dilakukan. Hal ini menghasilkan estimasi performa yang terlalu optimistis, karena data validasi secara tidak langsung mempengaruhi proses skalasi. Pipeline Scikit-Learn menyelesaikan masalah ini secara otomatis: di dalam setiap fold, seluruh langkah preprocessing hanya di-fit pada fold training yang bersangkutan.

## Menyimpan dan Memuat Model untuk Produksi

Sebuah model yang telah dilatih hanya memiliki nilai praktis jika dapat disimpan secara persisten dan dimuat kembali di lingkungan lain -- server web, proses batch, maupun microservice. Pipeline Scikit-Learn dapat diserialisasi secara lengkap: parameter preprocessing (mean dari scaler, kategori dari encoder) beserta bobot model disimpan dalam satu file tunggal. Untuk pemahaman menyeluruh mengenai [lanskap teknologi Data Science](/technologies/data-science), tersedia berbagai jalur pembelajaran yang dapat diikuti.

```python
# sklearn_export.py
import joblib
from pathlib import Path

# Save the complete pipeline (preprocessor + model)
model_dir = Path("models")
model_dir.mkdir(exist_ok=True)
joblib.dump(best_model, model_dir / "promotion_model_v1.joblib")

# Load and predict in a different process
loaded_model = joblib.load(model_dir / "promotion_model_v1.joblib")
new_data = pd.DataFrame({
    "salary": [75000],
    "experience_years": [4],
    "salary_ratio": [1.05],
    "tenure_days": [730],
    "department": ["Engineering"],
    "role_level": ["Mid"],
})

prediction = loaded_model.predict(new_data)
probability = loaded_model.predict_proba(new_data)[:, 1]
print(f"Promoted: {bool(prediction[0])}, Confidence: {probability[0]:.2%}")
```

`joblib` dioptimasi untuk array numerik dibandingkan `pickle` dan jauh lebih cepat pada model berukuran besar. Hal penting yang perlu diperhatikan: file `.joblib` menyimpan seluruh parameter scaler dan dictionary encoder -- saat dimuat di proses lain, tidak perlu lagi memproses ulang data training. Metode `predict_proba()` mengembalikan probabilitas untuk setiap kelas; slice `[:, 1]` mengekstrak probabilitas untuk kelas positif (dipromosikan), yang dalam praktiknya lebih informatif dibandingkan prediksi biner semata.

## Kesimpulan

NumPy, Pandas, dan Scikit-Learn saling melengkapi secara mulus dalam ekosistem data science Python:

- **NumPy** menyediakan operasi matriks dan array sebagai fondasi komputasi numerik -- dari aritmetika tervektorisasi hingga Boolean Indexing dan broadcasting.
- **Pandas** membangun di atas NumPy dan menghadirkan manipulasi data tabular yang fleksibel dengan kolom bernama, indeks, serta kemampuan GroupBy untuk agregasi dan feature engineering.
- **Scikit-Learn** memanfaatkan keduanya sebagai format input dan menyediakan pipeline yang menggabungkan preprocessing dan model dalam satu objek -- mencegah data leakage dan menyederhanakan deployment.
- Alur kerja yang ditunjukkan dalam artikel ini -- memuat dan membersihkan data, melakukan feature engineering, membangun pipeline, melakukan cross-validation, serta menyimpan model -- bukan sekadar konstruksi akademis, melainkan standar yang diterapkan di tim data science profesional.

Bagi yang ingin memperdalam pemahaman tentang algoritma di balik pustaka-pustaka ini, SharpSkill menyediakan latihan khusus untuk [Feature Engineering](/technologies/data-science/interview-questions/feature-engineering) dan [Supervised Classification](/technologies/data-science/interview-questions/ml-supervised-classification). Penguasaan ketiga pustaka ini membuka jalan menuju framework yang lebih kompleks seperti PyTorch atau XGBoost -- karena konvensi API mereka dibangun di atas prinsip dasar yang sama.

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/id/blog/data-science/python-data-science-numpy-pandas-scikit-learn-2026