Python - Kelas Penyelubung

Pengenalan ke Kelas Penyelubung

Halo disana, penyihir Python masa depan! Hari ini, kita akan melakukan perjalanan yang menarik ke dalam dunia kelas penyelubung. Jangan khawatir jika Anda baru mengenal pemrograman – saya akan memandu Anda melalui konsep ini langkah demi langkah, seperti yang saya lakukan untuk banyak mahasiswa selama tahun-tahun pengajaran saya.

Bayangkan Anda memiliki hadiah yang indah, tetapi Anda ingin membuatnya lebih spesial dengan membungkusnya dalam kertas yang bagus. Itu hampir sama dengan apa yang kita lakukan dengan kelas penyelubung di Python – kita mengambil objek yang ada dan "membungkus" mereka dengan fungsi tambahan. Keren, kan?

Apa Itu Kelas Penyelubung?

Kelas penyelubung adalah kelas yang mengelilingi (atau "membungkus") objek dari kelas lain atau tipe data primitif. Itu seperti menempatkan case perlindungan pada ponsel Anda – ponsel masih bekerja seperti biasa, tetapi sekarang memiliki beberapa fitur dan perlindungan ekstra.

Mengapa Menggunakan Kelas Penyelubung?

1. Untuk menambahkan fungsi baru ke objek yang ada
2. Untuk mengubah perilaku metode yang ada
3. Untuk mengontrol akses ke objek asli

Mari kita melompat ke beberapa contoh kode untuk melihat bagaimana ini bekerja dalam praktek!

Contoh Kelas Penyelubung Dasar

class StringWrapper:
def __init__(self, string):
self.string = string

def get_string(self):
return self.string

def append(self, text):
self.string += text

# Menggunakan penyelubung kita
wrapped_string = StringWrapper("Halo")
print(wrapped_string.get_string())  # Output: Halo
wrapped_string.append(" Dunia!")
print(wrapped_string.get_string())  # Output: Halo Dunia!

Dalam contoh ini, kita telah membuat kelas penyelubung sederhana untuk string. Mari kita pecahkan:

1. Kita mendefinisikan kelas bernama StringWrapper.
2. Metode __init__ menginisialisasi penyelubung kita dengan string.
3. get_string() memungkinkan kita untuk mengambil string yang dibungkus.
4. append() adalah metode baru yang menambahkan fungsi – itu menambahkan teks ke string kita.

Lihat bagaimana kita telah menambahkan fungsi baru (penambahan) ke string dasar? Itu adalah kekuatan kelas penyelubung!

Mengubah Perilaku dengan Kelas Penyelubung

Sekarang, mari kita lihat bagaimana kita dapat mengubah perilaku metode yang ada:

class ShoutingList(list):
def __getitem__(self, index):
return super().__getitem__(index).upper()

# Menggunakan penyelubung kita
normal_list = ["halo", "dunia", "python"]
shouting_list = ShoutingList(normal_list)

print(normal_list[0])     # Output: halo
print(shouting_list[0])   # Output: HALO

Dalam contoh ini:

1. Kita membuat kelas ShoutingList yang mewarisi kelas built-in list.
2. Kita menimpa metode __getitem__ untuk mengembalikan string huruf besar.
3. Ketika kita mengakses item di dalam ShoutingList, mereka secara otomatis dikonversi menjadi huruf besar.

Itu seperti memiliki teman yang selalu berteriak saat mengulangkan apa yang Anda katakan – konten yang sama, pengiriman yang berbeda!

Mengontrol Akses dengan Kelas Penyelubung

Kelas penyelubung juga dapat digunakan untuk mengontrol akses ke objek asli. Ini sangat berguna untuk perlindungan data atau implementasi objek hanya-baca:

class ReadOnlyWrapper:
def __init__(self, data):
self._data = data

def get_data(self):
return self._data

def __setattr__(self, name, value):
if name == '_data':
super().__setattr__(name, value)
else:
raise AttributeError("Objek ini hanya-baca")

# Menggunakan penyelubung kita
data = [1, 2, 3]
read_only_data = ReadOnlyWrapper(data)

print(read_only_data.get_data())  # Output: [1, 2, 3]
read_only_data.get_data().append(4)  # Ini bekerja, mengubah daftar asli
print(read_only_data.get_data())  # Output: [1, 2, 3, 4]

try:
read_only_data.new_attribute = "Tidak bisa menambahkan ini"
except AttributeError as e:
print(e)  # Output: Objek ini hanya-baca

