QBASIC Programming Solutions and SLC / SEE Computer Science Questions Solved Along PYTHON

📘 4.2 User-defined Functions [Python Programming] - SEE COMPUTER SCIENCE 2083 - CDC NEW CURRICULUM

DOWNLOAD PDF NOTES [4.2 USER DEFINED FUNCTIONS]

📘 4.2 User-defined Functions [Python Programming]

A Python function is a block of organized and reusable code designed to perform a specific task.

Functions provide better modularity for applications and reduce code repetition through reusability.

Modularity: Breaking down a large, complex application into smaller, manageable blocks.

Types of Python Functions

1. Built-in Functions (Library Functions)

Functions that are already available in Python are called built-in functions. They are loaded into the computer's memory as soon as the Python interpreter starts.

Example:

print ( ) - Displays output
input ( ) - Takes input from the user
len ( ) - Returns the length of a string or list
int ( ) - Converts a value to an integer
sum ( ) - Calculates the sum of elements

2. User-defined Functions

Functions created by the programmer to perform a specific task are called user-defined functions. User-defined functions are written using the def keyword. Once defined, they can be called multiple times in a program.

Difference Between Built-in Functions and User-defined Functions

Feature	Built-in Functions	User-defined Functions
Creator	Created by Python developers.	Created by the user / programmer.
Availability	Available by default in Python without importing additional modules.	Must be written before using.
Memory	Loaded immediately when interpreter starts.	Loaded only when defined in your code.
Examples	print(), len()	calculate_tax ( )
Real-Life Example	Readymade clothes from a store.	Tailor-stitched custom clothes.

Creating User-defined Functions

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

Syntax

def <function_name> (parameter1, parameter2, ...):

set of instructions to be executed

[return <value>]

Important Points

i. The items enclosed in “[ ]” are optional parameters. Therefore, a function may or may not have parameters. Similarly, a function may or may not return a value.

ii. The function header always ends with a colon (:).

iii. The function name should be unique. The rules for naming identifiers also apply to function names.

iv. The statements outside the function indentation are not considered part of the function.

Example

# Program to illustrate the use of user-defined functions

def add_numbers(x, y):

total = x + y

return total

num1 = 5

num2 = 6

print("The sum is", add_numbers(num1, num2))

Output

The sum is 11

Scope of Function

The scope of a function refers to the area of a program where a function or variable can be accessed.

Generally, scope can be classified into the following types:

i. Local Scope

Variables declared inside a function are accessible only within that function.

ii. Global Scope

Variables declared outside any function can be accessed from anywhere in the program.

Functions Returning a Value

The return statement in Python is used to return a value back to the calling function. A function can take input values as parameters, process them, and return the output using the return statement.

Usually, function definitions have the following basic structure:

Syntax

def function_name(arguments):

return <value>

Example

# Function to calculate the area of a rectangle

def area(length, width):

return length * width

length = 5

width = 8

result = area(length, width)

print("Area of Rectangle:")

print(result)

Output

Area of Rectangle:
40

Parameters and Arguments in Functions

Parameters are the variables written inside the parentheses in a function definition. These values are required for the function to work.

Example

# Function to calculate the area of circle using function
def area_of_circle(radius):

area = radius ** 2 * 22 / 7

return area

radius = float(input("Please enter the radius of the given circle: "))
print("The area of the given circle is:", area_of_circle(radius))

An argument is an actual value passed to a function. In other words, arguments are the values provided in the function call statement.

The list of arguments should match the order of parameters in the function definition.

Example of argument in function call

area(5)

5 is an argument. An argument can be constant, variable, or expression.

Parameters are actually variables/placeholders, not values.
Arguments are the actual values passed during function call.

Scope of Variables

The scope of a variable determines where the variable can be accessed in a program.

The two common types of variable scope are:

1. Local Scope

2. Global Scope

1. Local Scope

Variables declared inside a function are called local variables. These variables can only be accessed within that function. A local variable exists only while the function is executing.

Example

def multiply_by_two():
    number = 5   # local variable
    result = number * 2
    print("Inside function:", result)

multiply_by_two()
# print(result) # This will give an error because 'result' is local to the function

Output

Inside function: 10

2. Global Scope

Variables declared outside all functions are called global variables. These variables can be accessed from anywhere in the program.

Example

number = 10   # global variable

def add_five():
    result = number + 5
    print("Inside function:", result)

add_five()
print("Outside function:", number)

Output

Inside function: 15
Outside function: 10

Passing Parameters

Python allows different ways to pass data (arguments) into a function.

Python supports three types of arguments:

1. Positional (Required) Arguments

2. Default Arguments

3. Keyword (Named)

1. Positional/Required Arguments

Arguments passed in the same order as the parameters are defined are called positional or required arguments.

Example

If a function definition header is like

def check(a, b, c):

then function calls for this can be:

check(x, y, z)      # 3 values (all variables) passed

check(2, x, y)      # 3 values (literal variables) passed

check(2, 5, 7)      # 3 values (all literals) passed

2. Default Arguments

Default arguments are the parameters that take default values if no value is provided during the function call.

Example

def interest(principal, time, rate=0.10):

here 0.10 is the default value for parameter rate

The default value is specified in a manner syntactically similar to a variable initialization.

Example

def Interest(prin, time, rate=0.10):      # legal
def Interest(prin, time=2, rate):         # illegal
def Interest(prin=2000, time=2, rate):    # illegal
def Interest(prin, time=2, rate=0.10):    # legal
def Interest(prin=200, time=2, rate=0.10): # legal

Important point

Default parameters must always come after required parameters.

Example 2

def power (base, exp = 2) :

return base ** exp

print (power(4))

print (power (2, 3))

Here, in the first function call, only one argument, i.e. the base. So, it uses default value of exp, i.e. 2. In the second function call, both arguments are defined so base = 2 and exp = 3.

Output

3. Keyword (Named) Arguments

Arguments passed using parameter names in a function call, so the order does not matter, are called keyword (or named) arguments.

Examples

interest(prin=2000, time=2, rate=0.10)
interest(time=2, prin=2600, rate=0.09)
interest(time=2, rate=0.12, prin=2000)

All the above function calls are valid now, even if the order of arguments does not match the order of parameters as defined in the function header.

Returning Values from Functions

A function in Python can be defined with or without returning a value to the calling function. There are two types of functions in Python:

1. Functions Returning Values (Non-void Functions)
2. Functions Not Returning Values (Void Functions)

1. Functions Returning Values (Non-void Functions)

Functions that return a computed value to the calling function are called non-void functions.
The return statement is used to return the value.

The returned value may be a literal (5), a variable (x), or an expression (x + y).

Syntax

return <value>

Example

def add(x, y):

return x + y

result = add(5, 3)

Here, the returned value from add( ) replaces the function call.

2. Functions Not Returning Values (Void Functions)

Functions that perform a task but do not return any value to the calling function are called void functions.

A void function may contain:

return

That is, the return statement without any value or expression.

Examples of Void Functions

def greet():
    print("Hello")

def greet1(name):
    print("Hello", name)

def quote():

    print("Python is good")
    return

def printsum(a, b, c):
    print("Sum is", a + b + c)
    return