FilesExpand file tree

 master

/

strategy.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

93 lines (71 loc) · 2.56 KB

 master

/

strategy.py

Copy path

Top

File metadata and controls

• Code
• Blame

93 lines (71 loc) · 2.56 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

# strategy.py

# Strategy pattern -- function-based implementation

"""

# BEGIN STRATEGY_TESTS

>>> joe = Customer('John Doe', 0) # <1>

>>> ann = Customer('Ann Smith', 1100)

>>> cart = [LineItem('banana', 4, .5),

... LineItem('apple', 10, 1.5),

... LineItem('watermellon', 5, 5.0)]

>>> Order(joe, cart, fidelity_promo) # <2>

<Order total: 42.00 due: 42.00>

>>> Order(ann, cart, fidelity_promo)

<Order total: 42.00 due: 39.90>

>>> banana_cart = [LineItem('banana', 30, .5),

... LineItem('apple', 10, 1.5)]

>>> Order(joe, banana_cart, bulk_item_promo) # <3>

<Order total: 30.00 due: 28.50>

>>> long_order = [LineItem(str(item_code), 1, 1.0)

... for item_code in range(10)]

>>> Order(joe, long_order, large_order_promo)

<Order total: 10.00 due: 9.30>

>>> Order(joe, cart, large_order_promo)

<Order total: 42.00 due: 42.00>

# END STRATEGY_TESTS

"""

# BEGIN STRATEGY

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(self) # <1>

return self.total() - discount

def __repr__(self):

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

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

# <2>

def fidelity_promo(order): # <3>

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

# END STRATEGY