Atribut dan Tipe Data dengan NumPy

Sistem Tipe Data NumPy

Tipe data menentukan $representasi nilai di memori$ dan operasi yang dapat dilakukan NumPy pada nilai tersebut. Boolean NumPy memakai satu byte, sedangkan bilangan kompleks menyimpan komponen real dan imajiner secara terpisah.

Semua elemen dalam array NumPy biasa memakai tipe data yang sama. Dengan susunan ini, loop yang dijalankan NumPy dalam kode C dapat memproses elemen tanpa memeriksa tipe setiap nilai satu per satu.

Tipe Data Dasar

NumPy menerima tipe skalar bawaan Python dan menyediakan tipe skalar dengan $lebar tetap$ ketika representasi data harus ditentukan secara tepat:

$Boolean$ (bool atau np.bool_) untuk True dan False, dengan satu byte per elemen
$Integer$ (np.int8 hingga np.int64) untuk bilangan bulat bertanda dengan lebar yang eksplisit
$Float$ (np.float16, np.float32, atau np.float64) untuk nilai floating-point dengan tingkat presisi berbeda
$Complex$ (np.complex64 atau np.complex128) untuk nilai dengan komponen real dan imajiner

basic_data_types.py

import numpy as np

# Contoh tipe data dasar
bool_array = np.array([True, False, True], dtype=np.bool_)
print("Boolean array:", bool_array)  # Output: Boolean array: [ True False  True]
print("Dtype:", bool_array.dtype)  # Output: Dtype: bool

int_array = np.array([1, 2, 3], dtype=np.int64)
print("Integer array:", int_array)  # Output: Integer array: [1 2 3]
print("Dtype:", int_array.dtype)  # Output: Dtype: int64

float_array = np.array([1.0, 2.5, 3.7], dtype=np.float64)
print("Float array:", float_array)  # Output: Float array: [1.  2.5 3.7]
print("Dtype:", float_array.dtype)  # Output: Dtype: float64

Tipe Data Numerik Spesifik

NumPy menyediakan kontrol presisi yang detail dengan $berbagai ukuran tipe data numerik$ :

Kategori	Tipe Data	Deskripsi	Rentang Nilai
$Integer Signed$	`int8`	$8$ -bit signed integer	$-128 \text{ hingga } 127$
	`int16`	$16$ -bit signed integer	$-32768 \text{ hingga } 32767$
	`int32`	$32$ -bit signed integer	$-2147483648 \text{ hingga } 2147483647$
	`int64`	$64$ -bit signed integer	$-2^{63} \text{ sampai } 2^{63}-1$
$Integer Unsigned$	`uint8`	$8$ -bit unsigned integer	$0 \text{ hingga } 255$
	`uint16`	$16$ -bit unsigned integer	$0 \text{ hingga } 65535$
	`uint32`	$32$ -bit unsigned integer	$0 \text{ hingga } 4294967295$
	`uint64`	$64$ -bit unsigned integer	$0 \text{ sampai } 2^{64}-1$
$Float$	`float16`	Half-precision float	$5 \text{ bit eksponen}$ , $10 \text{ bit fraksi}$
	`float32`	Single-precision float	$8 \text{ bit eksponen}$ , $23 \text{ bit fraksi}$
	`float64`	Double-precision float	$11 \text{ bit eksponen}$ , $52 \text{ bit fraksi}$
$Complex$	`complex64`	Complex number	Dua $32$ -bit float
	`complex128`	Complex number	Dua $64$ -bit float

Menentukan Tipe Data

Kamu dapat menentukan tipe data $saat membuat array$ atau mengonversi nilainya menjadi array baru dengan dtype lain:

specify_data_types.py

import numpy as np

# Menentukan tipe data saat pembuatan array
a = np.array([0, 1, 2], dtype=float)
print("Array dengan dtype float:", a)  # Output: Array dengan dtype float: [0. 1. 2.]
print("Dtype:", a.dtype)  # Output: Dtype: float64

# Default adalah float untuk fungsi ones
a = np.ones((3, 3))
print("Default ones dtype:", a.dtype)  # Output: Default ones dtype: float64

# Mengubah ke integer
a = np.ones((3, 3), dtype=np.int64)
print("Ones dengan dtype int:", a.dtype)  # Output: Ones dengan dtype int: int64
print("Array:")
print(a)
# Output:
# [[1 1 1]
#  [1 1 1]
#  [1 1 1]]

