How to unpack tuple of length n to m<n variables [duplicate]
I found out that the related PEP3132 gives some examples for Python 2.x as well:
Many algorithms require splitting a sequence in a "first, rest" pair:
first, rest = seq[0], seq[1:]
[...]
Also, if the right-hand value is not a list, but an iterable, it has to be converted to a list before being able to do slicing; to avoid creating this temporary list, one has to resort to
it = iter(seq)first = it.next()rest = list(it)
Other approaches given in the answers to this question:
Function Argument List Unpacking Approach
requires an extra function definition/call:
def unpack(first, *rest): return first, restfirst, rest = unpack( *seq )
I wonder why it is implemented in unpacking function argument lists but not for normal tuple unpacking.
Generator Approach
Credits. Also requires a custom function implementation. Is a little more flexible concerning the number of first variables.
def unpack_nfirst(seq, nfirst): it = iter(seq) for x in xrange(nfirst): yield next(it, None) yield tuple(it)first, rest = unpack_nfirst(seq, 1)
The most pythonic would probably be the ones mentioned in the PEP above, I guess?
I may be wrong but as far as I know
a, *b = (1, 2, 3)
is just syntactic sugar for slicing and indexing tuples. I find it useful but not very explicit.
I've got this handy little function:
def just(n, seq): it = iter(seq) for _ in range(n - 1): yield next(it, None) yield tuple(it)
For example:
a, b, c = just(3, range(5))print a, b, c## 0 1 (2, 3, 4)
also works with less arguments:
a, b, c = just(3, ['X', 'Y'])print a, b, c## X Y ()
In response to the comment, you can also define:
def take2(a, *rest): return a, restdef take3(a, b, *rest): return a, b, restdef take4(a, b, c, *rest): return a, b, rest... etc
and use it like this:
p = (1,2,3)a, b = take2(*p)print a, b## 1 (2, 3)