When I want to do what I think you are asking, I create
an iterator in that returns a category item each time
the .next method is called. That way you can write.
ITEM=item(<args>)
..
..
..
for CATEGORY in ITEM:
<do anything>
in my item class:
class item:
def __init__(self, <other args>):
self.CATEGORIES=[]
self.next_index=0 # Index point for next method
def __iter__(self):
return self
def next(self):
#
# Try to get the next route
#
try: CATEGORY=self.CATEGORIES[self.next_index]
except:
self.next_index=0
raise StopIteration
#
# Increment the index pointer for the next call
#
self.next_index+=1
return CATEGORY
I had one project where these were nested 5-6 deep
and the resultant code reads beautifully.
Larry Bates
mike wrote:
i have an Item which belongs to a Category, so Item has:
- item.categoryId, the database primary key of its Category
- item.category, a reference to its Category. this null unless i need a
reference from item to its Category object, in which case i call
setCategory(category)
sometimes i want a list of categories, and from each i want to be able
to access a list of its items. in this case is it considered acceptable
to just create a list of those items and assign it as a property of
their category? eg:
category.items = listOfItems
this packages everything up into a hierarchy and is more convenient to
use, especially in Cheetah templates, but requries modifying the
structure of the object, which bothers me (probably for some
subconscious java-related reason).
the alternative might be to create a dictionary that keys the lists of
items on their category:
items = {}
items[category.id] = listOfItems
this feels less "controversial" to me, but requires extra objects and
house-keeping.
thanks - just curious if there were arguments one way or the other.