Deteksi Otomatis Tipe Data

NumPy secara otomatis mendeteksi tipe data berdasarkan $elemen yang diberikan$ :

automatic_dtype_detection.py

import numpy as np

# Semua integer
a = np.array([0, 1, 2])
print("Semua int - dtype:", a.dtype)  # Output umum pada sistem 64-bit: Semua int - dtype: int64

# Semua float
a = np.array([0., 1., 2.])
print("Semua float - dtype:", a.dtype)  # Output: Semua float - dtype: float64

# Campuran int dan float
a = np.array([0, 1, 2.])
print("Campuran - dtype:", a.dtype)  # Output: Campuran - dtype: float64
print("Array result:", a)  # Output: Array result: [0. 1. 2.]

Atribut Array NumPy

Atribut menjelaskan $struktur array$ tanpa membaca setiap nilai: bentuk, jumlah elemen, dtype, dan byte yang dipakai elemen. nbytes menghitung penyimpanan elemen, bukan seluruh memori proses Python atau metadata objek array.

Atribut Dimensi dan Bentuk

Contoh berikut membaca $atribut struktur utama$ dari sebuah array dua dimensi.

array_attributes.py

import numpy as np

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

print("Shape (bentuk):", a.shape)  # Output: Shape (bentuk): (2, 3)
print("Ndim (dimensi):", a.ndim)  # Output: Ndim (dimensi): 2
print("Size (total elemen):", a.size)  # Output: Size (total elemen): 6
print("Dtype (tipe data):", a.dtype)  # Output: Dtype (tipe data): int64
print("Byte yang dipakai elemen:", a.nbytes)  # Output: Byte yang dipakai elemen: 48

Atribut Array

Sebuah array melaporkan strukturnya sendiri melalui atribut. Tabel berikut memuat atribut yang paling sering dibaca dan $nilai yang dikembalikan$ masing-masing untuk array $2 \times 3$ .

Atribut	Fungsi	Contoh Hasil
`ndarray.shape`	Jumlah elemen di setiap axis	`(2, 3)` untuk array $2 \times 3$
`ndarray.ndim`	Jumlah axis/dimensi	`2` untuk array dua dimensi
`ndarray.size`	Total jumlah elemen	`6` untuk array $2 \times 3$
`ndarray.dtype`	Tipe data elemen	`int64`, `float64`, dll
`ndarray.nbytes`	Byte yang dipakai elemen array	`48` untuk enam nilai `int64`

Konsistensi Tipe Data

Semua elemen dalam array NumPy biasa berbagi satu tipe data. Objek numpy.dtype menjelaskan cara nilai tersebut disimpan dan dibaca di dalam memori. Jika input memiliki tipe berbeda, $NumPy memakai aturan promosi tipe$ untuk mencari dtype bersama yang cocok. Presisi dan kategori tipe input menentukan dtype hasil. Frekuensi kemunculan setiap tipe tidak memengaruhi aturan ini.

dtype_consistency.py

import numpy as np

# Semua integer
a = np.array([0, 1, 2])
print("Semua int - dtype:", a.dtype)  # Output umum pada sistem 64-bit: Semua int - dtype: int64

# Semua float
a = np.array([0., 1., 2.])
print("All float - dtype:", a.dtype)  # Output: All float - dtype: float64

# Campuran integer dan float (otomatis menjadi float)
a = np.array([0, 1, 2.])
print("Mixed - dtype:", a.dtype)  # Output: Mixed - dtype: float64
print("Mixed result:", a)  # Output: Mixed result: [0. 1. 2.]

Konversi dan Manipulasi Tipe Data

Lakukan konversi ketika $tipe yang dibutuhkan berbeda$ dari dtype saat ini, misalnya untuk memenuhi masukan suatu fungsi atau menghemat memori. Konversi dapat kehilangan presisi atau nilai pecahan. Menyimpan nilai sebagai integer juga tidak menjamin semua operasi berikutnya menghasilkan integer.

Method Konversi Tipe Data

Konversi tipe data mengubah array ke tipe yang dibutuhkan untuk analisis berikutnya. Method astype() mengembalikan array hasil konversi dan tidak mengubah array asal secara langsung. Saat mengubah nilai desimal menjadi integer, NumPy $memotong bagian pecahan menuju nol$ .

