Atribut itemsize dan nbytes

Mengetahui tipe elemen saja baru setengah cerita; bab ini mengukur berapa byte memori yang benar-benar dipakai array. Dua atribut mengerjakan pengukuran itu: itemsize menyatakan ukuran satu elemen dalam byte, dan nbytes menyatakan total memori seluruh elemen. Keduanya penting saat kita merencanakan pemrosesan data besar: satu juta catatan penjualan bisa memakan 8 juta byte atau 4 juta byte, tergantung dtype yang kita pilih.

Mengukur memori per elemen dengan itemsize #

itemsize diukur dalam byte. Array int64 menampung tiap bilangan bulat dalam 8 byte, dan float64 juga memakai 8 byte per elemen. Dari sini, total memori array memenuhi rumus nbytes = size × itemsize, yang bisa kita verifikasi langsung.

import numpy as np

penjualan_cabang = np.array([120, 95, 143, 88, 210, 176])
suhu = np.array([27.5, 29.0, 31.2])

print(penjualan_cabang.dtype, penjualan_cabang.itemsize)
print(suhu.dtype, suhu.itemsize)
print(penjualan_cabang.nbytes, suhu.nbytes)
print(penjualan_cabang.size * penjualan_cabang.itemsize == penjualan_cabang.nbytes)

Output yang Dihasilkan:

int64 8
float64 8
48 24
True

Mari kita bedah output di atas:

1. Baris 6: array int64 punya itemsize 8 — setiap bilangan bulat 64-bit menempati 8 byte.
2. Baris 7: array float64 juga memakai 8 byte per elemen.
3. Baris 8: nbytes array enam elemen adalah 6 × 8 = 48, dan array tiga elemen adalah 3 × 8 = 24.
4. Baris 9: perkalian size × itemsize dibandingkan dengan nbytes; hasil True membuktikan rumusnya.

Itemsize berbagai dtype #

Setiap dtype memiliki itemsize tetap. Tabel berikut memuat nilai yang paling sering kita temui:

Nilai int8 sebesar 1 byte sesuai dengan lebarnya 8 bit, dan <U10 memakai 40 byte karena setiap karakter unicode menempati 4 byte (10 × 4). Kita bisa memverifikasi seluruh tabel lewat np.dtype():

import numpy as np

daftar_tipe = ["int8", "int32", "int64", "float32", "float64", "bool", "<U10"]
for t in daftar_tipe:
    d = np.dtype(t)
    print(f"{str(d):>8} | {d.itemsize:>2} byte")

Output yang Dihasilkan:

    int8 |  1 byte
   int32 |  4 byte
   int64 |  8 byte
 float32 |  4 byte
 float64 |  8 byte
    bool |  1 byte
    <U10 | 40 byte

Kode di atas melakukan dua langkah untuk setiap tipe:

1. Baris 5 (d = np.dtype(t)): fungsi np.dtype() mengubah nama tipe dalam bentuk string menjadi objek dtype.
2. Baris 6 (print(f"...")): f-string merapikan notasi tipe ke lebar 8 karakter dan itemsize ke lebar 2 karakter agar kolomnya sejajar.

Estimasi memori array satu juta elemen #

Dengan rumus nbytes = size × itemsize, estimasi memori menjadi hitungan pasti, bukan tebakan. Untuk array 1.000.000 elemen bertipe float64, totalnya adalah 1.000.000 × 8 = 8.000.000 byte, atau sekitar 7,63 MiB bila dibagi 1024 × 1024. Mari kita hitung lewat kode.

import numpy as np

penjualan_tahunan = np.zeros(1_000_000, dtype=np.float64)
penjualan_ringan = np.zeros(1_000_000, dtype=np.float32)

print(penjualan_tahunan.nbytes)
print(penjualan_ringan.nbytes)
print(f"{penjualan_tahunan.nbytes / 1_000_000:.1f} juta byte")

Output yang Dihasilkan:

8000000
4000000
8.0 juta byte

Perhatikan peran setiap baris:

1. Baris 3: np.zeros() membuat array 1.000.000 elemen float64; nbytes-nya 8000000 (1.000.000 × 8 byte).
2. Baris 4: array dengan jumlah elemen sama tetapi bertipe float32 memakai 4000000 byte (1.000.000 × 4 byte), persis setengahnya.
3. Baris 8: pembagian nbytes / 1_000_000 dengan format :.1f menghasilkan teks 8.0 juta byte.