# User defined functions

## Contents

### What is a user defined function

Let’s take a simple task – Calculate the interest on the balance in your bank account since the beginning of the year. In order to do that, you first need 3 things

- account balance
- interest rate
- days since Jan 1st of the current year

def calculate_interest(balance,interest,days) : interest_amount = balance * ( interest / 100 ) * ( days/365 ) return interest_amount

To call the function, all you have to do is to just follow the signature of the function.

interest_amount = calculate_interest(1200,10,100) print ( interest_amount )

32.87671232876712

Think of functions as essentially outsourcing the processing to a different place. In a large project, each developer works on developing his/her own piece of logic. Eventually, all of them need to be linked together. Functions provide the most fundamental way in which logic can be clealy separated. Ofcourse, there are other things like modules, libraries etc that do the same at a much higher level, but that is a topic for another day.

Now, since the logic is separated into a separate function, the developer writing the function has to provide some kind of documentation on how to use the function. For example, in this case, the developer would have to provide some basic info on how to pass the arguments. For example, should the interest rate be passed as a percentage or value. How should the days be calculated – since the beginning of the fiscal year or the beginning of financial year etc.

In order to do this, python provides something called as a docstring.

### docstring

docstring is a simple way to provide documentation on the function. It can also be used for providing documentation on classes of modules as we will see when we get to them. Providing a docstring in a function is very simple – just provide the text enclosed in **triple quotes**.

def calculate_interest(balance,interest,days) : """ Calculates interest on a given balance. The key arguments are 1. Balance - Amount on which balance needs to be calculated 2. Interest - Annual interest in percentage 3. Days - Number of days since the beginning of the year """ interest_amount = balance * ( interest / 100 ) * ( days/365 ) return interest_amount

calculate_interest

<function __main__.calculate_interest(balance, interest, days)>

You can also get the same programmatically using the **doc** function.

print ( calculate_interest.__doc__ )

Calculates interest on a given balance. The key arguments are 1. Balance - Amount on which balance needs to be calculated 2. Interest - Annual interest in percentage 3. Days - Number of days since the beginning of the year

### Arguments

Arguments are how the function receives information from the caller. There are many variations in the way the arguments can be passed. For example, you can

- specify mandatory arguments
- pass default values to arguments
- have variable number of arguments and so on.

Let’s discover each of these variations.

### Required arguments

Most of the times some of the arguments to a function are required and some are not. Let’s take the **calculate_interest** example that we have seen above. There are 3 arguments.

def calculate_interest(balance,interest,days) : interest_amount = balance * ( interest / 100 ) * ( days/365 ) return interest_amount

What happens when you call the function with just 2 arguments ? Python throws a **TypeError**.

interest_amount = calculate_interest(1000, 5)

--------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-22-b464ba338fc0> in <module> ----> 1 interest_amount = calculate_interest(1000, 5) TypeError: calculate_interest() missing 1 required positional argument: 'days'

When you don’t specify argument names, the position of the arguments is important.

interest_amount = calculate_interest(1000, 5,100)

### Named Arguments

Named arguments can be passed in any order you like – as long as you specify the argument name Python does the matching automatically.

interest_amount = calculate_interest(interest = 5, days = 100, balance = 1000)

This would result in the sa

The reason is because, unless specified otherwise, all arguments to a function are mandatory. Sometimes, to simplify things, we might make it easy on the user of the function to default an argument to a fixed value.

### Default arguments

Say, the interest rate is 5% unless specified otherwise. This is how we would define that function.

def calculate_interest (balance,interest = 5,days) : interest_amount = balance * ( interest / 100 ) * ( days/365 ) return interest_amount

File "<ipython-input-11-c745ff0a87a1>", line 1 def calculate_interest (balance,interest = 5,days) : ^ SyntaxError: non-default argument follows default argument

That didn’t seem to work, right ? What python is saying is that default arguments should be specified at the end (before the non-default argument begins). In this case, specify the *days* argument before the *interest* argument.

def calculate_interest (balance,days, interest = 5) : interest_amount = balance * ( interest / 100 ) * ( days/365 ) return interest_amount

Now, if we call the function, we don’t need to pass the argument for *interest*.

interest_amount = calculate_interest(1200, 100) interest_amount

16.43835616438356

However, if you want, you can very well pass the argument for interest as well. The function works either way. Very convenient, isn’t it ?

A good example for this is the **print** function. Look at the signature of it.

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

The arguments for separator (sep), end of line (end), output stream (file) etc are all defaulted to some values so that you don’t have to specify them everytime. However, you can very well send them in based on your requirements. For example, if you don’t want the newline to be printed for everytime the print function is used, send in a blank for the *end* argument.I

print ( "Ajay", end="") print ( "Tech")

AjayTech

If not for that, this is how the default behaviour would look like.

print ( "Ajay") print ( "Tech")

Ajay Tech

### Variable number of arguments

The print function is a good example of a function with variable number of arguments. It can take as many strings as you want and still print all of them sequentially.

print ( "Ajay", "Tech", "is", "a","tech","company")

Ajay Tech is a tech company

The way to define a function like this is by using a star ( ***** ) before the parameter name. Here is an example of a function that takes in a variable number of grades and computes the average of them.

def avg_grade(*grades) : i = 0 sum = 0.0 for grade in grades : sum = sum + grade i = i + 1 avg = sum / i return avg

avg = avg_grade(2.5,3.0,3.5) # as many arguments as you like avg

3.0

Internally, python takes in these arguments as a tuple. We will discuss tuples in python in a later section.