dtype_conversion.py

import numpy as np

# Array float original
original = np.array([1.1, 2.7, 3.9])
print("Original array:", original)  # Output: Original array: [1.1 2.7 3.9]
print("Original dtype:", original.dtype)  # Output: Original dtype: float64

# Konversi ke integer menggunakan astype
converted = original.astype(np.int64)
print("Converted to int:", converted)  # Output: Converted to int: [1 2 3]
print("Converted dtype:", converted.dtype)  # Output: Converted dtype: int64

# Konversi ke tipe data spesifik
float32_array = original.astype(np.float32)
print("Float32 dtype:", float32_array.dtype)  # Output: Float32 dtype: float32

# Konversi string ke integer
string_array = np.array(['1', '2', '3'])
int_from_string = string_array.astype(np.int64)
print("Dari string:", int_from_string)  # Output: Dari string: [1 2 3]
print("Tipe data hasil konversi ke int:", int_from_string.dtype)  # Output: Tipe data hasil konversi ke int: int64

Optimasi Memori dengan Tipe Data

Memilih tipe data tersempit yang tetap mencakup $nilai dan presisi yang dibutuhkan$ dapat mengurangi penggunaan memori secara nyata. Sebelum memperkecil dtype, periksa rentangnya agar nilai tidak meluap atau kehilangan presisi penting.

memory_optimization.py

import numpy as np

# Array dengan tipe integer 64-bit yang eksplisit
large_array_int64 = np.arange(1000000, dtype=np.int64)
print("Int64 itemsize:", large_array_int64.itemsize, "bytes")  # Output: Int64 itemsize: 8 bytes
print("Int64 element memory:", large_array_int64.nbytes, "bytes")  # Output: Int64 element memory: 8000000 bytes

# Array dengan tipe data lebih kecil (int32)
large_array_int32 = np.arange(1000000, dtype=np.int32)
print("Int32 itemsize:", large_array_int32.itemsize, "bytes")  # Output: Int32 itemsize: 4 bytes
print("Int32 element memory:", large_array_int32.nbytes, "bytes")  # Output: Int32 element memory: 4000000 bytes

# Penghematan memori
memory_saved = large_array_int64.nbytes - large_array_int32.nbytes
print("Memory saved:", memory_saved, "bytes")  # Output: Memory saved: 4000000 bytes
print("Memory saved percentage:", (memory_saved / large_array_int64.nbytes) * 100, "%")  # Output: Memory saved percentage: 50.0 %

Informasi Detail Tipe Data

Atribut itemsize memperlihatkan langsung hubungan antara presisi dan $penggunaan memori pada setiap array$ .

dtype_info.py

import numpy as np

# Membuat array dengan berbagai tipe data
arrays = {
  'int8': np.array([1, 2, 3], dtype=np.int8),
  'int32': np.array([1, 2, 3], dtype=np.int32),
  'int64': np.array([1, 2, 3], dtype=np.int64),
  'float32': np.array([1.0, 2.0, 3.0], dtype=np.float32),
  'float64': np.array([1.0, 2.0, 3.0], dtype=np.float64)
}

print("Informasi Tipe Data:")
print("=" * 50)
for name, arr in arrays.items():
  print(f"{name:8} - itemsize: {arr.itemsize:2} bytes, dtype: {arr.dtype}")

# Output:
# Informasi Tipe Data:
# ==================================================
# int8     - itemsize:  1 bytes, dtype: int8
# int32    - itemsize:  4 bytes, dtype: int32
# int64    - itemsize:  8 bytes, dtype: int64
# float32  - itemsize:  4 bytes, dtype: float32
# float64  - itemsize:  8 bytes, dtype: float64

Penggunaan Praktis Atribut Array

Atribut array terutama berguna sebagai alat kontrol saat mengolah data. Dengan shape, ndim, dan dtype, kamu bisa memeriksa apakah hasil antara masih punya $struktur yang diharapkan$ dan menemukan kesalahan sebelum kesalahan itu terbawa ke langkah berikutnya.

Analisis Struktur Data

Fungsi analisis kecil dapat menampilkan $shape, jumlah dimensi, tipe data, dan pemakaian memori$ array dalam satu keluaran. Ringkasan ini memudahkan pencarian shape atau tipe data yang salah.

