Python Function

Functions are the most important aspect of an application. A function can be defined as the
organized block of reusable code, which can be called whenever required.

Python allows us to divide a large program into the basic building blocks known as a
function. The function contains the set of programming statements enclosed by {}. A
function can be called multiple times to provide reusability and modularity to the Python
program.

The Function helps to programmer to break the program into the smaller part. It organizes
the code very effectively and avoids the repetition of the code. As the program grows,
function makes the program more organized.

Python provide us various inbuilt functions like range() or print(). Although, the user can
create its functions, which can be called user-defined functions.

There are mainly two types of functions.

o User-define functions - The user-defined functions are those define by the user to

perform the specific task.
o Built-in functions - The built-in functions are those functions that are pre-
defined in Python.

In this tutorial, we will discuss the user define functions.

Advantage of Functions in Python

There are the following advantages of Python functions.

o Using functions, we can avoid rewriting the same logic/code again and again in a
program.
o We can call Python functions multiple times in a program and anywhere in a
program.
o We can track a large Python program easily when it is divided into multiple functions.
o Reusability is the main achievement of Python functions.
o However, Function calling is always overhead in a Python program.

Creating a Function
 Python provides the def keyword to define the function. The syntax of the define function is
given below.

Syntax:

1. def my_function(parameters):  
2.       function_block  
3. return expression  

Let's understand the syntax of functions definition.

o The def keyword, along with the function name is used to define the function.
o The identifier rule must follow the function name.
o A function accepts the parameter (argument), and they can be optional.
o The function block is started with the colon (:), and block statements must be at the
same indentation.
o The return statement is used to return the value. A function can have only
one return

Function Calling
In Python, after the function is created, we can call it from another function. A function
must be defined before the function call; otherwise, the Python interpreter gives an error.
To call the function, use the function name followed by the parentheses.

Consider the following example of a simple example that prints the message "Hello World".

1. #function definition  
2. def hello_world():    
3.     print("hello world")    
4. # function calling  
5. hello_world()      

Output:

hello world

The return statement

The return statement is used at the end of the function and returns the result of the
function. It terminates the function execution and transfers the result where the function is
called. The return statement cannot be used outside of the function.

Syntax
1. return [expression_list]  

It can contain the expression which gets evaluated and value is returned to the caller
function. If the return statement has no expression or does not exist itself in the function
then it returns the None object.

Consider the following example:

Example 1
1. # Defining function  
2. def sum():  
3.     a = 10  
4.     b = 20  
5.     c = a+b  
6.     return c  
7. # calling sum() function in print statement  
8. print("The sum is:",sum())  

Output:

The sum is: 30

In the above code, we have defined the function named sum, and it has a statement c =
a+b, which computes the given values, and the result is returned by the return statement
to the caller function.

Example 2 Creating function without return statement

1. # Defining function  
2. def sum():  
3.     a = 10  
4.     b = 20  
5.     c = a+b  
6. # calling sum() function in print statement  
7. print(sum())  

Output:

None

In the above code, we have defined the same function without the return statement as we
can see that the sum() function returned the None object to the caller function.
 Arguments in function
The arguments are types of information which can be passed into the function. The
arguments are specified in the parentheses. We can pass any number of arguments, but
they must be separate them with a comma.

Consider the following example, which contains a function that accepts a string as the
argument.

Example 1
1. #defining the function    
2. def func (name):    
3.     print("Hi ",name)   
4. #calling the function     
5. func("Devansh")     

Output:

Hi Devansh

Example 2
1. #Python function to calculate the sum of two variables     
2. #defining the function    
3. def sum (a,b):    
4.     return a+b;    
5.     
6. #taking values from the user    
7. a = int(input("Enter a: "))    
8. b = int(input("Enter b: "))    
9.     
10. #printing the sum of a and b    
11. print("Sum = ",sum(a,b))    

Output:

Enter a: 10
Enter b: 20
Sum = 30

