Atribut dan Method Bilangan

Bilangan sebagai Objek

Setiap bilangan Python adalah objek dengan tipe numerik. Tipe itu menentukan atribut dan method yang dapat kamu akses melalui notasi titik.

Menulis $5$ membuat int, sedangkan menulis $3.14$ membuat float. Objek numerik bawaan yang dibahas di sini bersifat tidak dapat diubah. Pemanggilan method seperti conjugate() mengembalikan hasil tanpa mengubah nilai objek semula.

Jika a = 5, penugasan a = a + 1 mengikat nama a ke objek bernilai 6. Identitas objek dan penugasan nama perlu kamu bedakan: objek bernilai 5 tidak berubah menjadi 6.

Mengakses Atribut dan Method

Akses atribut membaca nilai melalui nama anggota objek, sedangkan pemanggilan method menjalankan operasi. Secara umum, atribut juga dapat menghitung nilai saat dibaca. Kamu membaca atribut dengan object.attribute dan memanggil method dengan object.method(). Tanda kurung pada bentuk kedua itulah yang memberitahu Python untuk menjalankan method tersebut.

Bilangan kompleks memperlihatkan perbedaannya dengan jelas. Ekspresi c.real adalah data yang sudah disimpan Python di dalam c, dan akses atribut mengembalikan komponen riil itu. Pemanggilan c.conjugate() adalah pekerjaan yang Python lakukan saat itu juga, dan hasilnya adalah bilangan kompleks kedua yang membiarkan c tetap tidak berubah.

# Membuat bilangan kompleks
c = 2 + 3j

# Mengakses atribut real (bagian riil)
print(c.real)  # Output: 2.0

# Mengakses atribut imag (bagian imajiner)
print(c.imag)  # Output: 3.0

# Memanggil method conjugate() untuk mendapatkan konjugat
print(c.conjugate())  # Output: (2-3j)

Mengenali Tipe Numerik

Python memilih tipe numerik dari literal yang kamu tulis, dan tipe itu menentukan atribut serta method yang dibawa nilainya. Bertanya lebih dulu kepada Python tentang class-nya membuat kamu tidak perlu menebak apakah sebuah operasi tersedia pada nilai tersebut.

Fungsi type() mengembalikan class dari nilai, yaitu objek class, bukan string nama tipe. Ketiga literal di bawah ini terlihat mirip ketika kamu masukkan ke sebuah fungsi, tetapi type() melaporkan class yang berbeda untuk masing-masing.

Menggunakan Fungsi Tipe

Perbedaan literal dan ekspresi penting: 3j adalah literal imajiner, sedangkan 2 + 3j adalah penjumlahan yang menghasilkan objek complex.

# Melihat tipe data bilangan
print(type(42))        # Output: <class 'int'>
print(type(3.14))      # Output: <class 'float'>
print(type(2+3j))      # Output: <class 'complex'>

Membaca Bagian Bilangan Kompleks

Bilangan kompleks menyimpan dua komponennya secara terpisah, dan Python menyediakan keduanya sebagai atribut sehingga kamu tidak perlu membongkarnya sendiri. Atribut real menyimpan komponen riil, atribut imag menyimpan koefisien satuan imajiner, dan keduanya kembali sebagai float meskipun kamu menulis bilangan bulat.

Setiap atribut mengembalikan satu komponen dari bilangan tersebut. Membandingkan bilangan riil murni, bilangan imajiner murni, dan bilangan campuran memperlihatkan komponen mana yang menjadi milik atribut mana.

Atribut real

Atribut real mengembalikan komponen riil dari bilangan tersebut. Membacanya tidak pernah mengubah bilangan itu, sehingga kamu bisa memeriksa nilai yang sama sebanyak yang kamu butuhkan.

# Contoh penggunaan atribut real
z1 = 4 + 5j
z2 = -2 + 7j
z3 = 10 + 0j  # Bilangan riil murni

print(f"Bagian riil dari {z1} adalah {z1.real}")
print(f"Bagian riil dari {z2} adalah {z2.real}")
print(f"Bagian riil dari {z3} adalah {z3.real}")

# Output:
# Bagian riil dari (4+5j) adalah 4.0
# Bagian riil dari (-2+7j) adalah -2.0
# Bagian riil dari (10+0j) adalah 10.0

Atribut imag

Atribut imag mengembalikan koefisien $i$, dan Python menulis satuan itu sebagai j di dalam literal bilangan kompleks. Tanda milik koefisien tersebut, sehingga suku yang dikurangi kembali sebagai bilangan negatif.

