FUNCTIONS IN PYTHON

A complex program can be broken down into smaller programs by using functions, and these smaller
programs, known as modules, make the program easier to understand. A function is a piece of code that
only executes when called.

Once defined, a function can be used again throughout the program without requiring the user to write
out the entire code for it each time. It can also be used inside of other functions by simply writing the
function name and the necessary parameters.

The Advantages of Function

 Increases readability, particularly for longer code as by using functions, the program is better
organised and easy to understand.
 Reduces code length as same code is not required to be written at multiple places in a program.
This also makes debugging easier.
 Increases reusability, as function can be called from another function or another program. Thus,
we can reuse or build upon already defined functions and avoid repetitions of writing the same
piece of code.
 Work can be easily divided among team members and completed in parallel.

Type of Function

There are two types of function in python.

User – Define Function

Built – in – Function
The Python language includes built-in functions such as dir, len, and abs. The def keyword is used to
create functions that are user specified.

User – Define Function

User-defined functions are the fundamental building block of any program and are essential for
modularity and code reuse because they allow programrs to write their own function with function
name that the computer can use.

Creating User Defined Function

A function definition begins with def (short for define). The syntax for creating a user defined function is
as follows –

Syntax –

def function_name(parameter1, parameter2, …) :

statement_1
statement_2
statement_3
….
The items enclosed in “( )” are called parameters and they are optional. Hence, a function may or may
not have parameters. Also, a function may or may not return a value.

Function header always ends with a colon (:).

Function name should be unique. Rules for naming identifiers also applies for function naming.

The statements outside the function indentation are not considered as part of the function.
Q. Write a user defined function to add 2 numbers and display their sum.

#Function to add two numbers

def addnum():
fnum = int(input(“Enter first number: “))
snum = int(input(“Enter second number: “))
sum = fnum + snum
print(“The sum of “,fnum,”and “,snum,”is “,sum)
#function call
addnum()

Output:
Enter first number: 5
Enter second number: 6
The sum of 5 and 6 is 11

Arguments and Parameters

User-defined function could potentially take values when it is called. A value received in the matching
parameter specified in the function header and sent to the function as an argument is known as an
argument.

Q. Write a program using a user defined function that displays sum of first n natural numbers, where n is
passed as an argument.

#Program to find the sum of first n natural numbers

def sumSquares(n):
sum = 0
for i in range(1,n+1):
sum = sum + i
print(“The sum of first”,n,”natural numbers is: “,sum)
num = int(input(“Enter the value for n: “))
sumSquares(num) #function call

Q. Write a program using a user defined function myMean() to calculate the mean of floating values
stored in a list.

#Program

#Function to calculate mean

def myMean(myList):
total = 0
count = 0
for i in myList:
total = total + i
count = count + 1
mean = total/count
print(“The calculated mean is:”,mean)
myList = [1.3,2.4,3.5,6.9]
myMean(myList)

Output:
The calculated mean is: 3.5250000000000004
Q. Write a program using a user defined function calcFact() to calculate and display the factorial of a
number num passed as an argument.

#Function to calculate factorial

def calcFact(num):
fact = 1
for i in range(num,0,-1):
fact = fact * i
print(“Factorial of”,num,”is”,fact)
num = int(input(“Enter the number: “))
calcFact(num)

Output:
Enter the number: 5
Factorial of 5 is 120

String as Parameters

Some programs may require the user to supply string values as an argument.

Q. Write a program using a user defined function that accepts the first name and lastname as
arguments, concatenate them to get full name and displays the output as:

#Function to display full name

def fullname(first,last):
fullname = first + ” ” + last
print(“Hello”,fullname)
first = input(“Enter first name: “)
last = input(“Enter last name: “)
fullname(first,last)

Output:
Enter first name: Gyan
Enter last name: Vardhan
Hello Gyan Vardhan

Default Parameter

The argument can be given a default value in Python. When a function call doesn’t have its appropriate
argument, a default value is chosen in advance and given to the parameter.

