Topics to be covered

1. Introduction
2. Types of Functions
3. Create User Defined Function
4. Arguments And Parameters
5. Default Parameters
6. Positional Parameters
7. Function Returning Values
8. Flow of Execution
9. Scope of Variable

22 | P a g e
Function
Reusable block of code that performs a specific task. For example: len(), print(), min(),
max(), sorted () , type() etc.

Types of Functions

Defining a function in Python:

Name the function and specifies what to do when the function is called. Python
interpreter ignores the function definition until the function is called.

Calling a function:
Calling the function actually performs the specified actions with the indicated
parameters

Function Definition in Python

In Python a function is defined using the def keyword

 Arguments: Information can be passed into functions as arguments. Arguments

are specified after the function name, inside the parentheses. You can add as
many arguments as you want, just separate them with a comma.

23 | P a g e
 ● Actual Parameters (Arguments) are values supplied to the function when it is
invoked/called

● Formal Parameters are variables declared by the function that get values when
the function is called.

Example 1:
Observe the following code:

Output:

In the above example, a user defined function “function1” has been defined that
receives one argument. Once the function is defined, it can be called any number of
times with different arguments.
Formal argument: x
Actual argument:
“first call to function “ passed in first call
“second call to function” passed in second call

Example 2: Write a function ADD(A,B) that receives two integer arguments and prints
their sum.

Output:

return keyword:
In Python, the `return` keyword is used in functions to specify the value that the
function will return when it is called. When a function is executed, it may perform some
computations or operations, and the result can be sent back to the caller using the
`return` statement.

24 | P a g e
The basic syntax for using the `return` statement is as follows:

Here's what you need to know about the `return` statement:

1. Returning a Value:
When you want to return a specific value from the function, you can use the
`return` statement followed by the value you want to return.
Note: The function will stop executing immediately after the `return`
statement is encountered, and the value will be passed back to the caller.

2. Returning Multiple Values:

Python allows you to return multiple values from a function as a tuple. You can
simply separate the values with commas after the `return` statement.

3. Returning None:
If a function doesn't have a `return` statement or has a `return` statement
without any value, it implicitly returns `None`.
`None` is a special constant in Python that represents the absence of a value.

25 | P a g e
 4. Early Exit with Return:
You can use the `return` statement to exit a function early if certain conditions
are met. This is useful when you want to terminate the function before reaching
the end.

The `return` statement is a powerful tool that enables functions to produce

results and pass data back to the calling code. Understanding how to use it
correctly will help you design and implement effective functions in Python.

Scope of a variable:
In Python, the scope of a variable refers to the region of the program where the variable
is accessible. The scope determines where a variable is created, modified, and used.

Global Scope:
● Variables defined outside of any function or block have a global scope.
● They are accessible from anywhere in the code, including inside functions.
● To create a global variable, you define it at the top level of your Python script
or module.

Local Scope:
● Variables defined inside a function have a local scope.
● They are accessible only within the function where they are defined.
● Local variables are created when the function is called and destroyed when the
function returns.

26 | P a g e
 Points to be noted:
● When local variable and global variable have different names: global
variable can be accessed inside the function

● When local and global variable have same name : priority is given to local
copy of variable

Lifetime of a variable:
The lifetime of a variable in Python depends on its scope. Global variables persist
throughout the program's execution, local variables within functions exist only during
the function's execution.
Study the following programs:

Example 1:

27 | P a g e
Example 2:

Passing list as argument to the function:

Please note that when a list if passed as arguments , the original copy of list is passed
to the function i.e if any change is made at any index in the list inside the function , it is
reflected in original list . That is because list is a mutable datatype and in Python, when
you pass a list as an argument to a function, you are actually passing a reference to the
list rather than a copy of the list. This means that the function parameter will point to
the same memory location as the original list. As a result, any changes made to the list
within the function will be reflected in the original list outside the function.

However, if you assign a different list to a variable inside a function in Python, it will
create a new local variable that is separate from any variables outside the function. This
local variable will only exist within the scope of the function, and changes made to it
won't affect the original list outside the function.

28 | P a g e
 Output:

global keyword
In Python, the global keyword is used to indicate that a variable declared inside a
function should be treated as a global variable, rather than a local variable. When you
assign a value to a variable inside a function, Python, by default, creates a local variable
within that function's scope. However, if you need to modify a global variable from
within a function, you must use the global keyword to specify that you want to work
with the global variable instead.
Here's the basic syntax for using the global keyword:

For example:

Types of arguments passed to a function:

