Python - Penyahpepijat Akses

Hai di sana, pemrogram Python yang berhasrat! Hari ini, kita akan melakukan perjalanan yang menarik ke atas dunia Penyahpepijat Akses di Python. Jangan khawatir jika kamu baru mengenal pemrograman; Saya akan memandu kamu melalui konsep ini langkah demi langkah, dengan banyak contoh dan penjelasan di sepanjang jalan. Jadi, mari kita melompat masuk!

Python - Access Modifiers

Penyahpepijat Akses di Python

Dalam pemrograman berorientasi objek, penyahpepijat akses digunakan untuk mengawasi keberapa dan aksesibilitas anggota kelas (atribut dan metode). Walaupun banyak bahasa pemrograman memiliki penyahpepijat akses yang ketat seperti publik, pribadi, dan dilindungi, Python mengambil pendekatan yang lebih santai. Ia mengikuti filosofi yang sering dirujuk sebagai "Kami semua adalah orang dewasa yang memberikan persetujuan."

Di Python, kita memiliki tiga jenis penyahpepijat akses:

Publik
Dilindungi
Pribadi

Mari kita jelajahi masing-masing jenis ini dengan contoh.

Anggota Publik

Di Python, semua anggota adalah publik secara default. Ini berarti mereka dapat diakses dari luar kelas. Ini adalah contoh:

class Student:
def __init__(self, name, age):
self.name = name  # Atribut publik
self.age = age    # Atribut publik

def display_info(self):  # Metode publik
print(f"Name: {self.name}, Age: {self.age}")

# Membuat contoh dari Student
student1 = Student("Alice", 20)

# Mengakses anggota publik
print(student1.name)  # Output: Alice
student1.display_info()  # Output: Name: Alice, Age: 20

Dalam contoh ini, name, age, dan display_info() adalah semua anggota publik. Kita dapat mengakses mereka secara langsung dari luar kelas.

Anggota Dilindungi

Anggota dilindungi ditandai dengan awalan tanda underscore (_). Mereka tidak benar-benar pribadi dan masih dapat diakses dari luar kelas, tetapi merupakan konvensi untuk memperlakukan mereka sebagai hanya untuk penggunaan internal.

class Employee:
def __init__(self, name, salary):
self._name = name      # Atribut dilindungi
self._salary = salary  # Atribut dilindungi

def _display_salary(self):  # Metode dilindungi
print(f"{self._name}'s salary is ${self._salary}")

# Membuat contoh dari Employee
emp1 = Employee("Bob", 50000)

# Mengakses anggota dilindungi (Catatan: Ini mungkin tetapi tidak direkomendasikan)
print(emp1._name)  # Output: Bob
emp1._display_salary()  # Output: Bob's salary is $50000

Meskipun kita dapat mengakses _name, _salary, dan _display_salary(), secara umum tidak direkomendasikan untuk melakukan hal tersebut di luar kelas atau subkelasnya.

Anggota Pribadi

Anggota pribadi ditandai dengan awalan dua tanda underscores (__). Python melakukan pengganti nama untuk anggota ini, membuat mereka lebih sulit (tetapi tidak mustahil) untuk diakses dari luar kelas.

class BankAccount:
def __init__(self, account_number, balance):
self.__account_number = account_number  # Atribut pribadi
self.__balance = balance                # Atribut pribadi

def __display_balance(self):  # Metode pribadi
print(f"Balance: ${self.__balance}")

def public_display(self):
self.__display_balance()

# Membuat contoh dari BankAccount
account1 = BankAccount("123456", 1000)

# Mencoba mengakses anggota pribadi
# print(account1.__account_number)  # Ini akan menimbulkan kesalahan AttributeError
# account1.__display_balance()      # Ini juga akan menimbulkan kesalahan AttributeError

# Mengakses metode pribadi melalui metode publik
account1.public_display()  # Output: Balance: $1000

Dalam contoh ini, __account_number, __balance, dan __display_balance() adalah anggota pribadi. Mencoba mengakses mereka secara langsung dari luar kelas akan menimbulkan kesalahan AttributeError.

Pengganti Nama