Q. Write a program that accepts numerator and denominator of a fractional number and calls a user
defined function mixedFraction() when the fraction formed is not a proper fraction. The default value of
denominator is 1. The function displays a mixed fraction only if the fraction formed by the parameters
does not evaluate to a whole number.

#Function to display mixed fraction for an improper fraction

def mixedFraction(num,deno = 1):
remainder = num % deno
if remainder!= 0:
quotient = int(num/deno)
print(“The mixed fraction=”, quotient,”(“,remainder, “/”,deno,”)”)
else:
print(“The given fraction evaluates to a whole number”)
num = int(input(“Enter the numerator: “))
deno = int(input(“Enter the denominator: “))
print(“You entered:”,num,”/”,deno)
if num > deno:
mixedFraction(num,deno)
else:
print(“It is a proper fraction”)

Output:
Enter the numerator: 17
Enter the denominator: 2
You entered: 17 / 2
The mixed fraction = 8 ( 1 / 2 )

Functions Returning Value

The function’s values are returned using the return statement. A function that has finished its duty will
return a value to the script or function that called it.

The return statement does the following –

returns the control to the calling function.

return value(s) or None.

Q. Write a program using user defined function calcPow() that accepts base and exponent as arguments
and returns the value Baseexponent where Base and exponent are integers.

#Function to calculate and display base raised to the power exponent

def calcpow(number,power):
result = 1
for i in range(1,power+1):
result = result * number
return result
base = int(input(“Enter the value for the Base: “))
expo = int(input(“Enter the value for the Exponent: “))
answer = calcpow(base,expo)
print(base,”raised to the power”,expo,”is”,answer)

Output:
Enter the value for the Base: 5
Enter the value for the Exponent: 4
5 raised to the power 4 is 625

Flow of Execution

The first statement in a program is where the Python interpreter begins to carry out the instructions. As
they read from top to bottom, the statements are carried out one at a time.

The statements contained in a function definition are not executed by the interpreter until the function
is called.

Scope of a Variable

An internal function variable can’t be accessed from the outside. There is a well defined accessibility for
each variable. The scope of a variable is the area of the program that the variable is accessible from. A
variable may fall under either of the two scopes listed below:
A variable with a global scope is referred to as a global variable, whereas one with a local scope is
referred to as a local variable.

Global Variable – A variable that is defined in Python outside of any function or block is referred to as a
global variable. It is accessible from any functions defined afterward.

Local Variable – A local variable is one that is declared inside any function or block. Only the function or
block where it is defined can access it.

Built-in functions

The pre-made Python functions that are widely used in programs are known as built-in functions. Let’s
examine the subsequent Python program –

#Program to calculate square of a number