# Contoh penggunaan atribut imag
z1 = 3 + 8j
z2 = 6 - 4j
z3 = 0 + 9j  # Bilangan imajiner murni

print(f"Bagian imajiner dari {z1} adalah {z1.imag}")
print(f"Bagian imajiner dari {z2} adalah {z2.imag}")
print(f"Bagian imajiner dari {z3} adalah {z3.imag}")

# Output:
# Bagian imajiner dari (3+8j) adalah 8.0
# Bagian imajiner dari (6-4j) adalah -4.0
# Bagian imajiner dari 9j adalah 9.0

Hasil untuk z2 adalah $-4.0$, karena koefisiennya membawa tanda minus yang berdiri di depan satuan imajiner. Nilai z1 tetap positif, dan bilangan imajiner murni z3 melaporkan $9.0$ dengan komponen riil $0.0$.

Method pada Bilangan Kompleks

Bilangan kompleks juga membawa methodnya sendiri, dan method di bawah ini mencakup operasi yang paling sering kamu pakai. Method conjugate() mengembalikan bilangan kompleks, sehingga kamu bisa terus memanggil method pada hasilnya tanpa mengubah nilai tempat kamu memulai.

Method Conjugate

Untuk $z=a+bi$, conjugate() mengembalikan $\overline{z}=a-bi$. Bagian riilnya tetap dan hanya bagian imajinernya yang berubah tanda, sehingga konjugat menjadi bayangan cermin bilangan itu terhadap sumbu riil.

# Contoh penggunaan method conjugate()
z1 = 3 + 4j
z2 = -2 - 5j
z3 = 7 + 0j

print(f"Konjugat dari {z1} adalah {z1.conjugate()}")
print(f"Konjugat dari {z2} adalah {z2.conjugate()}")
print(f"Konjugat dari {z3} adalah {z3.conjugate()}")

# Output:
# Konjugat dari (3+4j) adalah (3-4j)
# Konjugat dari (-2-5j) adalah (-2+5j)
# Konjugat dari (7+0j) adalah (7-0j)

Hasil kedua memperlihatkan aturan itu pada koefisien negatif. Bagian imajiner z2 adalah $-5$, sehingga konjugatnya membawa $+5$, sementara bagian riilnya tetap $-2$. Bilangan riil seperti z3 adalah konjugat bagi dirinya sendiri, karena bagian imajinernya sudah bernilai nol.

Menghitung Ukuran Bilangan Kompleks

Identitas $z\overline{z}=|z|^2$ menghubungkan bilangan kompleks dengan modulusnya, dan contoh di bawah ini menjalankan identitas tersebut dalam kode. Pada kode Python sehari-hari kamu cukup memanggil abs(z) untuk modulus, jadi bacalah contoh ini sebagai alasan mengapa fungsi bawaan itu bekerja.

import math

# Menghitung modulus bilangan kompleks memakai konjugat
z = 3 + 4j
modulus_squared = z * z.conjugate()
modulus = math.sqrt(modulus_squared.real)

print(f"Bilangan kompleks: {z}")
print(f"Konjugatnya: {z.conjugate()}")
print(f"z × z*: {modulus_squared}")
print(f"Modulus |z|: {modulus}")
print(f"abs(z) bawaan: {abs(z)}")

# Output:
# Bilangan kompleks: (3+4j)
# Konjugatnya: (3-4j)
# z × z*: (25+0j)
# Modulus |z|: 5.0
# abs(z) bawaan: 5.0

Mengalikan $z$ dengan konjugatnya menghapus bagian imajiner dan menyisakan bilangan riil $25$. Akar kuadrat dari bilangan riil itu menghasilkan $5.0$, dan abs(z) bawaan melaporkan nilai yang sama dalam satu pemanggilan.

Method pada Bilangan Bulat dan Float

Bilangan bulat dan float menyediakan method yang sesuai dengan representasinya masing-masing, dan method itu tidak bisa saling ditukar dengan method bilangan kompleks. bit_length() menghitung bit pada nilai absolut bilangan bulat, to_bytes() menuliskan bit itu ke dalam urutan byte, is_integer() memeriksa apakah sebuah float punya bagian pecahan, dan as_integer_ratio() melaporkan pecahan yang benar-benar disimpan float.

Pada Python modern, int juga memiliki is_integer() dan as_integer_ratio(): (42).is_integer() menghasilkan True, sedangkan (42).as_integer_ratio() menghasilkan (42, 1). Tabel ini memilih tipe yang dipakai dalam contoh, bukan membatasi semua pemilik method.

Method Bilangan Bulat

# Beberapa method pada bilangan bulat
n = 42

