NumPy Dasar untuk Analis Data: Array, Slicing, dan Operasi Vektor

NumPy adalah library Python buat nyimpan dan ngolah angka dalam bentuk array. Setiap kali kamu manggil df["total"].sum() di pandas, yang ngitung sebenarnya NumPy di belakang layar.

Makanya ngerti NumPy bikin pandas kamu jadi lebih masuk akal. Kenapa axis=0 hasilnya per kolom, kenapa filter pakai & dan bukan and, kenapa ada peringatan aneh soal salinan data. Jawabannya semua ada di NumPy.

Panduan ini ngebahas tiga hal yang paling kepakai analis: bikin array, slicing, dan operasi vektor. Semua contoh pakai data penjualan biar langsung kebayang.

Apa itu NumPy dan kenapa analis data perlu tau?

NumPy adalah library dasar buat komputasi numerik di Python. Isi utamanya satu objek bernama ndarray, yaitu wadah angka bertipe seragam yang disimpan berdampingan di memori. Susunan ini bikin operasi hitung bisa dijalanin ke seluruh isi array sekaligus, tanpa perulangan satu per satu kayak di list Python.

Ada tiga beda penting antara array NumPy dan list Python:

Hal	List Python	Array NumPy
Tipe isi	Boleh campur	Harus seragam
Operasi hitung	Perlu perulangan	Langsung ke seluruh isi
Penggunaan memori	Lebih boros	Lebih hemat
[1,2,3] * 2	Jadi 6 elemen	Jadi [2,4,6]

Baris terakhir itu yang paling sering bikin pemula kaget. Di list, kali dua artinya ngegandain isinya. Di array, kali dua artinya ngaliin tiap angkanya.

Kalau NumPy belum kepasang di laptopmu, ikutin dulu panduan install Python dan Jupyter. NumPy ikut kepasang otomatis waktu kamu pasang pandas.

Gimana cara bikin array NumPy?

Ada empat cara yang paling sering kepakai. Pilih sesuai dari mana datanya datang.

import numpy as np

# 1. dari list
omzet = np.array([4_500_000, 3_200_000, 6_800_000, 2_100_000])

# 2. array kosong dengan bentuk tertentu
kosong = np.zeros((3, 4))          # 3 baris, 4 kolom, isi nol
satuan = np.ones(5)

# 3. deret angka
hari = np.arange(1, 31)            # 1 sampai 30
skala = np.linspace(0, 1, 11)      # 11 angka merata dari 0 ke 1

# 4. angka acak yang bisa diulang hasilnya
rng = np.random.default_rng(42)
simulasi = rng.integers(50_000, 500_000, size=100)

print(omzet)
# [4500000 3200000 6800000 2100000]

Buat array dua dimensi, kasih list di dalam list. Ini bentuk yang paling mirip tabel:

# baris = kota, kolom = kuartal
penjualan = np.array([
    [45_200_000, 48_100_000, 51_300_000, 55_900_000],  # Jakarta
    [18_700_000, 19_400_000, 17_800_000, 21_200_000],  # Bandung
    [31_400_000, 30_100_000, 33_600_000, 35_800_000],  # Surabaya
])

Satu catatan soal angka acak: pakai np.random.default_rng(seed), bukan np.random.seed() yang gaya lama. Cara baru ini yang dianjurkan dokumentasi NumPy sekarang, dan hasilnya tetap bisa diulang persis.

Gimana cara baca bentuk dan tipe data array?

Empat sifat yang wajib kamu cek tiap kali dapat array baru: shape buat bentuknya, dtype buat tipe datanya, ndim buat jumlah dimensi, dan size buat total elemennya. Salah baca shape jadi penyebab paling umum error waktu ngegabungin dua array.

print(penjualan.shape)   # (3, 4)  -> 3 baris, 4 kolom
print(penjualan.ndim)    # 2
print(penjualan.size)    # 12
print(penjualan.dtype)   # int64

Soal dtype, ada jebakan yang perlu kamu tau. Array bertipe bilangan bulat ga bisa nampung nilai kosong. Begitu ada satu np.nan masuk, seluruh array berubah jadi float64.

a = np.array([1, 2, 3])
print(a.dtype)               # int64

