Membuat Array dengan NumPy

Bekerja dengan Array di Python

NumPy membantu Python mengolah data numerik secara efisien. List Python dapat menampung tipe campuran, sedangkan array NumPy biasanya menyimpan nilai bertipe sama dalam struktur yang ringkas. Untuk operasi numerik pada banyak nilai sekaligus, susunan ini sering lebih cepat daripada loop Python yang setara.

Objek inti ndarray adalah array n-dimensi berukuran tetap yang seluruh elemennya memakai satu tipe data. Dengan ndarray, satu ekspresi dapat menjalankan operasi yang sama pada seluruh array.

Untuk pemrograman ilmiah, array NumPy menjalankan loop numerik dalam kode terkompilasi, menerapkan satu operasi pada seluruh array, dan menyimpan nilai homogen secara ringkas:

$Loop numerik yang efisien$ karena dijalankan dalam kode native terkompilasi
$Vektorisasi$ memungkinkan operasi pada seluruh array tanpa loop eksplisit
$Penyimpanan yang ringkas$ untuk nilai numerik homogen
$Banyak operasi matematika$ yang siap dipakai

Vektorisasi berarti $menyatakan operasi untuk seluruh array$ tanpa menulis loop Python secara eksplisit bagi setiap elemen. NumPy tetap memproses elemen-elemen tersebut secara internal, tetapi perulangannya berjalan dalam kode terkompilasi yang telah dioptimalkan.

vectorization_comparison.py

# Perkalian elemen menggunakan list Python
x = [1, 2, 3, 4, 5]
y = [2, 3, 4, 5, 6]
z = []
for i in range(len(x)):
  z.append(x[i] * y[i])
print("Hasil list:", z)  # Output: Hasil list: [2, 6, 12, 20, 30]

# Perkalian elemen menggunakan NumPy
import numpy as np
x_np = np.array([1, 2, 3, 4, 5])
y_np = np.array([2, 3, 4, 5, 6])
z_np = x_np * y_np
print("Hasil NumPy:", z_np)  # Output: Hasil NumPy: [ 2  6 12 20 30]

Pembuatan Array Manual

Gunakan np.array() untuk mengonversi $struktur data Python$ menjadi array NumPy.

Array satu dimensi seperti barisan angka dalam satu baris. Kamu dapat membuatnya dari list Python menggunakan fungsi np.array().

array_1d.py

import numpy as np

# Membuat array 1D dari list
a = np.array([0, 1, 2, 3])
print("Array 1D:", a)  # Output: Array 1D: [0 1 2 3]
print("Tipe data:", type(a))  # Output: Tipe data: <class 'numpy.ndarray'>
print("Shape:", a.shape)  # Output: Shape: (4,)
print("Dimensi:", a.ndim)  # Output: Dimensi: 1

Array dua dimensi seperti tabel dengan baris dan kolom. Kamu bisa membuatnya dari list bertingkat (nested list).

array_2d.py

import numpy as np

# Membuat array 2D dari nested list
a = np.array([[0, 1], [2, 3]])
print("Array 2D:")
print(a)
# Output:
# [[0 1]
#  [2 3]]

print("Shape:", a.shape)  # Output: Shape: (2, 2)
print("Dimensi:", a.ndim)  # Output: Dimensi: 2
print("Total elemen:", a.size)  # Output: Total elemen: 4

Array tiga dimensi dapat dibayangkan sebagai tumpukan tabel. Setiap lapisan memiliki baris dan kolom, sedangkan sumbu tambahan memilih lapisannya.

array_3d.py

import numpy as np

# Membuat array 3D
a = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
print("Array 3D:")
print(a)
# Output:
# [[[ 1  2  3]
#   [ 4  5  6]]
#  [[ 7  8  9]
#   [10 11 12]]]

print("Shape:", a.shape)  # Output: Shape: (2, 2, 3)
print("Axis 0 (planes):", a.shape[0])  # Output: Axis 0 (planes): 2
print("Axis 1 (rows):", a.shape[1])  # Output: Axis 1 (rows): 2
print("Axis 2 (columns):", a.shape[2])  # Output: Axis 2 (columns): 3

