Someone should really write up a PEP -- this was just discussed a week or two ago.

Heh.. I should follow the list more closely.

I personally think this is adequately handled by writing:

(first, second), rest = something[:2], something[2:]

That's an alternative indeed. But the the proposed way does look better: for item in iterator: (first, second), rest = item[2:], item[:2] ... vs. for first, second, *rest in iterator: ...

I believe that this wish is an example of "hypergeneralization" -- an incorrect generalization based on a misunderstanding of the underlying principle.

Thanks for trying so hard to say in a nice way that this is not a good idea. :-)

Argument lists are not tuples [*] and features of argument lists should not be confused with features of tuple unpackings.

Do you agree that the concepts are related? For instance:

...

...

def f(first, second, *rest): ... print first, second, rest ... f(1,2,3,4) 1 2 (3, 4)

...

...

first, second, *rest = (1,2,3,4) print first, second, rest 1 2 (3, 4)

[*] Proof: f(1) is equivalent to f(1,) even though (1) is an int but (1,) is a tuple.

"Extended *tuple* unpacking" was a wrong subject indeed. This is general unpacking, since it's supposed to work with any sequence. -- Gustavo Niemeyer http://niemeyer.net

On Sunday 09 October 2005 22:44, Greg Ewing wrote:

I'm aware of the differences, but I still see a strong similarity where this particular feature is concerned. The pattern of thinking is the same: "I want to deal with the first n of these things individually, and the rest collectively."

Well stated. I'm in complete agreement on this matter. -Fred -- Fred L. Drake, Jr. <fdrake at acm.org>

On 10/10/05, Nick Coghlan wrote:

It also works for situations where "the first n items are mandatory, the rest are optional". This usage was brought up in the context of a basic line interpreter:

cmd, *args = input.split()

That's a really poor example though. You really don't want a line interpreter to bomb if the line is empty!

Another usage is to have a Python function which doesn't support keywords for its positional arguments (to avoid namespace clashes in the keyword dict), but can still unpack the mandatory arguments easily:

def func(*args, **kwds): arg1, arg2, *rest = args # Unpack the positional arguments

Again, I'd be more comfortable if this was preceded by a check for len(args) >= 2. I should add that I'm just -0 on this. I think proponents ought to find better motivating examples that aren't made-up. Perhaps Raymond's requirement would help -- find places in the standard library where this would make code more readable/maintainable. -- --Guido van Rossum (home page: http://www.python.org/~guido/)