Exercise #1: Vector operators

Exercise #2: Strategy without classes

A. Review class-based implementation

1. Go to ``exercises/vector`` directory

2. Run test for unary ``-`` with the ``-x`` option to stop at first error or failure:

.. code-block:: shell

3. Edit ``vector.py`` to implement a ``__neg__`` method for unary negation. That method should return a new ``Vector`` instance with each component negated. See ``test_vector_neg.py`` for the expected behavior.

C. Vector addition

1. Run tests for vector addition ``+`` with the ``-x`` option to stop at first error or failure:

.. code-block:: shell

2. Edit ``vector.py`` to implement a ``__add__`` method for vector addition. That method should return a new ``Vector`` instance with each component of ``self`` added to the corresponding component of ``other``. See ``test_vector_add.py`` for the expected behaviors.

strategy

exercise_2

Rethinking strategy

``classic.py``

.. literalinclude:: ../exercises/strategy/classic.py

``strategy.py``

.. literalinclude:: ../exercises/strategy/strategy.py

``strategy2.py``

.. literalinclude:: ../exercises/strategy/strategy2.py

from collections import namedtuple

Customer = namedtuple('Customer', 'name fidelity')

class LineItem:

def __init__(self, product, quantity, price):

self.product = product

self.quantity = quantity

self.price = price

def total(self):

return self.price * self.quantity

class Order:

def __init__(self, customer, cart, promotion=None):

self.customer = customer

self.cart = list(cart)

self.promotion = promotion

def total(self):

if not hasattr(self, '__total'):

self.__total = sum(item.total() for item in self.cart)

return self.__total

def due(self):

if self.promotion is None:

discount = 0

else:

discount = self.promotion(self) # invoke the promotion function

return self.total() - discount

def __repr__(self):

fmt = '<Order total: {:.2f} due: {:.2f}>'

return fmt.format(self.total(), self.due())

def fidelity_promo(order):

"""5% discount for customers with 1000 or more fidelity points"""

return order.total() * .05 if order.customer.fidelity >= 1000 else 0

def bulk_item_promo(order):

"""10% discount for each LineItem with 20 or more units"""

discount = 0

for item in order.cart:

if item.quantity >= 20:

discount += item.total() * .1

return discount

def large_order_promo(order):

"""7% discount for orders with 10 or more distinct items"""

distinct_items = {item.product for item in order.cart}

if len(distinct_items) >= 10:

return order.total() * .07

return 0

from abc import ABC, abstractmethod

from collections import namedtuple

Customer = namedtuple('Customer', 'name fidelity')

class LineItem:

def __init__(self, product, quantity, price):

self.product = product

self.quantity = quantity

self.price = price

def total(self):

return self.price * self.quantity

class Order: # the Context

def __init__(self, customer, cart, promotion=None):

self.customer = customer

self.cart = list(cart)

self.promotion = promotion

def total(self):

if not hasattr(self, '__total'):

self.__total = sum(item.total() for item in self.cart)

return self.__total

def due(self):

if self.promotion is None:

discount = 0

else:

discount = self.promotion.discount(self)

return self.total() - discount

def __repr__(self):

fmt = '<Order total: {:.2f} due: {:.2f}>'

return fmt.format(self.total(), self.due())

class Promotion(ABC): # the Strategy: an Abstract Base Class

@abstractmethod

def discount(self, order):

"""Return discount as a positive dollar amount"""

class FidelityPromo(Promotion): # first Concrete Strategy

"""5% discount for customers with 1000 or more fidelity points"""

def discount(self, order):

return order.total() * .05 if order.customer.fidelity >= 1000 else 0

class BulkItemPromo(Promotion): # second Concrete Strategy

"""10% discount for each LineItem with 20 or more units"""

def discount(self, order):

discount = 0

for item in order.cart:

if item.quantity >= 20:

discount += item.total() * .1

return discount

class LargeOrderPromo(Promotion): # third Concrete Strategy

"""7% discount for orders with 10 or more distinct items"""

def discount(self, order):

distinct_items = {item.product for item in order.cart}

if len(distinct_items) >= 10:

return order.total() * .07

return 0

from abc import ABC, abstractmethod # DELETE THIS IMPORT. Yay!

from collections import namedtuple

Customer = namedtuple('Customer', 'name fidelity')

class LineItem:

def __init__(self, product, quantity, price):

self.product = product

self.quantity = quantity

self.price = price

def total(self):

return self.price * self.quantity

class Order:

def __init__(self, customer, cart, promotion=None):

self.customer = customer

self.cart = list(cart)

self.promotion = promotion

def total(self):

if not hasattr(self, '__total'):

self.__total = sum(item.total() for item in self.cart)

return self.__total

def due(self):

if self.promotion is None:

discount = 0

else:

discount = self.promotion(self) # invoke the promotion function

return self.total() - discount

def __repr__(self):

fmt = '<Order total: {:.2f} due: {:.2f}>'

return fmt.format(self.total(), self.due())

class Promotion(ABC): # DELETE THIS CLASS. HOORAY!

@abstractmethod

def discount(self, order):

"""Return discount as a positive dollar amount"""

class FidelityPromo(Promotion): # REFACTOR INTO A FUNCTION

"""5% discount for customers with 1000 or more fidelity points"""

def discount(self, order):

return order.total() * .05 if order.customer.fidelity >= 1000 else 0

class BulkItemPromo(Promotion): # REFACTOR INTO ANOTHER FUNCTION

"""10% discount for each LineItem with 20 or more units"""

def discount(self, order):

discount = 0

for item in order.cart:

if item.quantity >= 20:

discount += item.total() * .1

return discount

class LargeOrderPromo(Promotion): # REFACTOR INTO A THIRD FUNCTION

"""7% discount for orders with 10 or more distinct items"""

def discount(self, order):

distinct_items = {item.product for item in order.cart}

if len(distinct_items) >= 10:

return order.total() * .07

return 0