User Defined Functions

Python - User-Defined Functions
Python includes many built-in functions. These functions perform a predefined task
and can be called upon in any program, as per requirement. However, if you don't find
a suitable built-in function to serve your purpose, you can define one. We will now see
how to define and use a function in a Python program.
Defining a Function
A function is a reusable block of programming statements designed to perform a
certain task. To define a function, Python provides the def keyword. The following is
the syntax of defining a function.
Syntax:
def function_name(parameters):
"function docstring"
statement1
statement2
...
...
return [expr]
The keyword def is followed by a suitable identifier as the name of the function and
parentheses. One or more parameters may be optionally mentioned inside parentheses.
The : symbol after parentheses starts an indented block.
The first statement in this block is an explanatory string which tells something about
the functionality. It is called a docstring and it is optional. It is somewhat similar to a
comment. Subsequent statements that perform a certain task form the body of the
function.
The last statement in the function block includes the return keyword. It sends an
execution control back to calling the environment. If an expression is added in front of
return, its value is also returned.
Given below is the definition of the SayHello() function. When this function is called,
it will print a greeting message.
Example: Function
def SayHello():
""First line is docstring. When called, a greeting message will be displayed""
print ("Hello! Welcome to Python tutorial on TutorialsTeacher")
return
To call a defined function, just use its name as a statement anywhere in the code. For
example, the above function can be called as SayHello() and it will show the following
output.
>>> SayHello()
Hello! Welcome to Python tutorial on TutorialsTeacher
Function with Parameters

It is possible to define a function to receive one or more parameters (also called
arguments) and use them for processing inside the function block.
Parameters/arguments may be given suitable formal names. The SayHello() function is
now defined to receive a string parameter called name. Inside the
function, print() statement is modified to display the greeting message addressed to the
received parameter.
Example: Parameterized Function
def SayHello(name):
print ("Hello {}!.".format(name))
return
You can call the above function as shown below.
>>> SayHello("Gandhi")
Hello Gandhi!
The names of the arguments used in the definition of the function are called formal
arguments/parameters. Objects actually used while calling the function are called
actual arguments/parameters.
In the following example, the result() function is defined with three arguments as
marks. It calculates the percentage and displays pass/fail result. The function is called
by providing different values on every call.
FunctionTest.py
def result(m1,m2,m3):
ttl=m1+m2+m3
percent=ttl/3
if percent>=50:
print ("Result: Pass")
else:
print ("Result: Fail")
return
p=int(input("Enter your marks in physics: "))

c=int(input("Enter your marks in chemistry: "))
m=int(input("Enter your marks in maths: "))
result(p,c,m)
Run the above script in IDLE with two different sets of inputs is shown below:
Result:
Enter your marks in physics: 50
Enter your marks in chemistry: 60
Enter your marks in maths: 70
Result: Pass
Enter your marks in physics: 30

Enter your marks in chemistry: 40
Enter your marks in maths: 50
Result: Fail
Parameter with Default Value

While defining a function, its parameters may be assigned default values. This default
value gets substituted if an appropriate actual argument is passed when the function is
called. However, if the actual argument is not provided, the default value will be used
inside the function.
The following SayHello() function is defined with the name parameter having the
default value 'Guest'. It will be replaced only if some actual argument is passed.
Example: Parameter with Default Value

Copy
def SayHello(name='Guest'):
print ("Hello " + name)
return
You can call the above function with or without passing a value, as shown below.
>>> SayHello()
Hello Guest
>>> SayHello('Tom')
Hello Tom
Function with Keyword Arguments

In order to call a function with arguments, the same number of actual arguments must
be provided. Consider the following function.
def AboutMe(name, age):

print ("Hi! My name is {} and I am {} years old".format(name,age))
return
The above function is defined to receive two positional arguments. If we try to call it
with only one value passed, the Python interpreter flashes TypeError with the
following message:
>>> AboutMe("Ramesh")
TypeError: AboutMe() missing 1 required positional argument: 'age'
If a function receives the same number of arguments and in the same order as defined,
it behaves correctly.
>>> AboutMe("Mohan", 23)

Hi! My name is Mohan and I am 23 years old
Python provides a useful mechanism of using the name of the formal argument as a
keyword in function call. The function will process the arguments even if they are not
in the order provided in the definition, because, while calling, values are explicitly
assigned to them. The following calls to the AboutMe() function is perfectly valid.
>>> AboutMe(age=23, name="Mohan")

Hi! My name is Mohan and I am 23 years old
Function with Return Value

Most of the times, we need the result of the function to be used in further processes.
Hence, when a function returns, it should also return a value.
A user-defined function can also be made to return a value to the calling environment
by putting an expression in front of the return statement. In this case, the returned
value has to be assigned to some variable.
Consider the following example function with the return value.

Example: Function with Return Value
def sum(a, b):
return a + b
The above function can be called and provided the value, as shown below.
>>> total=sum(10, 20)

>>> total
30
>>> total=sum(5, sum(10, 20))
>>> total
35
Passing Arguments by Reference

In Python, arguments are always passed by reference. The following snippet will
confirm this:
Example: Passing Argument by Reference

def myfunction(arg):
print ('value received:',arg,'id:',id(arg))
return
x=10
print ('value passed:',x, 'id:',id(x))
myfunction(x)
The built-in id() function returns a unique integer corresponding to the identity of an
object. In the above code, id() of x before and after passing to a function shows a
similar value.
>>> x=10
>>> id(x)
1678339376
>>> myfunction(x)
value received: 10 id: 1678339376
If we change the above number variable inside a function then it will create a different
variable as number, which is immutable. However, if we modify a mutable list object
inside the function, and display its contents after the function is completed, the changes
are reflected outside the function as well.
Example: Passing List by Reference

def myfunction (list):
list.append(40)
print ("Modified list inside a function: ", list)
return
The following result confirms that arguments are passed by reference to a Python
function.
>>> mylist=[10,20,30]
>>> myfunction(mylist)
Modified list inside a function: [10, 20, 30, 40]
>>> mylist
[10, 20, 30, 40]

User Defined Functions

Uploaded by

Copyright:

Available Formats

User Defined Functions

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

User Defined Functions

Uploaded by

Copyright:

Available Formats

Python - User-Defined Functions

Function with Parameters

Example: Parameterized Function

You can call the above function as shown below.

p=int(input("Enter your marks in physics: "))

Enter your marks in physics: 30

Parameter with Default Value

Example: Parameter with Default Value

Function with Keyword Arguments

def AboutMe(name, age):

>>> AboutMe("Mohan", 23)

>>> AboutMe(age=23, name="Mohan")

Function with Return Value

Consider the following example function with the return value.

>>> total=sum(10, 20)

Passing Arguments by Reference

Example: Passing Argument by Reference

Example: Passing List by Reference

You might also like