CODEWITHSUNDEEP
python
showkey
showkey

Reputation: 298

How to understand variable-length argument in python function?

I want to write my own sum function to get the sum of a variable-length argument.

def myadd(*tuple):
    sum=0
    for element in tuple:
        sum=sum+element
    return(sum)

call method 1:

myadd(*(1,2,3,4))

It is the most formal way to call the function.no problem here.

call method 2:

myadd(1,2,3,4)

It also can get the result,why?

call method 3:

myadd((1,2,3,4))

error TypeError: unsupported operand type(s) for +: 'int' and 'tuple'.

In my point of view,call 2 and call 3 can not be accepted by python,there are no * operator in the position of arguments?can you tell me the pricinple of the operation on python function ?

Upvotes: 0

Views: 4271

Answers (3)

abarnert
abarnert

Reputation: 365975

You're mixing up variable-argument parameters and argument unpacking. This is a common mistake for beginners, because they both use the same * for syntax, and they're not completely unrelated… but they're not nearly as closely related as you think.

These two calls do the exact same thing:

myadd(*(1,2,3,4))
myadd(1, 2, 3, 4)

What the * means here is "take the following iterable, and unpack it into a bunch of separate arguments.

It doesn't matter whether the function you're calling was defined as f(*args), f(a, b, c, d), or f(a, b, *args), you're passing it 4 arguments.

This means method 1 is not "the most formal way to call the function"; in fact, it's just an obfuscated version of method 2.

This, on the other hand, does not do the same thing:

myadd((1, 2, 3, 4))

That passes a single argument, which happens to be a tuple.

So, your function is defined like this:

def myadd(*tuple):

This means whatever it arguments it's passed, no matter how they're passed (except for keyword arguments, but let's ignore that for the moment), they're going to be tossed into a list named tuple. So, let's look at your three cases.

In the first case, you're passing 4 arguments, all of which are integers. So, tuple gets a list of 4 integers. When you iterate over that list, each member is an integer, so you can add them up with no problem.

In the second case—which, again, is exactly the same—you're passing 4 integers, so tuple gets a list of 4 integers.

In the third case, you're passing 1 argument, which is a tuple, so tuple gets a list of 1 tuple. When you iterate over that list, each member is a tuple, and you can't add that to a number.

For more details, see Arguments and parameters, which has links to all the useful places to look in the docs, and hopefully a readable overview.

Upvotes: 6

Ashoka Lella
Ashoka Lella

Reputation: 6729

def myadd(x):                                
    sum=0                                    
    for element in x:                        
        sum=sum+element                      
    return(sum)                              

x=(1,2,3)                                    
print myadd(x)

output

6

Upvotes: 1

Ferdinand Beyer
Ferdinand Beyer

Reputation: 67197

You are passing the whole tuple as one argument, and tuples cannot be added to numbers. If you want to pass all the tuple elements as individual arguments, use the * operator:

myadd(*x)

Upvotes: 2

Related Questions