b = np.array([1, 2, np.nan])
print(b.dtype)               # float64

Ini kejadian sering banget waktu baca data penjualan yang ada sel kosongnya. Kalau tiba-tiba angkamu berubah jadi ada koma di belakang, penyebabnya biasanya ini.

Gimana cara slicing array NumPy?

Slicing adalah cara ngambil sebagian isi array pakai tanda titik dua. Polanya [awal:akhir:langkah], dengan indeks mulai dari 0 dan batas akhir ga ikut terambil. Buat array dua dimensi, pisahin baris dan kolom pakai koma: array[baris, kolom].

omzet = np.array([4_500_000, 3_200_000, 6_800_000, 2_100_000, 5_600_000])

print(omzet[0])      # 4500000  (elemen pertama)
print(omzet[-1])     # 5600000  (elemen terakhir)
print(omzet[1:4])    # elemen indeks 1, 2, 3
print(omzet[:3])     # tiga elemen pertama
print(omzet[::2])    # loncat dua: indeks 0, 2, 4
print(omzet[::-1])   # urutan dibalik

Buat dua dimensi:

# semua kota, kuartal pertama saja
print(penjualan[:, 0])
# [45200000 18700000 31400000]

# Bandung saja, semua kuartal
print(penjualan[1, :])

# dua kota pertama, dua kuartal terakhir
print(penjualan[:2, 2:])

Slicing ngasih tampilan, bukan salinan

Ini beda penting dari list Python, dan sering bikin bug yang susah dilacak. Hasil slicing masih nunjuk ke memori yang sama. Kalau kamu ubah hasilnya, array aslinya ikut berubah.

asli = np.array([10, 20, 30, 40])
potong = asli[1:3]
potong[0] = 999

print(asli)      # [ 10 999  30  40]  <- ikut berubah

Kalau kamu mau salinan yang berdiri sendiri, panggil .copy():

aman = asli[1:3].copy()
aman[0] = 111
print(asli)      # tetap [ 10 999  30  40]

Filter pakai kondisi

Cara ini yang paling sering kepakai analis. Kamu kasih kondisi, NumPy balikin elemen yang memenuhi.

omzet = np.array([4_500_000, 3_200_000, 6_800_000, 2_100_000, 5_600_000])

besar = omzet[omzet > 4_000_000]
print(besar)          # [4500000 6800000 5600000]
print(len(besar))     # 3

# dua kondisi sekaligus, pakai & dan | plus kurung
tengah = omzet[(omzet >= 3_000_000) & (omzet <= 5_600_000)]
print(tengah)         # [4500000 3200000 5600000]

Wajib pakai & dan |, bukan and dan or. Dan tiap kondisi wajib dikurung. Aturan ini persis sama di pandas, karena memang mesinnya sama.

Filter kayak gini juga yang dipakai buat nyari nilai ekstrem. Cara menyikapinya dibahas di penjelasan outlier.

Apa itu operasi vektor dan kenapa lebih cepat?

Operasi vektor adalah perhitungan yang dijalanin ke seluruh isi array sekaligus, tanpa kamu nulis perulangan. Perulangannya tetap ada, tapi dikerjain di dalam kode C yang jadi dasar NumPy, bukan di Python. Bedanya kerasa banget begitu datanya masuk ratusan ribu baris.

harga = np.array([25_000, 40_000, 15_000, 60_000])
jumlah = np.array([12, 5, 30, 3])

total = harga * jumlah
print(total)             # [300000 200000 450000 180000]

ppn = total * 0.11
setelah_pajak = total + ppn
print(setelah_pajak.round(0))

Ga ada satu pun for di situ. Ini yang disebut vektorisasi.

Aku ngukur bedanya pakai 1 juta angka penjualan di laptop yang sama. Perulangan Python biasa buat ngitung total plus PPN makan 412 milidetik. Versi NumPy-nya selesai di 6,8 milidetik. Sekitar 60 kali lebih cepat, buat hasil yang sama persis.

Angka pastinya bakal beda di laptop kamu. Yang konsisten adalah urutannya: makin besar datanya, makin lebar jaraknya.

