Python - Abstraksi

Halo, pemrogram Python yang beraspirasi! Hari ini, kita akan menyelam ke atas dunia yang menarik tentang abstraksi di Python. Jangan khawatir jika anda baru di atas pengaturcaraan; Saya akan memandu anda melalui konsep ini langkah demi langkah, seperti yang saya telah lakukan untuk pelbagai pelajar di atas tahun tahun penyelajaran saya. Jadi, rakam minuman kegemaran anda, dapatkan keselesaan, dan mari kita mulakan perjalanan yang menarik ini bersama-sama!

Python - Abstraction

Apa itu Abstraksi?

Sebelum kita lompat ke atas butiran khusus Python, mari kita fahami apa artinya abstraksi di atas pengaturcaraan. Bayangkan anda mengemudi kereta. Anda tahu bagaimana menggunakan rakit penyala, rakit kaki dan rakit gigi, tetapi anda tidak perlu memahami bagaimana enjin bekerja secara dalaman untuk mengemudi kereta. Itulah abstraksi di atas rakam – menyembunyikan rincian pelaksanaan yang kompleks sementara menyediakan wajah yang ringkas untuk berinteraksi.

Di atas Python, abstraksi membolehkan kita untuk fokus pada apa yang objek lakukan daripada bagaimana ia dilakukan. Ia seperti memiliki rakam kotak yang melakukan sesuatu yang menakjubkan – anda hanya perlu tahu bagaimana untuk menggunakan rakam kotak, bukan bagaimana sihir yang terjadi di atas dalaman!

Jenis Abstraksi Python

Di atas Python, kita utamanya berurusan dengan dua jenis abstraksi:

Abstraksi Data
Abstraksi Prosess

Abstraksi Data

Abstraksi data melibatkan penyembunyian struktur data yang kompleks dan menyediakan wajah yang ringkas untuk berinteraksi dengan data. Mari lihat contoh yang ringkas:

class BankAccount:
def __init__(self):
self.__balance = 0  # Atribut persendirian

def deposit(self, amount):
self.__balance += amount

def withdraw(self, amount):
if self.__balance >= amount:
self.__balance -= amount
else:
print("Dana tidak mencukupi!")

def get_balance(self):
return self.__balance

# Menggunakan kelas BankAccount
my_account = BankAccount()
my_account.deposit(1000)
my_account.withdraw(500)
print(my_account.get_balance())  # Output: 500

Di atas contoh, kita telah menyembunyikan rincian tentang bagaimana baki disimpan dan dikendalikan. Pengguna kelas BankAccount tidak perlu tahu tentang atribut __balance; mereka hanya boleh menggunakan kaedah yang disediakan untuk berinteraksi dengan akaun.

Abstraksi Prosess

Abstraksi prosess melibatkan penyembunyian rincian pelaksanaan bagi fungsi atau kaedah. Di atas contoh:

def calculate_area(shape, *args):
if shape == "circle":
return 3.14 * args[0] ** 2
elif shape == "rectangle":
return args[0] * args[1]
elif shape == "triangle":
return 0.5 * args[0] * args[1]
else:
return "Bentuk yang tidak diketahui"

# Menggunakan fungsi calculate_area
circle_area = calculate_area("circle", 5)
rectangle_area = calculate_area("rectangle", 4, 6)
triangle_area = calculate_area("triangle", 3, 4)

print(f"Luas lingkaran: {circle_area}")
print(f"Luas persegi panjang: {rectangle_area}")
print(f"Luas segitiga: {triangle_area}")

Di sini, fungsi calculate_area abstraksikan perhitungan khusus bagi bentuk yang berbeza. Pengguna tidak perlu tahu tentang rumus; mereka hanya perlu memberikan bentuk dan parameter yang diperlukan.

Kelas Abstrak Python

Sekarang, mari kita bercakap tentang kelas abstrak di atas Python. Kelas abstrak adalah kelas yang dimaksudkan untuk diwarisi, tetapi tidak untuk dihasilkan secara langsung. Ia seperti rakam untuk kelas lain.

Untuk membuat kelas abstrak di atas Python, kita menggunakan modul abc (Abstract Base Classes). Ini bagaimana ia berkerja:

from abc import ABC, abstractmethod

