7 Trik NumPy Praktis Agar Kode Kamu Makin Ngebut dan Efisien!

Oleh VOXBLICK

Sabtu, 18 Oktober 2025 - 20.55 WIB

7 Trik NumPy Praktis Agar Kode Kamu Makin Ngebut dan Efisien!

Trik NumPy percepat kode (Foto oleh Julio Lopez)

VOXBLICK.COM - Pernahkah kamu merasa kode Python untuk proyek AI atau data science kamu berjalan lambat? Terutama saat berhadapan dengan dataset yang besar, menunggu hasil komputasi bisa jadi sangat menyebalkan. Jika iya, kamu tidak sendirian! Banyak developer dan data scientist mengalami hal yang sama. Kunci untuk mengatasi bottleneck performa ini seringkali terletak pada bagaimana kita memproses data numerik, dan di sinilah NumPy masuk sebagai pahlawan.

NumPy (Numerical Python) adalah library fundamental di ekosistem Python untuk komputasi ilmiah.

Kekuatannya terletak pada kemampuannya untuk melakukan operasi array yang sangat cepat dan efisien, jauh melampaui kemampuan loop Python standar. Dengan menguasai beberapa trik NumPy praktis, kamu bisa mengubah kode yang tadinya lambat menjadi super ngebut, menghemat waktu, dan meningkatkan efisiensi proyek kamu secara drastis.

Siap-siap, karena artikel ini akan membongkar 7 trik NumPy yang bisa langsung kamu terapkan untuk membuang loop yang tidak perlu, melakukan vectorisasi, dan membuat komputasi data kamu jadi super efisien.

Yuk, kita tingkatkan performa kode Python kamu sekarang juga!

1. Buang Loop Python, Pakai Vectorisasi!

Ini adalah trik paling fundamental dan paling penting di NumPy. Alih-alih menulis loop Python satu per satu untuk memproses setiap elemen dalam array, gunakan operasi array bawaan NumPy.

Operasi ini ditulis dalam C, sehingga jauh lebih cepat. Misalnya, untuk menambahkan dua array, hindari:

import numpy as np import time # Cara lambat dengan loop list1 = list(range(1000000)) list2 = list(range(1000000)) result_list = start_time = time.time() for i in range(len(list1)): result_list.append(list1i + list2i) end_time = time.

time()
print(f"Waktu dengan loop: end_time - start_time:.4f detik")

Dan beralihlah ke:

# Cara cepat dengan vectorisasi NumPy arr1 = np.arange(1000000) arr2 = np.arange(1000000) start_time = time.time() result_array = arr1 + arr2 # Operasi vectorisasi! end_time = time.time() print(f"Waktu dengan NumPy: end_time - start_time:.

4f detik")

Perbedaannya akan sangat mencolok pada data skala besar. Dengan vectorisasi, kamu tidak hanya membuat kode lebih cepat, tapi juga lebih ringkas dan mudah dibaca.

2. Manfaatkan Fungsi Universal (Ufuncs)

NumPy menyediakan "Universal Functions" atau ufuncs, yaitu fungsi-fungsi yang beroperasi pada array secara elemen-demi-elemen, jauh lebih cepat daripada fungsi Python biasa. Contohnya adalah np.sin(), np.cos(), np.

exp(), np.sqrt(), atau bahkan operasi aritmatika dasar seperti np.add(), np.multiply(). Selalu utamakan ufuncs ini untuk operasi matematika pada array kamu.

# Contoh penggunaan ufuncs data = np.array(1, 2, 3, 4, 5) akar_kuadrat = np.sqrt(data) logaritma = np.

log(data)
print(f"Akar kuadrat: akar_kuadrat")
print(f"Logaritma: logaritma")

Menggunakan ufuncs berarti kamu memanfaatkan implementasi C yang dioptimalkan, yang secara signifikan mempercepat komputasi data numerik.

3. Kuasai Broadcasting untuk Operasi Fleksibel

Broadcasting adalah kemampuan NumPy untuk melakukan operasi pada array dengan bentuk yang berbeda, tanpa perlu mengubah bentuk array secara eksplisit.

Ini sangat berguna untuk operasi seperti menambahkan skalar ke array, atau menambahkan array 1D ke setiap baris array 2D. Pahami aturan broadcasting untuk menulis kode yang lebih efisien dan ringkas.

# Contoh broadcasting matrix = np.

array(1, 2, 3,
                   4, 5, 6,
                   7, 8, 9)
skalar = 10
hasil_tambah_skalar = matrix + skalar # Skalar di-broadcast ke seluruh elemen matrix
print(f"Hasil tambah skalar:\nhasil_tambah_skalar")

vector = np.array(1, 0, -1)
hasil_tambah_vector = matrix + vector # Vector di-broadcast ke setiap baris matrix
print(f"Hasil tambah vector:\nhasil_tambah_vector")

Broadcasting memungkinkan kamu melakukan operasi kompleks dengan sedikit baris kode, meningkatkan efisiensi dan keterbacaan.

4. Filter Data Lebih Cepat dengan Advanced Indexing

Untuk memilih atau memfilter elemen dari array berdasarkan kondisi tertentu, hindari loop dengan pernyataan if-else.

