Seorang analis kebijakan di Bank Indonesia baru saja menerima data inflasi bulanan Indonesia dari BPS untuk periode Januari 2014 sampai Desember 2024 — total 132 baris data, dengan kolom tahun, bulan, inflasi tahunan (yoy), inflasi bulanan (mom), dan kelompok barang ( Volatile Food, Administered Prices, Core Inflation). Ia perlu menganalisis tren, menghitung rata-rata tahunan, membandingkan kelompok, mengidentifikasi outlier, dan membuat 5 grafik untuk presentasi komite moneter besok pagi.

Di Excel, ini bisa dilakukan: Pivot Table, SUMIFS, beberapa chart. Tetapi ada masalah — datanya harus dibersihkan dulu (beberapa baris punya format teks “n.a.” untuk missing, kolom bulan kadang “Januari” kadang “January”), dan laporan akan diulang setiap bulan untuk dataset yang baru. Maka Excel mulai terasa terbatas: manual cleaning berulang, sulit mereproduksi langkah analisis, dan fitur charting terbatas untuk visualisasi kompleks.

Solusi modern untuk pekerjaan ini adalah Python dengan library Pandas dan Matplotlib. Python bukan hanya alat untuk software engineer — sejak 2008 ketika Wes McKinney merilis Pandas, Python telah menjadi standar de facto untuk analisis data di seluruh dunia, dipakai oleh data scientist di Tokopedia, Bank Mandiri, Gojek, BPS, Bappenas, dan ribuan organisasi lain. Artikel ini membangun dasar Python untuk analisis data dari nol, dengan asumsi Anda sudah familiar dengan Excel (Pivot Table, SUMIFS, charting) tetapi belum pernah coding. Studi kasus inflasi BPS akan menemani setiap langkah, sehingga Anda tidak sekadar membaca konsep tetapi melihat kode yang dapat langsung dipakai.

Catatan untuk pembaca stdsquare². Artikel ini melengkapi seri Excel toolkit (pivot-table-excel, excel-chart-panduan, vlookup-index-match). Logika analisis sama — yang berubah adalah tool. Bila Anda sudah mahir Pivot Table, transisi ke Pandas groupby akan terasa natural. Bila belum, mulailah dari Excel dulu, lalu kembali ke sini.

Mengapa Python (Bukan Excel atau R)

Excel itu hebat dan tidak akan hilang. Untuk dataset kecil (< 100.000 baris), analisis ad hoc, dan laporan yang dibagikan ke non-teknis, Excel tetap unggul. Tetapi Excel mulai terseok ketika:

  • Dataset besar (>1 juta baris): Excel mulai lambat, susah difilter, dan rentan crash.
  • Proses berulang: bila Anda harus membersihkan dataset serupa setiap bulan, mengulang klik di Excel melelahkan; di Python, satu script jalan dalam detik.
  • Reproducibility: bila dosen atau auditor bertanya “bagaimana Anda dapat angka ini?”, di Python Anda tunjukkan script yang dapat dijalankan ulang dengan output identik. Di Excel, jejak langkah sering hilang.
  • Integrasi: Python terhubung ke database (SQL), API (BPS, Bank Indonesia, Yahoo Finance), cloud storage (S3, Google Drive), dan sistem produksi.
  • Visualisasi kompleks: Python punya Seaborn, Plotly, Bokeh untuk visualisasi yang tidak mungkin di Excel chart.
  • Machine learning: scikit-learn, TensorFlow, PyTorch — semua tersedia di Python, tidak di Excel.

R adalah alternatif yang juga populer, terutama di statistika akademik. R unggul untuk uji statistik khusus dan visualisasi ggplot2 yang elegan. Pilihan antara Python dan R sering soal preferensi dan ekosistem — tetapi di industri (Tech, Finance, Consulting), Python mendominasi karena lebih general-purpose. Di riset akademik (Biostatistics, Psychology), R masih kuat. Untuk artikel ini, kita fokus Python karena lebih luas pemakaiannya.

Distribusi Python untuk analisis data

Ada beberapa cara memasang Python, masing-masing dengan trade-off:

DistribusiUkuranCocok untukKelebihanKekurangan
Anaconda~3 GBPemula, data sciencePre-bundled 1500+ package, Navigator GUI, conda env managementBesar, update lambat
Miniconda~80 MBIntermediateMinimalis, conda untuk install sesuai kebutuhanPerlu install paket manual
Python.org + pip~30 MBDeveloperStandar resmi, paling up-to-dateManual setup env
Google ColabCloud (gratis)Belajar, eksperimen cepatTidak perlu install, GPU gratis, sharing mudahButuh internet, terbatas 12 jam session

