Enkapsulasi di Python: Panduan Komprehensif

Enkapsulasi adalah prinsip dasar berorientasi objek di Python. Ini melindungi kelas Anda dari perubahan atau penghapusan yang tidak disengaja serta mendorong keterpakaiulangan dan kemudahan pemeliharaan kode. Pertimbangkan definisi kelas sederhana berikut:

class Smartphone:
   def __init__(self, brand, os):
       self.brand = brand
       self.os = os

iphone = Smartphone("Apple", "iOS 17")

Banyak programmer Python mendefinisikan kelas seperti ini. Namun, ini jauh dari praktik terbaik yang diikuti para Pythonista pro. Masalah dengan kelas ini terlihat jelas ketika Anda mencoba mengubah datanya:

iphone.os = "Android"
print(iphone.os)

Android

Bayangkan iPhone berjalan di Android — sungguh keterlaluan! Jelas, kita perlu menetapkan batasan dalam kelas kita agar pengguna tidak bisa mengubah atributnya sesuka hati.

Jika pun mereka memutuskan untuk mengubahnya, perubahan tersebut harus sesuai ketentuan kita, mengikuti aturan kita. Namun kita tetap ingin atribut .os atau .brand terlihat sama di permukaan.

Semua hal ini dapat ditingkatkan dengan enkapsulasi dan dalam tutorial ini, kita akan mempelajarinya secara menyeluruh. Mari mulai!

Bagaimana Enkapsulasi Dicapai di Python?

Python mendukung enkapsulasi melalui konvensi dan praktik pemrograman, bukan melalui pengubah akses yang dipaksakan. Anda lihat, prinsip mendasar di balik banyak desain kode Python adalah “Kita semua di sini orang dewasa.” Kita hanya dapat menerapkan enkapsulasi sebagai konvensi semata dan berharap pengembang Python lain mempercayai serta menghormati kode kita.

Di bahasa OOP lain seperti Java dan C++, enkapsulasi ditegakkan ketat dengan pengubah akses seperti public, private atau protected, tetapi Python tidak memiliki itu:

Jadi, sebagian besar, jika bukan semua, teknik enkapsulasi yang akan saya tunjukkan adalah konvensi Python. Konvensi ini mudah dilanggar jika Anda mau. Namun saya percaya Anda akan menghormati dan mengikutinya dalam proyek pengembangan Anda sendiri.

Pengubah akses di Python

Misalkan kita memiliki kelas sederhana berikut:

class Tree:
   def __init__(self, height):
       self.height = height

pine = Tree(20)
print(pine.height)

20

Kelas ini memiliki satu atribut height yang bisa kita cetak. Masalahnya, kita juga bisa mengubahnya sesuka hati:

pine.height = 50
pine.height

50

pine.height = "Grandma"
pine.height

'Grandma'

Jadi, bagaimana cara memberi tahu pengguna bahwa mengubah height itu terlarang? Kita bisa menjadikannya anggota terlindungi (protected) dengan menambahkan satu garis bawah di depan:

class Tree:
   def __init__(self, height):
       self._height = height

pine = Tree(20)
pine._height

20

Sekarang, orang yang paham konvensi ini akan tahu bahwa mereka hanya boleh mengakses atribut tersebut dan bahwa kita sangat tidak menyarankan mereka menggunakan serta mengubahnya. Namun jika mereka mau, mereka tetap bisa mengubahnya, oh iya.

Jadi, bagaimana cara mencegah itu juga? Dengan menggunakan konvensi lain — ubah atribut menjadi anggota privat dengan menambahkan dua garis bawah di depan:

class Tree:
   def __init__(self, height):
       self.__height = height


pine = Tree(20)
pine.__height

AttributeError: 'Tree' object has no attribute '__height'

Sekarang, Python akan menimbulkan error jika seseorang mencoba mengakses atribut tersebut, apalagi mengubahnya.

Namun Anda sadar apa yang baru saja kita lakukan? Kita menyembunyikan satu-satunya informasi terkait objek kita dari pengguna. Kelas kita jadi tidak berguna karena tidak memiliki atribut publik.

Lalu, bagaimana kita mengekspos tinggi pohon kepada pengguna namun tetap mengendalikan bagaimana atribut itu diakses dan diubah? Misalnya, kita ingin tinggi pohon berada dalam rentang tertentu dan hanya bernilai integer. Bagaimana menegakkannya?

Pada titik ini, teman Anda yang menggunakan Java mungkin menyela dan menyarankan penggunaan metode getter dan setter. Jadi, mari kita coba dulu:

class Tree:
   def __init__(self, height):
       self.__height = height

   def get_height(self):
       return self.__height

   def set_height(self, new_height):
       if not isinstance(new_height, int):
           raise TypeError("Tree height must be an integer")
       if 0 < new_height <= 40:
           self.__height = new_height
       else:
           raise ValueError("Invalid height for a pine tree")


pine = Tree(20)
pine.get_height()

20

Dengan cara ini, Anda membuat atribut privat __height tetapi membiarkan pengguna mengakses dan mengubahnya secara terkontrol menggunakan metode get_height dan set_height.

pine.set_height(25)

pine.get_height()

25

Sebelum menetapkan nilai baru, set_height memastikan bahwa tinggi baru berada dalam rentang tertentu dan bertipe numerik.

pine.set_height("Password")

TypeError: Tree height must be an integer

Namun metode-metode ini terasa berlebihan untuk operasi sederhana. Selain itu, kurang sedap ditulis seperti ini:

# Increase height by 5
pine.set_height(pine.get_height() + 5)

Bukankah akan lebih indah dan mudah dibaca jika kita bisa menulis kode ini:

pine.height += 5

