Strategy Kalıbı

Coddy'nin Python Journey'sinin Nesne Yönelimli Programlama bölümünün bir parçası. Ders 48 / 64.

Strategy Pattern, bir algoritma ailesi tanımlar, her birini kapsüller ve bunları birbirinin yerine kullanılabilir hâle getirir. İstemci kodunu değiştirmeden çalışma zamanında algoritmalar arasında geçiş yapabilirsiniz.

Farklı ödeme yöntemleri için basit strateji sınıfları:

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"

Her strateji aynı yöntemi (pay) uygular, ancak farklı davranış sergiler.

Stratejileri kullanan bir bağlam sınıfı oluşturun:

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)

Bağlam sınıfı farklı ödeme stratejileri arasında geçiş yapabilir.

Strateji desenini kullanın:

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

# Kredi kartı stratejisini kullan
cart.set_payment_strategy(CreditCard())
print(cart.checkout())

# PayPal stratejisine geç
cart.set_payment_strategy(PayPal())
print(cart.checkout())

Sıralama stratejileriyle başka bir örnek oluşturun:

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)

# Farklı sıralama stratejileri kullan
numbers = [3, 1, 4, 1, 5]

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

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

Çıktı:

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

Önemli Nokta: Strategy Pattern, algoritmaları çalışma zamanında değiştirmenize olanak tanır. Aynı arayüze sahip farklı stratejiler tanımlayın, ardından bağlam sınıfının hangisini kullanacağını seçmesine izin verin. Bu, mevcut kodu değiştirmeden yeni algoritmalarla esnek ve kolayca genişletilebilir kod yazmanızı sağlar.

Görev

Orta

Alışveriş sistemimiz için yeni bir BitcoinPayment stratejisi uygulayın.

Göreviniz:

PaymentStrategy uygulayan bir BitcoinPayment sınıfı oluşturun
- Kurucuda bir wallet_address kabul etmelidir
- pay yöntemi tam olarak şunu yazdırmalıdır: Paying $X using Bitcoin wallet: Y; burada X tutar, Y ise cüzdan adresidir
- pay yöntemi yazdırma işleminden sonra True döndürmelidir
Şunları yapan bir main işlevi yazın:
- Bir alışveriş sepeti oluşturur
- Sepete 1200 $ değerinde bir dizüstü bilgisayar ve 100 $ değerinde kulaklık ekler
- "1A1zP1eP5QGefi2DMPTfTL5SLmv7DivfNa" cüzdan adresiyle bir BitcoinPayment oluşturur
- Bu ödeme stratejisini sepette ayarlar
- checkout yöntemini çağırır

Başlangıç kodu, alt kısımda zaten if __name__ == "__main__": ifadesini içeriyor. Bunu kendiniz eklemeniz gerekmez. Bu, main() işlevinizin yalnızca dosya doğrudan çalıştırıldığında (başka bir modül tarafından içe aktarılmadığında) çalışmasını sağlayan bir Python kuralıdır. main() işlevinizi tanımlamanız yeterlidir; sağlanan blok bu işlevi otomatik olarak çağıracaktır.

Ders örneklerinde gösterilen yapının aynısını izleyin.

Kendin dene

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")

# Create your BitcoinPayment strategy class here


if __name__ == "__main__":
    main()