What does the `*` operator mean in Python, such as in code like `zip(*x)` or `f(**k)`?

 1. How is it handled internally in the interpreter?
 2. Does it affect performance at all? Is it fast or slow?
 3. When is it useful and when is it not?
 4. Should it be used in a function declaration or in a call?


What does the star and doublestar operator mean in a function call?

I&#39;m trying to store in a `std::tuple` a varying number of values, which will later be used as arguments for a call to a function pointer which matches the stored types.

I&#39;ve created a simplified example showing the problem I&#39;m struggling to solve:

    #include &lt;iostream&gt;
    #include &lt;tuple&gt;
    
    void f(int a, double b, void* c) {
      std::cout &lt;&lt; a &lt;&lt; &quot;:&quot; &lt;&lt; b &lt;&lt; &quot;:&quot; &lt;&lt; c &lt;&lt; std::endl;
    }
    
    template &lt;typename ...Args&gt;
    struct save_it_for_later {
      std::tuple&lt;Args...&gt; params;
      void (*func)(Args...);
    
      void delayed_dispatch() {
    	 // How can I &quot;unpack&quot; params to call func?
    	 func(std::get&lt;0&gt;(params), std::get&lt;1&gt;(params), std::get&lt;2&gt;(params));
    	 // But I *really* don&#39;t want to write 20 versions of dispatch so I&#39;d rather 
         // write something like:
    	 func(params...); // Not legal
      }
    };
    
    int main() {
      int a=666;
      double b = -1.234;
      void *c = NULL;
      
      save_it_for_later&lt;int,double,void*&gt; saved = {
                                     std::tuple&lt;int,double,void*&gt;(a,b,c), f};
      saved.delayed_dispatch();
    }

Normally for problems involving `std::tuple` or variadic templates I&#39;d write another template like `template &lt;typename Head, typename ...Tail&gt;` to recursively evaluate all of the types one by one, but I can&#39;t see a way of doing that for dispatching a function call.

The real motivation for this is somewhat more complex and it&#39;s mostly just a learning exercise anyway. You can assume that I&#39;m handed the tuple by contract from another interface, so can&#39;t be changed but that the desire to unpack it into a function call is mine. This rules out using `std::bind` as a cheap way to sidestep the underlying problem.
 
What&#39;s a clean way of dispatching the call using the `std::tuple`, or an alternative better way of achieving the same net result of storing/forwarding some values and a function pointer until an arbitrary future point?

&quot;unpacking&quot; a tuple to call a matching function pointer

Consider the following expressions. Note that some expressions are repeated to present the &quot;context&quot;.