Struktur Multidimensi

Dimensi	Shape	Struktur	Contoh	Axis
$Satu dimensi$	`(4,)`	Barisan angka dalam satu baris	`[0, 1, 2, 3]`	Axis $0$ untuk indeks elemen
$Dua dimensi$	`(2, 2)`	Tabel dengan baris dan kolom	`[[0, 1], [2, 3]]`	Axis $0$ untuk baris, Axis $1$ untuk kolom
$Tiga dimensi$	`(2, 2, 3)`	Tumpukan tabel (planes)	$2$ planes, setiap plane $2 \times 3$	Axis $0$ kedalaman, Axis $1$ tinggi, Axis $2$ lebar

Semakin tinggi dimensi array, semakin kompleks struktur datanya, tetapi prinsip dasarnya tetap sama. $Setiap axis$ mewakili satu dimensi pengorganisasian data.

NumPy dapat membuat array dari berbagai struktur data Python, termasuk list, tuple, dan campuran keduanya.

array_from_various_types.py

import numpy as np

# Dari list
arr_from_list = np.array([0, 1, 2, 3])
print("Dari list:", arr_from_list)  # Output: Dari list: [0 1 2 3]

# Dari tuple
arr_from_tuple = np.array((0, 1, 2, 3))
print("Dari tuple:", arr_from_tuple)  # Output: Dari tuple: [0 1 2 3]

# Dari campuran yang akan dikonversi ke tipe yang kompatibel
arr_mixed = np.array([0, 1, 2.5, 3])
print("Dari campuran:", arr_mixed)  # Output: Dari campuran: [0.  1.  2.5 3. ]
print("Tipe data otomatis:", arr_mixed.dtype)  # Output: Tipe data otomatis: float64

Fungsi Pembuat Array

Menuliskan setiap elemen satu per satu hanya praktis untuk contoh yang sangat kecil. NumPy menyediakan fungsi khusus yang membangun $array dari sebuah aturan$ , bukan dari daftar literal, sehingga kode tetap singkat dan bentuk array tetap eksplisit. Fungsi-fungsi di bawah ini terbagi menjadi tiga kelompok: array berisi nilai konstan, array berisi bilangan acak, dan array yang mengikuti pola matematis.

Fungsi Nilai Konstan

Fungsi np.ones() membuat array yang seluruh elemennya bernilai $1$ . Fungsi ini berguna ketika setiap elemen memerlukan $nilai awal yang sama$ .

ones_arrays.py

import numpy as np

# Array 1D dengan nilai 1
a = np.ones(3)
print("1D ones:", a)  # Output: 1D ones: [1. 1. 1.]

# Array 2D dengan nilai 1
a = np.ones((2, 3))
print("2D ones:")
print(a)
# Output:
# [[1. 1. 1.]
#  [1. 1. 1.]]

# Array 3D dengan nilai 1
a = np.ones((2, 2, 3))
print("3D ones shape:", a.shape)  # Output: 3D ones shape: (2, 2, 3)
print("3D ones:")
print(a)
# Output:
# [[[1. 1. 1.]
#   [1. 1. 1.]]
#  [[1. 1. 1.]
#   [1. 1. 1.]]]

Selain np.ones(), terdapat fungsi lain untuk membuat array dengan pola khusus:

special_arrays.py

import numpy as np

# Array dengan nilai nol
a = np.zeros((2, 3))
print("Zeros array:")
print(a)
# Output:
# [[0. 0. 0.]
#  [0. 0. 0.]]

# Array identitas (diagonal 1, lainnya 0)
a = np.eye(3, 3)
print("Identity matrix:")
print(a)
# Output:
# [[1. 0. 0.]
#  [0. 1. 0.]
#  [0. 0. 1.]]

# Array diagonal dengan nilai khusus
a = np.diag((1, 2, 3))
print("Diagonal array:")
print(a)
# Output:
# [[1 0 0]
#  [0 2 0]
#  [0 0 3]]

Fungsi Random

