Scribd
Upload
6 views31 pages

Function in Python

The document provides an overview of functions in Python, including function definitions, types of arguments (required, keyword, default, and variable-length), and the concept of anonymous functions using lambda. It also explains the difference between pass by reference and value, and demonstrates the use of built-in functions like filter, map, and reduce with lambda functions. Additionally, it covers the distinction between global and local variables.

Uploaded by

vinay.agrawal
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
6 views31 pages

Function in Python

The document provides an overview of functions in Python, including function definitions, types of arguments (required, keyword, default, and variable-length), and the concept of anonymous functions using lambda. It also explains the difference between pass by reference and value, and demonstrates the use of built-in functions like filter, map, and reduce with lambda functions. Additionally, it covers the distinction between global and local variables.

Uploaded by

vinay.agrawal
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 31

Function in Python

def function_name( parameters ):


‘’’function_docstring’’’
function_suite
return [expression]
def my_func():
x = 10
print("Value inside function:",x)

x = 20
my_func()
print("Value outside function:",x)

Value inside function: 10


Value outside function: 20
Pass by Reference vs Value
def changeme( mylist1 ):
"This changes a passed list into this function"
print ("before change: ", mylist1)
mylist1[2]=50
print ("after change: ", mylist1)
return
# Now you can call changeme function
mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)
• Here, we are maintaining reference of the passed object and appending values in
the same object.
• Therefore, this would produce the following result-
• before change: [10, 20, 30]
• after change: [10, 20, 50]
• Values outside the function: [10, 20, 50]
def changeme( mylist1 ):
"This changes a passed list into this function"
mylist1 = [1,2,3,4] # This would assign new reference in mylist
print ("Values inside the function: ", mylist1)
return

# Now you can call changeme function


mylist = [10,20,30]
changeme( mylist )
print ("Values outside the function: ", mylist)
• The parameter mylist is local to the function changeme.
• Changing mylist within the function does not affect mylist.
• The function accomplishes nothing and finally this would produce the following
result-

Values inside the function: [1, 2, 3, 4]

Values outside the function: [10, 20, 30]


Function Arguments
• You can call a function by using the following types of formal
arguments-
• Required arguments
• Keyword arguments
• Default arguments
• Variable-length arguments
Required Arguments

• the arguments passed to a function in correct positional order.


• the number of arguments in the function call should match exactly with the
function definition.
# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print (str)
return

# Now you can call printme function


printme(‘hello’)

Output: hello
Keyword Arguments

• related to the function calls.


• the caller identifies the arguments by the parameter name.
• This allows you to
• skip arguments or
• place them out of order
• because the Python interpreter is able to use the keywords provided
to match the values with parameters.
def printme( strn ):
"This prints a passed string into this function"
print (strn)
return

# Now you can call printme function


printme( strn = "My string")
# Function definition is here
def printinfo( name, age ):
"This prints a passed info into this function"
print ("Name: ", name)
print ("Age ", age)
return

# Now you can call printinfo function


printinfo( age=50, name="miki" )
Default Arguments
• A default argument is an argument that assumes a default value if a value is not provided in the function call for
that argument.

def printinfo( name, age = 35 ):


print ("Name: ", name)
print ("Age ", age)

# Now you can call printinfo function


printinfo( age=50, name="miki" )
printinfo( name="miki" )

Name: miki
Age 50
Name: miki
Age 35
Variable-length Arguments

• You may need to process a function for more arguments than you specified while
defining the function.
• These arguments are called variable-length arguments and are not named in the
function definition, unlike required and default arguments.
def function_name([formal_args,] *var_args_tuple ):
function_stmt
return [expression]
• An asterisk (*) is placed before the variable name that holds the
values of all non keyword variable arguments.
• This tuple remains empty if no additional arguments are specified
during the function call.
# Function definition is here printinfo( 10 )
def printinfo( arg1, *vartuple ): printinfo( 70, 60, 50 )
print ("Output is: ")
print (arg1) Output is:
for var in vartuple: 10
print (var)
Output is:
70
60
50
The Anonymous Functions

• These functions are called anonymous because they are not declared in the
standard manner by using the def keyword.
• You can use the lambda keyword to create small anonymous functions.
• lambda operator can have any number of arguments, but it can have only one
expression.
• It cannot contain any statements and
• it returns a function object which can be assigned to any variable.
• 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.
• Mostly lambda functions are passed as parameters to a function which expects a
function objects as parameter like map, reduce, filter functions
def add(x, y):
return x + y

# Call the function


add(2, 3)

# Output: 5
add = lambda x, y : x + y

print add(2, 3)

# Output: 5
• In lambda x, y: x + y; x and y are arguments to the function and x +
y is the expression which gets executed and its values is returned as
output.
• lambda x, y: x + y returns a function object which can be assigned to
any variable, in this case function object is assigned to
the add variable.
>>>type (add) # Output: function
• The syntax of lambda function contains only a single statement, which is as
follows-

lambda [arg1 [,arg2,.....argn]]:expression


# Function definition is here
>>>sum = lambda arg1, arg2: arg1 + arg2

# Now you can call sum as a function


>>>print ("Value of total : ", sum( 10, 20 ))
>>>print ("Value of total : ", sum( 20, 20 ))
Use of Lambda Function
• We use lambda functions when we require a nameless function for a short period
of time.
• In Python, we generally use it as an argument to a higher-order function (a
function that takes in other functions as arguments).
• Lambda functions are used along with built-in functions like filter(), map() etc.
filter()
filter(function, iterable)
• creates a new list from the elements for which the function returns True.

# Program to filter out only the even items from a list


my_list = [1, 5, 4, 6, 8, 11, 3, 12]
new_list = list(filter(lambda x: (x%2 == 0) , my_list))
print(new_list)

Output: [4, 6, 8, 12]


map()
map(function, iterable)
• It applies a function to every item in the iterable.
• We can use map() to on a lambda function with a list:

>>>M = [1,2,3,4,5]
>>>squaredList = list(map(lambda x: x*x, M))
>>>print(squaredList)
Reduce function
reduce(function, iterable)
• applies two arguments cumulatively to the items of iterable, from left to right.
>>>from functools import reduce
>>>list = [1,2,3,4,5]
>>>s = reduce(lambda x, y: x+y, list)
>>>print(s)
• In this case the expression is always true, thus it simply sums up the elements of
the list.
>>>def fahrenheit(T):
return ((float(9)/5)*T + 32)

>>>temp = [36.5, 37, 37.5,39]


>>>F = map(fahrenheit, temp)
>>>print(list(F))

[97.7, 98.600, 99.5, 102.2]


>>>temp = [36.5, 37, 37.5,39]
>>>F=map(lambda T:((float(9)/5)*T +32 ), temp)
>>>list(F)

[97.7, 98.600, 99.5, 102.2]


Global Vs Local variable
>>>total = 0 # This is global variable.

>>>def sum( arg1, arg2 ):


total = arg1 + arg2; # Here total is local variable.
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 )
• Inside the function local total : 30
• Outside the function global total : 0

You might also like