Scribd
Upload
6 views

Functions

Uploaded by

poonamsinghh1805
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
6 views

Functions

Uploaded by

poonamsinghh1805
Copyright
© © All Rights Reserved
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 32

FUNCTIONS:

• Function is a sub program which consists of set of instructions


used to perform a specific task. A large program is divided into
basic building blocks called function.
• Need For Function:

v When the program is too complex and large they are divided
into parts. Each part is separately coded and combined into single
program. Each subprogram is called as function.
v Debugging, Testing and maintenance becomes easy when the
program is divided into subprograms.
v Functions are used to avoid rewriting same code again and
again in a program.
v Function provides code re-usability
v The length of the program is reduced.
• Types of function:

Functions can be classified into two categories:


i) Built in function
ii) user defined function
i) Built in functions

v Built in functions are the functions that are already created and
stored in python.

These built in functions are always available for usage and accessed
by a programmer. It cannot be modified.
ii)User Defined Functions:
v User defined functions are the functions that programmers
create for their requirement and use.
v These functions can then be combined to form module which
can be used in other programs by importing them.

v Advantages of user defined functions:


· Programmers working on large project can divide the workload
by making different functions.
· If repeated code occurs in a program, function can be used to
include those codes and execute when needed by calling that
function.
Function definition: (Sub program)

v def keyword is used to define a function.


v Give the function name after def keyword followed by
parentheses in which arguments are given.
v End with colon (:)
v Inside the function add the program statements to be executed
v End with or without return statement
• Syntax:
def fun_name(Parameter1,Parameter2…Parameter n):
statement1
statement2…
statement n
return[expression]

• Example:
def my_add(a,b):
c=a+b
return c
Function Calling:
Ø Once we have defined a function, we can call it from another
function, program or even the Python prompt.
Ø To call a function we simply type the function name with
appropriate arguments.

• Example:
x=5
y=4
my_add(x,y)
Flow of Execution:
v The order in which statements are executed is called the flow of
execution
v Execution always begins at the first statement of the program
v Statements are executed one at a time, in order, from top to
bottom.
v Function definitions do not alter the flow of execution of the
program, but remember that statements inside the function are not
executed until the function is called.
v Function calls are like a bypass in the flow of execution. Instead
of going to the next statement, the flow jumps to the first line of
the called function, executes all the statements there, and then
comes back to pick up where it left off.
Note: When you read a program, don’t read from top to bottom.
Instead, follow the flow of execution. This means that you will read
the def statements as you are scanning from top to bottom, but you
should skip the statements of the function definition until you reach
a point where that function is called.
Parameters And Arguments:

Parameters(Formal Parameters):
· Parameters are the value(s) provided in the parenthesis when we
write function header.
· These are the values required by function to work.
· If there is more than one value required, all of them will be listed
in parameter list separated by comma.
· Example: def my_add(a,b):
Arguments(Actual Parameters) :
· Arguments are the value(s) provided in function call/invoke
statement.
· List of arguments should be supplied in same way as parameters
are listed.
· Bounding of parameters to arguments is done 1:1, and so there
should be same number and type of arguments as mentioned in
parameter list.
· Example: my_add(x,y)
RETURN STATEMENT:
• The return statement is used to exit a function and go back to
the place from where it was called.
• If the return statement has no arguments, then it will not return
any values. But exits from function.

• Syntax:
return[expression]
• Example:
def my_add(a,b):
c=a+b
return c
x=5
y=4
print(my_add(x,y))

• Output:
9
ARGUMENTS TYPES:
1. Required Arguments
2. Keyword(named) Arguments
3. Default Arguments
4. Variable length Arguments
1. Required Arguments:
• The number of arguments in the function call should
match exactly with the function definition.
def my_details( name, age ):
print("Name: ", name)
print("Age ", age)
return
my_details("george",56)

