Python : Functions

Function vs Method

A function can be written individually in a Python

Function is called using its name

A function within the class is called “Method”

Method is called in two ways,

objectname.methodname()

Classname.methodname()
Function & Method are same except thier placement and the way they are
called

Defining & Calling
Syntax
def function_name(para1, para2, para3,...)
""" docstring """
statements
Example
def sum(a, b):
""" This function finds sum of two numbers """
c = a + b
print('Sum= ', c)
#call the function
sum(10, 15)

Returning Value/s From a Function

Returning a Value
Example Description
return c Returns c from the function
return 100 Returns constant from a
function
return lst Return thelist that contains values
return z, y, z Returns more than one value

Returning a Value
Example
# A function to add two numbers
def sum(a, b):
c = a + b
return c # return result
#call the function
x = sum(10, 15)
print('The Sum is: ', x)
y = sum(1.5, 10.75)
print('The Sum is: ', y)

Returning ‘M’ Values
Example
# A function that returns two results
def sum_sub(a, b):
""" this function returns results of
addition and subtraction of a, b """
c = a + b
d = a - b
return c, d
# get the results from sum_sub() function
x, y = sum_sub(10, 5)
# display the results
print("Result of addition: ", x)
print("Result of subtraction: ", y)

Functions are First Class Objects

Functions
First Class Objects

Functions are considered as first class objects

When function is defined, python interpreter internally creates an Object

Noteworthy:

It is possible to assign a function to a variable

It is possible to define one function inside another function

It is possible to pass a function as parameter to a another function

It is possible that a function can return another function

Functions
Pass by Object References

The values are sent to the function by means of Object References

Objects are created on heap memory at run time

Location of the object can be obtained by using id( ) function

Functions

Example-1: To pass an integer to a function and modify it
# passing an integer to a function
def modify(x):
""" reassign a value to the variable """
x = 15
print(x, id(x))
# call mofify() and pass x
x = 10
modify(x)
print(x, id(x))
Inside modify()
function
x 15
10x
Outside the
function
Heap

Functions

Example-1: To pass a list to a function and modify it
# passing an list to a function
def modify(lst):
""" to create a new list """
lst = [10, 11, 12]
print(lst, id(lst))
# call mofify() and pass lst
lst = [1, 2, 3, 4]
modify(lst)
print(lst, id(lst))
Inside modify()
function
lst
1, 2, 3, 4lst
Outside the
function
Heap
If altogether a new object inside a function is created, then it will
not be available outside the function
10, 11, 12

Functions
Formal and Actual Arguments
# A function to add two numbers
def sum(a, b):
c = a + b
return c # return result
#call the function
x = sum(10, 15)
print('The Sum is: ', x)
y = sum(1.5, 10.75)
print('The Sum is: ', y)
Actual
Formal

Functions
Formal and Actual Arguments

Types: Actual Arguments

Positional

Keyword

Default

Variable length

Actual Arguments
Positional Arguments

Arguments are passed to a function in correct positional order
# positional arguments demo
def attach(s1, s2):
""" to joins1 and s2 and display total string """
s3 = s1 + s2
print('Total string: ' + s3)
# call attach() and pass 2 strings
attach('New','York') # positional arguments

Actual Arguments
Keyword Arguments

Keyword Arguments are arguments that identify the parameters by their names
# key word arguments demo
def grocery(item, price):
""" to display the given arguments """
print('Item = %s' % item)
print('Price = %.2f' % price)
# call grocerry() and pass two arguments
grocery(item='sugar', price = 50.75) #keyword arguments
grocery(price = 88.00, item = 'oil') #keyword arguments

Actual Arguments
Variable Length Arguments-1

An argument that can accept any number of arguments

Syntax: def function_name(farg, *args)

- farg: Formal argument

- *args: Can take 1 or more arguments

*args will be stored as tuple
# variable length arguments demo
def add(farg, *args): # *args can take 1 or more values
""" to add given numbers """
print('Formal arguments= ', farg)
sum = 0
for i in args:
sum += i
print('Sum of all numbers= ', (farg + sum))
# call add() and pass arguments
add(5, 10)
add(5, 10, 20, 30)

Actual Arguments
Variable Length Arguments-2

An argument that can accept any number of values provided in the format of keys and values

Syntax: def function_name(farg, **kwargs)

- farg: Formal argument

- **kwargs:

- Called as keyword variable

- Internally represents dictionary object

