In a function call *t means “treat the elements of this iterable as positional arguments to this function call.” def foo(x, y): print(x, y) >>> t = (1, 2) >>> foo(*t) 1 2 Since v3.5, you can also do this in a list/tuple/set literals: >>> [1, *(2, 3), 4] [1, 2, 3, 4] **d means … Read more
Another way is as follows. If one has a list of tuples say: mylst = [(a, b, c), (x, y, z), (l, m, n)] then one can unpack this list in the template file in the following manner. In my case I had a list of tuples which contained the URL, title, and summary of … Read more
I personally would write: a, _, b = myTuple This is a pretty common idiom, so it’s widely understood. I find the syntax crystal clear.
Scala knows the arity of the tuples and is thus able to provide accessors like _1, _2, etc., and produce a compile-time error if you select _3 on a pair, for instance. Moreover, the type of those fields is exactly what the type used as parameter for Tuple (e.g. _3 on a Tuple3[Int, Double, Float] … Read more
*x ,= p is basically an obfuscated version of x = list(p) using extended iterable unpacking. The comma after x is required to make the assignment target a tuple (it could also be a list though). *x, = p is different from x = p because the former creates a copy of p (i.e. a … Read more
You could google “tuple unpacking”. This can be used in various places in Python. The simplest is in assignment: >>> x = (1,2) >>> a, b = x >>> a 1 >>> b 2 In a for-loop it works similarly. If each element of the iterable is a tuple, then you can specify two variables, … Read more
I suspect this is an accident, based on the comments from this commit for Python 3.2. That commit enabled the assignment expression to take a testlist_star_expr production (what allows the unparenthesized unpacking), but left the return statement taking a testlist production. I suspect the commit just missed this (and possibly other locations, but I’m focusing … Read more
A work around is to use case : arrayOfTuples map {case (e1: Int, e2: String) => e1.toString + e2}
Return Series and it will put them in a DataFrame. def myfunc(a, b, c): do something return pd.Series([e, f, g]) This has the bonus that you can give labels to each of the resulting columns. If you return a DataFrame it just inserts multiple rows for the group.
According to PEP-0526, you should annotate the types first, then do the unpacking a: int b: int a, b = t