The ** syntax requires a mapping (such as a dictionary); each key-value pair in the mapping becomes a keyword argument. Your generate() function, on the other hand, returns a tuple, not a dictionary. You can pass in a tuple as separate arguments with similar syntax, using just one asterisk: create_character = player.Create(*generate_player.generate()) Alternatively, fix your … Read more
You can unpack the transpose of the array in order to use the columns for your function arguments: my_func(*arr.T) Here’s a simple example: >>> x = np.arange(15).reshape(5, 3) array([[ 0, 5, 10], [ 1, 6, 11], [ 2, 7, 12], [ 3, 8, 13], [ 4, 9, 14]]) Let’s write a function to add the … Read more
Unpacking in list, dict, set, and tuple literals has been added in Python 3.5, as described in PEP 448: Python 3.5.0 (v3.5.0:374f501f4567, Sep 13 2015, 02:27:37) on Windows (64 bits). >>> [1, 2, 3, *[4, 5, 6]] [1, 2, 3, 4, 5, 6] Here are some explanations for the rationale behind this change. Note that … Read more
You can unpack a tuple or a list into positional arguments using a star. def add(a, b, c): print(a, b, c) x = (1, 2, 3) add(*x) Similarly, you can use double star to unpack a dict into keyword arguments. x = { ‘a’: 3, ‘b’: 1, ‘c’: 2 } add(**x)
A single star * unpacks a sequence or collection into positional arguments. Suppose we have def add(a, b): return a + b values = (1, 2) Using the * unpacking operator, we can write s = add(*values), which will be equivalent to writing s = add(1, 2). The double star ** does the same thing … Read more
The *args calling convention is documented in the Expressions reference: If the syntax *expression appears in the function call, expression must evaluate to an iterable. Elements from this iterable are treated as if they were additional positional arguments; if there are positional arguments x1, …, xN, and expression evaluates to a sequence y1, …, yM, … Read more
When you define your function using this syntax: def someFunc(*args): for x in args print x You’re telling it that you expect a variable number of arguments. If you want to pass in a List (Array from other languages) you’d do something like this: def someFunc(myList = [], *args): for x in myList: print x … Read more
The __getitem__() and keys() methods will suffice: >>> class D: def keys(self): return [‘a’, ‘b’] def __getitem__(self, key): return key.upper() >>> def f(**kwds): print kwds >>> f(**D()) {‘a’: ‘A’, ‘b’: ‘B’}
My apologies for the length of this post, but I decided to opt for completeness. Once you know a few basic rules, it’s not hard to generalize them. I’ll do my best to explain with a few examples. Since you’re talking about evaluating these “by hand,” I’ll suggest some simple substitution rules. Basically, you might … Read more