Meaning of * operator when used with classes

Question

I've been trying to follow a video tutorial on Python and cannot understand one operation the developer performs.

class Polynomial():

    def __init__(self, *coeffs):
        self.coeffs = coeffs # (3,4,3)

    def __repr__(self):
        return 'Polynomial(*{!r})'.format(self.coeffs)

    def __add__(self, other):
        print(self.coeffs)
        print(other.coeffs)
        z = (x + y for x, y in zip(self.coeffs, other.coeffs))
        print(z)
        return Polynomial(*(x + y for x, y in zip(self.coeffs, other.coeffs)))

p1 = Polynomial(1, 2, 3) # x^2 + 2x + 3
p2 = Polynomial(3, 4, 3) # 3x^2 + 4x + 3
#print(p2) # Polynomial(*(3, 4, 3))
print(p1 + p2) # Polynomial(*(4, 6, 6))

The above example will print

<generator object Polynomial.__add__.<locals>.<genexpr> at 0x030D0390>

as the return value of z, I cannot understand why because I am performing a zip operation of two tuples?

Alongside that problem, I do not understand why removing the * during the return of __add__ causes a problem i.e return Polynomial(*(x + y for x, y in zip(self.coeffs, other.coeffs))) to return Polynomial((x + y for x, y in zip(self.coeffs, other.coeffs)))

What is the * operator doing, and why is z an object of Polynomial?

The _add__ method does not contain a parameter containing a * or ** and is therefore a different situation.

Possible duplicate of [What does \*\* (double star/asterisk) and \* (star/asterisk) do for parameters?](https://stackoverflow.com/questions/36901/what-does-double-star-asterisk-and-star-asterisk-do-for-parameters) — Norrius, Nov 15 '18 at 09:19

score 1 · Answer 1 · answered Nov 15 '18 at 09:21

So first.

Your print is ok. You defined a generator using () parentheses. You can change this to [] and then you should see the elements in list.

Or you can use your generator, so print:

print([el for el in z])

Second, the *.

It will simply pass iterable as separated args, so:

SomeClass(*args)

Will do:

SomeClass(args[0], args[1], args[2], ...)

You can read about this in official docs (single asterisk), here: https://docs.python.org/3/reference/expressions.html#expression-lists And here (double asterisk): https://docs.python.org/3/reference/expressions.html#dictionary-displays

or just print(list(z)). As to second question - you print the result of p1+p2 - i.e. print(p1 + p2). The __add__ method returns Polynominal object, so when you print it and because you don't have __str__ method, it calls the __repr__ method of Polynominal class — buran, Nov 15 '18 at 09:22

iElden · Answer 2 · 2018-11-15T09:18:34.367

0

When in a function declaration, * is list of args send.

For exemple:

def my_function(a, *b, **c):
    print(a)
    print(b)
    print(c)

my_function("1st arg", "other arg", "other arg again", 2, arg_type="kwargs")

output :

1st args
["other arg", "other arg again", 2]
{"arg_type": "kwargs"}

And when is not in function declaration, it's for unpack the list.

For exemple:

list_of_arguments = ['a', 'b', 'z']
my_str = "the first letter of alphabet is {}, the second is {} and the last is {}"
print(my_str.format(*list_of_arguments))

or other exemple

 def my_second_func(a, b, c):
     print(a)
     print(b)

 my_list = [1, 2, 3]
 my_second_func(a, b, c)

will output:

 1
 2

edited Nov 15 '18 at 09:18

answered Nov 15 '18 at 09:16

iElden

1,272
1
13
26

but __add__ does not have a parameter with a * – J.doe Nov 15 '18 at 09:18
i edited my post, in your code ``*`` is used for unpack the list returned by the zip() function – iElden Nov 15 '18 at 09:22

score 0 · Answer 3 · answered Nov 15 '18 at 09:27

Consider this easy example:

a = [1, 2, 3]
b = [4, 5, 6]

gen = (x + y for x, y in zip(a, b))

print(gen) ## this will print <generator object <genexpr> at 0x...>

In this case, the asterisk evaluates the generator expression. So when doing

print(*gen) ## this will print 5 7 9

you evaluate the generator expression.

Meaning of * operator when used with classes

3 Answers3