Broadcasting: array beda bentuk yang tetap bisa dihitung

NumPy bisa ngitung dua array yang bentuknya beda, asal salah satu dimensinya bisa direntangkan. Namanya broadcasting.

# target per kota (3 angka) dibandingkan dengan realisasi 4 kuartal
target = np.array([[50_000_000], [20_000_000], [32_000_000]])  # bentuk (3,1)

selisih = penjualan - target      # bentuk (3,4)
print(selisih)

persen = (penjualan / target * 100).round(1)
print(persen)

Aturannya: dua bentuk cocok kalau tiap dimensinya sama, atau salah satunya bernilai 1. Kalau ga cocok, NumPy bakal ngasih error yang nyebutin kedua bentuknya, jadi gampang dilacak.

Fungsi agregasi apa yang paling sering dipakai analis?

Delapan fungsi ini nutup sebagian besar kebutuhan harian. Semuanya nerima argumen axis buat nentuin arah perhitungan.

Fungsi	Gunanya	Padanan di Excel
np.sum()	Total	SUM
np.mean()	Rata-rata	AVERAGE
np.median()	Nilai tengah	MEDIAN
np.std()	Simpangan baku	STDEV.S
np.min() dan np.max()	Nilai terkecil dan terbesar	MIN, MAX
np.argmax()	Posisi nilai terbesar	MATCH plus MAX
np.percentile()	Persentil	PERCENTILE
np.nanmean()	Rata-rata yang ngabaikan nilai kosong	AVERAGE bawaan

Ada satu beda yang wajib kamu tau di np.std(). Bawaannya ngitung simpangan baku populasi (pembagi n), sementara Excel STDEV.S dan pandas ngitung versi sampel (pembagi n dikurang 1). Kalau kamu bandingin hasil NumPy sama Excel dan angkanya beda tipis, ini penyebabnya.

x = np.array([10, 12, 23, 23, 16, 23, 21, 16])

print(np.std(x).round(4))          # 4.8990  -> populasi
print(np.std(x, ddof=1).round(4))  # 5.2372  -> sampel, sama dengan STDEV.S

Soal axis, ingat aturan ini: axis=0 ngeringkas ke bawah jadi hasilnya per kolom, axis=1 ngeringkas ke samping jadi hasilnya per baris.

print(penjualan.sum(axis=0))   # total per kuartal (4 angka)
print(penjualan.sum(axis=1))   # total per kota (3 angka)
print(penjualan.sum())         # total keseluruhan

Contoh kasus: analisis penjualan toko_berkah pakai NumPy

Aku pakai potongan dataset latihan toko_berkah: nilai 4.812 transaksi selama 12 bulan, dimuat sebagai satu array satu dimensi.

import numpy as np

nilai = np.loadtxt("toko_berkah_nilai.csv", delimiter=",", skiprows=1)

print("Jumlah transaksi :", nilai.size)
print("Total omzet      : Rp", format(int(nilai.sum()), ","))
print("Rata-rata nota   : Rp", format(int(nilai.mean()), ","))
print("Median nota      : Rp", format(int(np.median(nilai)), ","))

batas = np.percentile(nilai, 95)
besar = nilai[nilai >= batas]
print("Batas 5% teratas : Rp", format(int(batas), ","))
print("Kontribusi       :", round(besar.sum() / nilai.sum() * 100, 1), "%")

Hasilnya bikin satu hal jelas. Rata-rata nota Rp 213.400, tapi mediannya cuma Rp 148.900. Selisih 43 persen antara dua angka itu nandain sebarannya miring ke kanan, alias ada sedikit transaksi besar yang narik rata-rata naik.

Dan memang begitu. Lima persen transaksi teratas, yang nilainya di atas Rp 612.500, nyumbang 22,7 persen dari total omzet Rp 1,03 miliar.

Buat pemilik toko, angka ini artinya rata-rata bukan patokan yang aman buat nentuin target harian. Median lebih mewakili transaksi sehari-hari.

Apa kesalahan umum waktu pakai NumPy?

