Question

I was wondering if the ‘a=a’, and ‘b=b’ can lead to problems/unexpected behaviour? code works fine in the example.

def add_func(a=2,b=3):
   return a+b

a=4
b=5
answer = add_func(a=a, b=b)

Thanks

Answer 1

Not that I know of, although I’d love to be proved wrong.

The formal language reference defines the lexical structure of a function call. The important bit is that it defines a “keyword_item” as identifier "=" expression. Also, here’s what it says about how the arguments to the call are interpreted:

If keyword arguments are present, they are first converted to
positional arguments, as follows. First, a list of unfilled slots is
created for the formal parameters. If there are N positional
arguments, they are placed in the first N slots. Next, for each
keyword argument, the identifier is used to determine the
corresponding slot (if the identifier is the same as the first formal
parameter name, the first slot is used, and so on). If the slot is
already filled, a TypeError exception is raised. Otherwise, the value
of the argument is placed in the slot, filling it (even if the
expression is None, it fills the slot). When all arguments have been
processed, the slots that are still unfilled are filled with the
corresponding default value from the function definition.

This lists a few possible scenarios.

In the simple case, like you mentioned, where there are two formal arguments (a and b), and if you specify the function call using keyword parameters like add_func(a=a, b=b), here’s what happens:

1. Two slots are created to hold the parameters.
2. Since you didn’t provide any positional arguments in the call (just keyword arguments), none of the slots are filled initially.
3. Each of your keyword arguments are analyzed individually, and the identifier of your argument (the “a” in the a= part) is compared with all of the formal parameters names of the function (the names that were given the parameters when the function was defined, in our case, a and b).
4. When a match occurs, the value of the keyword arguments (in this case, 4!) is used to fill the corresponding slot.
5. This repeats until all keyword arguments are analyzed. If all slots aren’t filled, then Python tries to assign a default value to the remaining slots if one exists. If not, an error is raised.

So, Python treats the “identifier” in a keyword argument completely differently. This is only true for keyword arguments, though; obviously, if you tried something like add_func(b, a), even though your parameters themselves are called b and a, this would not be mapped to the formal parameters in the function; your parameters would be backwards. However, add_func(b=b, a=a) works fine; the positions don’t matter as long as they are keyword arguments.