Rekomendasi stdsquare²: Untuk pemula di Indonesia, Anaconda paling mudah. Download dari anaconda.com, install seperti aplikasi biasa, dapatkan Jupyter Notebook dan Spyder IDE siap pakai. Untuk yang sudah intermediate atau memiliki komputer dengan storage terbatas, Miniconda lebih ramping.

Instalasi Step-by-Step (Anaconda di Windows)

Karena sebagian besar pembaca stdsquare² memakai Windows, berikut langkah instalasi konkret.

  1. Download Anaconda: buka anaconda.com/download, pilih Windows Python 3.12 (versi terbaru stabil 2026). File ~750 MB.
  2. Jalankan installer: klik kanan → Run as Administrator. Ikuti wizard, klik Next sampai “Install”. Tunggu 10-15 menit.
  3. Pilih “Add Anaconda to PATH”: NOT recommended oleh installer karena bisa konflik dengan Python lain. Sebagai gantinya, pakai Anaconda Prompt yang otomatis memiliki PATH benar.
  4. Buka Anaconda Prompt: dari Start Menu. Ketik python --version untuk verifikasi: harus muncul Python 3.12.x :: Anaconda, Inc.
  5. Update conda: conda update --all (memastikan paket terbaru).
  6. Install paket tambahan (opsional): conda install -c conda-forge seaborn plotly scikit-learn.
  7. Buka Jupyter Notebook: ketik jupyter notebook di Anaconda Prompt. Browser akan terbuka ke localhost:8888 dengan file manager.
  8. Buat notebook baru: klik New → Python 3 (ipykernel). Notebook terbuka dengan cell kosong.

Untuk pengguna Mac/Linux, proses serupa —Anaconda tersedia untuk semua platform. Atau pakai Homebrew (Mac) atau apt (Ubuntu) untuk instalasi via package manager sistem.

Verifikasi instalasi

Di cell pertama Jupyter, ketik kode berikut dan tekan Shift+Enter:

import sys
print("Python version:", sys.version)

import pandas as pd
print("Pandas version:", pd.__version__)

import numpy as np
print("NumPy version:", np.__version__)

import matplotlib
print("Matplotlib version:", matplotlib.__version__)

import seaborn as sns
print("Seaborn version:", sns.__version__)

Output yang diharapkan:

Python version: 3.12.7 | packaged by Anaconda...
Pandas version: 2.2.1
NumPy version: 1.26.4
Matplotlib version: 3.8.4
Seaborn version: 0.13.2

Bila semua import berhasil tanpa error, instalasi Anda siap. Selamat, Anda sekarang punya Python environment untuk analisis data profesional.

Dasar Python (10 Menit)

Sebelum loncat ke Pandas, mari pahami dasar Python. Bila Anda sudah pernah coding (bahasa apa pun), skip bagian ini.

Variabel dan tipe data

# Variabel dan tipe dasar
nama = "Budi"               # string (str)
umur = 25                   # integer (int)
berat = 65.5                # float
is_mahasiswa = True         # boolean (bool)

print(f"Nama: {nama}, Umur: {umur}, Berat: {berat}kg")
# Output: Nama: Budi, Umur: 25, Berat: 65.5kg

F-string (f"...") adalah cara modern untuk menyisipkan variabel ke string — sangat berguna.

List dan dictionary

# List: kumpulan terurut
buah = ["apel", "mangga", "jeruk", "pisang"]
print(buah[0])      # "apel" (indexing dari 0)
print(buah[-1])     # "pisang" (indexing dari belakang)
print(len(buah))    # 4

# Dictionary: pasangan key-value
mahasiswa = {
    "nama": "Andi",
    "npm": "22012345",
    "prodi": "Manajemen",
    "ipk": 3.75
}
print(mahasiswa["nama"])   # "Andi"
print(mahasiswa.get("ipk")) # 3.75

List dan dictionary adalah struktur data fundamental. Pandas DataFrame yang akan kita pakai dibangun di atas dictionary of lists.

Loop dan conditional

# For loop
total = 0
for i in range(1, 6):  # 1, 2, 3, 4, 5
    total += i
print(total)  # 15

# If-elif-else
nilai = 78
if nilai >= 85:
    grade = "A"
elif nilai >= 75:
    grade = "B"
elif nilai >= 65:
    grade = "C"
else:
    grade = "D"
print(f"Grade: {grade}")  # "B"

Function

def hitung_bmi(berat, tinggi):
    """Hitung Body Mass Index."""
    return berat / (tinggi ** 2)

bmi = hitung_bmi(65.5, 1.70)
print(f"BMI: {bmi:.2f}")  # "BMI: 22.66"

Itulah dasar Python yang perlu Anda tahu untuk analisis data. Sisanya akan dipelajari sambil memakai Pandas.

