itertools to iter transition (WAS: Pre-PEP: Dictionary accumulator methods)

Michael Spencer mahs at telcopartners.com
Tue Mar 29 21:32:33 CEST 2005


Steven Bethard wrote:
> Ville Vainio wrote:
> 
>>>>>>> "Raymond" == Raymond Hettinger <vze4rx4y at verizon.net> writes:
>>
>>
>>
>>     Raymond> If the experience works out, then all you're left with is
>>     Raymond> the trivial matter of convincing Guido that function
>>     Raymond> attributes are a sure cure for the burden of typing
>>     Raymond> import statements.
>>
>> For one thing, it would make it harder to find the functions from the
>> docs. It's easy to find the doc for 'itertools', but iter object
>> methods would require browsing that infamous Chapter 2 of the
>> documentation...
> 
> 
> Well, it would only make them as hard to find as, say, dict.fromkeys, 
> which is probably the best parallel here.  Of course iter would have to 
> be documented as a builtin type.  I don't find the argument "builtin 
> type methods are hard to find" convincing -- the solution here is to fix 
> the documentation, not refuse to add builtin types.
> 
>> Apart from that, I don't really see the advantage in moving away from
>> itertools.
> 
> 
> True it's not a huge win.  But I'd argue that for the same reasons that 
> dict.fromkeys is a dict classmethod, the itertools methods could be iter 
> classmethods (or staticmethods).  The basic idea being that it's nice to 
> place the methods associated with a type in that type's definiton.  The 
> parallel's a little weaker here because calling iter doesn't always 
> produce objects of type iter:
> 
> py> class C(object):
> ...     def __iter__(self):
> ...         yield 1
> ...
> py> iter(C())
> <generator object at 0x011805A8>
> 
> But note that iter does produce 'iterator' objects for the old 
> __getitem__ protocol:
> 
> py> class C(object):
> ...     def __getitem__(self, index):
> ...         if index > 5:
> ...             raise IndexError
> ...         return index
> ...
> py> iter(C())
> <iterator object at 0x01162EF0>
> 
> I guess the real questions are[1]:
> * How much does iter feel like a type?
> * How closely are the itertools functions associated with iter?
> 
> STeVe
> 
> [1] There's also the question of how much you believe in OO tenets like 
> "functions closely associated with a type should be members of that 
> type"...
While we're on the topic, what do you think of having unary, non-summary 
builtins automatically map themselves when called with an iterable that would 
otherwise be an illegal argument:

e.g.,
int(iterable) -> (int(i) for i in iterable)
ord(iterable) -> (ord(i) for i in iterable)


This would be unambiguous, I think, in the cases of bool, int, callable, chr, 
float, hex, id, long, oct, ord, vars...

It would shorten the common cases of:
for char in somestring:
     ordchar =  ord(char)
     # do something with ordchar, but not char
to
for ordchar in ord(somestring):
     ...

It would not work for summarizing functions or those that can accept an iterable 
today e.g., len, repr

Michael




More information about the Python-list mailing list