Ch3-Functions

Introduction
Function is a subprogram that acts on data and
often returns a value.

Large program into small units called functions.

Easier
No of lines are less
More readable/understandable
Understanding Functions

2
for x=1, result is 2
for x=2, result is 8
for x=3, result is 18
for x=4, result is 32
F(x)=2
Notataion f(x) is termed as function,
Where x is the argument.

 Can have arguments

 Can perform functionality
 Can return some value.
 Name of the function

Argument of the function

def calc(x):
r=2*x**2 Statement to return computed
body
result
retrun r
a=int(input(“enter a number”))
print(cal(a))

Function call
Calling/invoking /using a function
1.Passing literal as argument in function call.

cube(4)
2.Passing variable as argument in function call.
num=10

cube(num)
3.Taking input and passing the input as argument.
num=int(input(“enter a number”))
cube(num)
4.Using function call inside another stmt.
print(cube(3))
5.Using function call inside expression.
doubleofcube=2*cube(6)
Python function types
 Built-in functions
int(), type(), len(), input()

 Functions defined in modules

math module – sin(), random
module

 User defined functions

programmer defines the function. Add(),
sub() cube()
Defining functions in python
keyword

def greet():
print(“good mrng”)
parameters

def sum(x,y):
s=x+y Function header
return s
Sample code 1 Sample code 3

def sumof3multiples1(n): def sumof3multiples1(n):

s=n*1+n*2+n*3 s=n*1+n*2+n*3
return s print(s)

Sample code 2
def areaofsquare(a):
return a*a

Sample code 3
def quote():
print(“Do not expect anything from anyone”)
Structure of a python program
 By default, python names the segment with top-level statements
(main program) as __main__
def function():
:
def function2():
:
#top level stmt
stmt 1
stmt2
def greet():
print(“hi there”)
print(“at the top-level”)
print(“inside”,__name__)
Flow of execution in a function call
Flow of execution refers to the order in which statements are executed
during a program run.

A execution frame contains:

 Some internal information (used for debugging)
 Name of the function
 Values passed to function
 Variables created within function
 Information about the next instruction to be executed.
1 # function with two arguments
2 def add_numbers(num1, num2):
3 sum = num1 + num2
4 print("Sum: ",sum)
5 # function call with two values
6 add_numbers(5, 4)
 Execution always begins at the first line
 Comment lines are not executed
 Ifits is function header, executes only the header line
for any error
 Stmt inside the function is not executed.
 Function can have another function in it
 Without calling outer function, inner function can’t be
called.
 When function is called, first function header is
executed.
 Function ends with return or without return
1. #program for functions
2. def calcsum(x,y):
3. s=x+y
4. return s
5.
6.num1=float(input(“enter first number:”))
7.num2=float(input(“enter second number:”))
8.sum=calcsum(num1,num2)
9.print(“sum of two given numbers is”,sum)

2,6,7,8,2,3,4,8,9
 Arguments and parameters
Arguments : python refers to the values being passed as arguments
sum(5,6) (Actual parameter / actual argument)

Parameters: Values being received as parameters

def sum(x,y) (formal parameter / formal argument)

Arguments can be a , literals, variables and expressions

 Error

def one(a+1,b)
c=a+b
retrun(c)
Today’s Program:(04.03.23)
1.Write a function that takes amount-in-dollars-to-rupee conversion
price, it then returns the amount converted to rupees. Create the
function in both void and non-void forms.
2. Write a function to calculate volume of a box with appropriate default
values for its parameters. Your function should have the following input
parameters.
(a)Length of box
(b)Width of box
(c)height of box
Passing Parameters

 Positional arguments (required arguments)

 Default arguments

 Keyword (or named ) arguments

Positional arguments (required arguments)

def check(a,b,c) #function header

check (x,y,z)
Function call
check(2,x,y)
check(2,5,7)
Default arguments

def interest (principal,time,rate=0.10): #function header

Si_int=interest(5400,2) Function call

Si-int=interest(6100,3,0.15)
 def Legal