Pandas: DataFrame dan Operasi Dasar

Pandas adalah library Python untuk manipulasi data tabular — bayangkan Excel spreadsheet, tetapi di kode. Dua struktur utama:

  • Series: satu kolom data (1-dimensional).
  • DataFrame: tabel multi-kolom (2-dimensional), mirip sheet Excel.

Memuat data

Untuk studi kasus, mari buat dataset inflasi BPS simulasi (di praktik nyata, unduh dari bps.go.id). Kode berikut memuat CSV:

import pandas as pd

# Load dari CSV
df = pd.read_csv("inflasi_bps_2014_2024.csv")

# Atau dari Excel
df = pd.read_excel("inflasi_bps_2014_2024.xlsx", sheet_name="data")

# Lihat 5 baris pertama
print(df.head())

# Lihat 5 baris terakhir
print(df.tail())

# Informasi struktur
print(df.info())

Output df.head() nampak seperti:

   tahun     bulan  kelompok              inflasi_yoy  inflasi_mom
0  2014   Januari  Core Inflation              4.53         0.82
1  2014   Januari  Volatile Food               7.12         2.15
2  2014   Januari  Administered Prices         5.89         1.45
3  2014  Februari  Core Inflation              4.71         0.45
4  2014  Februari  Volatile Food               6.85         0.92

Sekarang kita punya DataFrame df dengan 132 baris (11 tahun × 12 bulan × 3 kelompok). Mari kita eksplorasi.

Struktur DataFrame

# Ukuran DataFrame: (baris, kolom)
print(df.shape)  # (132, 5)

# Nama kolom
print(df.columns)
# Index(['tahun', 'bulan', 'kelompok', 'inflasi_yoy', 'inflasi_mom'], dtype='object')

# Tipe data tiap kolom
print(df.dtypes)
# tahun              int64
# bulan             object
# kelompok          object
# inflasi_yoy      float64
# inflasi_mom      float64

Sesekali, df.shape mengikuti konvensi matriks $(n_{\text{rows}}, n_{\text{cols}})$. Bila kita perlukan ukuran populasi sampel:

$$\boxed{n = \text{df.shape[0]}, \quad k = \text{df.shape[1]}}$$

Statistik deskriptif cepat

# Statistik untuk kolom numerik
print(df.describe())

Output:

           tahun  inflasi_yoy  inflasi_mom
count   132.000      130.000      130.000
mean   2019.000        4.210        0.350
std       3.317        1.840        0.520
min    2014.000        1.320       -0.850
25%    2016.000        3.180        0.080
50%    2019.000        3.920        0.280
75%    2022.000        4.940        0.580
max    2024.000        8.750        2.150

Hanya dengan describe(), kita dapat count, mean, std, min, kuartil, max — setara dengan tabel pivot Excel. Perhatikan count 130 (bukan 132), yang berarti ada 2 missing values di kolom inflasi_yoy dan inflasi_mom.

Cleaning Data: Missing, Duplikasi, Tipe

Data dunia nyata selalu kotor. Mari kita bersihkan.

Identifikasi missing values

# Hitung missing per kolom
print(df.isnull().sum())

# Persentase missing
missing_rate = df.isnull().sum() / len(df)
print(missing_rate)

Formula missing rate:

$$\boxed{\text{Missing rate}_j = \frac{\text{jumlah null pada kolom } j}{n}}$$

Output:

tahun            0
bulan            0
kelompok         0
inflasi_yoy      2
inflasi_mom      2
dtype: int64

Missing rate kolom inflasi $\approx 1{,}5\%$ — kecil, tetap perlu ditangani.

Strategi penanganan missing

Opsi 1 — Drop baris dengan missing (cocok bila missing sedikit):

df_clean = df.dropna(subset=["inflasi_yoy", "inflasi_mom"])
print(df_clean.shape)  # (130, 5) — 2 baris dihapus

Opsi 2 — Fill dengan mean/median (imputasi sederhana):

median_yoy = df["inflasi_yoy"].median()
df["inflasi_yoy_filled"] = df["inflasi_yoy"].fillna(median_yoy)

Opsi 3 — Interpolasi (untuk data time series):

df["inflasi_yoy_interp"] = df["inflasi_yoy"].interpolate(method="linear")

Untuk data inflasi BPS yang berurutan waktu, interpolasi paling masuk akal. Untuk cross-sectional (misal data UMKM berbeda entitas), drop atau median lebih tepat.

Menghapus duplikasi

# Cek duplikasi
print(df.duplicated().sum())  # jumlah baris duplikat

# Hapus duplikasi (keep first)
df = df.drop_duplicates()

Mengoreksi tipe data

Salah satu masalah umum: kolom yang seharusnya datetime terbaca sebagai string. Atau kolom kategori sebagai object.