NumPy menyediakan advanced indexing menggunakan array Boolean atau array integer yang jauh lebih cepat. Ini adalah cara yang sangat efisien untuk memanipulasi subset data kamu.

# Contoh Boolean indexing data_angka = np.

array(10, 25, 5, 30, 15, 40, 20)
kondisi = data_angka > 20 # Membuat array Boolean
angka_besar = data_angkakondisi # Memilih elemen berdasarkan kondisi
print(f"Angka lebih besar dari 20: angka_besar")

# Contoh Integer array indexing
indeks_pilihan = np.array(0, 2, 4)
elemen_terpilih = data_angkaindeks_pilihan
print(f"Elemen pada indeks 0, 2, 4: elemen_terpilih")

Dengan advanced indexing, kamu bisa memfilter dan memilih data dalam sekejap, yang sangat krusial untuk analisis data berukuran besar.

5. Agregasi Data Sekejap Mata

Menghitung total, rata-rata, nilai maksimum, atau minimum dari sebuah array adalah operasi umum dalam data science. NumPy memiliki fungsi agregasi yang sangat dioptimalkan seperti np.sum(), np.mean(), np.

max(), np.min(), np.std(), dan banyak lagi. Selalu gunakan ini daripada menulis loop manual.

# Contoh fungsi agregasi nilai = np.array(10, 20, 30, 40, 50) total = np.sum(nilai) rata_rata = np.mean(nilai) maksimum = np.

max(nilai)
print(f"Total: total, Rata-rata: rata_rata, Maksimum: maksimum")

# Agregasi sepanjang axis tertentu (misal: baris atau kolom)
matrix_data = np.array(1, 2, 3,
                        4, 5, 6,
                        7, 8, 9)
sum_kolom = np.sum(matrix_data, axis=0) # Sum per kolom
sum_baris = np.sum(matrix_data, axis=1) # Sum per baris
print(f"Sum per kolom: sum_kolom")
print(f"Sum per baris: sum_baris")

Fungsi-fungsi ini tidak hanya cepat, tetapi juga mendukung operasi sepanjang sumbu (axis) tertentu, memberikan fleksibilitas tinggi untuk komputasi data.

6. Hindari Pembuatan Array yang Lambat

Saat membuat array, seringkali kita tergoda untuk menggunakan list comprehension Python dan kemudian mengubahnya menjadi array NumPy.

Meskipun itu berfungsi, ada cara yang lebih efisien jika kamu sudah tahu ukuran dan jenis data yang akan kamu buat. Gunakan fungsi-fungsi seperti np.zeros(), np.ones(), np.empty(), np.arange(), atau np.linspace() untuk inisialisasi array.

# Cara lebih efisien untuk membuat array array_nol = np.zeros((3, 3)) # Array 3x3 berisi nol array_satu = np.ones(5) # Array 1D berisi satu deret_angka = np.arange(0, 10, 2) # Deret angka dengan step linear_space = np.

linspace(0, 1, 5) # 5 angka berjarak sama antara 0 dan 1
print(f"Array nol:\narray_nol")
print(f"Array satu: array_satu")
print(f"Deret angka: deret_angka")
print(f"Linear space: linear_space")

Membuat array langsung dengan fungsi NumPy ini jauh lebih cepat karena alokasi memori dilakukan secara efisien sejak awal.

7. Gunakan `np.where()` untuk Logika Kondisional

Jika kamu perlu menerapkan logika kondisional (seperti if-else) pada elemen-elemen array, hindari loop yang memeriksa setiap elemen. Fungsi np.where() adalah alternatif vectorisasi yang sangat powerful dan cepat.

Ia mengembalikan elemen yang dipilih dari dua array berdasarkan kondisi yang diberikan.

# Contoh np.where() skor = np.array(75, 88, 62, 95, 55, 70) hasil = np.where(skor >= 70, "Lulus", "Gagal") print(f"Hasil ujian: hasil") # Mengganti nilai di array data_kotor = np.array(10, -5, 20, -1, 30) data_bersih = np.

where(data_kotor < 0, 0, data_kotor) # Ganti nilai negatif dengan 0
print(f"Data bersih: data_bersih")

np.where() memungkinkan kamu menerapkan logika kondisional yang kompleks pada seluruh array secara efisien, tanpa harus menulis loop eksplisit.

Selamat! Kamu sudah mempelajari 7 trik NumPy yang bisa langsung kamu gunakan untuk membuat kode Python kamu jauh lebih cepat dan efisien.

Dengan membuang loop Python dan beralih ke operasi vectorisasi, ufuncs, broadcasting, advanced indexing, fungsi agregasi, inisialisasi array yang efisien, dan np.where(), kamu akan melihat peningkatan performa yang signifikan dalam proyek-proyek AI dan data science kamu.

Mulai sekarang, coba identifikasi bagian-bagian kode kamu yang masih menggunakan loop dan pikirkan bagaimana kamu bisa menggantinya dengan pendekatan NumPy yang lebih efisien.

Ingat, efisiensi komputasi adalah kunci untuk menangani data besar dan membangun model yang lebih baik. Teruslah bereksimen dan rasakan sendiri perbedaan kecepatannya!