interest(prin,time,rate=0.10):
Illegal
 def interest(prin,time=2,rate):

 def interest (prin=2000,time=2,rate): Illegal

 def interest(prin,time=2,rate=0.10): Legal

 def legal
interest(prin=200,time=2,rate=0.10):
Keyword (or named ) arguments

def interest(prin,time,rate) #function header

interest (prin=2000,time=2,rate=0.10)
interest(time=4,prin=2600,rate=0.90) Function call

interest(time=2,rate=0.12,prin=2000)
Using Multiple argument types together
Function call
interest(5000,time=5)

Rules:
 Positional should be in first and then keyword argument.
 Cannot specify a value foe an argument more than one
time.
def interest(prin,cc,time=2,rate=0.09):
retrun prin*time*rate
Function call

interest(prin=3000,cc=5) Legal
interest(rate=0.12,prin=5000,cc=4) Legal
interest(cc=4,rate=0.12.prin=5000) Legal
interest(5000,3,rate=0.05) Legal
interest(rate=0.05,5000,3) Illegal
interest(5000,prin=300,cc=2) Illegal
interest(5000,principal=300,cc=2) Illegal
interest(500,time=2,rate=0.05) illegal
Returning values from functions

 Functions returning some values (non void functions)

 Functions not returning any value (void functions)

Functions returning some values (non void functions)

 Literal
 A variable
 Expression

 return 5
 return 6=4
 return a
 return a**3
 return (a+8**2)/b
 return a+b/c
add_result=sum(a,b)
print(sum(3,4))
sum(4,5)>6

If the returned value is not used, no error

def check(a):
a=math.fabs(a)
retrun a
print(a)
check(-15)
Function not returning any value
Code 1:
def replicate(): @@@@
None
print(“@@@@”)
print(“replicate())
Code 2:
def replicate(): @@@@
return “@@@@”
print(“replicate())
Returning Multiple values

def square(x,y,z):
return x*x,y*y,z*z
t=square(2,3,4)
Print(t) #t is tuple
def square(x,y,z):
return x*x,y*y,z*z
a,b,c=square(2,3,4)
Print(a,b,c) #a,b,c normal variables created based
on the values
Scope of variables
Parts of program within which a name is legal and
accessible , is called scope of the name.

For example: Local scope

Ticket 1 –monument1
Ticket 2-monument 2 Global scope

Ticket 3-for the all monuments in the city

Global scope

All the variables in the__main__ program are called

as global scope and can be used inside the whole
program (in other functions and blocks)
Local scope
 A local variable is a variable defined within a function.
 example
1.def calcsum(x,y):
2. z=x+y
3. return z
4.num1=int(input(“enter first number:”))
5.num2=int(input(“enter second number:”))
6.sum=calsum(num1,num2)
7.print(“sum of given number is”,sum)

x,y,z are local scope variables

num1, num2,sum are global scope variables
Variable defined outside all functions
are global variables
x=5
def func(a):
b=a+1
retrun b
y=int(input(“enter number’))
z=y+func(x)
print(z)
Example 2
1.def calcsum(a,b,c):
2. s=a+b+c
3. return s
4. def average(x,y,z):
5. sm=calcsum(x,y,z)
6. return sm/3
7.num1=int(input(“enter first number:”))
8.num2=int(input(“enter second number:”))
9. num3=int(input(“enter third number:”))
10.print(“average is”,average(num1,num2,num3))
 Lifetime of a variable
 Thetime for which a variable of name remains in
memory is called lifetime of variable

 Global variable-program run time

 Local variable-particular function run time
Name resolution (resolving scope of a Name)

LEGB

L- Local Environment
E- Enclosing Environment
G- Global Environment
B- Built-in Environment
Case 1: variable in global but not in local

def calcsum(x,y):
s=x+y
print(num1)
return s
num1=int(input(“enter first number:”))
num2=int(input(“enter second number:”))
print(“sum is”,calcsum(num1,num2))
Case 2: variable neither in local and
global
def greet()
print(“hello”,name)
greet()

