Python Functions
Python
Functions
In Python, function is a group of related
statements that perform a specific task.Functions help break our program into
smaller and modular chunks. As our program grows larger and larger, functions
make it more organized and manageable.
Furthermore, it avoids repetition and
makes code reusable.
Syntax of Function
def function_name(parameters):
"""docstring"""
statement(s)
Above shown is a function definition which
consists of following components.
·
Keyword def marks the
start of function header.
·
A function name to
uniquely identify it. Function naming follows the same rules of writing
identifiers in Python.
·
Parameters (arguments)
through which we pass values to a function. They are optional.
·
A colon (:) to mark the
end of function header.
·
Optional documentation
string (docstring) to describe what the function does.
·
One or more valid python
statements that make up the function body. Statements must have same
indentation level (usually 4 spaces).
·
An optional return
statement to return a value from the function.
Example of a function
def
greet(name):
"""This function greets to
the person passed in as
parameter"""
print("Hello, " + name + ". Good morning!")
Function Call
Once we have defined a function, we can
call it from another function, program or even the Python prompt. To call a
function we simply type the function name with appropriate parameters.
>>> greet('Paul')
Hello, Paul. Good morning!
Note: Try running the above code into the
Python shell to see the output.
Docstring
The first string after the function header
is called the docstring and is short for documentation string. It is used to
explain in brief, what a function does.
Although optional, documentation is a good
programming practice. Unless you can remember what you had for dinner last
week, always document your code.
In the above example, we have a docstring
immediately below the function header. We generally use triple quotes so that
docstring can extend up to multiple lines. This string is available to us as
__doc__ attribute of the function.
For example:
Try running the following into the Python
shell to see the output.
>>> print(greet.__doc__)
This function greets to
the
person passed into the
name
parameter
The return statement
The return statement is used to exit a
function and go back to the place from where it was called.
Syntax of return
return [expression_list]
This statement can contain expression
which gets evaluated and the value is returned. If there is no expression in
the statement or the return statement itself is not present inside a function,
then the function will return the None object.
For example:
>>> print(greet("May"))
Hello, May. Good morning!
None
Here, None is the returned value.
Example of return
def absolute_value(num):
"""This function returns the absolute
value of the entered number"""
if num >= 0:
return num
else:
return -num
# Output: 2
print(absolute_value(2))
# Output: 4
print(absolute_value(-4))
How Function works in Python?
How function works in Python?
Scope and Lifetime of variables
Scope of a variable is the portion of a
program where the variable is recognized. Parameters and variables defined
inside a function is not visible from outside. Hence, they have a local scope.
Lifetime of a variable is the period
throughout which the variable exits in the memory. The lifetime of variables
inside a function is as long as the function executes.
They are destroyed once we return from the
function. Hence, a function does not remember the value of a variable from its
previous calls.
Here is an example to illustrate the scope
of a variable inside a function.
def my_func():
x = 10
print("Value inside function:",x)
x = 20
my_func()
print("Value outside
function:",x)
Output
Value inside function: 10
Value outside function: 20
Here, we can see that the value of x is 20
initially. Even though the function my_func() changed the value of x to 10, it
did not effect the value outside the function.
This is because the variable x inside the
function is different (local to the function) from the one outside. Although
they have same names, they are two different variables with different scope.
On the other hand, variables outside of
the function are visible from inside. They have a global scope.
We can read these values from inside the
function but cannot change (write) them. In order to modify the value of
variables outside the function, they must be declared as global variables using
the keyword global.
Types of Functions
Basically, we can divide functions into
the following two types:
Built-in functions - Functions that are
built into Python.
User-defined functions - Functions defined
by the users themselves.
Builtin Functions:
dir(__builtins__)
User Defined Functions:
In user-defined function topic, we learned
about defining a function and calling it. Otherwise, the function call will
result into an error. Here is an example.
def
greet(name,msg):
"""This function greets to
the person with the provided message"""
print("Hello",name + ', ' + msg)
greet("Nikhil","Good
morning!")
Output
Hello Nikhil, Good morning!
Here, the function greet() has two
parameters.
Since, we have called this function with
two arguments, it runs smoothly and we do not get any error.
If we call it with different number of
arguments, the interpreter will complain. Below is a call to this function with
one and no arguments along with their respective error messages.
>>>
greet("Monica") # only one
argument
TypeError: greet() missing 1 required
positional argument: 'msg'
>>> greet() # no arguments
TypeError: greet() missing 2 required
positional arguments: 'name' and 'msg'
Variable Function Arguments
Up until now functions had fixed number of
arguments. In Python there are other ways to define a function which can take
variable number of arguments.
Three different forms of this type are
described below.
Python
Default Arguments:
Function arguments can have default values
in Python
We can provide a default value to an
argument by using the assignment operator (=). Here is an example.
def greet(name, msg = "Good morning!"):
"""
This function greets to
the person with the
provided message.
If message is not provided,
it defaults to "Good
morning!"
"""
print("Hello",name + ', ' + msg)
greet("Kate")
greet("Bruce","How do you
do?")
In this function, the parameter name does
not have a default value and is required (mandatory) during a call.
On the other hand, the parameter msg has a
default value of "Good morning!". So, it is optional during a call.
If a value is provided, it will overwrite the default value.
Any number of arguments in a function can
have a default value. But once we have a default argument, all the arguments to
its right must also have default values.
This means to say, non-default arguments
cannot follow default arguments. For example, if we had defined the function
header above as:
def greet(msg = "Good morning!", name):
We would get an error as:
SyntaxError: non-default argument follows
default argument
Python
Keyword Arguments
When we call a function with some values,
these values get assigned to the arguments according to their position.
For example, in the above function
greet(), when we called it as greet("Bruce","How do you do?"),
the value "Bruce" gets assigned to the argument name and similarly
"How do you do?" to msg.
Python allows functions to be called using
keyword arguments. When we call functions in this way, the order (position) of
the arguments can be changed. Following calls to the above function are all
valid and produce the same result.
>>> # 2 keyword arguments
>>> greet(name =
"Bruce",msg = "How do you do?")
>>> # 2 keyword arguments (out of
order)
>>> greet(msg = "How do you
do?",name = "Bruce")
>>> # 1 positional, 1 keyword
argument
>>> greet("Bruce",msg =
"How do you do?")
As we can see, we can mix positional
arguments with keyword arguments during a function call. But we must keep in
mind that keyword arguments must follow positional arguments.
Having a positional argument after keyword
arguments will result into errors. For example the function call as follows:
greet(name="Bruce","How do
you do?")
Will result into error as:
SyntaxError: non-keyword arg after keyword
arg
Python
Arbitrary Arguments
Sometimes, we do not know in advance the
number of arguments that will be passed into a function.Python allows us to
handle this kind of situation through function calls with arbitrary number of
arguments.
In the function definition we use an asterisk
(*) before the parameter name to denote this kind of argument. Here is an
example.
def greet(*names):
"""This function greets all
the person in the names tuple."""
#
names is a tuple with arguments
for name in names:
print("Hello",name)
greet("Monica","Luke","Steve","John")
Output
Hello Monica
Hello Luke
Hello Steve
Hello John
Here, we have called the function with
multiple arguments. These arguments get wrapped up into a tuple before being
passed into the function. Inside the function, we use a for loop to retrieve
all the arguments back.
Python
Recursion
We will learn to create a recursive
function; a function that calls itself.
Working of recursive function in Python
Recursion is the process of defining
something in terms of itself.
A physical world example would be to place
two parallel mirrors facing each other. Any object in between them would be
reflected recursively.
Python
Recursive Function
We know that in Python, a function can
call other functions. It is even possible for the function to call itself.
These type of construct are termed as recursive functions.
Following is an example of recursive
function to find the factorial of an integer.
Factorial of a number is the product of
all the integers from 1 to that number. For example, the factorial of 6
(denoted as 6!) is 1*2*3*4*5*6 = 720.
Example of recursive function
# An example of a recursive function to
# find the factorial of a number
def calc_factorial(x):
"""This is a recursive function
to find the factorial of an integer"""
if x == 1:
return 1
else:
return (x * calc_factorial(x-1))
num = 4
print("The factorial of", num,
"is", calc_factorial(num))
In the above example, calc_factorial() is
a recursive functions as it calls itself.
When we call this function with a positive
integer, it will recursively call itself by decreasing the number.
Each function call multiples the number
with the factorial of number 1 until the number is equal to one. This recursive
call can be explained in the following steps.
calc_factorial(4) # 1st call with 4
4 * calc_factorial(3) # 2nd call with 3
4 * 3 * calc_factorial(2) # 3rd call with 2
4 * 3 * 2 * calc_factorial(1) # 4th call with 1
4 * 3 * 2 * 1 # return from 4th call as number=1
4 * 3 * 2 # return from 3rd call
4 * 6 # return from 2nd
call
24 # return from 1st
call
Our recursion ends when the number reduces
to 1. This is called the base condition.
Every recursive function must have a base
condition that stops the recursion or else the function calls itself
infinitely.
Advantages
of recursion
Recursive functions make the code look
clean and elegant.
A complex task can be broken down into
simpler sub-problems using recursion.
Sequence generation is easier with
recursion than using some nested iteration.
Disadvantages
of recursion
Sometimes the logic behind recursion is
hard to follow through.
Recursive calls are expensive
(inefficient) as they take up a lot of memory and time.
Recursive functions are hard to debug.
Comments
Post a Comment