Python - Polymorphism: Panduan untuk Pemula

Halo di sana, masa depan ahli kesusasteraan Python! Hari ini, kita akan menyusun perjalanan yang menarik ke dunia polymorphism di Python. Jangan khawatir jika perkataan itu terdengar seperti satu penyataan penyembuhan daripada Harry Potter - pada akhir tutorial ini, kamu akan mengunakan polymorphism seperti seorang profesional!

Apa itu Polymorphism di Python?

Bayangkan kamu ada raksa penyembuhan (berhati-hati dengannya, kita akan sepenuhnya ke Hogwarts di sini). Raksa ini boleh berubah menjadi objek yang berbeza - kadang-kadang ia adalah raksa, kadang-kadang ia adalah pedang, dan kadang-kadang ia adalah raksa penyembuhan. Itulah hampir apa itu polymorphism dalam pemrograman!

Di Python, polymorphism membolehkan objek dari kelas yang berbeza untuk diperlakukan sebagai objek dari kelas dasar yang umum. Ia seperti memiliki raksa penyembuhan kod - satu antaramuka, banyak pelaksanaan.

mari kita lihat contoh yang ringkas:

class Animal:
def speak(self):
pass

class Dog(Animal):
def speak(self):
return "Woof!"

class Cat(Animal):
def speak(self):
return "Meow!"

def animal_sound(animal):
print(animal.speak())

# Mencipta objek
dog = Dog()
cat = Cat()

# Menggunakan polymorphism
animal_sound(dog)  # Output: Woof!
animal_sound(cat)  # Output: Meow!

Dalam contoh ini, kedua Dog dan Cat berasal dari kelas Animal. Fungsi animal_sound tidak peduli apa jenis haiwan yang ia terima - ia hanya memanggil method speak. Ini adalah polymorphism yang bertindak!

Cara untuk Menerapkan Polymorphism di Python

Python menawarkan beberapa cara untuk menerapkan polymorphism. Mari kita eksplorasi mereka satu persatu:

Duck Typing di Python

Duck typing adalah konsep di Python yang fokus kepada tingkah laku objek dan bukannya jenisnya. Seperti peribahasaannya, "Jika ia terlihat seperti raksa, berenang seperti raksa, dan bersuara seperti raksa, maka ia mungkin adalah raksa."

Berikut adalah contoh:

class Duck:
def quack(self):
print("Quack, quack!")

class Person:
def quack(self):
print("Saya menyamar menjadi raksa!")

def make_it_quack(thing):
thing.quack()

# Mencipta objek
duck = Duck()
person = Person()

# Menggunakan duck typing
make_it_quack(duck)    # Output: Quack, quack!
make_it_quack(person)  # Output: Saya menyamar menjadi raksa!

Dalam contoh ini, make_it_quack tidak peduli jenis objek yang ia terima. Selama objek memiliki method quack, ia akan berfungsi.

Method Overriding di Python

Method overriding adalah apabila kelas turunan menyediakan implementasi khusus untuk method yang sudah ditakrifkan dalam kelas dasarnya. Ia seperti mengatakan kepada ibu bapak anda, "Saya tahu anda melakukan ini cara ini, tetapi saya akan melakukan cara saya!"

Berikut adalah contoh:

class Vehicle:
def move(self):
print("Saya bergerak!")

class Car(Vehicle):
def move(self):
print("Saya mengemudi di atas jalan!")

class Boat(Vehicle):
def move(self):
print("Saya meng atas raksa!")

# Mencipta objek
vehicle = Vehicle()
car = Car()
boat = Boat()

# Menggunakan method overriding
vehicle.move()  # Output: Saya bergerak!
car.move()      # Output: Saya mengemudi di atas jalan!
boat.move()     # Output: Saya meng atas raksa!

Dalam contoh ini, kedua Car dan Boat menimpa method move kelas Vehicle dengan implementasi khusus mereka.

Overloading Operator di Python

Python membolehkan anda untuk menentukan bagaimana operator bertindak apabila diterapkan ke atas objek kelas buatan anda. Ini dipanggil pembebanan operator.

Berikut adalah contoh:

class Point:
def __init__(self, x, y):
self.x = x
self.y = y

def __add__(self, other):
return Point(self.x + other.x, self.y + other.y)

def __str__(self):
return f"({self.x}, {self.y})"

# Mencipta objek
p1 = Point(1, 2)
p2 = Point(3, 4)

# Menggunakan pembebanan operator
p3 = p1 + p2
print(p3)  # Output: (4, 6)

Dalam contoh ini, kita telah mengambil kembali operator + untuk kelas Point kita dengan menentukan method __add__.

Method Overloading di Python

Tidak seperti beberapa bahasa lain, Python tidak menyokong method overloading dalam pengertian tradisional. Walau bagaimanapun, kita boleh mencapai fungsi serupa menggunakan argumen lalai atau argumen panjang.

Berikut adalah contoh:

class Calculator:
def add(self, *args):
return sum(args)

# Mencipta objek
calc = Calculator()

# Menggunakan method overloading-like functionality
print(calc.add(1, 2))        # Output: 3
print(calc.add(1, 2, 3))     # Output: 6
print(calc.add(1, 2, 3, 4))  # Output: 10

Dalam contoh ini, method add kita boleh mengambil sebarang jumlah argumen, menyimulasi method overloading.

Jadual Method Polymorphism

Berikut adalah jadual yang menjelaskan method polymorphism yang kita telah diskusikan:

Method	Description	Example
Duck Typing	Fokus kepada tingkah laku objek dan bukannya jenisnya	make_it_quack(thing)
Method Overriding	Kelas turunan menyediakan implementasi khusus untuk method yang ditakrifkan dalam kelas dasarnya	Car.move() menimpa Vehicle.move()
Operator Overloading	Menentukan bagaimana operator bertindak untuk kelas buatan	Mengambil kembali + untuk kelas Point
Method Overloading-like	Menggunakan argumen lalai atau argumen panjang untuk menyimulasi method overloading	Calculator.add(*args)

Dan itu lah, rakan-rakan! Anda baru sahaja mengambil langkah pertama anda ke dunia yang menarik polymorphism di Python. Ingat, praktek membuat perfect, jadi jangan takut untuk bereksperimen dengan konsep ini di atas kod anda sendiri. Sebelum anda tahu, anda akan membentuk kod anda seperti seorang pelukis master, membuat program yang elegan dan fleksibel yang akan membuatkan Michelangelo iri hati!

Selamat coding, dan polymorphism akan bersama dengan anda!

Credits: Image by storyset