(this is a long list)

    a, b = 1, 2                          # simple sequence assignment
    a, b = [&#39;green&#39;, &#39;blue&#39;]             # list asqignment
    a, b = &#39;XY&#39;                          # string assignment
    a, b = range(1,5,2)                  # any iterable will do
    
    
                                         # nested sequence assignment
    
    (a,b), c = &quot;XY&quot;, &quot;Z&quot;                 # a = &#39;X&#39;, b = &#39;Y&#39;, c = &#39;Z&#39; 
    
    (a,b), c = &quot;XYZ&quot;                     # ERROR -- too many values to unpack
    (a,b), c = &quot;XY&quot;                      # ERROR -- need more than 1 value to unpack
    
    (a,b), c, = [1,2],&#39;this&#39;             # a = &#39;1&#39;, b = &#39;2&#39;, c = &#39;this&#39;
    (a,b), (c,) = [1,2],&#39;this&#39;           # ERROR -- too many values to unpack
    
    
                                         # extended sequence unpacking
    
    a, *b = 1,2,3,4,5                    # a = 1, b = [2,3,4,5]
    *a, b = 1,2,3,4,5                    # a = [1,2,3,4], b = 5
    a, *b, c = 1,2,3,4,5                 # a = 1, b = [2,3,4], c = 5
    
    a, *b = &#39;X&#39;                          # a = &#39;X&#39;, b = []
    *a, b = &#39;X&#39;                          # a = [], b = &#39;X&#39;
    a, *b, c = &quot;XY&quot;                      # a = &#39;X&#39;, b = [], c = &#39;Y&#39;
    a, *b, c = &quot;X...Y&quot;                   # a = &#39;X&#39;, b = [&#39;.&#39;,&#39;.&#39;,&#39;.&#39;], c = &#39;Y&#39;
    
    a, b, *c = 1,2,3                     # a = 1, b = 2, c = [3]
    a, b, c, *d = 1,2,3                  # a = 1, b = 2, c = 3, d = []
    
    a, *b, c, *d = 1,2,3,4,5             # ERROR -- two starred expressions in assignment
    
    (a,b), c = [1,2],&#39;this&#39;              # a = &#39;1&#39;, b = &#39;2&#39;, c = &#39;this&#39;
    (a,b), *c = [1,2],&#39;this&#39;             # a = &#39;1&#39;, b = &#39;2&#39;, c = [&#39;this&#39;]
    
    (a,b), c, *d = [1,2],&#39;this&#39;          # a = &#39;1&#39;, b = &#39;2&#39;, c = &#39;this&#39;, d = []
    (a,b), *c, d = [1,2],&#39;this&#39;          # a = &#39;1&#39;, b = &#39;2&#39;, c = [], d = &#39;this&#39;
    
    (a,b), (c, *d) = [1,2],&#39;this&#39;        # a = &#39;1&#39;, b = &#39;2&#39;, c = &#39;t&#39;, d = [&#39;h&#39;, &#39;i&#39;, &#39;s&#39;]
    
    *a = 1                               # ERROR -- target must be in a list or tuple
    *a = (1,2)                           # ERROR -- target must be in a list or tuple
    *a, = (1,2)                          # a = [1,2]
    *a, = 1                              # ERROR -- &#39;int&#39; object is not iterable
    *a, = [1]                            # a = [1]
    *a = [1]                             # ERROR -- target must be in a list or tuple
    *a, = (1,)                           # a = [1]
    *a, = (1)                            # ERROR -- &#39;int&#39; object is not iterable
    
    *a, b = [1]                          # a = [], b = 1
    *a, b = (1,)                         # a = [], b = 1
    
    (a,b),c = 1,2,3                      # ERROR -- too many values to unpack
    (a,b), *c = 1,2,3                    # ERROR - &#39;int&#39; object is not iterable
    (a,b), *c = &#39;XY&#39;, 2, 3               # a = &#39;X&#39;, b = &#39;Y&#39;, c = [2,3]
    
    
                                         # extended sequence unpacking -- NESTED
    
    (a,b),c = 1,2,3                      # ERROR -- too many values to unpack
    *(a,b), c = 1,2,3                    # a = 1, b = 2, c = 3
    
    *(a,b) = 1,2                         # ERROR -- target must be in a list or tuple
    *(a,b), = 1,2                        # a = 1, b = 2
    
    *(a,b) = &#39;XY&#39;                        # ERROR -- target must be in a list or tuple
    *(a,b), = &#39;XY&#39;                       # a = &#39;X&#39;, b = &#39;Y&#39;
    
    *(a, b) = &#39;this&#39;                     # ERROR -- target must be in a list or tuple
    *(a, b), = &#39;this&#39;                    # ERROR -- too many values to unpack
    *(a, *b), = &#39;this&#39;                   # a = &#39;t&#39;, b = [&#39;h&#39;, &#39;i&#39;, &#39;s&#39;]
    
    *(a, *b), c = &#39;this&#39;                 # a = &#39;t&#39;, b = [&#39;h&#39;, &#39;i&#39;], c = &#39;s&#39;
    
    *(a,*b), = 1,2,3,3,4,5,6,7           # a = 1, b = [2, 3, 3, 4, 5, 6, 7]
    
    *(a,*b), *c = 1,2,3,3,4,5,6,7        # ERROR -- two starred expressions in assignment
    *(a,*b), (*c,) = 1,2,3,3,4,5,6,7     # ERROR -- &#39;int&#39; object is not iterable
    *(a,*b), c = 1,2,3,3,4,5,6,7         # a = 1, b = [2, 3, 3, 4, 5, 6], c = 7
    *(a,*b), (*c,) = 1,2,3,4,5,&#39;XY&#39;      # a = 1, b = [2, 3, 4, 5], c = [&#39;X&#39;, &#39;Y&#39;]
    
    *(a,*b), c, d = 1,2,3,3,4,5,6,7      # a = 1, b = [2, 3, 3, 4, 5], c = 6, d = 7
    *(a,*b), (c, d) = 1,2,3,3,4,5,6,7    # ERROR -- &#39;int&#39; object is not iterable
    *(a,*b), (*c, d) = 1,2,3,3,4,5,6,7   # ERROR -- &#39;int&#39; object is not iterable
    *(a,*b), *(c, d) = 1,2,3,3,4,5,6,7   # ERROR -- two starred expressions in assignment
    
    
    *(a,b), c = &#39;XY&#39;, 3                  # ERROR -- need more than 1 value to unpack
    *(*a,b), c = &#39;XY&#39;, 3                 # a = [], b = &#39;XY&#39;, c = 3
    (a,b), c = &#39;XY&#39;, 3                   # a = &#39;X&#39;, b = &#39;Y&#39;, c = 3
    
    *(a,b), c = &#39;XY&#39;, 3, 4               # a = &#39;XY&#39;, b = 3, c = 4
    *(*a,b), c = &#39;XY&#39;, 3, 4              # a = [&#39;XY&#39;], b = 3, c = 4
    (a,b), c = &#39;XY&#39;, 3, 4                # ERROR -- too many values to unpack

How to correctly deduce the result of such expressions by hand?

Unpacking, extended unpacking and nested extended unpacking

When a Python list is known to always contain a single item, is there a way to access it other than:

    mylist[0]

You may ask, &#39;Why would you want to?&#39;. Curiosity alone. There seems to be an alternative way to do *everything* in Python.

Getting only element from a single-element list in Python?

I frequently find myself working with Lists, Seqs, and Iterators of Tuples and would like to do something like the following,

    val arrayOfTuples = List((1, &quot;Two&quot;), (3, &quot;Four&quot;))
    arrayOfTuples.map { (e1: Int, e2: String) =&gt; e1.toString + e2 }

However, the compiler never seems to agree with this syntax.  Instead, I end up writing,

    arrayOfTuples.map { 
        t =&gt; 
        val e1 = t._1
        val e2 = t._2
        e1.toString + e2 
    }

Which is just silly.  How can I get around this?

Tuple Unpacking in Map Operations

The Python language (especially 3.x) allows very general *unpacking* of iterables, a simple example of which is

    a, *rest = 1, 2, 3

Over the years, this unpacking has been gradually generalized (see e.g. [PEP 3132][1] and [PEP 448][2]), allowing it to be used in more and more circumstances. As so, I was surprised to discover that the following is invalid syntax in Python 3.6 (and remains so in Python 3.7):

    def f():
        rest = [2, 3]
        return 1, *rest  # Invalid

I can make it work by encapsulating the returned tuple in parentheses like so:

    def f():
        rest = [2, 3]
        return (1, *rest)  # Valid

The fact that I use this in a `return` statement seems to be important, as

    t = 1, *rest

is indeed legal and results in the same with and without parentheses.

Have this case simply been forgotten by the Python developers, or are there any reason why this case is invalid syntax?

### Why I care
This breaks an important contract I thought I had with the Python language. Consider the following (also valid) solution:

    def f():
        rest = [2, 3]
        t = 1, *rest
        return t

Normally when I have code like this, I consider `t` to be a temporary name, which I ought to be able to get rid of simply be replacing `t` in the bottom line with its definition. In this case though, this leads to the invalid code

    def f():
        rest = [2, 3]
        return 1, *rest

It&#39;s of course no big deal to have to place parentheses around the return value, but usually additional parentheses are only needed to distinguish between several possible outcomes (grouping). Here this is not the case, as leaving out the parentheses does not produce some other unwanted behavior, but rather no behavior at all.


### Update
Since Python 3.8 (see item 7 on [this list][3]), the generalized syntax discussed above is now valid.



  [1]: https://www.python.org/dev/peps/pep-3132/
  [2]: https://www.python.org/dev/peps/pep-0448/
  [3]: https://docs.python.org/3.8/whatsnew/3.8.html#other-language-changes


Why is starred iterable unpacking in a return statement invalid syntax without parentheses before Python 3.8?

Is it possible to use type hinting when unpacking a tuple?  I want to do this, but it results in a `SyntaxError`:

    from typing import Tuple
    
    t: Tuple[int, int] = (1, 2)
    a: int, b: int = t
    #     ^ SyntaxError: invalid syntax

Type hints when unpacking a tuple?

I stumbled across the following code:

    for i, a in enumerate(attributes):
       labels.append(Label(root, text = a, justify = LEFT).grid(sticky = W))
       e = Entry(root)
       e.grid(column=1, row=i)
       entries.append(e)
       entries[i].insert(INSERT,&quot;text to insert&quot;)

I don&#39;t understand the `i, a` bit, and searching for information on `for` didn&#39;t yield any useful results. When I try and experiment with the code I get the error:

&gt; ValueError: need more than 1 value to unpack

Does anyone know what it does, or a more specific term associated with it that I can google to learn more?

How are tuples unpacked in for loops?

I have a dataframe with a timeindex and 3 columns containing the coordinates of a 3D vector:

                             x             y             z
    ts
    2014-05-15 10:38         0.120117      0.987305      0.116211
    2014-05-15 10:39         0.117188      0.984375      0.122070
    2014-05-15 10:40         0.119141      0.987305      0.119141
    2014-05-15 10:41         0.116211      0.984375      0.120117
    2014-05-15 10:42         0.119141      0.983398      0.118164


I would like to apply a transformation to each row that also returns a vector

    def myfunc(a, b, c):
        do something
        return e, f, g

but if I do:

    df.apply(myfunc, axis=1)

I end up with a Pandas series whose elements are tuples. This is beacause apply will take the result of myfunc without unpacking it. How can I change myfunc so that I obtain a new df with 3 columns?



**Edit:**

All solutions below work. The Series solution does allow for column names, the List solution seem to execute faster.


    def myfunc1(args):
        e=args[0] + 2*args[1]
        f=args[1]*args[2] +1
        g=args[2] + args[0] * args[1]
        return pd.Series([e,f,g], index=[&#39;a&#39;, &#39;b&#39;, &#39;c&#39;])

    def myfunc2(args):
        e=args[0] + 2*args[1]
        f=args[1]*args[2] +1
        g=args[2] + args[0] * args[1]
        return [e,f,g]

    %timeit df.apply(myfunc1 ,axis=1)

    100 loops, best of 3: 4.51 ms per loop

    %timeit df.apply(myfunc2 ,axis=1)

    100 loops, best of 3: 2.75 ms per loop

pandas apply function that returns multiple values to rows in pandas dataframe

I&#39;m going through some old code trying to understand what it does, and I came across this odd statement:

    *x ,= p

`p` is a list in this context. I&#39;ve been trying to figure out what this statement does. As far as I can tell, it just sets `x` to the value of `p`. For example:

    p = [1,2]
    *x ,= p    
    print(x)

Just gives

    [1, 2]

So is this any different than `x = p`? Any idea what this syntax is doing?

Understanding *x ,= lst

&gt; _In mathematics and computer science, a tuple is an ordered list of elements. In set theory, an (ordered) n-tuple is a sequence (or ordered list) of n elements, where n is a positive integer._

So, for example, in Python the 2nd item of a tuple would be accessed via `t[1]`.

In Scala, access is only possible via strange names `t._2`.

So the question is, why can&#39;t I access data in tuples as Sequence or List if it is by definition? Is there some sort of idea or just yet not inspected?

Why is Scala&#39;s syntax for tuples so unusual?

In my views.py, I&#39;m building a list of two-tuples, where the second item in the tuple is another list, like this:

    
    [ Product_Type_1, [ product_1, product_2 ],
      Product_Type_2, [ product_3, product_4 ]]

In plain old Python, I could iteration the list like this:

    for product_type, products in list:
        print product_type
        for product in products:
            print product

I can&#39;t seem to do the same thing in my Django template:

    {% for product_type, products in product_list %}
        print product_type
        {% for product in products %}
            print product
        {% endfor %}
    {% endfor %}

I get this error from Django:

&lt;strong&gt;Caught an exception while rendering: zip argument #2 must support iteration&lt;/strong&gt;

Of course, there is some HTML markup in the template, not print statements. Is tuple unpacking not supported in the Django template language? Or am I going about this the wrong way? All I am trying to do is display a simple hierarchy of objects - there are several product types, each with several products (in models.py, Product has a foreign key to Product_type, a simple one-to-many relationship).

Obviously, I am quite new to Django, so any input would be appreciated.





Django - How to do tuple unpacking in a template &#39;for&#39; loop

If I have a tuple such as `(1,2,3,4)` and I want to assign 1 and 3 to variables a and b I could obviously say

    myTuple = (1,2,3,4)
    a = myTuple[0]
    b = myTuple[2]

Or something like

    (a,_,b,_) = myTuple

Is there a way I could unpack the values, but ignore one or more of them of them?

Ignore part of a python tuple

Today, I saw one statement which didn&#39;t throw an exception. Can anyone explain the theory behind it?

    &gt;&gt;&gt; x, y = {&#39;a&#39;: 2, &#39;b&#39;: 5}
    &gt;&gt;&gt; x
    &#39;a&#39;
    &gt;&gt;&gt; y
    &#39;b&#39;

Why can a dictionary be unpacked as a tuple?

I have only a single key-value pair in a dictionary. I want to assign key to one variable
and it&#39;s value to another variable. I have tried with below ways but I am getting error for same.
 
    &gt;&gt;&gt; d = {&quot;a&quot;: 1}
    
    &gt;&gt;&gt; d.items()
    [(&#39;a&#39;, 1)]
    
    &gt;&gt;&gt; (k, v) = d.items()
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
    ValueError: need more than 1 value to unpack
    
    &gt;&gt;&gt; (k, v) = list(d.items())
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
    ValueError: need more than 1 value to unpack

I know that we can extract key and value one by one, or by for loop and `iteritems()`, but isn&#39;t there a simple way such that we can assign both in a single statement? 


How to extract dictionary single key-value pair in variables

I am confused by the use of the ellipsis (`...`) in some functions, i.e. how to pass an object containing the arguments as a single argument.

In Python it is called &quot;unpacking argument lists&quot;, e.g.

    &gt;&gt;&gt; range(3, 6)             # normal call with separate arguments
    [3, 4, 5]
    &gt;&gt;&gt; args = [3, 6]
    &gt;&gt;&gt; range(*args)            # call with arguments unpacked from a list
    [3, 4, 5]

In R for instance you have the function `file.path(...)` that uses an ellipsis. I would like to have this behaviour:

    &gt; args &lt;- c(&#39;baz&#39;, &#39;foob&#39;) 
    &gt; file.path(&#39;/foo/bar/&#39;, args)
    [1] &#39;foo/bar/baz/foob&#39;

Instead, I get 
    
    [1] &#39;foo/bar/baz&#39; &#39;foo/bar/foob&#39;

where the elements of `args` are not &quot;unpacked&quot; and evaluated at the same time. Is there a R equivalent to Pythons `*arg`?

Unpacking argument lists for ellipsis in R

In Python 3 I can do the following (see also [PEP3132][1] 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)


  [1]: http://www.python.org/dev/peps/pep-3132/

All Iterable Unpacking Solutions on Gang of Coders

Total of 17 Iterable Unpacking Solutions