Gunakan $generator bilangan acak$ np.random.default_rng() untuk membuat data simulasi. Seed yang sama menghasilkan urutan yang dapat diulang dengan generator dan versi NumPy yang sama. Nilai uniform berikut berada dalam interval [0, 1): nol boleh muncul, sedangkan satu tidak termasuk.

random_arrays.py

import numpy as np

# Set seed untuk hasil yang konsisten
rng = np.random.default_rng(10)

# Array dengan nilai acak uniform antara 0 dan 1
a = rng.random((2, 3))
print("Random uniform [0,1):")
print(a)
# Output:
# [[0.95600171 0.20768181 0.82844489]
#  [0.14928212 0.51280462 0.1359196 ]]

# Array dengan distribusi normal (mean=0, std=1)
a = rng.standard_normal(3)
print("Random normal:", a)  # Output: Random normal: [0.84304257 0.85793655 0.47518364]

# Array dengan integer acak dalam rentang tertentu
a = rng.integers(1, 10, size=(2, 3))
print("Random integers [1,10):")
print(a)
# Output:
# [[5 9 3]
#  [8 1 4]]

Fungsi Matematika

Fungsi np.fromfunction memberikan $array koordinat indeks$ kepada fungsi yang kamu tulis. Fungsi f(i, j) di bawah menerima dua array: indeks baris dalam i dan indeks kolom dalam j. Penjumlahan i + j bekerja per elemen. Misalnya, posisi [1, 2] menghasilkan 3.

fromfunction_array.py

import numpy as np

# Membuat array menggunakan fungsi
def f(i, j):
  return i + j

# Array 2x3 dengan nilai berdasarkan fungsi f(i,j) = i + j
a = np.fromfunction(f, (2, 3))
print("Array dari fungsi f(i,j) = i + j:")
print(a)
# Output:
# [[0. 1. 2.]
#  [1. 2. 3.]]

# Fungsi yang lebih kompleks
def g(i, j):
  return i * j + 1

b = np.fromfunction(g, (3, 3))
print("Array dari fungsi g(i,j) = i*j + 1:")
print(b)
# Output:
# [[1. 1. 1.]
#  [1. 2. 3.]
#  [1. 3. 5.]]

Fungsi np.empty mengalokasikan array tanpa menentukan nilai awal elemennya. Nilai yang dibaca sebelum array diisi tidak dapat diprediksi. Gunakan fungsi ini hanya jika setiap elemen akan segera diberi nilai.

empty_array.py

import numpy as np

# Membuat array kosong (nilai tidak terdefinisi)
a = np.empty((3, 2))
a.fill(0)  # Isi semua elemen sebelum membaca nilainya
print("Array setelah diisi:")
print(a)
# Output:
# [[0. 0.]
#  [0. 0.]
#  [0. 0.]]

print("Shape:", a.shape)  # Output: Shape: (3, 2)
print("Dtype:", a.dtype)  # Output: Dtype: float64

Membuat Array Berpola

Sebagian array lebih mudah dijelaskan sebagai urutan daripada sebagai aturan untuk tiap elemen: semua nilai di antara dua batas, atau $sejumlah titik yang jaraknya sama$ . np.arange dan np.linspace membangun array semacam itu, dan perbedaannya terletak pada cara batas akhir urutan ditentukan.

Fungsi Arange pada NumPy

Fungsi np.arange menyerupai range() milik Python, tetapi mengembalikan array dan menerima argumen bertipe float. Jika nilai step bukan bilangan bulat, $pembulatan pada float$ dapat membuat batas akhir sulit dipastikan. Gunakan np.linspace jika kamu sudah mengetahui jumlah titik yang dibutuhkan.

arange_arrays.py

import numpy as np

# Array dari 0 hingga 4
a = np.arange(5)
print("arange(5):", a)  # Output: arange(5): [0 1 2 3 4]

# Array dengan start, stop, dan step
a = np.arange(1.5, 3., 0.5)
print("arange(1.5, 3., 0.5):", a)  # Output: arange(1.5, 3., 0.5): [1.5 2.  2.5]

# Array dengan step yang menghasilkan nilai desimal
a = np.arange(1.5, 4.)
print("arange(1.5, 4.):", a)  # Output: arange(1.5, 4.): [1.5 2.5 3.5]