dan tetap menegakkan tipe data dan rentang yang benar untuk height? Jawabannya ya, dan kita akan mempelajari caranya di bagian berikut.

Menggunakan dekorator @property dalam kelas Python

Kita perkenalkan teknik baru — membuat property untuk atribut:

class Tree:
   def __init__(self, height):
       # First, create a private or protected attribute
       self.__height = height

   @property
   def height(self):
       return self.__height

pine = Tree(17)
pine.height

17

Kita ingin pengguna mengakses atribut tersembunyi bernama __height seolah-olah itu atribut normal bernama height. Untuk mencapainya, kita mendefinisikan metode bernama height yang mengembalikan self.__height dan menghiasinya dengan @property.

Sekarang, kita bisa memanggil height dan mengakses atribut privat:

pine.height

17

Namun bagian terbaiknya adalah pengguna tidak bisa mengubahnya:

pine.height = 15

AttributeError: can't set attribute 'height'

Jadi, kita tambahkan metode lain bernama height(self, new_height) yang dibungkus oleh dekorator height.setter. Di dalam metode ini, kita menerapkan logika yang menegakkan tipe data dan rentang yang diinginkan untuk height:

class Tree:
   def __init__(self, height):
       self.__height = height

   @property
   def height(self):
       return self.__height

   @height.setter
   def height(self, new_height):
       if not isinstance(new_height, int):
           raise TypeError("Tree height must be an integer")
       if 0 < new_height <= 40:
           self.__height = new_height
       else:
           raise ValueError("Invalid height for a pine tree")

Sekarang, ketika pengguna mencoba mengubah atribut height, @height.setter akan dipanggil, sehingga memastikan nilai yang benar diteruskan:

pine = Tree(10)

pine.height = 33  # Calling @height.setter
pine.height = 45  # An error is raised

ValueError: Invalid height for a pine tree

Kita juga dapat menyesuaikan bagaimana atribut height diakses melalui notasi titik dengan @height.getter:

class Tree:
   def __init__(self, height):
       self.__height = height

   @property
   def height(self):
       return self.__height

   @height.getter
   def height(self):
       # You can return a custom version of height
       return f"This tree is {self.__height} meters"


pine = Tree(33)

pine.height

'This tree is 33 meters'

Meskipun kita membuat pine dengan tinggi bertipe integer, kita bisa memodifikasi nilai tampilannya dengan @height.getter.

Itu adalah contoh bagaimana kita dapat meningkatkan enkapsulasi dalam kelas Python. Ingat, enkapsulasi tetaplah konvensi karena kita masih bisa membobol anggota privat internal __height:

pine._Tree__height = "Gotcha!"

pine.height

'This tree is Gotcha! meters'

Segala sesuatu dalam kelas Python bersifat publik, begitu juga metode privat. Ini bukan cacat desain melainkan perwujudan pendekatan “Kita semua orang dewasa di sini”.

Berikut ringkasan pengubah akses Python yang baru saja kita tinjau:

Praktik Terbaik Saat Menerapkan Enkapsulasi

Ada sejumlah praktik terbaik yang dapat Anda ikuti untuk memastikan kode Anda selaras dengan kode yang ditulis oleh OOPista berpengalaman lainnya:

1. Buat atribut atau metode terlindungi atau privat jika hanya digunakan oleh Anda. Anggota terlindungi atau privat dikecualikan dari dokumentasi dan memberi sinyal kepada orang lain bahwa anggota tersebut dapat Anda ubah, sebagai pengembang, tanpa pemberitahuan, sehingga mencegah mereka menggunakannya.
2. Anda tidak selalu harus membuat property untuk setiap atribut kelas. Untuk kelas besar dengan banyak atribut, menulis metode attr.getter dan attr.setter bisa menjadi pekerjaan yang merepotkan.
3. Pertimbangkan untuk menimbulkan peringatan setiap kali pengguna mengakses anggota terlindungi (_).
4. Gunakan anggota privat seperlunya, karena dapat membuat kode sulit dibaca bagi yang tidak terbiasa dengan konvensi.
5. Utamakan kejelasan daripada kerumitan. Karena enkapsulasi bertujuan meningkatkan pemeliharaan kode dan perlindungan data, jangan sepenuhnya menyembunyikan detail implementasi penting dari kelas Anda.
6. Jika Anda ingin membuat property hanya-baca, jangan implementasikan metode @attr.setter. Pengguna akan dapat mengakses property tersebut tetapi tidak dapat mengubahnya.
7. Selalu ingat bahwa enkapsulasi adalah konvensi, bukan aspek yang dipaksakan oleh sintaks Python.
8. Untuk kelas sederhana, pertimbangkan menggunakan dataclass yang memungkinkan Anda mengaktifkan enkapsulasi kelas dengan satu baris kode. Namun, dataclass cocok untuk kelas yang lebih sederhana dengan atribut dan metode yang dapat diprediksi. Lihat tutorial dataclass ini untuk mempelajari lebih lanjut.

Kesimpulan dan Sumber Lanjutan

Dalam tutorial ini, kita telah mempelajari salah satu pilar inti pemrograman berorientasi objek di Python: enkapsulasi.

Enkapsulasi memungkinkan Anda mendefinisikan akses terkontrol ke data yang disimpan di dalam objek kelas Anda. Ini memungkinkan Anda menulis kode yang bersih, mudah dibaca, dan efisien serta mencegah perubahan atau penghapusan data kelas secara tidak sengaja.

Berikut beberapa sumber terkait untuk meningkatkan pengetahuan OOP Anda:

• Tutorial OOP Python
• Object-oriented Programming in Python
• Cara Menguasai Python — Panduan Ahli