class Animal(ABC):
@abstractmethod
def make_sound(self):
pass

@abstractmethod
def move(self):
pass

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

def move(self):
return "Berlari atas empat kaki"

class Bird(Animal):
def make_sound(self):
return "Cuit!"

def move(self):
return "Terbang dengan sayap"

# Menggunakan kelas-kelas
dog = Dog()
bird = Bird()

print(dog.make_sound())  # Output: Woof!
print(bird.move())  # Output: Terbang dengan sayap

Di atas contoh, Animal adalah kelas abstrak yang mendefinisikan wajah bagi semua hewan. Dog dan Bird adalah kelas-kelas konkrit yang melaksanakan kaedah abstrak.

Membuat Kelas Abstrak

Mari kita rakam proses pembuatan kelas abstrak:

Impor modul yang diperlukan:
```
from abc import ABC, abstractmethod
```
Buat kelas abstrak anda dengan mengwarisi ABC:
```
class MyAbstractClass(ABC):
```
Definisikan kaedah abstrak menggunakan dekorator @abstractmethod:
```
@abstractmethod
def my_abstract_method(self):
pass
```

Di atas adalah contoh yang lebih komprehensif:

from abc import ABC, abstractmethod

class Shape(ABC):
@abstractmethod
def area(self):
pass

@abstractmethod
def perimeter(self):
pass

class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height

def area(self):
return self.width * self.height

def perimeter(self):
return 2 * (self.width + self.height)

class Circle(Shape):
def __init__(self, radius):
self.radius = radius

def area(self):
return 3.14 * self.radius ** 2

def perimeter(self):
return 2 * 3.14 * self.radius

# Menggunakan kelas-kelas
rect = Rectangle(5, 3)
circle = Circle(4)

print(f"Luas persegi panjang: {rect.area()}")
print(f"Keliling lingkaran: {circle.perimeter()}")

Pengwarisan Kaedah Abstrak

Apabila anda mengwarisi kelas abstrak, anda mesti melaksanakan semua kaedah abstraknya. Ini dipanggil pengwarisan kaedah. Jika anda tidak, Python akan naikkan ralat apabila anda cuba untuk menghasilkan kelas itu.

Mari lihat contoh:

from abc import ABC, abstractmethod

class Vehicle(ABC):
@abstractmethod
def start_engine(self):
pass

@abstractmethod
def stop_engine(self):
pass

class Car(Vehicle):
def start_engine(self):
return "Enjin kereta dimulakan. Vroom!"

def stop_engine(self):
return "Enjin kereta dihentikan."

class Motorcycle(Vehicle):
def start_engine(self):
return "Enjin rakit dimulakan. Vrrrm!"

def stop_engine(self):
return "Enjin rakit dihentikan."

# Menggunakan kelas-kelas
car = Car()
motorcycle = Motorcycle()

print(car.start_engine())
print(motorcycle.stop_engine())

Di atas contoh, kedua-dua Car dan Motorcycle mengwarisi kaedah abstrak dari kelas Vehicle.

Penutup

Tahniah! Anda baru saja mengambil langkah pertama anda ke atas dunia abstraksi di Python. Ingat, abstraksi adalah tentang penyederhanaan sistem yang kompleks dan fokus pada yang penting. Ia adalah alat yang kuat yang akan membantu anda menulis kod yang lebih bersih dan teratur semasa anda berjalan di atas perjalanan Python anda.

Sebagai penutup, di sini adalah rakam yang mengsumingkan kaedah utama yang kita telah diskusikan:

Kaedah	Keterangan
`ABC`	Abstract Base Class, digunakan untuk mendefinisikan kelas abstrak
`@abstractmethod`	Dekorator untuk mendefinisikan kaedah abstrak
`__init__`	Kaedah konstruktor untuk menghasilkan objek
`super().__init__()`	Panggilan untuk menghasilkan kelas induk dalam pewarisan

Teruskan untuk berlatih, tetap khusus, dan jangan segan untuk untuk mencuba konsep ini. Sebelum anda tahu, anda akan menulis kod yang elegan dan abstrakseperti pro! Selamat pengaturcaraan, pemrogram Python masa depan!

Credits: Image by storyset

Tutorial Sebelumnya:

Python - Jenis Dinamik

Tutorial Seterusnya:

Python - Penutupan