Jadi, Anda mendalami pemrograman Python, dan Anda menemukan hal menarik yang disebut "polimorfisme". Ini mungkin terdengar mewah, tapi percayalah, ini tidak serumit kelihatannya. Polimorfisme adalah tentang fleksibilitas dan penggunaan kembali dalam kode kita. Mari kita selami dan mengungkapnya bersama-sama.
Apa itu Polimorfisme? Polimorfisme memungkinkan kita memperlakukan objek yang berbeda seolah-olah mereka termasuk dalam keluarga yang sama, meskipun objek tersebut memiliki karakteristik spesifik yang berbeda. Anggap saja sebagai cara menggunakan antarmuka umum untuk melakukan tindakan berbeda pada tipe objek berbeda. Ini menyelamatkan kita dari penulisan kode yang berulang dan membuat program kita lebih mudah beradaptasi.
Pengetikan Dinamis Python: Dalam Python, kami memiliki hal keren yang disebut "pengetikan dinamis". Artinya objek dapat berubah tipenya saat program sedang berjalan. Perilaku dinamis inilah yang membuat polimorfisme di Python begitu kuat. Kita dapat dengan mudah beralih di antara berbagai jenis objek dan menulis kode yang lebih ekspresif.
Bagaimana Cara Kerja Polimorfisme? Polimorfisme dicapai melalui dua konsep utama: pewarisan kelas dan penggantian metode.
Pewarisan Kelas: Dengan pewarisan kelas, kita dapat membuat hierarki kelas. Setiap kelas dapat mewarisi atribut dan metode dari “kelas super” atau “kelas induk” yang umum. Warisan ini memungkinkan kita untuk berbagi fungsionalitas umum di antara kelas-kelas terkait sambil tetap memiliki fleksibilitas untuk menyesuaikan perilaku tertentu di setiap kelas.
Method Overriding: Method overriding seperti memberikan kekuatan khusus pada subclass. Hal ini memungkinkan subkelas untuk menyediakan implementasi metodenya sendiri yang diwarisi dari superkelas. Jadi, meskipun kelas yang berbeda mungkin memiliki nama metode yang sama, mereka dapat berperilaku berbeda berdasarkan kebutuhan spesifiknya. Di sinilah keajaiban polimorfisme terjadi!
Contoh Praktis Polimorfisme:
Perilaku Abstrak:
Bayangkan Anda memiliki beberapa kelas yang berbagi beberapa fungsi umum. Dengan menggunakan polimorfisme, Anda dapat menentukan antarmuka umum (seperangkat metode) yang harus diimplementasikan oleh kelas-kelas ini.
- Bayangkan sekelompok hewan seperti anjing, kucing, dan burung. Meski berbeda-beda, semuanya bisa mengeluarkan suara. Polimorfisme memungkinkan kita memperlakukan mereka dengan cara yang sama, seolah-olah mereka semua termasuk dalam kelompok “hewan pembuat suara” yang sama. Kita bisa mempunyai aturan yang berbunyi, “Jika itu binatang, mintalah ia mengeluarkan suara.” Dengan cara ini, kita dapat membuat berbagai hewan mengeluarkan suara uniknya sendiri tanpa menulis instruksi terpisah untuk setiap hewan.
class Bird:
def sound(self):
print('The bird goes tweet tweet')
class Cat:
def sound(self):
print('The cat meowed')
animal1 = Bird()
animal2 = Cat()
animal1.sound() #The bird goes tweet tweet
animal2.sound() #The cat meowed
Menangani Koleksi:
Polimorfisme menyederhanakan bekerja dengan koleksi yang berisi berbagai jenis objek. Daripada menulis kode terpisah untuk setiap jenis objek, Anda dapat memperlakukan semuanya dengan cara yang sama berdasarkan antarmuka bersama. Hal ini membuat kode Anda lebih fleksibel dan mudah dipelihara.
- Bayangkan Anda mempunyai sekotak mainan, dan setiap mainan melakukan sesuatu yang berbeda. Daripada mengeluarkan setiap mainan secara terpisah dan memainkannya secara berbeda, kita dapat memperlakukan semuanya sebagai mainan dan bermain bersama. Polimorfisme memungkinkan kita memiliki aturan yang mengatakan, “Jika itu mainan, ayo kita mainkan!” Dengan cara ini, kita dapat bersenang-senang dengan mainan yang berbeda tanpa mengkhawatirkan fitur spesifiknya. Kita dapat memperlakukan mereka semua dengan cara yang sama berdasarkan sifat “mainan” mereka.
class Toy:
def play(self):
pass
class Car(Toy):
def play(self):
print("Vroom! I'm a fast car!")
class Robot(Toy):
def play(self):
print("Beep boop! I'm a dancing robot!")
class TeddyBear(Toy):
def play(self):
print("Hug me! I'm a cuddly teddy bear!")
# Create a collection of toys
toys = [Car(), Robot(), TeddyBear()]
# Play with each toy in the collection
for toy in toys:
toy.play()
Pada contoh di atas kita mendefinisikan kelas dasar yang disebut Toy, yang memiliki metode bermain. Metode play dimaksudkan untuk ditimpa oleh subkelas. Kami kemudian membuat subkelas mainan tertentu seperti Mobil, Robot, dan Teddy Bear, masing-masing dengan metode permainannya sendiri.
Selanjutnya, kita membuat koleksi yang disebut mainan yang menyimpan contoh objek mainan yang berbeda (mobil, robot, dan boneka beruang).
Terakhir, kami mengulangi setiap mainan di koleksi mainan dan memanggil metode permainan pada setiap mainan. Di sinilah polimorfisme berperan. Meskipun kita memanggil metode yang sama (bermain), setiap objek mainan berperilaku berbeda berdasarkan implementasinya sendiri. Hasil akhirnya adalah:
#Vroom! I'm a fast car! #Beep boop! I'm a dancing robot! #Hug me! I'm a cuddly teddy bear!
Sistem Plugin:
Sistem plugin seperti memiliki alat berbeda yang dapat dimasukkan ke dalam slot khusus di mesin. Setiap alat memiliki fitur uniknya masing-masing, namun semuanya mengikuti serangkaian aturan atau instruksi agar dapat berfungsi dengan baik.
Polimorfisme berguna saat membuat sistem plugin karena kita dapat menentukan seperangkat aturan standar atau antarmuka yang harus diikuti oleh semua plugin. Antarmuka ini menguraikan metode atau tindakan yang harus dimiliki plugin, seperti “eksekusi” atau “performTask.”
Dengan mengikuti antarmuka ini, berbagai plugin dapat dengan mudah masuk ke dalam mesin tanpa mengubah struktur utama mesin. Mereka terintegrasi dengan mulus dan menyediakan fitur tambahan tanpa perlu mengubah kode inti mesin.
Ini seperti memiliki seperangkat alat yang dapat dipertukarkan yang dapat meningkatkan kemampuan mesin tanpa harus membangunnya kembali. Kita dapat memasang plugin yang berbeda, dan plugin tersebut akan berfungsi karena mengikuti serangkaian aturan yang sama. Fleksibilitas ini memungkinkan kami memperluas fungsionalitas aplikasi kami tanpa membuat perubahan besar pada basis kode utama.
Jadi, polimorfisme dalam sistem plugin adalah tentang menciptakan landasan bersama atau serangkaian instruksi yang dapat diikuti oleh plugin, sehingga memudahkan untuk menambahkan fitur baru tanpa mengacaukan inti program.
- Bayangkan sekotak balok warna-warni yang dapat dihubungkan menjadi satu. Setiap blok memiliki bentuk dan warna tersendiri. Dengan polimorfisme, kita dapat membuat aturan yang mengatakan, “Jika sebuah blok, maka dapat dihubungkan ke blok lain.” Artinya, kita dapat memadupadankan balok-balok berbeda untuk membangun struktur unik tanpa memerlukan instruksi khusus untuk setiap balok. Kita bisa mempunyai balok-balok dengan bentuk dan ukuran yang berbeda-beda, tapi semuanya bisa saling terhubung karena mengikuti aturan yang sama.
class Block:
def connect(self):
pass
class BlueBlock(Block):
def connect(self):
print("Connecting the blue block...")
class RedBlock(Block):
def connect(self):
print("Connecting the red block...")
class YellowBlock(Block):
def connect(self):
print("Connecting the yellow block...")
# Create a collection of blocks
blocks = [BlueBlock(), RedBlock(), YellowBlock()]
# Connect each block in the collection
for block in blocks:
block.connect()
Dalam contoh ini, kita mendefinisikan kelas dasar yang disebut Block, yang memiliki metode connect. Metode ini dimaksudkan untuk ditimpa oleh subkelas. Kami kemudian membuat subkelas blok tertentu seperti BlueBlock, RedBlock, dan YellowBlock, masing-masing dengan implementasi metode koneksinya sendiri.
Selanjutnya, kita membuat koleksi bernama blok yang menampung instance objek blok berbeda. Kami memiliki blok biru, blok merah, dan blok kuning dalam koleksi.
Terakhir, kami mengulangi setiap blok dalam kumpulan blok dan memanggil metode connect pada setiap blok. Di sinilah polimorfisme berperan. Meskipun kita memanggil metode yang sama (koneksi), setiap objek blok berperilaku berbeda berdasarkan implementasinya sendiri. Outputnya adalah:
#Connecting the blue block... #Connecting the red block... #Connecting the yellow block...
Dalam contoh ini, polimorfisme memungkinkan kita mengelompokkan berbagai hal berdasarkan karakteristik atau perilaku yang sama. Ini menyelamatkan kita dari menulis instruksi yang berulang dan memungkinkan kita bekerja dengan objek yang berbeda dengan cara yang lebih fleksibel dan kreatif. Sama seperti hewan yang dapat mengeluarkan suara, mainan dapat dimainkan, dan balok dapat dihubungkan, polimorfisme membantu kita memperlakukan berbagai hal dengan cara yang sama dan membuat program kita lebih menyenangkan dan mudah beradaptasi!
Penanganan Koleksi dan Sistem Plugin terlihat mirip, apa penyebabnya?
Mari kita lihat perbedaannya:
Menangani Koleksi:Saat kami menangani koleksi menggunakan polimorfisme, kami mengelompokkan objek yang berbeda menjadi satu, seperti mainan di dalam kotak mainan. Kami memperlakukan semuanya seolah-olah mereka termasuk dalam kategori yang sama, meskipun mungkin berbeda. Kita dapat melakukan tindakan pada objek ini tanpa mengkhawatirkan tipe spesifiknya. Misalnya, kita dapat membuat setiap mainan dalam koleksi dapat dimainkan, meskipun mainan tersebut berbeda dengan aksi uniknya masing-masing.
Sistem Plugin:Sistem plugin yang menggunakan polimorfisme seperti menambahkan fitur tambahan ke program utama tanpa mengubah kode utamanya. Kami menetapkan serangkaian aturan atau persyaratan yang harus diikuti oleh fitur tambahan (plugin) ini. Setiap plugin dapat menerapkan aturan ini sendiri. Hal ini memungkinkan kami untuk menyambungkan plugin yang berbeda ke dalam program utama, dan plugin tersebut bekerja sama dengan lancar dengan mengikuti serangkaian aturan yang sama. Ini seperti menambahkan alat baru ke kotak alat tanpa mengubah kotak alat itu sendiri.
Singkatnya, menangani koleksi dengan polimorfisme adalah tentang memperlakukan objek berbeda dalam koleksi seolah-olah mereka termasuk dalam grup yang sama, sedangkan sistem plugin dengan polimorfisme melibatkan penambahan fitur tambahan ke program dengan cara yang fleksibel dan konsisten.
Kesimpulan:
Polimorfisme di Python adalah tentang membuat kode Anda fleksibel, dapat digunakan kembali, dan lebih mudah digunakan. Fitur pengetikan dinamis Python, bersama dengan pewarisan kelas dan penggantian metode, memungkinkan kita mencapai fleksibilitas ini. Rangkullah kekuatan polimorfisme, dan Anda akan membuka kemungkinan-kemungkinan baru dalam perjalanan pemrograman Python Anda!
Sumber daya:
https://towardsdatascience.com/polymorphism-in-python-fundamentals-for-data-scientists-9dc19071da55
