Delaney, Timothy (Tim) wrote:
> Paul Du Bois wrote:
>
>
>>On 10/10/05, Nick Coghlan <[EMAIL PROTECTED]> wrote:
>>
>>> cmd, *args = input.split()
>>
>>These examples also have a reasonable implementation using list.pop(),
>>albeit one that requires more typing. On the plus side, it does not
>>violate
>>DRY and is explicit about the error cases.
>>
>> args = input.split()
>> try:
>> cmd = input.pop(0)
>> except IndexError:
>> cmd = ''
>
>
> I'd say you violated it right there ... (should have been)::
>
> args = input.split()
>
> try:
> cmd = arg.pop()
> except IndexError:
> cmd = ''
>
> FWIW, I've been +1 on * unpacking since I first saw the proposal, and
> have yet to see a convincing argument against it other than people
> wanting to stick the * anywhere but at the end. Perhaps I'll take the
> stdlib challenge (unfortunately, I have to travel this weekend, but I'll
> see if I can make time).
>
> Tim Delaney
I'm +1 for some way to do partial tuple unpacking, yet -1 on using the *
symbol for that purpose outside of functions calls.
The problem is the '*' means different things depending on where it's
located. In a function def, it means to group or to pack, but from the
calling end it's used to unpack. I don't expect it to change as it's
been a part of Python for a long time and as long as it's only used with
argument passing it's not too difficult to keep straight.
My concern is if it's used outside of functions, then on the left hand
side of assignments, it will be used to pack, but if used on the right
hand side it will be to unpack. And if it becomes as common place as I
think it will, it will present confusing uses and or situations where
you may have to think, "oh yeah, it's umm... unpacking here and umm...
packing there, but multiplying there". The point is it could be a
stumbling block, especially for new Python users. So I think a certain
amount of caution should be in order on this item. At least check that
it's doesn't cause confusing situations.
I really would like some form of easy and efficient tuple unpacking if
possibly. I've played around with using '/' and '-' to split and to
partially unpack lists, but it's probably better to use a named method.
That has the benefit of always reading the same.
Also packing tuples (other than in function defs) isn't needed if you
have a way to do partial unpacking.
a,b,c = alist[:2]+[alist[2:]] # a,b,rest
Not the most efficient way I think, but maybe as a sequence method
written in C it could be better?
Cheers,
Ron
_______________________________________________
Python-Dev mailing list
Python-Dev@python.org
http://mail.python.org/mailman/listinfo/python-dev
Unsubscribe:
http://mail.python.org/mailman/options/python-dev/archive%40mail-archive.com