# Demonstrasi parameter
print("\nParameter arange(start, end, step):")
print("- start, end, step dapat berupa float")
print("- end dikecualikan dari hasil")
print("- step default adalah 1")
print("- start default adalah 0")

Fungsi Linspace pada NumPy

Berbeda dengan np.arange yang menggunakan step tetap, np.linspace membagi rentang menjadi $sejumlah titik yang sama rata$ .

linspace_arrays.py

import numpy as np

# Membuat 5 titik merata antara 0 dan 10
a = np.linspace(0, 10, 5)
print("linspace(0, 10, 5):", a)  # Output: linspace(0, 10, 5): [ 0.   2.5  5.   7.5 10. ]

# Membuat 11 titik merata antara -1 dan 1
a = np.linspace(-1, 1, 11)
print("linspace(-1, 1, 11):", a)
# Output: linspace(-1, 1, 11): [-1.  -0.8 -0.6 -0.4 -0.2  0.   0.2  0.4  0.6  0.8  1. ]

# Perbandingan linspace vs arange
print("\nPerbedaan linspace vs arange:")
print("linspace: jumlah elemen ditentukan, jarak antarelemen dihitung")
print("arange: step ditentukan, jumlah elemen mengikuti batas")

Membandingkan arange dan linspace

Kedua fungsi menyusun array dari sebuah rentang, dan parameter yang kamu berikan menentukan perbedaannya. arange menetapkan $jarak antar elemen$ , sedangkan linspace menetapkan banyak elemen yang kamu inginkan.

Aspek	`np.arange`	`np.linspace`
Parameter utama	start, stop, step	start, stop, num
Kontrol	Jarak antar elemen	Jumlah total elemen
Titik akhir	Dikecualikan	Disertakan secara bawaan
Tipe data	Disimpulkan dari input	`float` secara default dan dapat diatur dengan `dtype`
Kegunaan	Deret nilai dengan selisih tetap	Pembagian rentang merata

Operasi Dasar

Sebelum mengubah bentuk array, periksa $jumlah elemen dan shape$ . Array di bawah memiliki dua baris dan tiga kolom, sehingga size bernilai 6. Tipe int64 memakai delapan byte per elemen.

array_info.py

import numpy as np

# Membuat array contoh
a = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int64)
print("Array:")
print(a)
# Output:
# [[1 2 3]
#  [4 5 6]]

print("Shape (bentuk):", a.shape)  # Output: Shape (bentuk): (2, 3)
print("Size (total elemen):", a.size)  # Output: Size (total elemen): 6
print("Ndim (dimensi):", a.ndim)  # Output: Ndim (dimensi): 2
print("Dtype (tipe data):", a.dtype)  # Output: Dtype (tipe data): int64
print("Itemsize (bytes per elemen):", a.itemsize)  # Output: Itemsize (bytes per elemen): 8

Dengan reshape(), jumlah elemen $harus tetap sama$ : 3 * 4, 2 * 6, dan 4 * 3 semuanya bernilai 12. Argumen -1 meminta NumPy menghitung satu dimensi yang belum diketahui. Operasi ini dapat menghasilkan view atau salinan, bergantung pada tata letak array.

array_reshape.py

import numpy as np

# Array 1D dengan 12 elemen
a = np.arange(12)
print("Array original:", a)  # Output: Array original: [ 0  1  2  3  4  5  6  7  8  9 10 11]

# Reshape ke 3x4
b = a.reshape(3, 4)
print("Reshape 3x4:")
print(b)
# Output:
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]

# Reshape ke 2x6
c = a.reshape(2, 6)
print("Reshape 2x6:")
print(c)
# Output:
# [[ 0  1  2  3  4  5]
#  [ 6  7  8  9 10 11]]

# Reshape dengan -1 (otomatis menghitung dimensi)
d = a.reshape(4, -1)
print("Reshape 4x-1 (otomatis):")
print(d)
# Output:
# [[ 0  1  2]
#  [ 3  4  5]
#  [ 6  7  8]
#  [ 9 10 11]]