# Konversi tahun-bulan ke datetime
df["tanggal"] = pd.to_datetime(df["tahun"].astype(str) + "-" + df["bulan"], 
                                format="%Y-%B")

# Konversi kelompok ke category (hemat memory)
df["kelompok"] = df["kelompok"].astype("category")

print(df.dtypes)

Konversi ke category penting bila kolom punya sedikit nilai unik (3 kelompok × 132 baris) — hemat memori sampai 90%.

Standarisasi teks

# Standarisasi nama bulan ke English (untuk kompatibilitas datetime)
bulan_map = {
    "Januari": "January", "Februari": "February", "Maret": "March",
    "April": "April", "Mei": "May", "Juni": "June",
    "Juli": "July", "Agustus": "August", "September": "September",
    "Oktober": "October", "November": "November", "Desember": "December"
}
df["bulan_en"] = df["bulan"].map(bulan_map)

# Buat datetime column
df["tanggal"] = pd.to_datetime(df["tahun"].astype(str) + "-" + df["bulan_en"],
                                format="%Y-%B")

Sekarang kolom tanggal adalah tipe datetime64[ns], yang memungkinkan operasi time series.

Eksplorasi Data: Filter, Group, Pivot

Setelah data bersih, saatnya eksplorasi. Di sinilah Pandas menyerupai Pivot Table Excel, tetapi dengan fleksibilitas lebih.

Filter (setara AutoFilter Excel)

# Filter baris dengan kondisi
df_2024 = df[df["tahun"] == 2024]
print(df_2024.shape)  # (36, 7) — 12 bulan × 3 kelompok

# Multiple conditions
df_core_2020_2024 = df[(df["kelompok"] == "Core Inflation") & 
                        (df["tahun"].between(2020, 2024))]

Operator logika di Pandas: & (AND), | (OR), ~ (NOT). Selalu bungkus kondisi dalam tanda kurung.

Select kolom

# Pilih kolom tertentu
df_kecil = df[["tahun", "bulan", "inflasi_yoy"]]

# Drop kolom
df = df.drop(columns=["bulan_en"])

# Select berdasarkan tipe
numeric_cols = df.select_dtypes(include=["number"]).columns

Groupby: agregasi per kategori (setara Pivot Table)

Groupby adalah operasi paling powerful di Pandas. Konsepnya: split-apply-combine.

# Rata-rata inflasi_yoy per kelompok
mean_by_kelompok = df.groupby("kelompok")["inflasi_yoy"].mean()
print(mean_by_kelompok)

Output:

kelompok
Administered Prices    4.85
Core Inflation         3.42
Volatile Food          5.18
Name: inflasi_yoy, dtype: float64

Hanya satu baris kode! Setara dengan Pivot Table di Excel: Rows = kelompok, Values = Average of inflasi_yoy.

# Multiple aggregations
agg_stats = df.groupby("kelompok")["inflasi_yoy"].agg(
    ["count", "mean", "std", "min", "max", "median"]
)
print(agg_stats)

Output:

                     count  mean  std  min  max  median
kelompok
Administered Prices    44  4.85 2.15 1.32 8.75    4.62
Core Inflation         44  3.42 0.65 2.15 5.10    3.35
Volatile Food          44  5.18 2.45 0.85 11.20   4.95

Groupby bisa multi-level:

# Rata-rata per tahun dan kelompok
mean_yearly = df.groupby(["tahun", "kelompok"])["inflasi_yoy"].mean()
print(mean_yearly)

Hasilnya MultiIndex Series, yang bisa di-unstack ke DataFrame:

mean_yearly_df = mean_yearly.unstack(level="kelompok")
print(mean_yearly_df.head())

Output:

kelompok  Administered Prices  Core Inflation  Volatile Food
tahun
2014                       6.85            4.42           6.95
2015                       4.12            4.21           5.45
2016                       3.15            3.45           3.85
2017                       2.95            3.80           3.95
2018                       3.50            2.95           3.20

Sekarang kita punya tabel rapi: tahun di baris, kelompok di kolom, rata-rata inflasi di sel. Setara Pivot Table Excel dengan Rows = tahun, Columns = kelompok, Values = Average inflasi_yoy.

Pivot table eksplisit

Pandas punya fungsi pivot_table yang lebih fleksibel dari groupby:

pivot = df.pivot_table(
    values="inflasi_yoy",
    index="tahun",
    columns="kelompok",
    aggfunc="mean",
    margins=True,        # tambah baris/kolom "All" (grand total)
    margins_name="Rata-rata"
)
print(pivot)

Crosstab (frequency table)

Untuk data kategorikal:

# Frekuensi kombinasi tahun × kelompok
crosstab = pd.crosstab(df["tahun"], df["kelompok"])
print(crosstab)