**kwargs will be stored as dictionary
# keyword variable argument demo
def display(farg, **kwargs): # **kwargs can take 0 or more values
""" to add given values """
print('Formal arguments= ', farg)
for x, y in kwargs.items(): # items() will give pair of items
print('key = {}, value = {}'.format(x, y))
# pass 1 formal argument and 2 keyword arguments
display(5, rno = 10)
print()
#pass 1 formal argument and 4 keyword arguments
display(5, rno = 10, name = 'Prakesh')

Local & Global Vars
The Global Keyword

The global variable can be accessed inside the function using the global keyword

- global var
# accesing the global variable from inside a function
a = 1 # this is global variable
def myfunction():
global a # this is global variable
print('global a =', a) # display global variable
a = 2 # modify global variable value
print('modified a =', a) # display new value
myfunction()
print('global a =', a) # display modified value

Local & Global Vars
The Global Keyword

Syntax to get a copy of the global variable inside the function and work on it

- globals()[“global_var_name”]
#same name for global and local variable
a = 1 # this is global variable:
def myfunction():
a = 2 # a is local var
x = globals()['a'] # get global var into x
print('global var a =', x) # display global variable
print('local a =', a) # display new value
myfunction()
print('global a =', a)

Passing Group of Items to a
Function

Passing
The Group Of Items

To pass the group of items to a function, accept them as a list and then pass it.
# a function to find total and average
def calculate(lst):
""" to find total and average """
n = len(lst)
sum = 0
for i in lst:
sum += i
avg = sum / n
return sum, avg
# take a group of integers from keyboard
print('Enter numbers seperated by space: ')
lst = [int(x) for x in input().split()]
#call calculate() and pass the list
x, y = calculate(lst)
print('Total: ', x)
print('Average: ', y)
Example-1

Recursions

A function calling itself is called as Recursions
# resursive function to calculate factorial
def factorial(n):
""" to find factorial of n """
if n == 0:
result = 1
else:
result = n * factorial(n - 1)
return result
# find factorial values for first 10 numbers
for i in range(1, 11):
print('Factorial of {} is {}'.format(i, factorial(i)))
Example-1

Anonymous Functions Or
Lambdas

Lambdas

A function without name is called ‘Anonymous functions’

Anonymous functions are not defined using the ‘def’ keyword

Defined using the keyword ‘lambda’, hence called as lambda function

Example
Normal Function Anonymous Function
def square(x):
return x * x
f = lambda x: x * x
#f = function name
#Calling the function
square(x)
#Calling the function
value = f(5)

Syntax
lambda argument_list: expression

Lambdas
Example

Example
# lambda function to calculate square value
f = lambda x: x*x # write lambda function
value = f(5) # call lambda func
print('Square of 5 = ', value) # display result

Lambdas
using lambdas with filter()

A filter() is useful to filter out the elements of a sequence depending on the
result of a function

Syntax: filter(function, sequence)

Example
def is_even(x):
if x % 2 == 0:
return True
else:
return False

filter (is_even, lst)
- is_even function acts on every element on the lst

Lambdas
using lambdas with filter()

Example
# a normal function that returns
# even numbers from a list
def is_even(x):
if x % 2 == 0:
return True
else:
return False
# let us take a list of numbers
lst = [10, 23, 45, 46, 70, 99]
# call filter() eith is_even() and list
lstl = list(filter(is_even, lst))
print(lstl)
# lambda function that returns even numbers from
list
lst = [10, 23, 45, 46, 70, 99]
lstl = list(filter(lambda x: (x % 2 == 0), lst))
print(lstl)

Lambdas
using lambdas with map()

A map() is similar to filter(), but it acts on each element of the sequence and changes the items

Syntax: map(function, sequence)

Example
Normal Function Lambdas
#map() function that gives squares
def squares(x):
return x * x
#let us take a lis of numbers
lst = [1, 2, 3, 4, 5]
# call map() with square()s and lst
lstl = list(map(squares, lst))
print(lstl)
# lambda that returns squares
lst = [1, 2, 3, 4, 5]
lstl = list(map(lambda x: x * x, lst))
print(lstl)
Writing using the lambdas will be more elegant

Lambdas
using lambdas with reduce()

A reduce() reduces a sequence of elements to a single value by processing the elements according to the
function supplied

Syntax: reduce(function, sequence)

