iterable-unpacking

This question already has an answer here: Extended tuple unpacking in Python 2 4 answers In Python 3 I can do the following (see also PEP3132 on Extended Iterable Unpacking): a, *b = (1, 2, 3) # a = 1; b = (2, 3) What can I do to achieve the same similarly elegant in Python 2.x? I know that I could use single element access and slicing operations, but I wonder if there is a more pythonic way. My code so far: a, b = (1, 2, 3)[0], (1, 2, 3)[1:] # a = 1; b = (2, 3) moooeeeep I found out that the related PEP3132 gives some examples for Python 2.x as well: Many algorithms require splitting a

This questions stems from PEP 448 -- Additional Unpacking Generalizations and is present in Python 3.5 as far as I'm aware (and not back-ported to 2.x ). Specifically, in the section Disadvantages , the following is noted: Whilst *elements, = iterable causes elements to be a list , elements = *iterable , causes elements to be a tuple . The reason for this may confuse people unfamiliar with the construct. Which does indeed hold, for iterable = [1, 2, 3, 4] , the first case yields a list : >>> *elements, = iterable >>> elements [1, 2, 3, 4] While for the second case a tuple is created: >>>

I'm playing now with Python 3.5 interpreter and found very interesting behavior: >>> (1,2,3,"a",*("oi", "oi")*3) (1, 2, 3, 'a', 'oi', 'oi', 'oi', 'oi', 'oi', 'oi') >>> [1,2,3,"a",*range(10)] [1, 2, 3, 'a', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> ('aw','aw',*range(10),*(x**2 for x in range(10))) ('aw', 'aw', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 4, 9, 16, 25, 36, 49, 64, 81) >>> {"trali":"vali", **dict(q=1,p=2)} {'q': 1, 'p': 2, 'trali': 'vali'} >>> {"a",1,11,*range(5)} {0, 1, 2, 3, 4, 11, 'a'} I have never seen that neither in documentation and examples nor in any source code despite several years of

Just came across this little bit of weirdness in Python and thought I'd document it write it as a question here in case anyone else is trying to find an answer with the same fruitless search terms I was Looks like tuple unpacking makes it so you can't return a tuple of length 1 if you're expecting to iterate over the return value. Although it seems that looks are deceiving. See the answers. >>> def returns_list_of_one(a): ... return [a] ... >>> def returns_tuple_of_one(a): ... return (a) ... >>> def returns_tuple_of_two(a): ... return (a, a) ... >>> for n in returns_list_of_one(10): ... print

This came up in a recent PyCon talk . The statement [] = [] does nothing meaningful, but it does not throw an exception either. I have the feeling this must be due to unpacking rules. You can do tuple unpacking with lists too, e.g., [a, b] = [1, 2] does what you would expect. As logical consequence, this also should work, when the number of elements to unpack is 0, which would explain why assigning to an empty list is valid. This theory is further supported by what happens when you try to assign a non-empty list to an empty list: >>> [] = [1] Traceback (most recent call last): File "<stdin>",