Setara COUNTIFS di Excel.

Merge dan join (setara VLOOKUP)

Bila Anda punya dua dataset yang ingin digabung:

# Dataset utama
df_inflasi = pd.read_csv("inflasi_bps.csv")

# Dataset lookup: kode kelompok ke kategori besar
df_kategori = pd.DataFrame({
    "kelompok": ["Core Inflation", "Volatile Food", "Administered Prices"],
    "kategori_besar": ["Inti", "Pangan", "Harga Admin"]
})

# Left join
df_merged = df_inflasi.merge(df_kategori, on="kelompok", how="left")
print(df_merged.head())

Hasilnya DataFrame baru dengan kolom kategori_besar yang ditambahkan. Setara VLOOKUP di Excel, tetapi jauh lebih cepat untuk dataset besar.

Matplotlib: Visualisasi Dasar

Matplotlib adalah library plotting standar Python — fleksibel, dapat dikustomisasi penuh, tetapi syntax-nya verbose. Seaborn adalah layer di atas Matplotlib yang menambahkan tema lebih cantik dan fungsi statistical plotting.

Setup dan line chart

import matplotlib.pyplot as plt
import seaborn as sns

# Set style
sns.set_theme(style="whitegrid", palette="muted")
plt.rcParams["figure.figsize"] = (10, 6)
plt.rcParams["font.size"] = 11

# Filter data Core Inflation untuk line chart
df_core = df[df["kelompok"] == "Core Inflation"].sort_values("tanggal")

# Line chart
plt.figure()
plt.plot(df_core["tanggal"], df_core["inflasi_yoy"], 
         color="steelblue", linewidth=2, marker="o", markersize=4)

plt.title("Inflasi Inti (Core Inflation) Indonesia 2014-2024", 
          fontsize=14, fontweight="bold")
plt.xlabel("Tahun")
plt.ylabel("Inflasi YoY (%)")
plt.grid(True, alpha=0.3)

# Format sumbu x
plt.gcf().autofmt_xdate()

plt.tight_layout()
plt.savefig("inflasi_core_line.png", dpi=300, bbox_inches="tight")
plt.show()

Beberapa elemen kunci:

  • plt.figure() buat kanvas baru.
  • plt.plot() gambar garis. Argumen marker menambahkan titik di setiap observasi.
  • plt.title(), plt.xlabel(), plt.ylabel() menambahkan label.
  • plt.grid(True) menyalakan grid.
  • plt.tight_layout() mencegah label terpotong.
  • plt.savefig() simpan ke file (PNG, PDF, SVG). dpi=300 untuk kualitas publikasi.
  • plt.show() tampilkan di layar.

Bar chart

# Rata-rata per kelompok
mean_by_kel = df.groupby("kelompok")["inflasi_yoy"].mean().sort_values()

plt.figure()
mean_by_kel.plot(kind="barh", color=["steelblue", "coral", "seagreen"])

plt.title("Rata-rata Inflasi YoY per Kelompok Barang (2014-2024)")
plt.xlabel("Rata-rata Inflasi YoY (%)")
plt.ylabel("Kelompok")

# Tambah nilai di ujung bar
for i, v in enumerate(mean_by_kel):
    plt.text(v + 0.05, i, f"{v:.2f}%", va="center")

plt.tight_layout()
plt.savefig("inflasi_by_kelompok_bar.png", dpi=300)
plt.show()

Histogram dan density

plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.hist(df["inflasi_yoy"].dropna(), bins=20, color="steelblue", 
         edgecolor="white", alpha=0.8)
plt.title("Distribusi Inflasi YoY (Histogram)")
plt.xlabel("Inflasi YoY (%)")
plt.ylabel("Frekuensi")

plt.subplot(1, 2, 2)
sns.kdeplot(data=df, x="inflasi_yoy", hue="kelompok", fill=True, alpha=0.5)
plt.title("Distribusi Inflasi YoY per Kelompok (KDE)")
plt.xlabel("Inflasi YoY (%)")

plt.tight_layout()
plt.savefig("inflasi_distribution.png", dpi=300)
plt.show()

plt.subplot(1, 2, 1) membuat grid 1 baris × 2 kolom, dan kita pilih panel ke-1. Ini cara membuat multi-panel figure.

Scatter plot

# Scatter: inflasi mom vs yoy
plt.figure()
sns.scatterplot(data=df, x="inflasi_mom", y="inflasi_yoy", 
                hue="kelompok", style="kelompok", s=60, alpha=0.7)

plt.title("Hubungan Inflasi MoM dan YoY")
plt.xlabel("Inflasi MoM (%)")
plt.ylabel("Inflasi YoY (%)")
plt.axhline(0, color="gray", linestyle="--", alpha=0.5)
plt.axvline(0, color="gray", linestyle="--", alpha=0.5)

