is extending an object considered acceptable usage?

[mike]

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.

 

[Terry Reedy]

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:

To me, Python is about being what it is, and not any other language. It is
about writing correct readable algorithms. It is about enjoying
programming. It is about programmers being responsible for their own code.

I hope you find this more helpful than any yes or no could be.

Terry J. Reedy

 

[Larry Bates]

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