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.
Challenges
codeChallenge : Create a python function to return the length of a string excluding the number of blank characters
Take a string as an argument and count the length of the string using a for loop and return the length. While counting the characters, exclude the count if the character is a space.
def str_len ( string ) :
length = 0
for char in string :
if char != " " :
length = length + 1
return length
codeChallenge : Create a python function that takes in a number and multiples it by another number. By default the multiplication factor should be 5. If the user specifies one, it should be used.
The function should take in 2 numbers. The first parameter is sent by the user and the second parameter should be defaulted to 5. Both numbers should be multiplied and sent back. If the user sends a number other than 5 as the second parameter that number should be used as the multiplication factor.
def multiplier ( num_1, num_2 = 5) :
return num_1 * num_2
codeChallenge : Create a python function that takes in any number of numbers and returns the sum of them.
The function should take in a variable number of numbers as arguments and returns the sum of the numbers. Do not use a list to send the arguments.
def sum_numbers ( *numbers) :
sum = 0
for number in numbers :
sum = sum + number
return sum