Types of arguments
 There may be several types of arguments which can be passed at the time of function call.

1. Required arguments
2. Keyword arguments
3. Default arguments
4. Variable-length arguments

Required Arguments
Till now, we have learned about function calling in Python. However, we can provide the
arguments at the time of the function call. As far as the required arguments are concerned,
these are the arguments which are required to be passed at the time of function calling with
the exact match of their positions in the function call and function definition. If either of the
arguments is not provided in the function call, or the position of the arguments is changed,
the Python interpreter will show the error.

Consider the following example.

Example 1

1. def func(name):    
2.     message = "Hi "+name  
3.     return message  
4. name = input("Enter the name:")    
5. print(func(name))    

Output:

Enter the name: John

Hi John

Example 2

1. #the function simple_interest accepts three arguments and returns the simple intere
st accordingly    
2. def simple_interest(p,t,r):    
3.     return (p*t*r)/100    
4. p = float(input("Enter the principle amount? "))    
5. r = float(input("Enter the rate of interest? "))    
6. t = float(input("Enter the time in years? "))    
7. print("Simple Interest: ",simple_interest(p,r,t))    

Output:

Enter the principle amount: 5000

 Enter the rate of interest: 5
Enter the time in years: 3
Simple Interest: 750.0

Example 3

1. #the function calculate returns the sum of two arguments a and b    
2. def calculate(a,b):    
3.     return a+b    
4. calculate(10) # this causes an error as we are missing a required arguments b.    

Output:

TypeError: calculate() missing 1 required positional argument: 'b'

Default Arguments
Python allows us to initialize the arguments at the function definition. If the value of any of
the arguments is not provided at the time of function call, then that argument can be
initialized with the value given in the definition even if the argument is not specified at the
function call.

Example 1

1. def printme(name,age=22):    
2.     print("My name is",name,"and age is",age)    
3. printme(name = "john")  

Output:

My name is John and age is 22

Example 2

1. def printme(name,age=22):    
2.     print("My name is",name,"and age is",age)    
3. printme(name = "john") #the variable age is not passed into the function however t
he default value of age is considered in the function    
4. printme(age = 10,name="David") #the value of age is overwritten here, 10 will be 
printed as age   

Output:

My name is john and age is 22

My name is David and age is 10
 Variable-length Arguments (*args)
In large projects, sometimes we may not know the number of arguments to be passed in
advance. In such cases, Python provides us the flexibility to offer the comma-separated
values which are internally treated as tuples at the function call. By using the variable-
length arguments, we can pass any number of arguments.

However, at the function definition, we define the variable-length argument using

the *args (star) as *<variable - name >.

Consider the following example.

Example

1. def printme(*names):    
2.     print("type of passed argument is ",type(names))    
3.     print("printing the passed arguments...")    
4.     for name in names:    
5.         print(name)    
6. printme("john","David","smith","nick")    

Output:

type of passed argument is <class 'tuple'>

printing the passed arguments...
john
David
smith
nick

In the above code, we passed *names as variable-length argument. We called the function

and passed values which are treated as tuple internally. The tuple is an iterable sequence
the same as the list. To print the given values, we iterated *arg names using for loop.

Keyword arguments(**kwargs)
Python allows us to call the function with the keyword arguments. This kind of function call
will enable us to pass the arguments in the random order.

The name of the arguments is treated as the keywords and matched in the function calling
and definition. If the same match is found, the values of the arguments are copied in the
function definition.

Consider the following example.

Example 1
1. #function func is called with the name and message as the keyword arguments    
2. def func(name,message):    
3.     print("printing the message with",name,"and ",message)    
4.       
5.     #name and message is copied with the values John and hello respectively    
6.     func(name = "John",message="hello")   

Output:

printing the message with John and hello

Example 2 providing the values in different order at the calling