Example
Lambdas
# lambda that returns products of elements of a list
from functools import *
lst = [1, 2, 3, 4, 5]
result = reduce(lambda x, y: x * y, lst)
print(result)
import functools, since reduce() belongs to functools

Lambdas
using lambdas with reduce(): Exercise
Problem
To calculate sum of numbers from 1 to 50 using reduce() & lambda functions
import functools, since reduce() belongs to functools

Function Decorators

A decorator is a function that accepts a function as parameter and returns a
function

A decorator takes the result of a function, modifies and returns it

Function Decorators
Steps to Create Decorators

STEP-1: Define the decorator

STEP-2: Define the function inside the decorator
def decor(fun):
def decor(fun):
def inner():
value = fun()
return value + 2
return inner
• STEP-3: Define one function
def num():
return 10
• STEP-4: Call the decorator
res = decor(num)

Function Decorators
Complete Program
# a decorator that increments the value of a function by 2
def decor(fun): #this is decorator func
def inner(): #this is inner func that modifies
value = fun()
return value + 2
return inner # return inner function
# take a function to which decorator should be applied
def num():
return 10
#call decorator func and pass me
result_fun = decor(num) # result_fun represents ''inner function
print(result_fun()) # call result_fun and display

Function Decorators
@ decor

To apply the decorator to a function
@decor
def num():
return 10

It means decor() is applied to process or decorate the result of the num() function

No need to call decorator explicitly and pass the function name

@ is useful to call the decorator function internally

Function Decorators
@ decor: Example
# a decorator that increments the value of a function by 2
def inner(): #this is inner func that modifies
value = fun()
return value + 2
# take a function to which decorator should be applied
@decor #apply decor to the below function
def num():
return 10
#call num() function and display its result
print(num())

Function Decorators
@ decor: More than one decorator
Without using @, decorators can be called
# a decorator that increments the value of a
function by 2
def inner(): #inner func that modifies
value = fun()
return value + 2
# a decorator that doubles the value of a function
def decor1(fun): #this is decorator func
def inner(): #Inner func that modifies
value = fun()
return value * 2
# take a function to which decorator should be
applied
@decor
@decor1
def num():
return 10
#call num() function and apply decor1 and then
decor
print(num())

Function Generators

Generator: Function that returns sequence of values

It is written like ordinary function but it uses ‘yield’ statement
# generator that returns sequence from x and y
def mygen(x, y):
while x <= y:
yield x
x += 1
# fill generator object with 5 and 10
g = mygen(5, 10)
# display all numbers in the generator
for i in g:
print(i, end=' ')
To retrieve element by element from a generator object,
use next() function

Creating Our Own Modules in
Python

Creating
Own Modules in Python

A module represents a group of
1. Classes
2. Methods
3. Functions
4. Variables

Modules can be reused

Types:

Built-in: sys, io, time ...

User-defined

Creating
Own Modules in Python: Example
employee.py usage.py
# to calculate dearness allowance
def da(basic):
""" da is 80% of basic salary """
da = basic * 80 / 100
return da
from employee import *
# calculate gross salary of employee by taking
basic
basic= float(input('Enter basic salary: '))
# calculate gross salary
gross = basic + da(basic) + hra(basic)
print('Your gross salary: {:10.2f}'.
format(gross))
# calculate net salary
net = gross - pf(basic) - itax(gross)
print('Your net salary: {:10.2f}'. format(net))
# to calculate house rent allowance
def hra(basic):
""" hra is 15% of basic salary """
hra = basic * 15 / 100
return hra
# to calculate provident fund amount
def pf(basic):
""" pf is 12% of basic salary """
pf = basic * 12 / 100
return pf
# to calculate income tax
def itax(gross):
""" tax is calculated
at 10% on gross """
tax = gross * 0.1
return tax

The Special Variable
__name__

It is internally created, when program is executed

Stores information regarding whether the program is executed as an individual program or as a
module

When a program is executed directly, it stores __main__

When a program is executed as a module, the python interpreter stores module name

__name__ : Example-1
#python program to display message. save this as one.py
def display():
print('Hello Python')
if __name__ == '__main__':
display() # call display func
print('This code is run as a program')
else:
print('This code is run as a module')

__name__ : Example-2
# in this program one.py is imported as a module. save this as two.py
import one
one.display() # call module one's display function.

Python : Functions

More Related Content

What's hot

Similar to Python : Functions

More from Emertxe Information Technologies Pvt Ltd

Recently uploaded

In this document

Python : Functions