469,282 Members | 1,977 Online
Bytes | Developer Community
New Post

Home Posts Topics Members FAQ

Post your question to a community of 469,282 developers. It's quick & easy.

Customize the effect of enumerate()?

Can I make enumerate(myObject) act differently?

class A(object):
def __getitem__(self, item):
if item 0:
return self.sequence[item-1]
elif item < 0:
return self.sequence[item]
elif item == 0:
raise IndexError, "Index 0 is not valid."
else:
raise IndexError, "Invalid Index."
def __iter__(self): return iter(self.sequence)

Why the funny behavior, you ask? For my class A, it doesn't make sense
to number everything the standard programming way. Of course, if
someone uses enumerate, it's going to number the items the same way as
ever. Is there any way to modify that behavior, any special function to
set? There doesn't appear to be, according to the docs, but it never
hurts to make sure.

Oct 21 '06 #1
8 1251
"Dustan" <Du**********@gmail.comwrites:
Can I make enumerate(myObject) act differently?
No.
Why the funny behavior, you ask? For my class A, it doesn't make sense
to number everything the standard programming way.
Add an enumerate method to the class then, that does what you want.
Maybe dict.iteritems would be a better example to follow.
Oct 21 '06 #2

Paul Rubin wrote:
"Dustan" <Du**********@gmail.comwrites:
Can I make enumerate(myObject) act differently?

No.
Why the funny behavior, you ask? For my class A, it doesn't make sense
to number everything the standard programming way.

Add an enumerate method to the class then, that does what you want.
Maybe dict.iteritems would be a better example to follow.
That's what I thought. Thanks anyway!

Oct 21 '06 #3
Dustan wrote:
Can I make enumerate(myObject) act differently?

class A(object):
def __getitem__(self, item):
if item 0:
return self.sequence[item-1]
elif item < 0:
return self.sequence[item]
elif item == 0:
raise IndexError, "Index 0 is not valid."
else:
raise IndexError, "Invalid Index."
def __iter__(self): return iter(self.sequence)
That final else clause is a little funny... What kind of indices are
you expecting that will be neither less than zero, greater than zero,
or equal to zero?
Why the funny behavior, you ask? For my class A, it doesn't make sense
to number everything the standard programming way. Of course, if
someone uses enumerate, it's going to number the items the same way as
ever. Is there any way to modify that behavior, any special function to
set? There doesn't appear to be, according to the docs, but it never
hurts to make sure.
You can write your own enumerate function and then bind that to the
name 'enumerate'.

Oct 22 '06 #4
Simon Forman wrote:
Dustan wrote:
>>Can I make enumerate(myObject) act differently?

class A(object):
def __getitem__(self, item):
if item 0:
return self.sequence[item-1]
elif item < 0:
return self.sequence[item]
elif item == 0:
raise IndexError, "Index 0 is not valid."
else:
raise IndexError, "Invalid Index."
def __iter__(self): return iter(self.sequence)


That final else clause is a little funny... What kind of indices are
you expecting that will be neither less than zero, greater than zero,
or equal to zero?
Good defensive programming albeit of a somewhat extreme nature. Should
one of the tests be removed at a later date the else clause will trap
occurrences of the no-longer handled case.
>
>>Why the funny behavior, you ask? For my class A, it doesn't make sense
to number everything the standard programming way. Of course, if
someone uses enumerate, it's going to number the items the same way as
ever. Is there any way to modify that behavior, any special function to
set? There doesn't appear to be, according to the docs, but it never
hurts to make sure.


You can write your own enumerate function and then bind that to the
name 'enumerate'.
Yes, but if you do you had better make sure that it gives the standard
behavior for normal uses.

regards
Steve
--
Steve Holden +44 150 684 7255 +1 800 494 3119
Holden Web LLC/Ltd http://www.holdenweb.com
Skype: holdenweb http://holdenweb.blogspot.com
Recent Ramblings http://del.icio.us/steve.holden

Oct 23 '06 #5

Simon Forman wrote:
Dustan wrote:
Can I make enumerate(myObject) act differently?

class A(object):
def __getitem__(self, item):
if item 0:
return self.sequence[item-1]
elif item < 0:
return self.sequence[item]
elif item == 0:
raise IndexError, "Index 0 is not valid."
else:
raise IndexError, "Invalid Index."
def __iter__(self): return iter(self.sequence)

