Kapan NumPy Bukan Pilihan Terbaik

Sejauh ini bab-bab section ini membantu NumPy bekerja makin cepat. Bab ini justru berisi kemampuan yang sama pentingnya: mengenali situasi ketika NumPy bukan alat yang paling pas, sehingga keputusan arsitektur tidak terpaku pada satu pustaka. NumPy dirancang untuk blok angka homogen yang dihitung sekaligus; di luar profil itu, keunggulannya menipis.

Empat situasi yang paling sering muncul: data terlalu kecil, beban kerja didominasi string, data datang bertahap, dan data heterogen ala tabel. Kita bahas satu per satu, lengkap dengan alternatif yang lebih sehat.

Data Kecil dengan Logika Python #

Membuat array, menjalankan ufunc, dan membaca hasilnya semuanya berbiaya tetap. Untuk sepuluh elemen, biaya tetap itu lebih besar daripada pekerjaannya:

# notest
import numpy as np
import timeit

data_kecil = list(range(10))
arr = np.array(data_kecil)

def dengan_list():
    return [x * 2 for x in data_kecil]

def dengan_numpy():
    return arr * 2

t_list = min(timeit.repeat(dengan_list, number=10_000, repeat=5)) / 10_000
t_np = min(timeit.repeat(dengan_numpy, number=10_000, repeat=5)) / 10_000
print(f"list comprehension : {t_list * 1_000_000:.2f} mikrodetik")
print(f"NumPy              : {t_np * 1_000_000:.2f} mikrodetik")

Output yang Dihasilkan:

# (ilustrasi — angka waktu berbeda di tiap komputer)
list comprehension : 0.35 mikrodetik
NumPy              : 0.55 mikrodetik

Angkanya ilustratif dan berbeda di tiap komputer, tetapi polanya konsisten: pada puluhan elemen, list Python biasanya lebih cepat karena arr * 2 harus membayar biaya mesin array untuk hasil yang hanya berisi sepuluh angka. Pedoman kasarnya: di bawah sekitar seribu elemen, tulis kode Python biasa yang paling mudah dibaca; baru pindah ke NumPy ketika data membesar. Latar pembandingannya diuraikan pada Chapter NumPy vs Python List dan Kapan Menggunakan NumPy.

Beban Kerja yang Dominan String #

Array NumPy menyimpan string sebagai teks lebar tetap (fixed-width) — <U5 berarti setiap elemen mendapat ruang lima karakter Unicode, dan string lebih panjang terpangkas saat dibuat. Operasi teks tersedia lewat modul np.char, tetapi ia tetap bekerja elemen demi elemen tanpa kecepatan khas ufunc numerik:

import numpy as np

nama = np.array(["Budi", "Ani", "Citra", "Budi"])
print("dtype :", nama.dtype)
print(np.char.upper(nama))

Output yang Dihasilkan:

dtype : <U5
['BUDI' 'ANI' 'CITRA' 'BUDI']

Cara membacanya:

1. Baris 3 (nama.dtype): lebar <U5 diambil dari string terpanjang, "Citra" — inilah sebabnya dtype string bergantung isi data.
2. Baris 4 (np.char.upper): hasilnya benar, tetapi di balik layar setiap elemen diproses dengan method string Python; tidak ada sapuan byte seperti pada ufunc numerik.

Ketika pekerjaan utama adalah pencarian teks, pemisahan kolom, atau pattern matching, str Python biasa atau pandas memberi perkakas yang jauh lebih lengkap dengan performa yang setara atau lebih baik. Perbandingan penyimpanan teks dibahas pada Chapter Tipe Data String dan Object.

Data yang Datang Bertahap #

Array NumPy berukuran tetap: menambah elemen berarti membuat array baru dan menyalin seluruh isi — np.append bukan operasi murah. Untuk aliran data yang tidak diketahui panjangnya, pola yang tepat bukan “menumbuhkan array”, melainkan mengakumulasi ringkasan secara bertahap:

import numpy as np

total = 0.0
jumlah = 0
for batch in (np.array([10, 20, 30]), np.array([40, 50]), np.array([60, 70, 80, 90])):
    total += batch.sum()
    jumlah += batch.size
rata_streaming = total / jumlah

semua = np.array([10, 20, 30, 40, 50, 60, 70, 80, 90])
print("rata streaming    :", rata_streaming)
print("rata sekali hitung:", semua.mean())
print("sama              :", rata_streaming == semua.mean())

Output yang Dihasilkan:

rata streaming    : 50.0
rata sekali hitung: 50.0
sama              : True

1. Baris 4-7: setiap batch dijumlahkan segera; hanya dua angka kecil — total dan jumlah — yang disimpan, berapa pun panjang alirannya.
2. Baris 9-10: hasil bertahap cocok persis dengan perhitungan sekali jalan untuk data ini; untuk float yang panjang, gunakan np.allclose sebagai pembanding (Chapter Floating Point Comparison).
3. Konsekuensi: bila data memang harus utuh di memori dan berukuran raksasa, pertimbangkan np.load dengan mmap_mode seperti pada Chapter Memory-mapped Array, atau pemrosesan per chunk pada Chapter Mengurangi Penggunaan Memori.

Data Heterogen ala Tabel #

Kolom nama, harga, dan stok bisa dipadatkan ke structured array, tetapi perilakunya kaku: lebar string terkunci, penambahan kolom berarti membuat array baru, dan sintaksnya lebih verbose daripada tabel sejati:

import numpy as np

stok = np.zeros(2, dtype=[("nama", "U10"), ("harga", "i4"), ("jumlah", "i4")])
stok["nama"] = ["Buku", "Pulpen"]
stok["harga"] = [45000, 5000]
stok["jumlah"] = [12, 100]
print(stok)
print("total nilai:", (stok["harga"] * stok["jumlah"]).sum())

Output yang Dihasilkan:

[('Buku', 45000,  12) ('Pulpen',  5000, 100)]
total nilai: 1040000

Cara membacanya:

1. Baris 3 (dtype=[(...), ...]): tipe per kolom dideklarasikan di muka, termasuk lebar U10 untuk nama — kolom string lebar tetap itu hadir kembali di sini.
2. Baris 4-6: isi diisi per kolom; mengisi per baris jauh lebih berat karena setiap baris harus mengikuti layout kolom.
3. Baris 8: perhitungan numerik tetap cepat karena setiap kolom adalah array biasa.

Untuk tabel campuran yang akan dibersihkan, digabung, atau di-query, pandas memberi lapisan yang jauh lebih nyaman — dan menariknya, kolom-kolom pandas tetap disimpan sebagai blok NumPy di balik layar. Detailnya ada pada Chapter NumPy dan pandas, sementara bentuk structured array dibedah pada Chapter Structured Array.

Ringkasan Keputusan #