Python - Pengubah Akses

Halo para pemrogram Python yang aspiratif! Hari ini, kita akan melakukan perjalanan yang menarik ke dunia Pengubah Akses di Python. Jangan khawatir jika Anda baru mengenal pemrograman; saya akan memandu Anda melalui konsep ini langkah demi langkah, dengan banyak contoh dan penjelasan di sepanjang jalan. Jadi, mari kita wadek!

Pengubah Akses di Python

Dalam pemrograman berorientasi objek, pengubah akses digunakan untuk mengontrol kenampakan dan aksesibilitas dari anggota kelas (atribut dan metode). Sementara banyak bahasa pemrograman memiliki pengubah akses yang ketat seperti public, private, dan protected, Python mengambil pendekatan yang lebih santai. Itu mengikuti filosofi yang sering di maksudkan sebagai "Kami semua adalah orang dewasa yang memberikan persetujuan."

Dalam Python, kita memiliki tiga jenis pengubah akses:

1. Public
2. Protected
3. Private

Mari kita jelajahi masing-masing dari ini dengan contoh.

Anggota Public

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

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 sebuah 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 Protected

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

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

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

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

# Mengakses anggota protected (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 melakukannya di luar kelas atau subkelasnya.

Anggota Private

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

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

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

def public_display(self):
self.__display_balance()

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

# Mencoba mengakses anggota pribadi
# print(account1.__account_number)  # Ini akan memunculkan AttributeError
# account1.__display_balance()      # Ini juga akan memunculkan 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 memunculkan AttributeError.

Pengacakan Nama

Ingat ketika saya membahas bahwa anggota pribadi di Python tidak benar-benar pribadi? Ini karena mekanisme yang disebut pengacakan nama. Ketika Anda membuat anggota pribadi menggunakan dua tanda underscore, Python mengubah nama internal untuk membuatnya lebih sulit untuk diakses secara kebetulan.

Inilah bagaimana itu bekerja:

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 diacak
print(demo._NameManglingDemo__private_var)  # Output: Saya pribadi!

Seperti yang Anda lihat, Python mengubah __private_var menjadi _NameManglingDemo__private_var. Itu adalah pengacakan nama dalam aksi!

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.

Inilah contohnya:

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 saat menyimpan secara internal dalam Celsius.

Metode Getter dan Setter

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

Inilah contohnya 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("Name must be a 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("Age must be a positive integer")
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: Age must be a positive integer

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, di sini adalah tabel dalam format Markdown:

Metode	Deskripsi	Contoh
Public	Dapat diakses dari mana saja	self.name
Protected	Dapat diakses dalam kelas dan subkelas (oleh konvensi)	self._name
Private	Nama diacak untuk membatasi akses	self.__name
Properti	Menciptakan objek properti	property(get_method, set_method)
Getter	Metode untuk mendapatkan nilai dari atribut	@property
Setter	Metode untuk mengatur nilai dari atribut	@attribute.setter

Dan itu adalah semua! Kita telah membahas pengubah akses di Python, pengacakan 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 Anda melanjutkan perjalanan Python Anda, Anda akan menemukan bahwa fleksibilitas ini memungkinkan kode yang bersih dan dapat dibaca sambil masih menyediakan cara untuk mengimplementasikan enkapsulasi saat diperlukan.

Terus latihan, tetap curious, dan happy coding!

Credits: Image by storyset