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(cat egory)

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 "controvers ial" to me, but requires extra objects and
house-keeping.


thanks - just curious if there were arguments one way or the other.

[Terry Reedy]

Re: is extending an object considered acceptable usage?


"mike" <ng01.spamguard @icewater.org> wrote in message
news:qijJd.1467 9$Gc2.13828@fe0 6.lga...[color=blue]
> 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:[/color]

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]

Re: is extending an object considered acceptable usage?

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.C ATEGORIES[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:[color=blue]
>
> 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(cat egory)
>
> 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 "controvers ial" to me, but requires extra objects and
> house-keeping.
>
>
> thanks - just curious if there were arguments one way or the other.[/color]