• Output:
Name: george
Age 56
2. Keyword(named) Arguments:
• Python interpreter is able to use the keywords provided to match
the values with parameters even though if they are arranged in out
of order.
def my_details( name, age ):
print("Name: ", name)
print("Age ", age)
return
my_details(age=56,name="george")

• Output:
Name: george
Age 56
3. Default Arguments:
• Assumes a default value if a value is not provided in the function
call for that argument.
def my_details( name, age=40 ):
print("Name: ", name)
print("Age ", age)
return
my_details(name="george")

• Output:
Name: george
Age 40
4. Variable length Arguments
• If we want to specify more arguments than specified while
defining the function, variable length arguments are used.
• It is denoted by * symbol before parameter.
def my_details(*name ):
print(*name)
my_details("rajan","rahul","micheal",ä rjun")
• Output:
rajan rahul micheal ä rjun
• MODULES:

Ø A module is a file containing Python definitions, functions, statements


and instructions.
Ø Standard library of Python is extended as modules.
Ø To use these modules in a program, programmer needs to import
the module.
Ø Once we import a module, we can reference or use to any of its functions or
variables in our code.
o There is large number of standard modules also available in python.
o Standard modules can be imported the same way as we import our user-
defined modules.
o Every module contains many function.
o To access one of the function , you have to specify the name of the module and
the name of the function separated by dot . This format is called dot notation.
• Syntax:
import module_name
module_name.function_name(variable)

• Importing Builtin Module:


import math
x=math.sqrt(25)
print(x)
• Importing User Defined Module:
import cal
x=cal.add(5,4)
print(x)
• Built-in python modules are,
1.math – mathematical functions:
• some of the functions in math module is,
• math.ceil(x) - Return the ceiling of x, the smallest integer greater than or equal to x
• math.floor(x) - Return the floor of x, the largest integer less than or equal to x.
• math.factorial(x) -Return x factorial.
• math.gcd(x,y)- Return the greatest common divisor of the integers a and b
• math.sqrt(x)- Return the square root of x
• math.log(x)- return the natural logarithm of x math.log10(x) – returns the
base-10 logarithms math.log2(x) - Return the base-2 logarithm of x. math.sin(x) –
returns sin of x radians
• math.cos(x)- returns cosine of x radians
• math.tan(x)-returns tangent of x radians
• math.pi - The mathematical constant π = 3.141592 math.e – returns The
mathematical constant e = 2.718281
Lambda Functions
The Anonymous Functions:
You can use the lambda keyword to create small anonymous
functions. These functions are called anonymous because
they are not declared in the standard manner by using the
def keyword.
• Lambda forms can take any number of arguments but return
just one value in the form of an expression. They cannot
contain commands or multiple expressions.
• An anonymous function cannot be a direct call to print
because lambda requires an expression.
• Lambda functions have their own local namespace and
cannot access variables other than those in their parameter
list and those in the global namespace.
• Syntax:
lambda [arg1[,arg2,.....argn]]:expression
Example:
• Following is the example to show how lembda form of
function works:
sum = lambda arg1, arg2: arg1 + arg2
print "Value of total : ", sum( 10, 20 )
print "Value of total : ", sum( 20, 20 )
• This would produce following result:
Value of total : 30
Value of total : 40
Scope of Variables:
• All variables in a program may not be accessible at all locations in that
program. This depends on where you have declared a variable.
• The scope of a variable determines the portion of the program where you can
access a particular identifier. There are two basic scopes of variables in Python:
Global variables
Local variables
• Global vs. Local variables:
• Variables that are defined inside a function body have a local scope, and those
defined outside have a global scope.
• This means that local variables can be accessed only inside the function in
which they are declared whereas global variables can be accessed throughout
the program body by all functions. When you call a function, the variables
declared inside it are brought into scope.
• Example:
total = 0; # This is global variable.
def sum( arg1, arg2 ):
"Add both the parameters"
total = arg1 + arg2;
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)
• This would produce following result:
Inside the function local total : 30
Outside the function global total : 0

You might also like