1. #The function simple_interest(p, t, r) is called with the keyword arguments the order 
of arguments doesn't matter in this case    
2. def simple_interest(p,t,r):    
3.     return (p*t*r)/100    
4. print("Simple Interest: ",simple_interest(t=10,r=10,p=1900))     

Output:

Simple Interest: 1900.0

If we provide the different name of arguments at the time of function call, an error will be
thrown.

Consider the following example.

Example 3

1. #The function simple_interest(p, t, r) is called with the keyword arguments.     
2. def simple_interest(p,t,r):    
3.     return (p*t*r)/100    
4.   
5. # doesn't find the exact match of the name of the arguments (keywords)      
6. print("Simple Interest: ",simple_interest(time=10,rate=10,principle=1900))   

Output:

TypeError: simple_interest() got an unexpected keyword argument 'time'

The Python allows us to provide the mix of the required arguments and keyword arguments
at the time of function call. However, the required argument must not be given after the
keyword argument, i.e., once the keyword argument is encountered in the function call, the
following arguments must also be the keyword arguments.
 Consider the following example.

Example 4

1. def func(name1,message,name2):    
2.     print("printing the message with",name1,",",message,",and",name2)    
3. #the first argument is not the keyword argument    
4. func("John",message="hello",name2="David")   

Output:

printing the message with John , hello ,and David

The following example will cause an error due to an in-proper mix of keyword and required
arguments being passed in the function call.

Example 5

1. def func(name1,message,name2):   
2.     print("printing the message with",name1,",",message,",and",name2)    
3. func("John",message="hello","David")        

Output:

SyntaxError: positional argument follows keyword argument

Python provides the facility to pass the multiple keyword arguments which can be
represented as **kwargs. It is similar as the *args but it stores the argument in the
dictionary format.

This type of arguments is useful when we do not know the number of arguments in
advance.

Consider the following example:

Example 6: Many arguments using Keyword argument

1. def food(**kwargs):  
2.     print(kwargs)  
3. food(a="Apple")  
4. food(fruits="Orange", Vagitables="Carrot")  

Output:

{'a': 'Apple'}
{'fruits': 'Orange', 'Vagitables': 'Carrot'}
 Scope of variables
The scopes of the variables depend upon the location where the variable is being declared.
The variable declared in one part of the program may not be accessible to the other parts.

In python, the variables are defined with the two types of scopes.

1. Global variables
2. Local variables

The variable defined outside any function is known to have a global scope, whereas the
variable defined inside a function is known to have a local scope.

Consider the following example.

Example 1 Local Variable

1. def print_message():    
2.     message = "hello !! I am going to print a message." # the variable messa
ge is local to the function itself    
3.     print(message)    
4. print_message()    
5. print(message) # this will cause an error since a local variable cannot be accessible 
here.      

Output:

hello !! I am going to print a message.

File "/root/PycharmProjects/PythonTest/Test1.py", line 5, in
print(message)
NameError: name 'message' is not defined

Example 2 Global Variable

1. def calculate(*args):    
2.     sum=0    
3.     for arg in args:    
4.         sum = sum +arg    
5.     print("The sum is",sum)    
6. sum=0    
7. calculate(10,20,30) #60 will be printed as the sum    
8. print("Value of sum outside the function:",sum) # 0 will be printed  Output:  
 Output:

The sum is 60
Value of sum outside the function: 0

--Call by reference in Python

In Python, call by reference means passing the actual value as an argument in the function.
All the functions are called by reference, i.e., all the changes made to the reference inside
the function revert back to the original value referred by the reference.

Example 1 Passing Immutable Object (List)

1. #defining the function    
2. def change_list(list1):    
3.     list1.append(20)   
4.     list1.append(30)    
5.     print("list inside function = ",list1)    
6.     
7. #defining the list    
8. list1 = [10,30,40,50]    
9.     
10. #calling the function     
11. change_list(list1)  
12. print("list outside function = ",list1)  

Output:

list inside function = [10, 30, 40, 50, 20, 30]