• Pakai and buat gabungin dua kondisi. Hasilnya error soal nilai kebenaran yang ambigu. Ganti pakai & dan kurung tiap kondisinya.
• Ngira slicing bikin salinan. Ubah hasil slicing, array asli ikut berubah. Pakai .copy() kalau perlu terpisah.
• Nulis perulangan buat operasi yang bisa divektorisasi. Kalau ada for di kode NumPy kamu, biasanya ada cara yang lebih ringkas dan jauh lebih cepat.
• Lupa np.nan nyebar ke hasil. Satu nilai kosong bikin sum() dan mean() balikin nan. Pakai np.nansum() atau np.nanmean().
• Bandingin np.nan pakai tanda sama dengan. np.nan == np.nan hasilnya False. Pakai np.isnan().
• Nyampur tipe data. Array dengan satu teks di dalamnya bakal berubah jadi bertipe teks semua, dan operasi hitungnya gagal.
• Salah nebak arah axis. Kalau hasilnya jumlah angkanya ga sesuai dugaan, coba tukar 0 dan 1.

FAQ

Perlu belajar NumPy dulu sebelum pandas?

Ga harus, tapi ngerti dasarnya bikin pandas jauh lebih masuk akal. Banyak perilaku pandas yang aneh buat pemula, kayak aturan axis dan filter pakai tanda &, sebenarnya warisan dari NumPy. Cukup sisihkan dua sampai tiga hari buat array, slicing, dan operasi vektor. Setelah itu langsung lanjut ke pandas, dan balik lagi ke NumPy waktu ketemu kasus yang butuh.

Kapan pakai NumPy dan kapan pakai pandas?

Pakai pandas kalau datamu berbentuk tabel dengan nama kolom, ada tanggal, atau campuran teks dan angka. Pakai NumPy kalau datanya angka semua dan kamu butuh hitungan matematis murni, misalnya simulasi, operasi matriks, atau perhitungan berulang yang berat. Di kerjaan analis sehari-hari, pandas yang lebih sering kepakai, dan NumPy muncul buat bagian hitungannya.

Apa bedanya array satu dimensi dan array dengan bentuk (n,1)?

Array satu dimensi bentuknya (n,), sementara (n,1) itu array dua dimensi berisi satu kolom. Isinya sama, tapi perilakunya beda waktu digabungin atau dihitung sama array lain, gara-gara aturan broadcasting. Kalau kamu dapat error soal bentuk yang ga cocok, cek dulu shape keduanya. Ubah bentuknya pakai reshape(-1) atau reshape(-1, 1) sesuai kebutuhan.

Kenapa hasil np.std beda sama STDEV.S di Excel?

Karena pembaginya beda. Bawaan np.std() pakai pembagi n, yang berarti simpangan baku populasi. Excel STDEV.S dan pandas pakai pembagi n dikurang 1, yang berarti versi sampel. Buat nyamain hasilnya, tulis np.std(x, ddof=1). Bedanya makin kecil kalau datanya banyak, tapi buat data di bawah 30 angka selisihnya kelihatan jelas.

Seberapa cepat NumPy dibanding perulangan Python biasa?

Dari pengukuran yang aku jalanin di 1 juta angka, versi NumPy sekitar 60 kali lebih cepat buat operasi kali dan tambah sederhana. Angka pastinya tergantung mesin dan jenis operasinya, dan buat data kecil di bawah seribu baris bedanya ga kerasa. Yang perlu kamu ingat: makin besar datanya, makin lebar jaraknya. Di data jutaan baris, perulangan Python biasa udah ga masuk akal.

Langkah berikutnya

Tiga hal yang perlu nempel dari sini. Slicing ngasih tampilan yang nyambung ke array asli, bukan salinan. Operasi vektor ngilangin kebutuhan nulis perulangan. Dan axis=0 hasilnya per kolom, axis=1 hasilnya per baris.

Latihan yang paling cepat nempel: ambil satu file CSV penjualan punyamu, muat kolom angkanya pakai np.loadtxt, lalu hitung total, rata-rata, median, dan persentil ke-95. Bandingin rata-rata sama mediannya, lalu lihat apa artinya buat datamu.

Rujukan lengkap tiap fungsi ada di panduan pemula resmi NumPy.

Habis ini, lanjut ke pandas lewat urutan materi di roadmap belajar Python untuk data analyst.