DP(Dynamic Programming) demo: optimal substructure(recursion) + overlapping structure(memo)

#quote from 'introduction to computation and programming using python,
# revised edition, MIT'
class Item(object):
def __init__(self, n, v, w):
self.name = n
self.value = float(v)
self.weight = float(w)
def getName(self):
return self.name
def getValue(self):
return self.value
def getWeight(self):
return self.weight
def __str__(self):
result = '<' + self.name + ', ' + str(self.value)\
+ ', ' + str(self.weight) + '>'
return result

def fastMaxVal(toConsider, avail, memo = {}):
"""Asumes toConsider a list of items, avail a weight
memo used only by recursive calls
Returns a tuple of the total weight of a solution to the
0/1 knapsack problem and the items of that solution"""
if (len(toConsider), avail) in memo:
result = memo[(len(toConsider), avail)]
elif toConsider == [] or avail == 0:
result = (0, ())
elif toConsider[0].getWeight() > avail:
#Explore right branch only
result = fastMaxVal(toConsider[1:], avail, memo)
else:
nextItem = toConsider[0]
#Explore left branch
withVal, withToTake =\
fastMaxVal(toConsider[1:],
avail - nextItem.getWeight(), memo)
withVal += nextItem.getValue()
#Explore right branch
withoutVal, withoutToTake = fastMaxVal(toConsider[1:],
avail, memo)
#Choose better branch
if withVal > withoutVal:
result = (withVal, withToTake + (nextItem,))
else:
result = (withoutVal, withoutToTake)
memo[(len(toConsider), avail)] = result
return result

def smallTest():
names = ['a', 'b', 'c', 'd']
vals = [6, 7, 8, 9]
weights = [3, 3, 2, 5]
Items = []
for i in range(len(vals)):
Items.append(Item(names[i], vals[i], weights[i]))
val, taken = fastMaxVal(Items, 5)
for item in taken:
print item
print 'Total value of items taken =', val