Python - Kelas Penyelit

Pengenalan kepada Kelas Penyelit

Hai di sana, pelindung Python masa depan! Hari ini, kita akan melakukan perjalanan yang menarik ke dunia kelas penyelit. Jangan khawatir jika anda baru dalam pemrograman – saya akan pandu anda melalui konsep ini langkah demi langkah, sama seperti saya telah lakukan untuk pelbagai pelajar selama tahun tahun pengajaran saya.

Bayangkan anda memiliki hadiah yang indah, tetapi anda ingin menjadikannya lebih istimewa dengan mengikatnya di atas kertas yang kemas. Itulah yang kita lakukan dengan kelas penyelit di Python – kita mengambil objek yang ada dan "mengikat" mereka dengan fungsi tambahan. Keren, kan?

Apa itu Kelas Penyelit?

Kelas penyelit adalah kelas yang menyelit (atau "mengikat") objek dari kelas lain atau jenis data primitif. Ia seperti meletakkan rakitan perlindungan di atas ponsel anda – ponsel masih berfungsi seperti biasa, tetapi sekarang ia memiliki beberapa fitur dan perlindungan tambahan.

Mengapa Gunakan Kelas Penyelit?

1. Untuk menambah fungsi baru kepada objek yang ada
2. Untuk mengubah tingkah laku method yang ada
3. Untuk mengawal akses kepada objek asal

Mari kita melompat ke beberapa contoh kode untuk melihat bagaimana ini berkerja di atas lapangan!

Contoh Kelas Penyelit 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 penyelit kita
wrapped_string = StringWrapper("Hello")
print(wrapped_string.get_string())  # Output: Hello
wrapped_string.append(" World!")
print(wrapped_string.get_string())  # Output: Hello World!

Dalam contoh ini, kita telah membuat kelas penyelit sederhana untuk string. Mari kita kongsi:

1. Kita mendefinisikan kelas yang dipanggil StringWrapper.
2. Method __init__ menginisialisasi penyelit kita dengan string.
3. get_string() membolehkan kita untuk mendapatkan string yang diselit.
4. append() adalah method baru yang menambah fungsi – ia menambah teks kepada string kita.

Lihat bagaimana kita telah menambah fungsi baru (penambahan) kepada string biasa? Itulah kekuatan kelas penyelit!

Mengubah Tingkah Laku dengan Kelas Penyelit

Sekarang, mari kita lihat bagaimana kita dapat mengubah tingkah laku method yang ada:

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

# Menggunakan penyelit kita
normal_list = ["hello", "world", "python"]
shouting_list = ShoutingList(normal_list)

print(normal_list[0])     # Output: hello
print(shouting_list[0])   # Output: HELLO

Dalam contoh ini:

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

Ini seperti memiliki rakan yang selalu untuk mengekuk di atas apa yang anda katakan – konten yang sama, penghantaran yang berbeza!

Mengawal Akses dengan Kelas Penyelit

Kelas penyelit juga dapat digunakan untuk mengawal akses kepada objek asal. Ini adalah sangat berguna untuk perlindungan data atau pelaksanaan 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 adalah hanya-baca")

# Menggunakan penyelit 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 berfungsi, mengubah senarai asal
print(read_only_data.get_data())  # Output: [1, 2, 3, 4]

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

Dalam contoh ini:

1. Kita membuat kelas ReadOnlyWrapper yang hanya membenarkan pembacaan data.
2. Kita menimpa __setattr__ untuk mencegah penambahan atribut baru kepada penyelit.
3. Data asal masih boleh diubah melalui get_data(), tetapi tidak ada atribut baru yang boleh ditambahkan kepada penyelit itu sendiri.

Ini seperti memiliki rakaman di atas rakaman – anda boleh lihat, tetapi anda tidak boleh sentuh!

Aplikasi Praktikal Kelas Penyelit

Kelas penyelit memiliki banyak aplikasi dunia sebenar. Berikut adalah beberapa contoh:

1. Logging: Selit objek untuk melog panggilan method atau akses atribut.
2. Caching: Pelaksanaan lapisan penyelamat di atas operasi yang mahal.
3. Pengesahan input: Tambah pemeriksaan untuk memastikan data memenuhi kriteria tertentu sebelum digunakan.
4. Lazy loading: Tangguhkan penciptaan objek sehingga ia benar-benar diperlukan.

Mari kita implementasikan penyelit 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"Panggil {name}, ambil {end_time - start_time:.2f} saat")
return result
return wrapper
return original_attr

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

calc = SlowCalculator()
logged_calc = LoggingWrapper(calc)

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

Output:

Panggil add, ambil 1.00 saat
Hasil: 7

Dalam contoh ini:

1. Kita membuat LoggingWrapper yang menyelit apa jua objek.
2. Ia menangkap panggilan method, log masa yang diambil, dan kemudian panggil method asal.
3. Kita gunakan itu untuk menyelit objek SlowCalculator dan log panggilan methodnya.

Ini seperti memiliki wakil pribadi yang masa semua tugasan anda dan melaporkan kembali kepada anda!

Kesimpulan

Kelas penyelit adalah alat yang berkuasa di Python yang membolehkan anda untuk melanjutkan, mengubah dan mengawal objek dengan cara yang fleksibel. Ia seperti rakitan tentera Swiss dalam pemrograman berorientasi objek – serba guna dan sangat berguna dalam situasi yang betul.

Ingat, kunci untuk menguasai kelas penyelit adalah praktek. Cuba untuk membuat penyelit anda sendiri untuk objek yang berbeza dan lihat bagaimana anda dapat meningkatkan fungsi mereka. Siapa tahu? Anda mungkin hanya perlu untuk menyelit jalan anda untuk menjadi master Python!

Selamat coding, dan may kod anda sentiasa diikat dengan baik! ??

Method	Keterangan
__init__(self, obj)	Inisialisasi penyelit dengan objek yang akan diselit
__getattr__(self, name)	Tangkap akses atribut di atas penyelit
__setattr__(self, name, value)	Tangkap penetapan atribut di atas penyelit
__getitem__(self, key)	Tangkap akses item (cth, untuk objek seperti senarai)
__setitem__(self, key, value)	Tangkap penetapan item
__call__(self, *args, **kwargs)	Jadikan penyelit dapat dipanggil jika objek yang diselit dapat dipanggil
__iter__(self)	Jadikan penyelit dapat diiterasi jika objek yang diselit dapat diiterasi
__len__(self)	Implementasi pelaporan panjang bagi penyelit
__str__(self)	Ubah representasi string penyelit
__repr__(self)	Ubah representasi repr penyelit

Method ini membolehkan anda untuk menyesuaikan hampir setiap aspek bagaimana kelas penyelit anda berkelakuan, memberikan anda kawalan yang halus atas interaksi objek yang diselit dengan keseluruhan kod anda.

Credits: Image by storyset