Python – Functions

Functions is a structured and reusable organization that is used to perform only practical action. The Python Function will regularly make your application and a higher level of reuse.
As you have already learned, Python offers many local functions such as print (), etc., but you can also create your own work. These staff are called user-defined.

Defining a Function

You can describe jobs to pay for necessary work. Here are some simple rules to describe Python’s activities.

1. The types of activity begin with the main language followed by the name of the job and the cards ().
2. All borders or panels should be placed inside. You can also do the holes in these articles.
3. The first evidence of action can be voluntary training – documented work document or document.
4. The pulse code for each function starts with a clot (:) and goes backwards.
5. The return statement [presentation] deletes the action, submitting it voluntarily to the applicant. Evidence of return without any argument is the same.

Syntax:

def functionname( parameters ):
   "function_docstring"
   function_suite
   return [expression]

If they do not appreciate, the boundaries have a temporary nature and it is necessary to report the same as described.

For example

The next task uses a string like a cordless print on the screen.

def printme( str ):
   "This prints a passed string into this function"
   print str
   return

Calling a Function:

The definition of the job gives name, defines the boundaries that need to be included in the waste disposal and the structure of the waste.

Become a Python Certified Expert in 25Hours

When the basic structure of the task is finished, you can kill it by calling another activity or directly on the Python chart. Next, for example, you should call the print action ()

#!/usr/bin/python
# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;
# Now you can call printme function
printme("I'm first call to user defined function!")
printme("Again second call to the same function")

When the previous code is implemented, it produces the following results –

I'm first call to user defined function!
Again second call to the same function

Call by Reference vs Value

All the boundaries of the Python language are referred to as references. This means that if you change the boundaries of the technology, the change also returns to the call functions. For example –

#!/usr/bin/python
# Function definition is here
def changeme( mylist ):
   "This changes a passed list into this function"
   mylist.append([1,2,3,4]);
   print "Values inside the function: ", mylist
   return
# Now you can call changeme function
mylist = [10,20,30];
changeme( mylist );
print "Values outside the function: ", mylist

Here, we keep referring to previous items and adding value to the same thing. After this, this will produce the following results –

Values inside the function:  [10, 20, 30, [1, 2, 3, 4]]
Values outside the function:  [10, 20, 30, [1, 2, 3, 4]]

Function Arguments:

You can call technique using the following types of formal arguments:

1. Required Arguments
2. Keyword Arguments
3. Default Arguments
4. Variable Length Arguments

Required Arguments:

The necessary arguments are the arguments that have been submitted to the appropriate action in the correct position. Here, the number of calls to the call must correctly define the activities.
To call the publishing task (), you must properly log in, otherwise, give the error device the following –

#!/usr/bin/python
# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;
# Now you can call printme function
printme()

When the previous code is implemented, it generates the following results –

Traceback (most recent call last):
   File "test.py", line 11, in <module>
      printme();
TypeError: printme() takes exactly 1 argument (0 given)

Keyword Arguments:

The term debate depends on call activities. When you use the key arguments in the action, the caller describes the arguments using the name of the control.
This will allow you to ignore the debate or post an order because the Python interpreter can use the displayed words to match the value of the boundary. You can also make important calls about print jobs () in the following ways:

#!/usr/bin/python
# Function definition is here
def printme( str ):
   "This prints a passed string into this function"
   print str
   return;
# Now you can call printme function
printme( str = "My string")

When the previous code is implemented, it generates the following results –

My string

Default Arguments:

The common argument is a debate that is assumed to be a standard value if there is no value in the ‘debate’. The following examples give you an idea of ​​how to debate the debate, it will generate the normal age if not exempt –

#!/usr/bin/python
# Function definition is here
def printinfo( name, age = 35 ):
   "This prints a passed info into this function"
   print "Name: ", name
   print "Age ", age
   return;
# Now you can call printinfo function
printinfo( age=50, name="miki" )
printinfo( name="miki" )

When the previous code is implemented, it generates the following results –

Name: miki
Age 50
Name: miki
Age 35

Variable Length Argument:

It may be necessary to solve the many arguments you have described as defined in the work. These discussions are called adventurous arguments that are not defined in the definition of action, which is different from those for which they are needed.

Get Python Online Certification Training

Articles for non-argumentative arguments for this –

def functionname([formal_args,] *var_args_tuple ):
   "function_docstring"
   function_suite
   return [expression]

The Anonymous Function:

These jobs are called unspecified names because they are not mentioned in the standard method of keyword. You can use lambda lamb to create confidential jobs.

1. Lamb Number can have any number of arguments, but only return the value of the sound. They can not take orders or comments.
2. Confidential work can not be a direct and printed call because the Lamb needs a talk.
3. Number number jobs have their own local advertisements and can not access other variables other than their strategic list and domain names.
4. Although it appears that the Lamb is a single-line function, it does not correspond to the C or C ++ guidelines, and their purpose is to pass the assignment process during the application for performance reasons.

Syntax:

The numbers in the lamb numbers contain only one sign, which is the following:

lambda [arg1 [,arg2,.....argn]]:expression

Below is an example of how the Lamb works –

#!/usr/bin/python
# Function definition is here
sum = lambda arg1, arg2: arg1 + arg2;
# Now you can call sum as a function
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )

When the previous code is implemented, it generates the following results –

Value of total :  30
Value of total :  40

Return Statement:

The return statement [show] leaves the job, preferring a proposal for the call. Evidence of return without any argument is the same.

Learn Python From Experts at Besant Technologies

All previous models did not return any value. You can repeat the value of the performance in the following –

#!/usr/bin/python
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2
   print "Inside the function : ", total
   return total;
# Now you can call sum function
total = sum( 10, 20 );
print "Outside the function : ", total 

When the previous code is implemented, it generates the following results –

Inside the function :  30
Outside the function :  30

The scope of Variable:

All program variables may not be all programs in the program. This depends on where you declared the variable.
The scope of the change determines part of the program that you can get specific identification. There are two basic components in Python –

1. Global Variable
2. Local Variable

Global Vs Local Variable:

The changes described in FGM have the local area definition described in the international dimension.
This means that local variables are available only for the announced activities, while the global change is available in all parts of the program. When the action is called, the alterations in the sound are placed in size. Here is a simple example –

#!/usr/bin/python
total = 0; # This is global variable.
# Function definition is here
def sum( arg1, arg2 ):
   # Add both the parameters and return them."
   total = arg1 + arg2; # Here total is local variable.
   print "Inside the function local total : ", total
   return total;
# Now you can call sum function
sum( 10, 20 );
print "Outside the function global total : ", total 

When the above code is executed, it produces the following result −

Inside the function local total :  30
Outside the function global total :  0

To getting expect level training for Python training in your Location – Python Training in Chennai | Python Training in Bangalore | Python Training in Pune | Python Training institute in Chennai | Python Interview Questions | Python Course in Chennai