Python_Functions_Modules_ User define Functions-

Python Programming – Unit 3
Part – 1
Functions
1
https://www.scribd.com/presentation/831767862/
Python-Unit2-Loop
Dr.VIDHYA B
ASSISTANT PROFESSOR & HEAD
Department of Computer Technology
Sri Ramakrishna College of Arts and Science
Coimbatore - 641 006
Tamil Nadu, India

February 23, 2025 Functions 4
WHAT IS A FUNCTION?
-a block of statements that can be used repeatedly in
a program
- will not execute immediately when a page loads
- will be executed by a call to the function
- takes one or more input in the form of parameter
- does some processing using the input and returns a
value.

USER DEFINED FUNCTION
Func1() is called the
program control is passed
to the first statement in the
function.
All statements in the
functions are executed and
then the program control is
passed to the statement
following the one that
called the function
func1()calls func2().
func1() is known as calling
function.
func2() is known as called
function.
func1() can call as many
functions as many times.

NEED FOR FUNCTIONS
• Dividing the program into separate well defined
functions , helps each function to be written
separately .
• Simplifies process of program development

NEED FOR FUNCTIONS
• Understanding, coding and testing multiple separate
functions are easier.
• Big program without function lead to large number
of coding and maintain the program is mess. In
microcomputer memory space is less, hence it is a
serous issue.
• Libraries in python are predefined and pretested,
programmers are able to use directly hence speeds
up the program development.
• Programmers can design own functions and use
from different points.

NEED FOR FUNCTIONS
• Large Programs follow code reuse hence DRY
principle is used – Don’t Repeat Yourself
• Bad Code uses – WET principle Write Everything
Twice or We Enjoy Typing

User Define Functions
- option to create user’s own functions
- two parts in a user defined function
(i) Calling Function – The function which invokes
the action
(ii) Called Function - The Function which does
the job by receiving the call
from the calling function

CALLING AND CALLED FUNCTION
Calling Function:
The Function
which invokes the
action
Called Function:
The Function
which does the job by
receiving the call from
the Calling function

FUNCTION Definition
Terminology for functions:
- Input Function takes is known as arguments/ parameters.
- Called function returns some result back to calling
function, it is said to return the result.
- Calling function may or may not pass parameters to
called function.
- Function declaration is the a declaration statement
identifies a function name, arguments & type of data
returned.
- Function definition consists of function header (identifies
the function), followed by the body of the function.

FUNCTION Definition
- Function blocks starts with keyword def .
- Keyword followed by function name with()
- After () : is placed
- Parameters or arguments are placed inside()
- First statement can be optional, docstring describe
what function does.
- Code block within function to be indented.
- Function may have return expression
- Function name can be assigned to a variable.
}

FUNCTION Definition
Function definition consists of 2 parts:
- Function Header & - Function Body
- Where def => Keyword for defining a function
- Function_name => Name of the function
- Parameter list => Data to be passed to be used by
the function for operation
- Function body => contains a collection of
statements that define what the function does.
def function_name( parameter list )
body of the function
}

EXAMPLE: FUNCTION DEFINITION
( CALLED FUNCTION)
def diff (x ,y) #function to subtract to numbers
return x-y
a=20
b=10
operation=diff #function name assigned to a
variable
print(operation(a,b)) #function called – variable
name
Output: 10

FUNCTION CALL
(CALLING FUNCTION)
- tells about a function name and how to call the
function
- It has the following form…
- Function_name => Name of the function
- Parameter list => Data to be passed to be used by
the function for operation
Function_name(Parameter list)

PASSING PARAMETER
- Data to be passed to be used by the function for
operation
Types of Parameter:
1) Actual Parameter –
Parameters passed to the function actually- used
in function call
2) Formal Parameter –
Parameters received by the function
When a function is called checks for number and
types of arguments used and return value type.

Function Parameters
- Function Name, number of arguemnts in the
function call must be the same as function
definition
def func(i,j)
print(“hello world”,i,j)
func(5)
def func(i)
print(“hello world”,i)
func(5,5)
def func(i)
print(“hello world”,i)
j=10
func(j)
O/P:
Hello world 10
def func(i)
print(“hello world” +i)
func(5)

