[Python-ideas] Python Users Aren't Perfect

[Guido van Rossum]

On Thu, Dec 15, 2011 at 6:56 PM, Ned Batchelder <ned at nedbatchelder.com>wrote:

>  On 12/15/2011 8:39 PM, Guido van Rossum wrote:
>
> On Thu, Dec 15, 2011 at 5:16 PM, Terry Reedy <tjreedy at udel.edu> wrote:
>
>> On 12/15/2011 3:42 PM, Ned Batchelder wrote:
>>
>>  This is another place where Python is inconsistent. We're told, "lists
>>> are for homogenous sequences of varying length, like a C array; tuples
>>> are for heterogenous aggregations of known length, like a C struct."
>>>
>>
>>  I have not been told that for several years, and I am pretty sure you
>> will not find any such thing in the current docs. I consider it pretty much
>> obsolete, as the differences that flowed from that idea are gone. In Python
>> 3, tuples have all the non-mutating sequence methods that list does. The
>> situation was much different in 1.4.
>>
>
> I strongly disagree. Being immutable sequences (i.e. homogeneous) is a
> minor secondary role for tuples. Their primary role remains to hold a small
> bunch of heterogeneous values -- like namedtuple, but without needing
> forethought. A good example are dictionary items -- these are (key, value)
> pairs where for a given dict, the keys are all of the same type (or of a
> small set of related types) and ditto for the values, but the key type and
> the value types are unrelated.
>
> Could you explain why the foo(*args) syntax creates args as a tuple rather
> than a list?
>

It's a historical accident. In ABC, functions didn't have multiple
arguments -- instead there was a single argument that was a tuple. If you
go back way, way in Python's early history (before 1.0 I think) you'll find
that arguments kind of worked the same way. Then an idiom developed to
accept a variable number of arguments, in order to support default argument
values (because Python's tuples, unlike ABC's, were sequences even then).
This turned out to be awkward if you wanted 1 or 2 arguments (the 1-arg
case had to be dealt with special because you'd receive a plain value
instead of a tuple) and then the *args and arg=value syntax was invented.
But because previously varargs had been tuples, we kept them tuples. (I
think this was also in the days that you couldn't unpack a list -- but I'm
not actually sure of that. I do know that tuple unpacking was always in the
language.)

-- 
--Guido van Rossum (python.org/~guido)
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-ideas/attachments/20111215/5152850b/attachment.html>