Pola Strategy

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan Python di Coddy. Pelajaran 48 dari 64.

Strategy Pattern mendefinisikan sekumpulan algoritma, mengenkapsulasi masing-masing, dan membuatnya dapat saling dipertukarkan. Kamu dapat mengganti algoritma saat program berjalan tanpa mengubah kode client.

Berikut adalah class strategi sederhana untuk berbagai metode pembayaran:

class CreditCard:
    def pay(self, amount):
        return f"Paid ${amount} with Credit Card"

class PayPal:
    def pay(self, amount):
        return f"Paid ${amount} with PayPal"

class Bitcoin:
    def pay(self, amount):
        return f"Paid ${amount} with Bitcoin"

Setiap strategi menerapkan method yang sama (pay), tetapi dengan perilaku yang berbeda.

Buat class konteks yang menggunakan strategi:

class ShoppingCart:
    def __init__(self):
        self.total = 0
        self.payment_strategy = None
    
    def add_item(self, price):
        self.total += price
    
    def set_payment_strategy(self, strategy):
        self.payment_strategy = strategy
    
    def checkout(self):
        return self.payment_strategy.pay(self.total)

Class konteks dapat beralih di antara berbagai strategi pembayaran.

Gunakan pola strategi:

cart = ShoppingCart()
cart.add_item(50)
cart.add_item(30)

# Gunakan strategi kartu kredit
cart.set_payment_strategy(CreditCard())
print(cart.checkout())

# Beralih ke strategi PayPal
cart.set_payment_strategy(PayPal())
print(cart.checkout())

Buat contoh lain dengan strategi pengurutan:

class BubbleSort:
    def sort(self, data):
        return f"Bubble sorted: {sorted(data)}"

class QuickSort:
    def sort(self, data):
        return f"Quick sorted: {sorted(data)}"

class Sorter:
    def __init__(self, strategy):
        self.strategy = strategy
    
    def set_strategy(self, strategy):
        self.strategy = strategy
    
    def sort_data(self, data):
        return self.strategy.sort(data)

# Gunakan strategi pengurutan yang berbeda
numbers = [3, 1, 4, 1, 5]

sorter = Sorter(BubbleSort())
print(sorter.sort_data(numbers))

sorter.set_strategy(QuickSort())
print(sorter.sort_data(numbers))

Output:

Paid $80 with Credit Card
Paid $80 with PayPal
Bubble sorted: [1, 1, 3, 4, 5]
Quick sorted: [1, 1, 3, 4, 5]

Poin penting: Strategy Pattern memungkinkan kamu mengganti algoritma saat program berjalan. Definisikan berbagai strategi dengan antarmuka yang sama, lalu biarkan class konteks memilih strategi yang akan digunakan. Dengan begitu, kodemu menjadi fleksibel dan mudah diperluas dengan algoritma baru tanpa mengubah kode yang sudah ada.

Tantangan

Sedang

Implementasikan strategi BitcoinPayment baru untuk sistem belanja kita.

Tugasmu:

Buat class BitcoinPayment yang mengimplementasikan PaymentStrategy
- Class ini harus menerima wallet_address di constructor
- Method pay harus mencetak persis: Paying $X using Bitcoin wallet: Y, dengan X sebagai jumlah dan Y sebagai alamat dompet
- Method pay harus mengembalikan True setelah mencetak
Tulis fungsi main yang:
- Membuat keranjang belanja
- Menambahkan laptop seharga $1200 dan headphone seharga $100 ke keranjang
- Membuat BitcoinPayment dengan alamat dompet "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa"
- Menetapkan strategi pembayaran ini pada keranjang
- Memanggil method checkout

Kode awal sudah menyertakan if __name__ == "__main__": di bagian bawah. Kamu tidak perlu menambahkannya sendiri. Ini adalah konvensi Python yang memastikan fungsi main() hanya dijalankan saat file dieksekusi secara langsung, bukan saat diimpor oleh module lain. Cukup definisikan fungsi main(), lalu blok yang disediakan akan memanggilnya secara otomatis.

Ikuti struktur yang sama seperti yang ditunjukkan dalam contoh pelajaran.

Coba sendiri

from abc import ABC, abstractmethod

class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

class CreditCardPayment(PaymentStrategy):
    def __init__(self, card_number, expiry_date, cvv):
        self.card_number = card_number
        self.expiry_date = expiry_date
        self.cvv = cvv
        
    def pay(self, amount):
        print(f"Paying ${amount} using Credit Card: {self.card_number}")
        return True

class PayPalPayment(PaymentStrategy):
    def __init__(self, email, password):
        self.email = email
        self.password = password
        
    def pay(self, amount):
        print(f"Paying ${amount} using PayPal account: {self.email}")
        return True

class ShoppingCart:
    def __init__(self):
        self.items = []
        self.payment_strategy = None
    
    def add_item(self, item, price):
        self.items.append({"item": item, "price": price})
    
    def set_payment_strategy(self, payment_strategy):
        self.payment_strategy = payment_strategy
    
    def checkout(self):
        total = sum(item["price"] for item in self.items)
        if self.payment_strategy:
            return self.payment_strategy.pay(total)
        else:
            raise ValueError("No payment strategy set")

# Buat class strategi BitcoinPayment milikmu di sini


if __name__ == "__main__":
    main()