plt.tight_layout()
plt.savefig("inflasi_scatter.png", dpi=300)
plt.show()

Boxplot per kategori

plt.figure()
sns.boxplot(data=df, x="kelompok", y="inflasi_yoy", 
            palette="Set2")

# Overlay stripplot untuk lihat observasi individual
sns.stripplot(data=df, x="kelompok", y="inflasi_yoy", 
              color="black", alpha=0.4, size=3)

plt.title("Sebaran Inflasi YoY per Kelompok (Boxplot + Observasi)")
plt.xlabel("Kelompok")
plt.ylabel("Inflasi YoY (%)")

plt.tight_layout()
plt.savefig("inflasi_boxplot.png", dpi=300)
plt.show()

Boxplot menunjukkan median, kuartil, dan outlier. Stripplot overlay menambah observasi individual sehingga terlihat distribusi sebenarnya.

Heatmap korelasi

# Hitung korelasi
corr_matrix = df[["inflasi_yoy", "inflasi_mom", "tahun"]].corr()
print(corr_matrix)

Korelasi Pearson formula:

$$\boxed{r_{xy} = \frac{\sum (x_i - \bar{x})(y_i - \bar{y})}{\sqrt{\sum (x_i - \bar{x})^2 \cdot \sum (y_i - \bar{y})^2}}}$$
# Visualisasi
plt.figure(figsize=(6, 5))
sns.heatmap(corr_matrix, annot=True, cmap="RdBu_r", center=0,
            vmin=-1, vmax=1, fmt=".2f", square=True)

plt.title("Heatmap Korelasi Variabel Inflasi")
plt.tight_layout()
plt.savefig("inflasi_corr_heatmap.png", dpi=300)
plt.show()

Facet grid (multi-panel per kategori)

g = sns.FacetGrid(df, col="kelompok", height=4, aspect=1.5)
g.map_dataframe(sns.lineplot, x="tanggal", y="inflasi_yoy", color="steelblue")
g.set_axis_labels("Tahun", "Inflasi YoY (%)")
g.set_titles("{col_name}")
g.figure.suptitle("Tren Inflasi per Kelompok (2014-2024)", y=1.03, 
                   fontweight="bold")

plt.savefig("inflasi_facet.png", dpi=300, bbox_inches="tight")
plt.show()

Facet grid membuat tiga panel terpisah, satu per kelompok, dengan skala sama — ideal untuk komparasi tren.

Workflow Reproduksibilitas: Script dan Environment

Salah satu kekuatan Python vs Excel adalah reproducibility — kemampuan menjalankan ulang analisis dengan output identik. Untuk mencapainya, ada beberapa praktik.

Pisahkan notebook dan script

  • Notebook (.ipynb): untuk eksplorasi, dokumentasi, presentasi.
  • Script (.py): untuk produksi, reusable function, deployment.

Konversi notebook ke script:

jupyter nbconvert --to script analysis.ipynb

Environment file

Untuk memastikan orang lain (atau Anda di masa depan) dapat menjalankan kode dengan versi paket yang sama:

# Buat file requirements.txt dari environment aktif
pip freeze > requirements.txt

# Atau dengan conda
conda env export > environment.yml

Untuk re-create environment di komputer lain:

pip install -r requirements.txt
# atau
conda env create -f environment.yml

Struktur proyek

inflasi-analysis/
├── data/
│   ├── raw/              # data mentah dari BPS
│   └── processed/        # data cleaned
├── notebooks/
│   ├── 01_cleaning.ipynb
│   ├── 02_eda.ipynb
│   └── 03_visualization.ipynb
├── src/
│   ├── cleaning.py
│   └── plots.py
├── output/
│   ├── figures/
│   └── tables/
├── requirements.txt
└── README.md

Struktur ini mengikuti konvensi Cookiecutter Data Science — standar industri.

Version control dengan Git

# Inisialisasi repo
git init

# Tambah .gitignore
echo "data/raw/\nvenv/\n__pycache__/\n.ipynb_checkpoints/" > .gitignore

# Commit pertama
git add .
git commit -m "Initial commit: inflasi analysis 2014-2024"

# Push ke GitHub (bila ada remote)
git remote add origin https://github.com/username/inflasi-analysis.git
git push -u origin main

Sekarang seluruh analisis Anda versi-terkontrol, dapat di-share, dan reproducible. Ini adalah praktik yang dipakai di reproducible research (lihat replication-package-aea).

Studi Kasus Lengkap: Inflasi BPS 2014-2024

Mari gabungkan semua yang kita pelajari ke analisis end-to-end.