Dalam contoh ini:

1. Kita membuat kelas ReadOnlyWrapper yang hanya memungkinkan membaca data.
2. Kita menimpa __setattr__ untuk mencegah penambahan atribut baru ke penyelubung.
3. Data asli masih dapat diubah melalui get_data(), tetapi tidak ada atribut baru yang dapat ditambahkan ke penyelubung itu sendiri.

Itu seperti memiliki pameran museum – Anda dapat melihat, tetapi tidak dapat menyentuh!

Aplikasi Praktis dari Kelas Penyelubung

Kelas penyelubung memiliki banyak aplikasi dunia nyata. Berikut adalah beberapa contoh:

1. Logging: Membungkus objek untuk mencatat panggilan metode atau akses atribut.
2. Caching: Mengimplementasikan lapisan caching di sekitar operasi yang mahal.
3. Validasi Masukan: Menambahkan pemeriksaan untuk memastikan data memenuhi kriteria tertentu sebelum digunakan.
4. Lazy Loading: Meng推迟 pembuatan objek sampai objek benar-benar diperlukan.

Mari kita implementasikan penyelubung logging sederhana:

import time

class LoggingWrapper:
def __init__(self, obj):
self.wrapped_obj = obj

def __getattr__(self, name):
original_attr = getattr(self.wrapped_obj, name)
if callable(original_attr):
def wrapper(*args, **kwargs):
start_time = time.time()
result = original_attr(*args, **kwargs)
end_time = time.time()
print(f"Dipanggil {name}, memakan {end_time - start_time:.2f} detik")
return result
return wrapper
return original_attr

# Menggunakan penyelubung logging kita
class SlowCalculator:
def add(self, x, y):
time.sleep(1)  # Simulasikan operasi lambat
return x + y

calc = SlowCalculator()
logged_calc = LoggingWrapper(calc)

result = logged_calc.add(3, 4)
print(f"Hasil: {result}")

Output:

Dipanggil add, memakan 1.00 detik
Hasil: 7

Dalam contoh ini:

1. Kita membuat LoggingWrapper yang membungkus objek apapun.
2. itu menangkap panggilan metode, mencatat waktu yang diambil, dan kemudian memanggil metode asli.
3. Kita menggunakannya untuk membungkus objek SlowCalculator dan mencatat panggilannya.

Itu seperti memiliki asisten pribadi yang menghitung waktu semua tugas Anda dan melaporkan kembali kepada Anda!

Kesimpulan

Kelas penyelubung adalah alat yang kuat di Python yang memungkinkan Anda untuk memperpanjang, mengubah, dan mengontrol objek dengan cara yang fleksibel. Mereka seperti pisaunya penyihir Python – serbaguna dan sangat berguna dalam situasi yang tepat.

Ingat, kunci untuk menguasai kelas penyelubung adalah praktek. Cobalah membuat penyelubung Anda sendiri untuk objek yang berbeda dan lihat bagaimana Anda dapat meningkatkan fungsionalitas mereka. Siapa tahu? Anda mungkin saja membungkus jalan Anda menjadi seorang master Python!

Selamat coding, dan semoga kode Anda selalu tertutup secara rapi! ??

Metode	Deskripsi
__init__(self, obj)	Inisialisasi penyelubung dengan objek yang akan dibungkus
__getattr__(self, name)	Tangkap akses atribut pada penyelubung
__setattr__(self, name, value)	Tangkap penetapan atribut pada penyelubung
__getitem__(self, key)	Tangkap akses item (misalnya, untuk objek seperti list)
__setitem__(self, key, value)	Tangkap penetapan item
__call__(self, *args, **kwargs)	Jadikan penyelubung dapat dipanggil jika objek yang dibungkus dapat dipanggil
__iter__(self)	Jadikan penyelubung dapat diiterasi jika objek yang dibungkus dapat diiterasi
__len__(self)	Implementasikan pelaporan panjang untuk penyelubung
__str__(self)	Sesuaikan representasi string penyelubung
__repr__(self)	Sesuaikan representasi repr penyelubung

Metode ini memungkinkan Anda untuk menyesuaikan hampir setiap aspek tentang bagaimana kelas penyelubung Anda berinteraksi dengan kode Anda, memberikan Anda kontrol yang halus atas interaksi objek yang dibungkus dengan kode Anda yang lain.

Credits: Image by storyset