[Python-Dev] PEP czar for PEP 3144? (original) (raw)

Steven D'Aprano steve at pearwood.info
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(somelist)' 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

More information about the Python-Dev mailing list