Positional Arguments:
● These are the most common type of arguments and are matched to the
function parameters based on their positions. The first argument corresponds
to the first parameter, the second argument corresponds to the second
parameter, and so on.
● The number and order of positional arguments must match the function's
parameter list.

29 | P a g e
Default Arguments:
● Default arguments are used when a function is called with fewer arguments
than there are parameters.
● The default values are specified in the function definition.
● If a value is not provided for a parameter during the function call, the default
value is used.

Keyword Arguments:
● In this type, each argument is preceded by a keyword (parameter name)
followed by an equal sign.
● The order of keyword arguments does not matter, as they are matched to the
function parameters based on their names.
● These arguments provide flexibility to call a function with arguments passed in
any order.

Python modules:
● In Python, a module is a file containing Python code that defines variables,
functions, and classes.
● Modules allow you to organize and reuse code by breaking it into separate files,
making it easier to maintain and understand complex programs.
● Python's standard library comes with a vast collection of built-in modules that
cover various functionalities
● If needed, you can also create your own custom modules.
● To use a module in your Python code, you need to import it using the import
statement.
math module:

30 | P a g e
 ● The math module in Python is a built-in module that provides various
mathematical functions and constants.
● It is part of the Python Standard Library i.e. it does not require any additional
installation to use.
● To use the math module, you need to import it at the beginning of your Python
script.

● Once you've imported the module, you can access its functions and constants
using the math prefix.
Here are some commonly used functions and constants provided by the math
module:

Mathematical Constants:
● math.pi: Represents the mathematical constant π (pi).
● math.e: Represents the mathematical constant e (Euler's number).
Basic Mathematical Functions:
● math.sqrt(x): Returns the square root of x.
● math.pow(x, y): Returns x raised to the power y.
● math.exp(x): Returns the exponential of x (e^x).
● math.log(x, base): Returns the logarithm of x to the specified base (default base
is e).
Trigonometric Functions (all angles are in radians):
● math.sin(x), math.cos(x), math.tan(x): Sine, cosine, and tangent of x,
respectively.
● math.asin(x), math.acos(x), math.atan(x): Arcsine, arccosine, and arctangent of
x, respectively.
Hyperbolic Functions:
● math.sinh(x), math.cosh(x), math.tanh(x): Hyperbolic sine, cosine, and tangent
of x, respectively.
Angular Conversion:
● math.degrees(x): Converts x from radians to degrees.
● math.radians(x): Converts x from degrees to radians.
Miscellaneous:
● math.ceil(x): Returns the smallest integer greater than or equal to x.
● math.floor(x): Returns the largest integer less than or equal to x.
● math.factorial(x): Returns the factorial of x.
Study the following examples:

Example 1:

31 | P a g e
Example 2:

Example 3:

Statistics module:
● The statistics module in Python is another built-in module that provides
functions for working with statistical data.
● It offers a variety of statistical functions to compute measures like mean,
median, standard deviation, variance, etc.
● The statistics module is part of the Python Standard Library, so there's no need
to install any additional packages to use it.
Here are some commonly used functions provided by the statistics module:
● statistics.mean(data): Calculates the arithmetic mean (average) of the data.
● statistics.median(data): Computes the median value of the data.
● statistics.mode(data): Finds the mode (most common value) in the data.

Example 1:

32 | P a g e
Example 2:

random module
● The random module in Python is another built-in module that provides
functions for generating random numbers, sequences, and making random
choices.
● It is commonly used for tasks such as random number generation, random
shuffling, and random sampling.

Here are some commonly used functions provided by the random module:
● random.random(): Generates a random float number in the range [0.0, 1.0).
● random.uniform(a, b): Generates a random float number in the range [a, b).
● random.randint(a, b): Generates a random integer in the range [a, b]
(inclusive).
● random.choice(sequence): Picks a random element from a sequence (list,
tuple, string, etc.).
● random.shuffle(sequence): Shuffles the elements of a sequence randomly (in-
place).

Example 1:
What is the possible outcome/s of following code?

Possible options:
a) green
b) yellow

33 | P a g e
 c) blue
d) orange

Solution:
Here, the possible values for variable random-sample are 3, 4 and 5. Hence, the possible
Outputs of above code are b) Yellow and d) orange.

Example 2:
What are the possible output/s for the following code?

Output Options:
i. 29: 26:25 :28 : ii. 24: 28:25:26:
iii. 29: 26:24 :28 : iv. 29: 26:25:26:

Solution:
Option iv

Example 3:
What are the possible outcome/s for the following code:

Output Options:
i. 103#102#101#100# ii. 100#101#102#103#
iii. 100#101#102#103#104# iv. 4#103#102#101#100#

Solution:
Option i and option iv

34 | P a g e