Python function calling another function and arguments

Question

Let's say that I have a function which takes 10 arguments and another functions which takes 11 arguments and the second one is calling the first one. My code:

def func10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10):
    return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10

def func11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11):
    return a11 + func10(a1=a1, a2=a2, a3=a3, a4=a4, a5=a5, a6=a6, a7=a7, a8=a8, a9=a9, a10=a10)

Is it possible to write it nicer, i.e. without writing a1=a1, a2=a2, ...?

EDIT Maybe to be more precise: in the function func11 the arguments are a1, a2, ... a11. Ten of these arguments are also passed to func10 function with exactly the same names. I would like to make this works:

def func11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11):
    return a11 + func10(arguments)

func11(a1=a1, a11=11, a2=a2, a3=a3, a4=a4, a5=a5, a6=a6, a7=a7, a8=a8, a9=a9, a10=10)

so that I can change the order of arguments when calling func11 but the proper arguments (i.e. a1 - a10) should be passed to func10 inside func11 in a simple way instead of writing again a1=a1 .... How can I do that? And I don't want to do summation in my function, this is just an example!

Answer 1

You don’t need the equals sign and the extra

You can just call it like this:

def func11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11):
    return a11 + func10(a1,a2,a3,a4,a5,a6,a7,a8,a9,a10)

As far as I know you only need argname=object when you use kwargs or a single kwarg.

Update: to match the questions update.

You can define function 11 with kwargs and then pass them on.

def func11(**kwargs):
   return kwargs['a11'] + func10(kwargs['a1'],kwargs['a2'], etc.)
#this let’s you change the position how you want ;)

Answer 2

You don't need to explicitly state a1=a1 for every argument func10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) will do the same although you most likely should consider using *args or **kwargs for something like this. Example:

def func10(*args):
    total = 0
    for num in args:
        total += num
    return num

Edit: To clarify this would only work if you intended on doing something similar with each argument

Check @MatsLindh answer I think its the best for your scenario if your doing anything more advanced than the solution I suggested (which is likely)

Answer 3

"""
The following takes advantage of un-packing in function 11.

Receive 10 arguments in func10 pass the 10 arguments to func11 
in a different order plus one additional argument.

"""

def func10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10):
    print('func10 original order  ',[a1, a2, a3, a4, a5, a6, a7, a8, a9, a10] )
    a11 = 5
    # Pass original arguments to func11 in different order
    for_func11 = [a3, a2, a1, a4, a6, a5, a7, a8, a11, a10,a9]
    func11(*for_func11)
       
    return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10

def func11(b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11):
    print('func11 parameter values',list((b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11)))
    return b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11


func10(1, 2, 3, 4, 6, 7, 8, 9, 10, 11)

output

func10 original order   [1, 2, 3, 4, 6, 7, 8, 9, 10, 11]
func11 parameter values [3, 2, 1, 4, 7, 6, 8, 9, 5, 11, 10]

Answer 4

Define your functions to instead take a list of arguments for a1-a10 then specify a11 as a keyword argument:

def func10(*args):
    return sum(args)

def func11(*args, **kwargs):
    return kwargs['a11'] + func10(*args)

print(func11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, a11=11))
# Outputs 66

Note: This assume a11 exists.

Answer 5

In python you can use *args and **kwargs to pass arguments to a function. Here's some examples on how you could use them:

using args only

def func10(*args):
    return sum(args)

def func11(*args):
    return args[-1] + func10(*args[:-1])

the_args = [1,2,3,4,5,6,7,8,9,10,42]
print(func11(*the_args))

using kwargs and ignoring a11

def func10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, **ignored_kwargs):
    return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10

def func11(**kwargs):
    return kwargs['a11'] + func10(**kwargs)

the_kwargs = dict(a1=1, a2=2, a3=3, a4=4, a5=5, a6=6, a7=7, a8=8, a9=9, a10=10, a11=42)
print(func11(**the_kwargs))

using kwargs values assuming order is correct as args

def func10(*args):
    return sum(args[:-1])

def func11(**kwargs):
    return kwargs['a11'] + func10(*kwargs.values())

the_kwargs = dict(a1=1, a2=2, a3=3, a4=4, a5=5, a6=6, a7=7, a8=8, a9=9, a10=10, a11=42)
print(func11(**the_kwargs))

Answer 6

def func10(data):
    return sum(data)
    
    
def func11(data):
    return data[10] + func10(data[:10:])
    
    
def main():
    a1 = 1
    a2 = 2
    a3 = 3
    a4 = 4
    a5 = 5
    a6 = 6
    a7 = 7
    a8 = 8
    a9 = 9
    a10 = 10
    a11 = 11
    print(func11([a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11]))

main()

Based on your edit you can change the order of the arguments inside the list for the initial func11 call.

Answer 7

You can do a bit of trickery by using locals() as the first statement inside your function, effectively capturing all the arguments given to the function and their values. You can then use **kwargs to pass these on to the previous function - but you need to remove a11 first, since func10 doesn't know anything about it.

def func10(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10):
    return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10


def func11(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11):
    given_args = locals()
    del given_args['a11']
    
    return func10(**given_args) + a11
    
    
print(func10(1, 2, 3, 4, 5, 6, 7, 8, 9, 10))
print(func11(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11))

Output:

55
66

However, if this is something you see yourself having to do a lot, you might want to define a1, a2 etc. as properties of a Pydantic model instead, and then let each step populate another value in that model.