Function Arguments

def squares_a_list(numerical_list):
    new_squared_list = list()
    
    for number in numerical_list:
        new_squared_list.append(number ** 2)
    
    return new_squared_list

def cubes_a_list(numerical_list):
    new_cubed_list = list()
    
    for number in numerical_list:
        new_cubed_list.append(number ** 3)
    
    return new_cubed_list

Let’s talk more about function arguments.

Arguments play a paramount role when it comes to adhering to the DRY principle as well as adding flexibility to your code.

Let’s bring back the function we made named squares_a_list().

The reason we made this function in the first place was to DRY out our code and avoid repeating the same for loop for any additional list we wished to operate on.

What happens now if we no longer wanted to square a number but calculate a specified exponential of each element, perhaps n³, or n⁴?

Would we need a new function?

We could make a similar new function for cubing the numbers.

But this feels repetitive.

def exponent_a_list(numerical_list, exponent):
    new_exponent_list = list()
    
    for number in numerical_list:
        new_exponent_list.append(number ** exponent)
    
    return new_exponent_list

numbers = [2, 3, 5]
exponent_a_list(numbers, 3)

[8, 27, 125]

exponent_a_list(numbers, 5)

[32, 243, 3125]

A better solution that adheres to the DRY principle is to tweak our original function but add an additional argument.

Take a look at exponent_a_list() which now takes 2 arguments; the original numerical_list, and now a new argument named exponent.

This gives us a choice of the exponent. We could use the same function now for any exponent we want instead of making a new function for each.

This makes sense to do if we foresee needing this versatility, else the additional argument isn’t necessary.

Default Values for Arguments

def exponent_a_list(numerical_list, exponent=2):
    new_exponent_list = list()
    
    for number in numerical_list:
        new_exponent_list.append(number ** exponent)
    
    return new_exponent_list

numbers = [2, 3, 5]
exponent_a_list(numbers)

[4, 9, 25]

Python allows for default values in the event that an argument is not provided to the function.

For example, in a new version of exponent_a_list(), the function uses a default value of 2 for exponent.

Since we do not specify the exponent argument when we call our function, it defaults to an exponent of 2.

These arguments with default values are also called optional arguments (because you don’t have to specify them), or “keyword arguments”.

exponent_a_list(numbers, exponent=5)

[32, 243, 3125]

exponent_a_list(numbers, 5)

[32, 243, 3125]

We also have the option of assigning this exponent argument something other than 2.

We can specify a value for exponent using exponent=5 if we need to.

def exponent_a_list(exponent=2, numerical_list):
    new_exponent_list = list()
    
    for number in numerical_list:
        new_exponent_list.append(number ** exponent)
    
    return new_exponent_list

Error: parameter without a default follows parameter with a default (<string>, line 1)

Functions can have any number of arguments and any number of optional arguments, but we must be careful with the order of the arguments.

When we define our arguments in a function, all arguments with default values (aka optional arguments) need to be placed after required arguments.

If any required arguments follow any arguments with default values, an error will occur.

Let’s take our original function exponent_a_list() and re-order it so the optional exponent argument is defined first.

We will see Python throw an error.

Argument Ordering

def exponent_a_list(numerical_list, exponent=2):
    new_exponent_list = list()
    
    for number in numerical_list:
        new_exponent_list.append(number ** exponent)
    
    return new_exponent_list

exponent_a_list([2, 3, 5], 5)

[32, 243, 3125]

Up to this point, we have been calling functions with multiple arguments in a single way.

When we call our function, we have been ordering the arguments in the order the function defined them in.

So, in exponent_a_list(), the argument numerical_list is defined first, followed by the argument exponent.

Naturally, we have been calling our function with the arguments in this order as well.

exponent_a_list([2, 3, 5], exponent= 5)

[32, 243, 3125]

exponent_a_list(numerical_list=[2, 3, 5], exponent=5)

[32, 243, 3125]

exponent_a_list(exponent=5, numerical_list=[2, 3, 5])

[32, 243, 3125]

We showed earlier that we could also call the function by specifying exponent=5.

Another way of calling this would be to also specify any of the argument names that do not have default values, in this case, numerical_list.

What happens if we switch up the order of the arguments and put exponent=5 followed by numerical_list=numbers?

It still works!

exponent_a_list(5,  [2, 3, 5])

TypeError: 'int' object is not iterable

Detailed traceback: 
  File "<string>", line 1, in <module>
  File "<string>", line 4, in exponent_a_list

What about if we switch up the ordering of the arguments without specifying any of the argument names.

Our function doesn’t recognize the input arguments, and an error occurs because the two arguments are being swapped - it thinks 5 is the list, and [2, 3, 5] is the exponent.

It’s important to take care when ordering and calling a function.

The rule of thumb to remember is if you are going to call a function where the arguments are in a different order from how they were defined, you need to assign the argument name to the value when you call the function.

Let’s apply what we learned!