Ingat ketika saya menyebutkan bahwa anggota pribadi di Python tidak benar-benar pribadi? Ini karena mekanisme yang disebut pengganti nama. Ketika kamu membuat anggota pribadi menggunakan dua tanda underscores, Python mengubah nama internal mereka untuk membuat mereka lebih sulit untuk diakses secara kebetulan.

Berikut ini adalah cara kerjanya:

class NameManglingDemo:
def __init__(self):
self.__private_var = "Saya pribadi!"

demo = NameManglingDemo()
print(dir(demo))
# Output: [..., '_NameManglingDemo__private_var', ...]

# Mengakses variabel pribadi menggunakan nama yang diganti
print(demo._NameManglingDemo__private_var)  # Output: Saya pribadi!

Seperti yang dapat dilihat, Python mengubah __private_var menjadi _NameManglingDemo__private_var. Ini adalah pengganti nama yang sedang beraksi!

Objek Properti Python

Fungsi property() di Python adalah fungsi bawaan yang menciptakan dan mengembalikan objek properti. Ini adalah cara untuk menambahkan metode getter, setter, dan deleter ke atribut kelas.

Berikut ini adalah contoh:

class Temperature:
def __init__(self, celsius):
self._celsius = celsius

def get_fahrenheit(self):
return (self._celsius * 9/5) + 32

def set_fahrenheit(self, fahrenheit):
self._celsius = (fahrenheit - 32) * 5/9

fahrenheit = property(get_fahrenheit, set_fahrenheit)

# Menggunakan properti
temp = Temperature(25)
print(temp.fahrenheit)  # Output: 77.0

temp.fahrenheit = 86
print(temp._celsius)  # Output: 30.0

Dalam contoh ini, fahrenheit adalah properti yang memungkinkan kita untuk mendapatkan dan mengatur suhu dalam Fahrenheit sementara menyimpannya secara internal dalam Celsius.

Metode Getter dan Setter

Getter dan setter adalah metode yang digunakan untuk mendapatkan dan mengatur nilai atribut kelas. Mereka menyediakan cara untuk mengakses dan mengubah atribut pribadi sambil menjaga enkapsulasi.

Berikut ini adalah contoh menggunakan dekorator @property, yang adalah cara yang lebih Pythonic untuk mengimplementasikan getter dan setter:

class Person:
def __init__(self, name, age):
self._name = name
self._age = age

@property
def name(self):
return self._name

@name.setter
def name(self, value):
if not isinstance(value, str):
raise ValueError("Nama harus berupa string")
self._name = value

@property
def age(self):
return self._age

@age.setter
def age(self, value):
if not isinstance(value, int) or value < 0:
raise ValueError("Umur harus berupa integer positif")
self._age = value

# Menggunakan getter dan setter
person = Person("Charlie", 30)
print(person.name)  # Output: Charlie

person.name = "David"
print(person.name)  # Output: David

try:
person.age = -5
except ValueError as e:
print(e)  # Output: Umur harus berupa integer positif

Dalam contoh ini, kita telah membuat getter dan setter untuk name dan age. Metode setter termasuk validasi untuk memastikan bahwa nilai yang diatur memenuhi kriteria tertentu.

Untuk ringkasan metode yang kita telah membahas, berikut ini adalah tabel dalam format Markdown:

Metode	Deskripsi	Contoh
Publik	Dapat diakses dari mana saja	`self.name`
Dilindungi	Dapat diakses dalam kelas dan subkelas (menurut konvensi)	`self._name`
Pribadi	Nama diganti untuk membatasi akses	`self.__name`
Properti	Menciptakan objek properti	`property(get_method, set_method)`
Getter	Metode untuk mendapatkan nilai atribut	`@property`
Setter	Metode untuk mengatur nilai atribut	`@attribute.setter`

Dan itu saja! Kita telah membahas penyahpepijat akses di Python, pengganti nama, objek properti, dan metode getter dan setter. Ingat, pendekatan Python terhadap kontrol akses adalah lebih tentang konvensi dan kepercayaan daripada aturan yang ketat. Sebagai kamu melanjutkan perjalanan Pythonmu, kamu akan menemukan bahwa fleksibilitas ini memungkinkan kode yang bersih dan dapat dibaca sambil masih menyediakan cara untuk mengimplementasikan enkapsulasi ketika diperlukan.

Teruskan untuk berlatih, tetap curious, dan happy coding!

Credits: Image by storyset