osdir.com

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Python-Dev] PEP czar for PEP 3144?


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