data_structure_analysis.py

import numpy as np

def analyze_array(arr, name="Array"):
  """Fungsi untuk menganalisis struktur array"""
  print(f"\n=== Analisis {name} ===")
  print(f"Shape: {arr.shape}")
  print(f"Dimensions: {arr.ndim}")
  print(f"Size: {arr.size}")
  print(f"Data type: {arr.dtype}")
  print(f"Item size: {arr.itemsize} bytes")
  print(f"Element memory: {arr.nbytes} bytes")

  if arr.ndim <= 2:
      print(f"Array content:\n{arr}")

# Contoh analisis berbagai array
array_1d = np.array([1, 2, 3, 4, 5], dtype=np.int64)
array_2d = np.array([[1, 2, 3], [4, 5, 6]], dtype=np.int64)
array_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], dtype=np.int64)

analyze_array(array_1d, "1D")
analyze_array(array_2d, "2D")
analyze_array(array_3d, "3D")

# Output:
# === Analisis 1D ===
# Shape: (5,)
# Dimensions: 1
# Size: 5
# Data type: int64
# Item size: 8 bytes
# Element memory: 40 bytes
# Array content:
# [1 2 3 4 5]
#
# === Analisis 2D ===
# Shape: (2, 3)
# Dimensions: 2
# Size: 6
# Data type: int64
# Item size: 8 bytes
# Element memory: 48 bytes
# Array content:
# [[1 2 3]
#  [4 5 6]]
#
# === Analisis 3D ===
# Shape: (2, 2, 2)
# Dimensions: 3
# Size: 8
# Data type: int64
# Item size: 8 bytes
# Element memory: 64 bytes

Validasi Data dan Pelacakan Kesalahan

Sebelum meneruskan array ke model, periksa $bentuk, dtype, nilai yang hilang$ , dan penggunaan memori yang benar-benar diharapkan model tersebut.

data_validation.py

import numpy as np

def validate_feature_matrix(arr):
  """Periksa matriks fitur numerik sebelum pemodelan."""
  print("=== Validasi Array untuk ML ===")

  # Cek dimensi
  if arr.ndim != 2:
      print(f"WARNING: Array bukan 2D (current: {arr.ndim}D)")
  else:
      print(f"✓ Array 2D dengan shape: {arr.shape}")

  # Periksa apakah matriks berisi nilai numerik
  if not np.issubdtype(arr.dtype, np.number):
      print(f"WARNING: Tipe data mungkin perlu konversi: {arr.dtype}")
      return

  print(f"✓ Tipe data numerik: {arr.dtype}")

  # Cek missing values (NaN)
  if np.isnan(arr).any():
      nan_count = np.isnan(arr).sum()
      print(f"WARNING: Terdapat {nan_count} nilai NaN")
  else:
      print("✓ Tidak ada nilai NaN")

  # Informasi memori
  memory_mib = arr.nbytes / (1024 * 1024)
  print(f"Penggunaan memori: {memory_mib:.2f} MiB")

# Test dengan berbagai array
test_arrays = [
  np.array([[1, 2, 3], [4, 5, 6]], dtype=np.float64),
  np.array([1, 2, 3, 4, 5], dtype=np.int64),
  np.array([[1, 2, np.nan], [4, 5, 6]], dtype=np.float64)
]

for i, arr in enumerate(test_arrays):
  print(f"\n--- Test Array {i+1} ---")
  validate_feature_matrix(arr)

# Output:
# --- Test Array 1 ---
# === Validasi Array untuk ML ===
# ✓ Array 2D dengan shape: (2, 3)
# ✓ Tipe data numerik: float64
# ✓ Tidak ada nilai NaN
# Penggunaan memori: 0.00 MiB
#
# --- Test Array 2 ---
# === Validasi Array untuk ML ===
# WARNING: Array bukan 2D (current: 1D)
# ✓ Tipe data numerik: int64
# ✓ Tidak ada nilai NaN
# Penggunaan memori: 0.00 MiB
#
# --- Test Array 3 ---
# === Validasi Array untuk ML ===
# ✓ Array 2D dengan shape: (2, 3)
# ✓ Tipe data numerik: float64
# WARNING: Terdapat 1 nilai NaN
# Penggunaan memori: 0.00 MiB