Learn Python – Python Function- Basic and advance

Functions are the most important element of an application. A function can be defined as the prepared block of reusable code, which can be called every time required.

Python permits us to divide a large application into the fundamental building blocks regarded as a function. The function incorporates the set of programming statements enclosed through {}. A feature can be called multiple times to supply reusability and modularity to the Python program.

The Function helps to programmer to destroy the program into the smaller part. It organizes the code very successfully and avoids the repetition of the code. As the application grows, feature makes the application extra organized.

Python provide us quite a number in-built functions like range() or print(). Although, the user can create its functions, which can be known as user-defined functions.

There are mainly two types of functions.

User-define functions – The user-defined functions are those define by the user to perform the specific task.

Built-in functions – The built-in functions are those functions that are pre-defined in Python.

In this tutorial, we will talk about the person outline functions.

Advantage of Functions in Python

There are the following benefits of Python functions.

Using functions, we can avoid rewriting the same logic/code again and again in a program.

We can call Python functions multiple times in a program and anywhere in a program.

We can track a large Python program easily when it is divided into multiple functions.

Reusability is the main achievement of Python functions.

However, Function calling is always overhead in a Python program.

Creating a Function

Python presents the def key-word to define the function. The syntax of the outline feature is given below.

Syntax:

def my_function(parameters):  
      function_block  
return expression  

Let’s recognize the syntax of features definition.

The def keyword, along with the function name is used to define the function.

The identifier rule must follow the function name.

A function accepts the parameter (argument), and they can be optional.

The function block is started with the colon (:), and block statements must be at the same indentation.

The return statement is used to return the value. A function can have only one return

Function Calling

In Python, after the characteristic is created, we can call it from another function. A function must be defined earlier than the characteristic call; otherwise, the Python interpreter gives an error. To call the function, use the feature identify followed with the aid of the parentheses.

Consider the following example of a simple instance that prints the message “Hello World”.

#function definition  
def hello_world():    
    print("hello world")    
# function calling  
hello_world()      

Output:

return [expression_list]  

It can comprise the expression which receives evaluated and price is again to the caller function. If the return statement has no expression or does no longer exist itself in the feature then it returns the None object.

Consider the following example:

Example 1

# Defining function  
def sum():  
    a = 10  
    b = 20  
    c = a+b  
    return c  
# calling sum() function in print statement  
print("The sum is:",sum())  

Output:

# Defining function  
def sum():  
    a = 10  
    b = 20  
    c = a+b  
# calling sum() function in print statement  
print(sum())  

Output:

None

In the above code, we have described the same characteristic without the return declaration as we can see that the sum() feature lower back the None object to the caller function.

Arguments in function

The arguments are kinds of records which can be surpassed into the function. The arguments are precise in the parentheses. We can skip any number of arguments, however they ought to be separate them with a comma.

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

Example 1

#defining the function    
def func (name):    
    print("Hi ",name)   
#calling the function     
func("Devansh")     

Output:

Hi Devansh

Example 2

#Python function to calculate the sum of two variables     
#defining the function    
def sum (a,b):    
    return a+b;    
    
#taking values from the user    
a = int(input("Enter a: "))    
b = int(input("Enter b: "))    
    
#printing the sum of a and b    
print("Sum = ",sum(a,b))    

Output:

Enter a: 10
Enter b: 20
Sum =  30

Call by reference in Python

In Python, name with the aid of reference means passing the true cost as an argument in the function. All the functions are called by way of reference, i.e., all the adjustments made to the reference inside the function revert again to the authentic value referred via the reference.

Example 1 Passing Immutable Object (List)

#defining the function    
def change_list(list1):    
    list1.append(20)   
    list1.append(30)    
    print("list inside function = ",list1)    
    
#defining the list    
list1 = [10,30,40,50]    
    
#calling the function     
change_list(list1)  
print("list outside function = ",list1)  

Output:

#defining the function    
def change_string (str):    
    str = str + " Hows you "  
    print("printing the string inside function :",str)  
    
string1 = "Hi I am there"    
    
#calling the function    
change_string(string1)    
    
print("printing the string outside function :",string1)    

Output:

Required arguments
Keyword arguments
Default arguments
Variable-length arguments

Required Arguments