That final else clause is a little funny... What kind of indices are
you expecting that will be neither less than zero, greater than zero,
or equal to zero?
I'm not 'expecting' anything to reach that clause, but it is a good
catch-all if I forget something or have a bug somewhere.
Why the funny behavior, you ask? For my class A, it doesn't make sense
to number everything the standard programming way. Of course, if
someone uses enumerate, it's going to number the items the same way as
ever. Is there any way to modify that behavior, any special function to
set? There doesn't appear to be, according to the docs, but it never
hurts to make sure.

You can write your own enumerate function and then bind that to the
name 'enumerate'.
Except that my program is supposed to be treated as a module with tools
to do certain things. I certainly can't control whether a 3rd party
programmer uses "import myModule" or "from myModule import *".

I haven't gotten around to doing it yet, but I'm pretty sure I'm
planning on taking Paul Rubin's course of action - make a method
(iteritems or similar) that will enumerate correctly.

Oct 23 '06 #6
"Dustan" wrote:
Except that my program is supposed to be treated as a module with tools
to do certain things. I certainly can't control whether a 3rd party
programmer uses "import myModule" or "from myModule import *".
anything can happen if people use "from import *" in the wrong way, so that's
not much of an argument, really.

</F>

Oct 23 '06 #7
On Sun, 22 Oct 2006 15:56:16 -0700, Simon Forman wrote:
Dustan wrote:
>Can I make enumerate(myObject) act differently?

class A(object):
def __getitem__(self, item):
if item 0:
return self.sequence[item-1]
elif item < 0:
return self.sequence[item]
elif item == 0:
raise IndexError, "Index 0 is not valid."
else:
raise IndexError, "Invalid Index."
def __iter__(self): return iter(self.sequence)

That final else clause is a little funny... What kind of indices are
you expecting that will be neither less than zero, greater than zero,
or equal to zero?
Possible a NaN value? Maybe a class instance with strange comparison
methods?

Personally, I don't like the error message. "Invalid index" doesn't really
tell the caller what went wrong and why it is an invalid index. If I were
programming that defensively, I'd write:

if item 0:
return self.sequence[item-1]
elif item < 0:
return self.sequence[item]
elif item == 0:
raise IndexError, "Index 0 is not valid."
else:
print repr(item)
raise ThisCanNeverHappenError("Congratulations! You've discovered "
"a bug that can't possibly occur. Contact the program author for "
"your reward.")

I know some programmers hate "Can't happen" tests and error messages, but
if you are going to test for events that can't possibly happen, at least
deal with the impossible explicitly!
--
Steven.

Oct 23 '06 #8
Fredrik Lundh wrote:
"Dustan" wrote:
Except that my program is supposed to be treated as a module with tools
to do certain things. I certainly can't control whether a 3rd party
programmer uses "import myModule" or "from myModule import *".

anything can happen if people use "from import *" in the wrong way, so that's
not much of an argument, really.

</F>
My argument was that if they use "import myModule", overriding
enumerate() wouldn't work. So "from myModule import *" would work
nicely, but not the former. Given that, I'm not getting your rebuttal,
or whatever it is.
Steven D'Aprano wrote:
On Sun, 22 Oct 2006 15:56:16 -0700, Simon Forman wrote:
That final else clause is a little funny... What kind of indices are
you expecting that will be neither less than zero, greater than zero,
or equal to zero?

Possible a NaN value? Maybe a class instance with strange comparison
methods?

Personally, I don't like the error message. "Invalid index" doesn't really
tell the caller what went wrong and why it is an invalid index. If I were
programming that defensively, I'd write:

if item 0:
return self.sequence[item-1]
elif item < 0:
return self.sequence[item]
elif item == 0:
raise IndexError, "Index 0 is not valid."
else:
print repr(item)
raise ThisCanNeverHappenError("Congratulations! You've discovered "
"a bug that can't possibly occur. Contact the program author for "
"your reward.")

I know some programmers hate "Can't happen" tests and error messages, but
if you are going to test for events that can't possibly happen, at least
deal with the impossible explicitly!
I certainly can't argue with that logic; I might even go so far as to
agree with you and start raising impossible errors with this kind of
explicitness.

What reward should I offer? ;-)

Oct 23 '06 #9

This discussion thread is closed

Replies have been disabled for this discussion.

Similar topics

5 posts views Thread by Pekka Niiranen | last post: by
5 posts views Thread by HL | last post: by
1 post views Thread by smichr | last post: by
4 posts views Thread by Fred | last post: by
6 posts views Thread by Gregory Petrosyan | last post: by
2 posts views Thread by eight02645999 | last post: by
21 posts views Thread by James Stroud | last post: by
1 post views Thread by CARIGAR | last post: by
reply views Thread by zhoujie | last post: by
reply views Thread by suresh191 | last post: by
By using this site, you agree to our Privacy Policy and Terms of Use.