"""
Analisis Inflasi BPS Indonesia 2014-2024
Author: Analis stdsquare²
Date: 2026-07-17
"""

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

sns.set_theme(style="whitegrid")
plt.rcParams["figure.figsize"] = (10, 6)
plt.rcParams["font.size"] = 11

# === Langkah 1: Load data ===
df = pd.read_csv("data/raw/inflasi_bps_2014_2024.csv")
print(f"Data loaded: {df.shape[0]} baris, {df.shape[1]} kolom")

# === Langkah 2: Cleaning ===
# Standarisasi nama bulan
bulan_map = {"Januari": "January", "Februari": "February", "Maret": "March",
             "April": "April", "Mei": "May", "Juni": "June",
             "Juli": "July", "Agustus": "August", "September": "September",
             "Oktober": "October", "November": "November", "Desember": "December"}
df["bulan_en"] = df["bulan"].map(bulan_map)

# Buat datetime
df["tanggal"] = pd.to_datetime(df["tahun"].astype(str) + "-" + df["bulan_en"],
                                format="%Y-%B")

# Interpolasi missing values
df["inflasi_yoy"] = df["inflasi_yoy"].interpolate(method="linear")
df["inflasi_mom"] = df["inflasi_mom"].interpolate(method="linear")

# Konversi kelompok ke category
df["kelompok"] = df["kelompok"].astype("category")

print(f"After cleaning: {df.shape[0]} baris")

# === Langkah 3: Eksplorasi ===
print("\n=== Statistik Deskriptif ===")
print(df.groupby("kelompok")["inflasi_yoy"].describe())

# Identifikasi outlier (z-score > 3)
df["z_yoy"] = (df["inflasi_yoy"] - df["inflasi_yoy"].mean()) / df["inflasi_yoy"].std()
outliers = df[np.abs(df["z_yoy"]) > 3]
print(f"\nOutlier (|z| > 3): {len(outliers)} observasi")
if len(outliers) > 0:
    print(outliers[["tanggal", "kelompok", "inflasi_yoy"]])

# === Langkah 4: Agregasi tahunan ===
yearly = df.groupby(["tahun", "kelompok"])["inflasi_yoy"].mean().unstack()
print("\n=== Rata-rata Inflasi Tahunan (%) ===")
print(yearly.round(2))

# === Langkah 5: Visualisasi ===
# Plot 1: Line chart per kelompok
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# Subplot 1: Tren time series
ax1 = axes[0, 0]
for kelompok in df["kelompok"].unique():
    data = df[df["kelompok"] == kelompok].sort_values("tanggal")
    ax1.plot(data["tanggal"], data["inflasi_yoy"], label=kelompok, linewidth=1.5)
ax1.set_title("Tren Inflasi YoY per Kelompok (2014-2024)")
ax1.set_xlabel("Tahun"); ax1.set_ylabel("Inflasi YoY (%)")
ax1.legend(); ax1.grid(True, alpha=0.3)

# Subplot 2: Bar chart rata-rata per kelompok
ax2 = axes[0, 1]
mean_kel = df.groupby("kelompok")["inflasi_yoy"].mean().sort_values()
mean_kel.plot(kind="barh", ax=ax2, color="steelblue")
ax2.set_title("Rata-rata Inflasi per Kelompok")
ax2.set_xlabel("Rata-rata YoY (%)")

# Subplot 3: Boxplot
ax3 = axes[1, 0]
sns.boxplot(data=df, x="kelompok", y="inflasi_yoy", ax=ax3, palette="Set2")
ax3.set_title("Distribusi Inflasi per Kelompok")
ax3.set_xlabel("Kelompok"); ax3.set_ylabel("Inflasi YoY (%)")
ax3.tick_params(axis='x', rotation=15)

# Subplot 4: Heatmap korelasi
ax4 = axes[1, 1]
corr = df[["inflasi_yoy", "inflasi_mom", "tahun"]].corr()
sns.heatmap(corr, annot=True, cmap="RdBu_r", center=0, ax=ax4, 
            vmin=-1, vmax=1, fmt=".2f", square=True)
ax4.set_title("Korelasi Variabel")

plt.suptitle("Analisis Komprehensif Inflasi BPS Indonesia 2014-2024", 
             fontsize=14, fontweight="bold", y=1.00)
plt.tight_layout()
plt.savefig("output/figures/inflasi_dashboard.png", dpi=300, bbox_inches="tight")
plt.show()

# === Langkah 6: Save hasil agregasi ===
yearly.to_csv("output/tables/inflasi_tahunan.csv")
print("\nHasil disimpan ke output/tables/inflasi_tahunan.csv")

Satu script, satu dashboard, satu tabel agregasi. Setiap bulan, ganti CSV di data/raw/, jalankan ulang script, semua output diperbarui. Bandingkan dengan mengulang manual di Excel!