a = int(input(“Enter a number: “)

b=a*a

print(” The square of “,a ,”is”, b)

In the program mentioned above, the built-in functions input(), int(), and print() are used. The Python
interpreter already defines the set of instructions that must be followed in order to use these built-in
functions.

Commonly used built-in functions

Function Arguments Returns Example

Syntax Output

abs(x) x may be an integer or floating point number Absolute value of x abs(4) 4

abs(-5.7) 5.7

divmod(x,y) x and y are integers A tuple: (quotient, remainder) divmod(7,2) (3, 1)

divmod(7.5,2) (3.0, 1.5)

divmod(-7,2) (-4, 1)

max(sequence)
or
max(x,y,z,…) x,y,z,.. may be integer or floating point number Largest number in the sequence/
largest of two or more arguments max([1,2,3,4]) 4
#Based on ASCII value max(“Sincerity”) ‘y’

max(23,4,56) 56

min(sequence)

or

min(x,y,z,…) x, y, z,.. may be integer or floating point number Smallest number in the sequence/
smallest of two or more arguments min([1,2,3,4]) 1

Uppercase letters have lower ASCII values than lowercase letters. min(“Sincerity”) ‘S’

min(23,4,56) 4

pow(x,y[,z]) x, y, z may be integer or floating point number xy (x raised to the power y)

if z is provided, then: (xy ) % z pow(5,2) 25.0

pow(5.3,2.2) 39.2

pow(5,2,4) 1

sum(x[,num]) x is a numeric sequence and num is an optional argument. Sum of all the elements in
the sequence from left to right. if given parameter, num is added to the sum

sum([2,4,7,3]) 16

sum([2,4,7,3],3) 19

sum((52,8,4,2)) 66

len(x) x can be a sequence or a dictionary Count of elements in x

len(“Patience”) 8

len([12,34,98]) 3

len((9,45)) 2

>>>len({1:”Anuj”,2:”Razia”,3:”Gurpreet”,4:”Sandra”}) 4

Module

The Python standard library includes a number of modules. A module is a collection of functions,
whereas a function is a collection of instructions. suppose we have created some functions in a program
and we want to

reuse them in another program. In that case, we can save those functions under a module and reuse
them. A module is created as a python (.py) file containing a collection of function definitions.

To use a module, we need to import the module. Once we import a module, we can directly use all the
functions of that module. The syntax of import statement is as follows:

import modulename1 [,modulename2, …]

Built-in Modules

Let’s examine a few widely used modules and the functions that are contained in such modules:

Module name : math

Function Arguments Returns Example

Syntax Output
math.ceil(x) x may be an integer or floating point number ceiling value of x

math.ceil(-9.7) -9

math.ceil (9.7) 10

math.ceil(9) 9

math.floor(x) x may be an integer or floating point number floor value of x

math.floor(-4.5) -5

math.floor(4.5) 4

math.floor(4) 4
math.fabs(x) x may be an integer or floating point number absolute value of x

math.fabs(6.7) 6.7

math.fabs(-6.7)6.7

math.fabs(-4)4.0

math.factorial(x) x is a positive integer factorial of x

math.factorial(5) 120

math.fmod(x,y) x and y may be an integer or floating point number x % y with sign of x

math.fmod(4,4.9) 4.0

math.fmod(4.9,4.9) 0.0

math.fmod(-4.9,2.5) -2.4

math.fmod(4.9,-4.9) 0.0

math.gcd(x,y) x, y are positive integers gcd (greatest common divisor) of x and y

math.gcd(10,2) 2

math.pow(x,y) x, y may be an integer or

floating point number xy (x raised to the power y)

math.pow(3,2) 9.0

math.pow(4,2.5) 32.0

math.pow(6.5,2) 42.25

math.pow(5.5,3.2) 233.97

math.sqrt(x) x may be a positive integer or floating point number square root of x

math.sqrt(144) 12.0

math.sqrt(.64) 0.8

math.sin(x) x may be an integer or floating point number in radians sine of x in radians

math.sin(0) 0

math.sin(6) -0.279

Module name : random

Function Arguments Returns Example

Syntax Output
random.random() No argument (void)Random Real Number (float) in the range 0.0 to 1.0
random.random() 0.65333522

random.randint(x,y) x, y are integers such that x <= y Random integer between x and
yrandom.randint(3,7) 4

random.randint(-3,5) 1

random.randint(-5,-3) -5.0
random.randrange(y) y is a positive integer signifying the stop value Random integer between 0 and y
random.randrange(5) 4

random.randrange(x,y) x and y are positive integers signifying the start and stop value Random integer
between x and y

random.randrange(2,7) 2

Module name : statistics

Function Arguments Returns Example

Syntax Output
statistics.mean(x) x is a numeric sequence arithmetic mean

statistics.mean([11,24,32,45,51]) 32.6

statistics.median(x) x is a numeric sequence median (middle value) of

statistics.median([11,24,32,45,51]) 32

statistics.mode(x) x is a sequence mode (the most repeated value)

statistics.mode([11,24,11,45,11]) 11

statistics.mode((“red”,”blue”,”red”)) ‘red’