# Method bit_length() - menghitung jumlah bit yang dibutuhkan
print(f"Jumlah bit untuk {n}: {n.bit_length()}")

# Method to_bytes() - mengubah ke byte
byte_representation = n.to_bytes(2, byteorder='big')
print(f"Representasi byte dari {n}: {byte_representation}")

# Output:
# Jumlah bit untuk 42: 6
# Representasi byte dari 42: b'\x00*'

bit_length() menghitung bit yang dibutuhkan nilai absolut bilangan bulat, dan perhitungan itu mengabaikan tanda serta angka nol di depan. Pada contoh ini, to_bytes() diberi panjang keluaran dan urutan byte secara eksplisit, sehingga hasil dua byte di atas dibuka dengan satu byte nol untuk memenuhi lebar yang kamu minta.

Method Float

# Beberapa method pada bilangan float
f = 3.14159

# Method is_integer() - memeriksa apakah float bilangan bulat
print(f"{f} adalah bilangan bulat: {f.is_integer()}")
print(f"{4.0} adalah bilangan bulat: {(4.0).is_integer()}")

# Method as_integer_ratio() - mengembalikan rasio sebagai pecahan
ratio = f.as_integer_ratio()
print(f"Rasio dari {f}: {ratio}")

# Output:
# 3.14159 adalah bilangan bulat: False
# 4.0 adalah bilangan bulat: True
# Rasio dari 3.14159: (3537115888337719, 1125899906842624)

is_integer() memeriksa apakah sebuah float terhingga tidak punya bagian pecahan, sehingga $3.14159$ gagal pada pemeriksaan itu sementara $4.0$ lolos. as_integer_ratio() mengembalikan pecahan tepat yang tersimpan dalam biner, dan itulah alasan rasio untuk $3.14159$ memuat bilangan sebesar itu alih-alih pecahan desimal yang kamu harapkan.

Memeriksa dan Menghitung dengan Objek Numerik

Atribut dan method juga mendukung pemeriksaan serta konversi, dan kedua langkah itu memang berjalan berurutan. Kamu memeriksa masukannya lebih dulu lalu menghitung, sehingga nilai yang melanggar aturan domain dapat ditolak sebelum perhitungan.

Memeriksa Masukan Sebelum Menghitung

Atribut bisa membawa aturan pemeriksaan yang eksplisit. Fungsi di bawah ini menuntut objek complex terlebih dahulu, lalu menerapkan dua contoh aturan domain pada komponennya dan melaporkan pesan untuk setiap kasus yang ditolak.

def validate_complex_input(z):
  """Fungsi untuk memeriksa masukan bilangan kompleks"""
  if not isinstance(z, complex):
      return False, "Masukan bukan bilangan kompleks"

  if z.real < 0:
      return False, "Bagian riil tidak boleh negatif"

  if z.imag == 0:
      return False, "Bagian imajiner tidak boleh nol"

  return True, "Masukan valid"

# Menguji fungsi pemeriksa
test_numbers = [3+4j, -2+5j, 7+0j, 2.5+1.5j]

for num in test_numbers:
  is_valid, message = validate_complex_input(num)
  print(f"{num}: {message}")

Fungsi itu mengembalikan sepasang nilai, sehingga pemanggilnya menerima keputusan dan alasannya sekaligus. Dari empat bilangan uji, $3+4j$ dan $2.5+1.5j$ lolos ketiga pemeriksaan, $-2+5j$ ditolak karena bagian riilnya negatif, dan $7+0j$ ditolak karena bagian imajinernya nol.

Menghitung dengan Bilangan Kompleks

def complex_operations(z1, z2):
  """Menjalankan berbagai operasi pada bilangan kompleks"""
  print(f"Bilangan 1: {z1}")
  print(f"Bilangan 2: {z2}")
  print(f"Bagian riil z1: {z1.real}")
  print(f"Bagian imajiner z1: {z1.imag}")
  print(f"Konjugat z1: {z1.conjugate()}")

  # Operasi matematika
  addition = z1 + z2
  multiplication = z1 * z2.conjugate()

  print(f"z1 + z2 = {addition}")
  print(f"z1 × z2* = {multiplication}")

# Contoh pemakaian
z1 = 2 + 3j
z2 = 1 - 2j
complex_operations(z1, z2)

Dengan masukan tersebut, z1 + z2 bernilai $3+1j$, karena bagian riil dan bagian imajiner dijumlahkan secara terpisah. Ekspresi z1 * z2.conjugate() mengalikan $2+3j$ dengan $1+2j$ dan mengembalikan $-4+7j$.