Tips Performa dan Best Practices

1. Vektorisasi, bukan loop

Hindari for loop pada DataFrame besar. Pakai operasi vektor:

# LAMBAT (loop)
for i in range(len(df)):
    df.loc[i, "kategori"] = "Tinggi" if df.loc[i, "inflasi_yoy"] > 5 else "Normal"

# CEPAT (vektorisasi)
df["kategori"] = np.where(df["inflasi_yoy"] > 5, "Tinggi", "Normal")

Untuk kondisi kompleks, pakai np.select() atau pd.cut() untuk binning.

2. Pakai dtype yang tepat

# Konversi int64 ke int32 (hemat 50% memory)
df["tahun"] = df["tahun"].astype("int32")

# Konversi float64 ke float32 untuk presisi cukup
df["inflasi_yoy"] = df["inflasi_yoy"].astype("float32")

# Konversi string kategorikal ke category
df["kelompok"] = df["kelompok"].astype("category")

Untuk dataset besar (>1 juta baris), penghematan memory bisa 5-10×.

3. Chunking untuk file besar

# Baca CSV besar per chunk
chunk_size = 100_000
for chunk in pd.read_csv("big_file.csv", chunksize=chunk_size):
    process(chunk)  # proses per chunk

4. Profile dan optimasi

%load_ext line_profiler

def my_function():
    # ... kode
    pass

%lprun -f my_function my_function()

line_profiler menunjukkan baris mana yang lambat.

Sumber Belajar Lanjutan

  • Buku: Python for Data Analysis oleh Wes McKinney (pencipta Pandas) — referensi definitif.
  • Buku: Python Data Science Handbook oleh Jake VanderPlas — gratis online.
  • Kursus online: Coursera “Data Science Professional Certificate” oleh University of Michigan; DataCamp “Pandas Foundations”; freeCodeCamp.
  • Komunitas Indonesia: PyData Jakarta, PyData Bandung; telegram group “Python Indonesia”.
  • Dataset latihan: BPS (bps.go.id), Kaggle datasets Indonesia, Google Dataset Search.

Jebakan Umum Pemula

1. Indexing chaining. Hindari df[col1][col2] = ... — gunakan .loc[]:

# SALAH (SettingWithCopyWarning)
df[df["tahun"] == 2024]["inflasi_yoy"] = 0

# BENAR
df.loc[df["tahun"] == 2024, "inflasi_yoy"] = 0

2. Mengabaikan copy vs view. Setelah filter, kadang dapat view (referensi), kadang copy. Untuk aman, pakai .copy():

df_2024 = df[df["tahun"] == 2024].copy()

3. Tidak cek dtype setelah load. CSV kadang membaca kolom numerik sebagai string (karena ada karakter “n.a.”). Selalu cek df.dtypes dan konversi.

4. Lupa inplace=True. Banyak fungsi Pandas return DataFrame baru, tidak modifikasi asli. Pilih: df = df.drop(...) atau df.drop(..., inplace=True).

5. Plot default jelek. Default Matplotlib kadang terlihat dated. Pakai sns.set_theme() untuk tampilan modern.

6. Tidak reproducible. Random seed belum diset → hasil random beda tiap run. Untuk ML: np.random.seed(42).

Penutup

Python dengan Pandas dan Matplotlib membuka pintu ke analisis data profesional — dari yang sederhana seperti menghitung rata-rata inflasi, sampai machine learning prediktif dan big data. Bagi mahasiswa, dosen, analis, dan peneliti di Indonesia, kemampuan ini semakin menjadi keterampilan wajib di 2026 — bersanding dengan Excel, bukan menggantikannya.

Empat pesan kunci:

  1. Mulai dari Jupyter Notebook. Iteraktif, mudah belajar, dokumentasi otomatis.
  2. Pahami logika, bukan hafal syntax. Setiap fungsi Pandas punya padanan di Excel — bila bingung, pikirkan “apa yang saya lakukan di Excel?” lalu cari padanan Pandas.
  3. Reproducibility adalah kekuatan. Script yang dapat dijalankan ulang dengan output identik adalah standar riset modern.
  4. Visualisasi = komunikasi. Plot yang baik menceritakan kisah; plot yang buruk menyembunyikan temuan. Invest waktu di Seaborn.

Notebook Jupyter template dengan kode lengkap studi kasus inflasi BPS tersedia di workbook stdsquare² pendamping. Cukup ganti path file CSV dengan dataset Anda sendiri — penjualan UMKM, data nilai mahasiswa, transaksi e-commerce, cuaca harian — dan seluruh analisis dapat diadaptasi. Selamat mempelajari Python, alat yang akan membuka banyak pintu.