error
Case 3:Same variable in local and global
def state():
tigers=15
print(tigers)
Output:
tigers=95 95
Print (tigers) 15
State() 95
Print(tigers)
What if you want the global variable
inside local scope
Global keyword is used
def state():
global tigers
tigers=15 Output:
print(tigers) 95
tigers=95 15
Print(tigers) 15
State()
Print(tigers)
Find output

def update(x=10):
x+=15
print(‘x=‘,x) Output:
x=20 x=25
update() x=20
print(‘x=‘,x)
Find the output

def addem(x,y,z):
print(x,y,z)
def prod(x,y,z): Output:
return x*y*z 6 16 26
a=addem(6,16,26) None 36
b=prod(2,3,6)
Print(a,b)
Write a function that takes a positive
integer and returns the one’s position
digit of the integer.
Mutable /Immutable Properties of
passed data objects
Sample code 1 Calling myFunc1() by passing ‘num’ with value 3
Inside myFunc1()
Passing an Immutable type value to a function.
Value received in ‘a’ as 3
1.def myfunc1(a): Value of ‘a’ now changes to 8
returning from myFunc1()
2. print(“\t Inside myFunc1()”) Back from myFunc1().Value of ‘num’ is 3

3. print(“\t Value received in ‘a’ as”,a)

4. a=a+2
5. print(“\t value of ‘a’ now changes to”,a)
6. print(“\t returning from myfunc1()”)
7.num=3
8.print(“calling myFunc1() by passing ‘num’ with value”,num)
9.myfunc1(num)
10.print(“Back from myFunc1().Value of ‘num’ is”,num)
Sample code 2
Passing an mutable type value to a function-making changes in place

1.def myfunc2(myList): List before function call:[1]

Inside called function now
2. print(“\t Inside Called function now”) List received:[1]
3. print(“\t List received:”,myList) List within called function, after changes:
[3]
4. myList[0]+=2 List after function call:[3]

5. print(“\t List within called function,after

changes:”,myList)
6. return
7.List1=[1]
8.print(“List before function call:”,List1)
9.myFunc2(List1)
10.print(“\n List after function call:”,List1)
Sample code 3
Passing an mutable type value to a function – Adding/Deleting items to it

1.def myfunc3(myList): List before function call:[1]

Inside called function now
2. print(“\t Inside Called function now”)
List received:[1]
3. print(“\t List received:”,myList) List after adding some elements:[1,2,5,1]
List within called function, after all changes:
4. myList.append(2) [1,2,1]
5. myList.extend([5,1]) List after function call:[1,2,1]

6. print(“\t List after adding some elements”,myList)

7. myList.remove(5)
8. print(“List within called function.after all changes:”,myList)
9. return
10.List1=[1]
11.print(“List before function call:”,List1)
12.myFunc3(List1)
Sample code 4
Passing an mutable type value to a function – Assigning parameter to a new value/variable.

1.def myfunc4(myList):
2. print(“\n Inside Called function now”)
List before function call:[1,4]
inside called function now
3. print(“\t List received:”,myList) List received: [1,4]
4. new=[3,5] List within called function, after changes: [3,5
List after function call:[1,4]
5. myList=new
6. myList.append(6)
7. print(“\t List within called function,after changes”,myList)
8. return
9.List1=[1,4]
10.print(“List before function call:”,List1)
11.myFunc4(List1)
12.print(“\n List after function call:”,List1)
Mutable Argument (say A) assigned to mutable parameter (say p)

If p is not assigned any new name If p is assigned a new name or different

or different data type value datatype value (e.g p=different-variable,
changes in p are performed in then any changes in p are not reflected
place and get reflected back to back to __main__
__main__ that is , A will show the That is , A will not show changed data.
changed data.
That means, we can sat that:
 Changes in immutable types are not reflected in the caller function at all.
 Changes, if any, in mutable types
 Are reflected in caller function if its name is not assigned a different
variable or datatype.
 Are not reflected in the caller function if it is assigned a different variable
or datatype.