list outside function = [10, 30, 40, 50, 20, 30]

Example 2 Passing Mutable Object (String)

1. #defining the function    
2. def change_string (str):    
3.     str = str + " Hows you "  
4.     print("printing the string inside function :",str)  
5.     
6. string1 = "Hi I am there"    
7.     
8. #calling the function    
9. change_string(string1)    
10.     
11. print("printing the string outside function :",string1)    

Output:

printing the string inside function : Hi I am there Hows you

printing the string outside function : Hi I am there

Functions in Python
A function is a set of statements that take inputs, do some specific computation and
produces output. The idea is to put some commonly or repeatedly done task together
and make a function, so that instead of writing the same code again and again for
different inputs, we can call the function.
Python provides built-in functions like print(), etc. but we can also create your own
functions. These functions are called user-defined functions.

# A simple Python function to check

# whether x is even or odd
def evenOdd( x ):
    if (x % 2 == 0):
        print "even"
    else:
        print "odd"
  
# Driver code
evenOdd(2)
evenOdd(3)
Output:
even
odd

Pass by Reference or pass by value?

One important thing to note is, in Python every variable name is a reference. When we
pass a variable to a function, a new reference to the object is created. Parameter
passing in Python is same as reference passing in Java.

# Here x is a new reference to same list lst

def myFun(x):
   x[0] = 20
  
# Driver Code (Note that lst is modified
# after function call.
lst = [10, 11, 12, 13, 14, 15] 
myFun(lst);
print(lst) 
Output:
[20, 11, 12, 13, 14, 15]

When we pass a reference and change the received reference to something else, the
connection between passed and received parameter is broken. For example, consider
below program.
Output:
10
Output:
('x: ', 10)
('y: ', 50)

Like C++ default arguments, any number of arguments in a function can have a default
value. But once we have a default argument, all the arguments to its right must also
have default values.

Keyword arguments:
The idea is to allow caller to specify argument name with values so that caller does not need to
remember order of parameters.
Python Functions

A function is a block of code which only runs when it is called.

You can pass data, known as parameters, into a function.

A function can return data as a result.

Creating a Function
In Python a function is defined using the def keyword:

Example
def my_function():
  print("Hello from a function")

Calling a Function
To call a function, use the function name followed by parenthesis:

Example
def my_function():
  print("Hello from a function")

my_function()
Try it Yourself »

Arguments
Information can be passed into functions as arguments.

Arguments are specified after the function name, inside the parentheses. You
can add as many arguments as you want, just separate them with a comma.

The following example has a function with one argument (fname). When the
function is called, we pass along a first name, which is used inside the function
to print the full name:

Example
def my_function(fname):
  print(fname + " Refsnes")

my_function("Emil")
my_function("Tobias")
my_function("Linus")
Try it Yourself »

Arguments are often shortened to args in Python documentations.

Parameters or Arguments?
The terms parameter and argument can be used for the same thing:
information that are passed into a function.

From a function's perspective:

A parameter is the variable listed inside the parentheses in the function

definition.

An argument is the value that is sent to the function when it is called.

Number of Arguments
By default, a function must be called with the correct number of arguments.
Meaning that if your function expects 2 arguments, you have to call the function
with 2 arguments, not more, and not less.

Example
This function expects 2 arguments, and gets 2 arguments:

def my_function(fname, lname):
  print(fname + " " + lname)

my_function("Emil", "Refsnes")
Try it Yourself »

If you try to call the function with 1 or 3 arguments, you will get an error:
Example
This function expects 2 arguments, but gets only 1:

def my_function(fname, lname):
  print(fname + " " + lname)

my_function("Emil")
Try it Yourself »

Arbitrary Arguments, *args

If you do not know how many arguments that will be passed into your function,
add a * before the parameter name in the function definition.

This way the function will receive a tuple of arguments, and can access the
items accordingly:

Example
If the number of arguments is unknown, add a * before the parameter name:

def my_function(*kids):
  print("The youngest child is " + kids[2])

my_function("Emil", "Tobias", "Linus")
Try it Yourself »
Arbitrary Arguments are often shortened to *args in Python documentations.

Keyword Arguments
You can also send arguments with the key = value syntax.

This way the order of the arguments does not matter.

Example
def my_function(child3, child2, child1):
  print("The youngest child is " + child3)

my_function(child1 = "Emil", child2 = "Tobias", child3 = "Linus")

Try it Yourself »

The phrase Keyword Arguments are often shortened to kwargs in Python

documentations.

Arbitrary Keyword Arguments, **kwargs

If you do not know how many keyword arguments that will be passed into your
function, add two asterisk: ** before the parameter name in the function
definition.

This way the function will receive a dictionary of arguments, and can access the
items accordingly:

Example
If the number of keyword arguments is unknown, add a double ** before the
parameter name:

def my_function(**kid):
  print("His last name is " + kid["lname"])

my_function(fname = "Tobias", lname = "Refsnes")

Try it Yourself »
Arbitrary Kword Arguments are often shortened to **kwargs in Python
documentations.

Default Parameter Value

The following example shows how to use a default parameter value.

If we call the function without argument, it uses the default value:

Example
def my_function(country = "Norway"):
  print("I am from " + country)

my_function("Sweden")
my_function("India")
my_function()
my_function("Brazil")
Try it Yourself »

Passing a List as an Argument

You can send any data types of argument to a function (string, number, list,
dictionary etc.), and it will be treated as the same data type inside the function.

E.g. if you send a List as an argument, it will still be a List when it reaches the
function:

Example
def my_function(food):
  for x in food:
    print(x)

fruits = ["apple", "banana", "cherry"]

my_function(fruits)

Try it Yourself »
Return Values
To let a function return a value, use the return statement:

Example
def my_function(x):
  return 5 * x

print(my_function(3))
print(my_function(5))
print(my_function(9))
Try it Yourself »

The pass Statement

function definitions cannot be empty, but if you for some reason have
a function definition with no content, put in the pass statement to avoid getting
an error.

Example
def myfunction():
  pass
Try it Yourself »

--Recursion
Python also accepts function recursion, which means a defined function can call
itself.

Recursion is a common mathematical and programming concept. It means that

a function calls itself. This has the benefit of meaning that you can loop through
data to reach a result.
The developer should be very careful with recursion as it can be quite easy to
slip into writing a function which never terminates, or one that uses excess
amounts of memory or processor power. However, when written correctly
recursion can be a very efficient and mathematically-elegant approach to
programming.

In this example, tri_recursion() is a function that we have defined to call

itself ("recurse"). We use the k variable as the data, which decrements (-1)
every time we recurse. The recursion ends when the condition is not greater
than 0 (i.e. when it is 0).

To a new developer it can take some time to work out how exactly this works,
best way to find out is by testing and modifying it.

Example
Recursion Example

def tri_recursion(k):
  if(k > 0):
    result = k + tri_recursion(k - 1)
    print(result)
  else:
    result = 0
  return result

print("\n\nRecursion Example Results")

tri_recursion(6)

Try it Yourself »

Python Functions
In this guide, we will learn about functions in Python. A function is a block of
code that contains one or more Python statements and used for performing a
specific task.
Why use function in Python?
As I mentioned above, a function is a block of code that performs a specific task.
Lets discuss what we can achieve in Python by using functions in our code:
1. Code re-usability: Lets say we are writing an application in Python where we
need to perform a specific task in several places of our code, assume that we
need to write 10 lines of code to do that specific task. It would be better to write
those 10 lines of code in a function and just call the function wherever needed,
because writing those 10 lines every time you perform that task is tedious, it
would make your code lengthy, less-readable and increase the chances of
human errors.

