[Python-Dev] PEP czar for PEP 3144?

Tue Mar 20 03:51:37 CET 2012

On Mon, Mar 19, 2012 at 02:50:22PM -0700, Ethan Furman wrote:
> Guido van Rossum wrote:
[...]
> >And remember that consistency is good in moderation, but if it becomes
> >a goal in itself you may have a problem.
>> While I agree that consistency as a goal in and of itself is not good, I 
> consider it more important than 'moderation' implies; in my own code I 
> try to only be inconsistent when there is a good reason to be.

I think we're probably in violent agreement, but I would put it this 
way:
Consistency for its own sake *is* good, since consistency makes it 
easier for people to reason about the behaviour of functions on the 
basis that they are similar to other functions. But it is not the *only* 
good, and it is legitimate to trade-off one good for another good as 
needed.
> To me, "it's already a list" isn't a good reason -- yes, that's easier 
> for the library author, but is it easier for the library user? What is 
> the library user gaining by having a list returned instead of an iterator?

I guess this discussion really hinges on which of these two positions 
you take:
1. The function naturally returns a list, should we compromise that 
 simplicity by returning an iterator to be consistent with the other 
 related/similar functions in the library?
2. These related/similar functions naturally return iterators, should we 
 compromise that consistency by allowing one of them to return a list 
 as it simplifies the implementation?
> Of course, the flip-side also holds: what is the library user losing by 
> getting an iterator when a list was available?
>> When we way the pros and cons, and it comes down to a smidgeon of 
> performance in trade for consistency [1], I would vote for consistency.

I lean that way as well.

> ~Ethan~
>> [1] I'm assuming that 'iter(some_list)' is a quick operation.

For very small lists, it's about half as expensive as creating the list 
in the first place:
steve at runes:~$ python3.2 -m timeit -s "x = (1,2,3)" "list(x)"
1000000 loops, best of 3: 0.396 usec per loop
steve at runes:~$ python3.2 -m timeit -s "x = (1,2,3)" "iter(list(x))"
1000000 loops, best of 3: 0.614 usec per loop
For large lists, it's approximately free:
steve at runes:~$ python3.2 -m timeit -s "x = (1,2,3)*10000" "list(x)"
10000 loops, best of 3: 111 usec per loop
steve at runes:~$ python3.2 -m timeit -s "x = (1,2,3)*10000" "iter(list(x))"
10000 loops, best of 3: 111 usec per loop
On the other hand, turning the list iterator into a list again is 
probably not quite so cheap.
-- 
Steven