Till now, we have discovered about function calling in Python. However, we can supply the arguments at the time of the feature call. As far as the required arguments are concerned, these are the arguments which are required to be passed at the time of feature calling with the exact match of their positions in the feature call and feature definition. If both of the arguments is now not supplied in the function call, or the position of the arguments is changed, the Python interpreter will exhibit the error.

Consider the following example.

Example 1

def func(name):    
    message = "Hi "+name  
    return message  
name = input("Enter the name:")    
print(func(name))    

Output:

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

Output:

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

Output:

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

Output:

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

Output:

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

Output:

#function func is called with the name and message as the keyword arguments    
def func(name,message):    
    print("printing the message with",name,"and ",message)    
      
    #name and message is copied with the values John and hello respectively    
    func(name = "John",message="hello")   

Output:

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

Output:

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

Output:

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

Output:

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

Output:

def food(**kwargs):  
    print(kwargs)  
food(a="Apple")  
food(fruits="Orange", Vagitables="Carrot")  

Output:

{'a': 'Apple'}
{'fruits': 'Orange', 'Vagitables': 'Carrot'}

Scope of variables

The scopes of the variables depend upon the location the place the variable is being declared. The variable declared in one phase of the software may also not be accessible to the other parts.

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

Global variables
Local variables

The variable described backyard any characteristic is recognised to have a world scope, whereas the variable defined inner a function is acknowledged to have a local scope.

Consider the following example.

Example 1 Local Variable

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

Output:

def calculate(*args):    
    sum=0    
    for arg in args:    
        sum = sum +arg    
    print("The sum is",sum)    
sum=0    
calculate(10,20,30) #60 will be printed as the sum    
print("Value of sum outside the function:",sum) # 0 will be printed  Output:  

Output:

Example 2 Global Variable

Python affords the facility to ignore the a couple of key-word arguments which can be represented as **kwargs. It is comparable as the *args however it stores the argument in the dictionary format.

This kind of arguments is useful when we do not be aware of the variety of arguments in advance.

Consider the following example:

Example 6: Many arguments using Keyword argument

The following example will motive an error due to an in-proper combine of keyword and required arguments being handed in the function call.

Example 5

The Python lets in us to provide the combine of the required arguments and key-word arguments at the time of feature call. However, the required argument have to no longer be given after the keyword argument, i.e., as soon as the key-word argument is encountered in the function call, the following arguments ought to additionally be the key-word arguments.

Consider the following example.

Example 4

If we furnish the exceptional name of arguments at the time of feature call, an error will be thrown.

Consider the following example.

Example 3

Example two imparting the values in one-of-a-kind order at the calling

In the above code, we handed *names as variable-length argument. We referred to as the characteristic and surpassed values which are treated as tuple internally. The tuple is an iterable sequence the identical as the list. To print the given values, we iterated *arg names the usage of for loop.

Keyword arguments(**kwargs)

Python allows us to call the feature with the key-word arguments. This variety of function call will enable us to ignore the arguments in the random order.

The title of the arguments is handled as the keywords and matched in the characteristic calling and definition. If the equal healthy is found, the values of the arguments are copied in the feature definition.

Consider the following example.

Example 1

Variable-length Arguments (*args)

In giant projects, every so often we may not comprehend the wide variety of arguments to be passed in advance. In such cases, Python presents us the flexibility to provide the comma-separated values which are internally treated as tuples at the characteristic call. By using the variable-length arguments, we can pass by any quantity of arguments.

However, at the characteristic definition, we define the variable-length argument using the *args (star) as *identify >.

Consider the following example.

Example

Example 2

Default Arguments

Python allows us to initialize the arguments at the characteristic definition. If the value of any of the arguments is not supplied at the time of function call, then that argument can be initialized with the cost given in the definition even if the argument is no longer certain at the feature call.

Example 1

Example 3

Example 2

Types of arguments

There may additionally be numerous types of arguments which can be handed at the time of function call.

Example 2 Passing Mutable Object (String)

In the above code, we have described the feature named sum, and it has a statement c = a+b, which computes the given values, and the end result is back with the aid of the return announcement to the caller function.

Example two Creating feature besides return declaration

The return statement

The return declaration is used at the quit of the function and returns the end result of the function. It terminates the characteristic execution and transfers the end result the place the characteristic is called. The return statement cannot be used outdoor of the function.

Syntax