2. Improves Readability: By using functions for frequent tasks you make your
code structured and readable. It would be easier for anyone to look at the code
and be able to understand the flow and purpose of the code.

3. Avoid redundancy: When you no longer repeat the same lines of code
throughout the code and use functions in places of those, you actually avoiding
the redundancy that you may have created by not using functions.

Syntax of functions in Python

Function declaration:

def function_name(function_parameters):
function_body # Set of Python statements
return # optional return statement
Calling the function:

# when function doesn't return anything

function_name(parameters)
OR

# when function returns something

# variable is to store the returned value
variable = function_name(parameters)

Python Function example

Here we have a function add() that adds two numbers passed to it as parameters.
Later after function declaration we are calling the function twice in our program to
perform the addition.
def add(num1, num2):
return num1 + num2

sum1 = add(100, 200)

sum2 = add(8, 9)
print(sum1)
print(sum2)
Output:

300
17

Default arguments in Function

Now that we know how to declare and call a function, lets see how can we use
the default arguments. By using default arguments we can avoid the errors that
may arise while calling a function without passing all the parameters. Lets take
an example to understand this:

In this example we have provided the default argument for the second
parameter, this default argument would be used when we do not provide the
second parameter while calling this function.

# default argument for second parameter

def add(num1, num2=1):
return num1 + num2

sum1 = add(100, 200)

sum2 = add(8) # used default argument for second param
sum3 = add(100) # used default argument for second param
print(sum1)
print(sum2)
print(sum3)
Output:

300
9
101

Types of functions
There are two types of functions in Python:
1. Built-in functions: These functions are predefined in Python and we need not
to declare these functions before calling them. We can freely invoke them as and
when needed.
2. User defined functions: The functions which we create in our code are user-
defined functions. The add() function that we have created in above examples is
a user-defined function.

--Python Recursion
A function is said to be a recursive if it calls itself. For example, lets say we have
a function abc() and in the body of abc() there is a call to the abc().

Python example of Recursion

In this example we are defining a user-defined function factorial(). This function
finds the factorial of a number by calling itself repeatedly until the base case(We
will discuss more about base case later, after this example) is reached.

# Example of recursion in Python to

# find the factorial of a given number

def factorial(num):
"""This function calls itself to find
the factorial of a number"""

if num == 1:
return 1
else:
return (num * factorial(num - 1))

num = 5
print("Factorial of", num, "is: ", factorial(num))
Output:

Factorial of 5 is: 120

Lets see what happens in the above example:

factorial(5) returns 5 * factorial(5-1)

i.e. 5 * factorial(4)
|__5*4*factorial(3)
|__5*4*3*factorial(2)
|__5*4*3*2*factorial(1)
Note: factorial(1) is a base case for which we already know the value of factorial.
The base case is defined in the body of function with this code:

if num == 1:
return 1

What is a base case in recursion

When working with recursion, we should define a base case for which we already
know the answer. In the above example we are finding factorial of an integer
number and we already know that the factorial of 1 is 1 so this is our base case.

Each successive recursive call to the function should bring it closer to the base
case, which is exactly what we are doing in above example.

We use base case in recursive function so that the function stops calling itself
when the base case is reached. Without the base case, the function would keep
calling itself indefinitely.

Why use recursion in programming?

We use recursion to break a big problem in small problems and those small
problems into further smaller problems and so on. At the end the solutions of all
the smaller subproblems are collectively helps in finding the solution of the big
main problem.

Advantages of recursion
Recursion makes our program:
1. Easier to write.
2. Readable – Code is easier to read and understand.
3. Reduce the lines of code – It takes less lines of code to solve a problem using
recursion.

Disadvantages of recursion
1. Not all problems can be solved using recursion.
2. If you don’t define the base case then the code would run indefinitely.
3. Debugging is difficult in recursive functions as the function is calling itself in a
loop and it is hard to understand which call is causing the issue.
4. Memory overhead – Call to the recursive function is not memory efficient.