Atribut dan Tipe Data dengan NumPy

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 bilangan titik mengambang 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

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	Rentang sangat besar
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	Rentang sangat besar positif
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

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]]

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.]

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	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`

Semua elemen dalam array NumPy biasa berbagi satu tipe data. Objek numpy.dtype menjelaskan cara nilai tersebut disimpan dan diinterpretasikan dalam memori. Jika masukan memiliki tipe berbeda, NumPy memakai aturan promosi tipe untuk mencari dtype bersama yang kompatibel. Hasilnya bergantung pada presisi dan kategori tipe, bukan pada tipe yang paling sering muncul.

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.]

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

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 total memory:", large_array_int64.nbytes, "bytes")  # Output: Int64 total 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 total memory:", large_array_int32.nbytes, "bytes")  # Output: Int32 total 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 %

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

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"Total 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
# Total 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
# Total 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
# Total memory: 64 bytes

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_mb = arr.nbytes / (1024 * 1024)
  print(f"Penggunaan memori: {memory_mb:.2f} MB")

# 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 MB
#
# --- 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 MB
#
# --- 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 MB

Atribut dan Tipe Data dengan NumPy

Sistem Tipe Data NumPy

Atribut dan Tipe Data dengan NumPy

Sistem Tipe Data NumPy

Tipe Data Dasar

Tipe Data Numerik Spesifik

Menentukan Tipe Data

Deteksi Otomatis Tipe Data

Atribut Array NumPy

Atribut Dimensi dan Bentuk

Penjelasan Atribut Penting

Konsistensi Tipe Data

Konversi dan Manipulasi Tipe Data

Metode Konversi Tipe Data

Optimasi Memori dengan Tipe Data

Informasi Detail Tipe Data

Penggunaan Praktis Atribut Array

Analisis Struktur Data

Validasi Data dan Debugging