Variable Scope and Life time
Scope – Part of a
program in which a
variable is accessible
Life time of the variable-
Duration for which the
variable exists

LOCALAND GLOBAL VARIABLES
- refers to the area of the program where the
variables can be accessed after its declaration
- variable declared within a function is different
from a variable declared outside a function.
POSITION TYPE
Inside a Function or a
Block
Local Variable
Outside of all functions Global Variable

Scope of a Variable (Example)
greeting = "Hello" # Global Variable
def greeting_world():
world = "World" #Local Variable
print(greeting, world)
def greeting_name(name):
print(greeting, name)
greeting_world()
greeting_name(“India")
Output:
Hello World
Hello India

Comparison

The Return Statement
• Every function has an implicit return statement.
• Implicit return does not returns nothing to it
caller and said to return none.
• But can be changed using return statement
Syntax:
return[expression]
Return statements used for 2 things:
- Return a value to the caller.
- To end and exit a function and go back to its
caller.

FUNCTION WITH RETURN VALUE
def cube(x):
return(x*x*x)
num=10
result=cube(num)
print(“the cube of ”, num “is”,
result)
Output:
cube of 10 is 1000
Points to Remember:
- Return Statement
must appear within
function
- Once a value is
returned from a
function, immediately
exists from the
function.
- Any code written after
the return statement
will not be executed

More on Defining Functions
More on
defining
Functions
Required
Arguments
KEYWORD
ARGUMENTS
VARIABLE-
LENGTH
ARGUMENTS
Default
arguments

Required Arguments – The arguments are passed to a
function in a correct positional order.

Keyword Arguments – The order of the arguments
can be changed. Values are not assigned to
arguments according to the position but based on
their name.
Benefits:
- If argument is skipped
- If function call changes its order
Points to Remember:
- All the keyword arguments passed should match one
of the arguments accepted by the function.
- The order of keyword arguments is not important
- In no case an argument should receive a value more
than once.

Default Arguments – Allows function arguments
can have default values.
Default value to an argument is provided using
assignment operator =.
Default values can be specified for one or more
arguments.
Points to Remember:
- If default argument is present should be written after
non-default arguments.
- The order of keyword arguments is not important
- In no case an argument should receive a value more
than once.

Variable-Length Arguments – Allows function to
have arbitrary number of arguments.
Use * before the parameter name.
Points to Remember:
- Basically forms a tuple.
- Inside Called function, for loop is used to access the
arguments
- If present in function definition should be the last in
the list of formal parameters
- Any formal parameters written after variable is only
keyword –only arguments.

Syntax:
def function_name([arg1, arg2,….] *var_args-tuple):
Function statements
Return[expression]

WHAT IS RECURSION ?
A repeated
Process, or a
Definition or a
Procedure

WHAT IS RECURSIVE?
- breaking down a problem into smaller and
smaller sub problems
- until the problem is made small enough that it can
be solved trivially

RECURSIVE FUNCTION
- process of calling a function by itself
- The function call is within the same function
- Every recursive has two major cases:
*Base Case – problem solved directly without
making any further calls
*Recursive case – divided into subparts, function call
itself, result obtained by combining the solutions of
simpler parts.

Recursive Function (Example)
def fact(n):
if (n == 0 or n= = 1):
return 1
else:
return n* fact(n-1)
n = int(input("Enter a number: "))
print(“Factorial of",n,"is:“,fact(n))
Output:
Enter a number: 5
Factorial of 5 is 120

Recursive Function (Example)
Steps:
1) Specify the base case which will
stop the function from making a
call to itself.
2) Check to see current value
matches with the value of base
case, if yes , process nad return
value
3) Divide the problem into smaller
or simpler problem.
4) Call the function
on the subproblem.
5) Combine the
results of the
subproblem.
6) Return the results
of the entire problem.

RECURSIVE FUNCTION

Python_Functions_Modules_ User define Functions-

More Related Content

Similar to Python_Functions_Modules_ User define Functions- (20)

More from VidhyaB10 (16)

Recently uploaded (20)

Python_Functions_Modules_ User define Functions-