While writing programs, sometimes we need to write the same group of statements again and again.

Writing the same code repeatedly is not a good programming practice because it increases the size of the program and makes maintenance difficult.

Instead of rewriting the same statements multiple times, we can group them together into a single unit and use that unit whenever required.

This single unit is called a Function.

A function allows us to write the code once and execute it many times by simply calling the function.

A Function is a group of related statements that performs a specific task.

Once a function is created, it can be called whenever required without rewriting the same code.

Suppose a school management system needs to print the following message many times:

Hello Students
Welcome to Python Class

Instead of writing these statements repeatedly, we can place them inside a function and call that function whenever needed.

According to the tutorial, the main advantage of functions is Code Reusability.

Functions also provide several additional benefits.

• Code Reusability.
• Reduces duplicate code.
• Improves readability.
• Makes programs easier to maintain.
• Reduces program size.
• Makes debugging easier.
• Improves modular programming.

Code Reusability means writing the code once and using it many times.

Instead of copying the same statements into different parts of the program, we simply call the function.

This saves both time and effort.

Python supports two types of functions.

1. Built-in Functions
2. User Defined Functions

Functions that are already available in Python are called Built-in Functions or Predefined Functions.

These functions are automatically available after installing Python.

We do not need to write their implementation.

Functions created by the programmer according to business requirements are called User Defined Functions.

These functions are written using the def keyword.

Part	Description
def	Keyword used to define a function.
function_name	Name of the function.
parameters	Input values accepted by the function.
Doc String	Description of the function.
statements	Task performed by the function.
return	Returns the result to the caller.

The def keyword is used to create a User Defined Function.

Every function definition begins with the def keyword.

def wish():

Defines a function named wish().

print("Hello Good Morning")

This statement is executed whenever the function is called.

wish()

Calls the function.

Since the function is called three times, the message is printed three times.

A function is executed only when it is called.

Simply defining a function does not execute it.

Merely defining a function does not execute it.

The function body is executed only when the function is called.

Defining Function	Calling Function
Creates the function.	Executes the function.
Uses def.	Uses the function name followed by parentheses.
Executed only once.	Can be executed any number of times.

Topic	Description
Function	Group of statements written as a single unit.
Main Advantage	Code Reusability.
Built-in Functions	Functions provided by Python.
User Defined Functions	Functions created by the programmer.
def	Keyword used to define a function.
Function Call	Executes the function.

• A function is a group of statements that performs a specific task.
• The main advantage of functions is Code Reusability.
• Python supports Built-in Functions and User Defined Functions.
• Built-in Functions are available automatically with Python.
• User Defined Functions are created by the programmer.
• The def keyword is used to define a function.
• Defining a function does not execute it.
• A function executes only when it is called.
• In other programming languages, functions may also be called methods, procedures, or subroutines.

Functions become more useful when they can accept input values.

These input values are called Arguments and they are received by the function through Parameters.

Parameters allow the same function to work with different values without changing the function code.

There are two important terms in Functions:

• Formal Parameters
• Actual Arguments

The variables declared inside the function definition are called Formal Parameters.

They receive values from the function call.

The values passed while calling a function are called Actual Arguments.

These values are copied into the formal parameters.

In the above program:

• name is the Formal Parameter.
• "Durga", "Ravi" and "Sunny" are the Actual Arguments.
• Every time the function is called, the argument value is assigned to the parameter.

Python supports different types of arguments.

1. Positional Arguments
2. Keyword Arguments
3. Default Arguments
4. Variable Length Arguments (covered in the next part)

In Positional Arguments, values are assigned to parameters according to their position.

The first argument is assigned to the first parameter, the second argument to the second parameter, and so on.

Parameter	Argument
a	100
b	20

Since the arguments follow the correct order, the subtraction result is 80.

Because positional arguments depend on their position, changing the order changes the result.

• The number of arguments must match the number of parameters.
• The order of arguments is very important.
• Changing the order changes the result.

In Keyword Arguments, values are passed using the parameter names.

Since the parameter name is specified, the order of arguments does not matter.

Although the order of the arguments is changed, the output remains the same because values are assigned using parameter names.

• Arguments can be supplied in any order.
• Programs become easier to read.
• The possibility of assigning incorrect values is reduced.

Python allows positional and keyword arguments to be used together.

However, positional arguments must always come before keyword arguments.

Positional arguments must always appear before keyword arguments.

A positional argument cannot appear after a keyword argument.

Sometimes we want a parameter to have a default value.

If the caller does not supply a value, the default value is used automatically.

During the first function call, no argument is passed.

Therefore, the default value "Guest" is used.

During the remaining calls, the supplied arguments replace the default value.

• Default parameters must be declared after non-default parameters.
• A default value is used only when no argument is supplied.
• If an argument is supplied, the default value is ignored.

Argument Type	Assignment Method	Order Required
Positional	Based on position.	Yes
Keyword	Based on parameter name.	No
Default	Uses predefined value if no argument is supplied.	No

Topic	Description
Formal Parameter	Variable declared in the function definition.
Actual Argument	Value passed during the function call.
Positional Argument	Arguments assigned according to position.
Keyword Argument	Arguments assigned using parameter names.
Default Argument	Uses a predefined value when no argument is supplied.

• Formal Parameters receive values from Actual Arguments.
• Positional Arguments depend on the order of values.
• Keyword Arguments depend on parameter names.
• Keyword Arguments can be supplied in any order.
• Positional Arguments must appear before Keyword Arguments.
• Default Arguments provide default values for parameters.
• Default parameters must always come after non-default parameters.
• If a value is supplied, the default value is ignored.

In the previous section, we learned that a function can receive parameters.

Normally, the number of arguments passed to a function must exactly match the number of formal parameters.

If the number of arguments is different, Python raises an error.

Sometimes, we do not know in advance how many arguments will be passed to a function.

In such situations, Python provides Variable Length Arguments.

Variable Length Arguments allow a function to accept any number of arguments.

Consider a program that calculates the sum of numbers.

Sometimes the user wants to add two numbers, sometimes three numbers, and sometimes ten numbers.

If we use normal parameters, we have to create different functions for every possible case.

This increases code duplication and makes the program difficult to maintain.

Variable Length Arguments solve this problem by allowing a single function to accept any number of values.

The function add() is defined with only two parameters:

a, b

The first function call passes two arguments, so it executes successfully.

The second function call passes three arguments.

Since the function expects only two arguments, Python raises a TypeError.

This is one of the biggest limitations of normal parameters.

Python provides the * (asterisk) operator to solve this problem.

The * operator allows a function to receive any number of positional arguments.

All the arguments are automatically collected into a single tuple.

Part	Description
*	Indicates Variable Length Positional Arguments.
args	Stores all arguments inside a tuple.
function_name	Name of the function.

The name args is not a keyword.

It is only a naming convention.

You can use any valid variable name after the * operator.

Whenever the function is called, Python collects all positional arguments into a tuple.

The tuple is stored inside the variable args.

The number of arguments can be zero, one, two, or any number.

Therefore, the same function works for every function call.

Function Call	args Value
display()	()
display(10)	(10,)
display(10,20)	(10,20)
display(10,20,30)	(10,20,30)

• Accepts any number of positional arguments.
• Removes the limitation of fixed parameters.
• Reduces duplicate functions.
• Improves code reusability.
• Makes functions more flexible.

Variable Length Arguments are commonly used in:

• Calculator applications.
• Logging utilities.
• Mathematical operations.
• Data processing utilities.
• Framework development.

Concept	Description
Normal Parameters	Accept a fixed number of arguments.
Variable Length Arguments	Accept any number of arguments.
*args	Collects all positional arguments into a tuple.
Data Type of args	Tuple

• *args accepts any number of positional arguments.
• All arguments are stored as a tuple.
• args is only a variable name, not a keyword.
• The variable name can be changed.
• Variable Length Arguments remove the limitation of fixed parameters.
• Functions become more flexible and reusable.

In the previous section, we learned that *args collects any number of positional arguments into a tuple.

Now let's understand how to work with *args by using different examples.

Since args is a tuple, we can perform all tuple operations on it such as:

• Traversing
• Indexing
• Finding Length
• Calculating Sum

All positional arguments are collected into a tuple.

The tuple is printed directly.

The number of arguments can be different in every function call.

Since args is a tuple, we can traverse it by using a for loop.

Each argument is printed one by one.

The built-in len() function returns the total number of elements stored in the tuple.

This allows us to determine how many arguments were passed to the function.

The parameter numbers stores all arguments as a tuple.

The sum() function calculates the total of all tuple elements.

The built-in max() function returns the largest value from the tuple.

*args can store values of different data types because tuples support heterogeneous elements.

Function Call	Tuple Created
display()	()
display(10)	(10,)
display(10,20)	(10,20)
display(10,20,30)	(10,20,30)
display(10,20,30,40)	(10,20,30,40)

• Accepts unlimited positional arguments.
• Eliminates the need for multiple overloaded functions.
• Reduces duplicate code.
• Improves code reusability.
• Makes functions flexible.
• Useful when the number of inputs is unknown.

• Calculator applications.
• Shopping cart total calculation.
• Statistical calculations.
• Logging systems.
• Data processing libraries.
• Framework development.

Operation	Description
Print	Display all arguments.
Traversal	Use a for loop.
Count	Use len(args).
Sum	Use sum(args).
Maximum	Use max(args).
Minimum	Use min(args).

• *args stores all positional arguments in a tuple.
• Since it is a tuple, all tuple operations are supported.
• The number of arguments can vary for each function call.
• The parameter name args can be replaced with any valid identifier.
• len(), sum(), max(), and min() can be used directly with *args.
• *args is commonly used in Python libraries and frameworks.

In the previous section, we learned that *args can accept any number of positional arguments.

Sometimes, a function requires one or more fixed parameters along with additional variable-length arguments.

Python allows us to combine Normal Parameters and *args in the same function.

The fixed values are received by the normal parameters, and all remaining positional arguments are collected into *args.

Part	Description
parameter1	Receives the first positional argument.
parameter2	Receives the second positional argument.
*args	Collects all remaining positional arguments into a tuple.

The first argument is assigned to the normal parameter name.

All remaining arguments are collected into the tuple marks.

The first argument is assigned to name.

The second argument is assigned to age.

All remaining arguments are stored inside subjects as a tuple.

The first argument is stored in title.

The remaining numeric values are collected into numbers.

The sum() function calculates the total of all values stored in numbers.

• Normal parameters must appear before *args.
• *args should be the last positional parameter.
• Python first assigns values to the normal parameters.
• All remaining positional arguments are stored in *args.

Argument	Assigned To
10	a
20	b
30	args Tuple
40
50

After *args, every parameter becomes a keyword-only parameter.

Therefore, the parameter a must be supplied using its name.

It cannot receive a positional argument.

Feature	Normal Parameter	*args
Accepts	One Value	Multiple Values
Data Type	Depends on Input	Tuple
Position	Before *args	After Normal Parameters
Purpose	Required Values	Additional Values

• Student management systems where a student has a fixed name but variable subjects.
• Billing systems where the customer name is fixed but purchased items vary.
• Employee systems where employee details are fixed but allowances vary.
• Framework APIs that accept mandatory parameters along with optional values.

Concept	Description
Normal Parameters	Receive fixed positional arguments.
*args	Receives all remaining positional arguments.
Order	Normal parameters must come before *args.
Data Type of args	Tuple.

• Normal parameters receive fixed arguments.
• *args receives all remaining positional arguments.
• Python first fills the normal parameters.
• The remaining positional arguments are stored in a tuple.
• Parameters written after *args become keyword-only parameters.
• The name args is only a convention and can be replaced with any valid identifier.

In the previous sections, we learned about *args, which accepts any number of positional arguments.

Python also provides **kwargs, which accepts any number of keyword arguments.

Keyword arguments are passed using the syntax parameter=value.

All keyword arguments are automatically collected into a Dictionary.

Sometimes we do not know in advance how many keyword arguments will be passed to a function.

Instead of creating multiple parameters, we can use **kwargs.

This makes the function flexible and reusable.

Part	Description
**	Indicates Variable Length Keyword Arguments.
kwargs	Stores all keyword arguments in a Dictionary.
function_name	Name of the function.

The name kwargs is not a Python keyword.

It is only a naming convention.

You may use any valid variable name after **.

Each keyword argument is stored as a key-value pair inside the Dictionary kwargs.

The function can receive zero, one, or many keyword arguments.

Since kwargs is a Dictionary, we can use the items() method to traverse all key-value pairs.

The normal parameter name receives the first positional argument.

All keyword arguments are collected into the Dictionary details.

• **kwargs accepts only keyword arguments.
• All keyword arguments are stored in a Dictionary.
• Keys represent parameter names.
• Values represent the supplied values.
• The variable name kwargs can be replaced with any valid identifier.

Feature	*args	**kwargs
Accepts	Positional Arguments	Keyword Arguments
Data Type	Tuple	Dictionary
Symbol	*	**
Access Method	Loop through tuple	Loop through Dictionary
Example	fun(10,20,30)	fun(a=10,b=20)

Feature	Normal Parameter	*args	**kwargs
Accepts	Fixed Arguments	Variable Positional Arguments	Variable Keyword Arguments
Data Type	Depends on Value	Tuple	Dictionary
Flexibility	Low	High	High

• Configuration settings.
• API development.
• Framework development (Django, Flask, FastAPI).
• Passing optional settings.
• Database configuration.
• Logging utilities.

Concept	Description
**kwargs	Accepts any number of keyword arguments.
Storage	Dictionary.
Key	Parameter Name.
Value	Supplied Value.
Traversal	Using items().

• **kwargs accepts any number of keyword arguments.
• All keyword arguments are stored in a Dictionary.
• kwargs is not a keyword; it is only a variable name.
• Dictionary methods like keys(), values(), and items() can be used with kwargs.
• *args stores positional arguments in a Tuple.
• **kwargs stores keyword arguments in a Dictionary.
• Both *args and **kwargs make functions flexible and reusable.

When a function completes its execution, sometimes it needs to send a result back to the function caller.

To send the result from a function, Python provides the return statement.

The return statement terminates the execution of the function and transfers control back to the calling statement.

If a value is specified after the return keyword, that value is returned to the caller.

Consider a function that adds two numbers.

If the function only prints the result, the result cannot be used elsewhere in the program.

If the function returns the result, it can be stored in a variable, used in calculations, or passed to another function.

Therefore, returning values makes functions more useful and reusable.

Statement	Purpose
return value	Returns the specified value to the caller.
return	Terminates the function without returning any value.

The function receives two numbers.

It calculates their sum and returns the result.

The returned value is stored in the variable result.

Finally, the value is printed.

The expression n * n is evaluated first.

The calculated value is then returned to the caller.

The function prints the message.

Since there is no return statement, Python automatically returns None.

Therefore, the variable result stores None.

When Python encounters the return statement, the function immediately terminates.

The statement after return is never executed.

Step	Action
1	Function is called.
2	Function executes its statements.
3	return sends the result back.
4	Function execution stops.
5	Control returns to the caller.

print()	return
Displays output on the screen.	Returns a value to the caller.
Does not terminate the function.	Terminates the function immediately.
Cannot be reused directly.	The returned value can be reused anywhere.
Mainly used for displaying information.	Mainly used for sending results back.

• Returning calculated values from mathematical functions.
• Returning database query results.
• Returning API responses.
• Returning validation results.
• Returning processed data from helper functions.

Concept	Description
return value	Returns a value to the caller.
return	Terminates the function.
No return statement	Python returns None.
After return	Remaining statements are not executed.
Purpose	Send results back to the caller.

• The return statement sends a value back to the caller.
• It immediately terminates the function.
• A function can return numbers, strings, lists, tuples, dictionaries, Boolean values, or objects.
• If no return statement is written, Python automatically returns None.
• Statements written after return are never executed.
• The returned value can be stored in a variable or passed to another function.
• return is different from print(); print() displays output, whereas return sends data back to the caller.

In the previous section, we learned how a function can return a single value by using the return statement.

Python also allows a function to return multiple values.

This is one of the powerful features of Python because many programming languages can return only one value directly.

When multiple values are returned, Python automatically packs them into a Tuple.

Sometimes a function performs multiple calculations and needs to send several results back to the caller.

For example:

• Returning addition, subtraction, multiplication and division together.
• Returning student name, marks and grade.
• Returning minimum and maximum values.
• Returning multiple statistics from a dataset.

Instead of calling multiple functions, Python allows us to return all results together.

Although multiple values appear to be returned, Python actually returns a single Tuple.

Python automatically performs Tuple Packing.

The function returns four values.

Python automatically packs these values into a tuple.

Therefore, the variable result stores a tuple.

When multiple values are returned, Python automatically creates a tuple.

This process is called Tuple Packing.

Instead of storing the returned tuple in a single variable, we can receive each value into separate variables.

This process is called Tuple Unpacking.

The returned tuple contains four values.

Each value is automatically assigned to the corresponding variable.

This process is known as Tuple Unpacking.

Return Statement	Python Stores As
return 10,20	(10,20)
return 10,20,30	(10,20,30)
return "A",100	("A",100)
return True,50.5	(True,50.5)

Single Return	Multiple Return
Returns one value.	Returns multiple values.
Any data type.	Automatically packed into a tuple.
Stored in one variable.	Can be stored in one variable or unpacked into multiple variables.

• Returning multiple calculation results.
• Returning database records.
• Returning API response values.
• Returning student information.
• Returning minimum and maximum values.
• Returning statistical information.

Concept	Description
Multiple Return	Return more than one value.
Tuple Packing	Python automatically creates a tuple.
Tuple Unpacking	Assign returned values to multiple variables.
Storage	Tuple.
Advantage	Return multiple results using one function.

• Python supports returning multiple values from a function.
• Multiple returned values are automatically packed into a tuple.
• This automatic conversion is called Tuple Packing.
• The returned tuple can be stored in a single variable.
• It can also be unpacked into multiple variables.
• The number of receiving variables should match the number of returned values.
• Multiple return values make functions more reusable and efficient.

Variables are used to store data in a program.

Depending on where a variable is declared, Python classifies variables into different types.

Python supports two types of variables:

• Global Variables
• Local Variables

Understanding the scope of variables is very important because it determines where a variable can be accessed and modified.

Before learning Global and Local Variables, it is important to understand three related terms.

Term	Description
Function	A group of statements written together to perform a specific task.
Module	A file that contains one or more functions.
Library	A collection of multiple related modules.

The variables declared outside of every function are called Global Variables.

Global variables belong to the entire module.

Every function inside the same module can access global variables unless a local variable with the same name exists.

• Declared outside all functions.
• Accessible throughout the module.
• Can be shared by multiple functions.
• Remain available until the program finishes.

The variable a is declared outside every function.

Therefore, it becomes a Global Variable.

Both f1() and f2() can access the same variable.

No separate copy of the variable is created for each function.

Declared Outside Function?	Accessible Inside Function?	Accessible by Multiple Functions?
Yes	Yes	Yes

The variables declared inside a function are called Local Variables.

A local variable exists only while the function is executing.

After the function completes, the local variable is destroyed.

It cannot be accessed from outside the function in which it is declared.

• Declared inside a function.
• Accessible only inside that function.
• Cannot be accessed from outside the function.
• Created when the function starts executing.
• Destroyed after the function finishes execution.

The variable a is created inside f1().

Therefore, it is a Local Variable.

It is available only while f1() is executing.

When f2() tries to access it, Python cannot find the variable and raises a NameError.

Event	Local Variable
Function starts	Created
Function executes	Available
Function ends	Destroyed

Global Variable	Local Variable
Declared outside functions.	Declared inside functions.
Accessible throughout the module.	Accessible only inside its function.
Can be shared by multiple functions.	Cannot be shared outside the function.
Exists throughout program execution.	Exists only while the function executes.

• Global variables are used for application-wide configuration settings.
• Global variables can store constants shared by many functions.
• Local variables are used for temporary calculations.
• Loop counters and intermediate results are generally local variables.
• Keeping temporary values local improves program safety and readability.

Topic	Description
Global Variable	Declared outside a function.
Local Variable	Declared inside a function.
Scope of Global Variable	Entire module.
Scope of Local Variable	Only inside the function.
Lifetime of Local Variable	Until the function completes execution.

• Python supports Global Variables and Local Variables.
• Global variables are declared outside functions.
• Local variables are declared inside functions.
• Global variables can be accessed by all functions in the same module.
• Local variables are available only within the function where they are declared.
• A local variable is created when the function starts and destroyed when the function ends.
• Attempting to access a local variable outside its function results in a NameError.

In the previous section, we learned that a Global Variable can be accessed inside a function.

However, if we try to modify a Global Variable directly inside a function, Python creates a new Local Variable instead of modifying the Global Variable.

To modify a Global Variable inside a function, we must use the global keyword.

The global keyword tells Python that the variable belongs to the Global Scope and not to the Local Scope.

Keyword	Purpose
global	Allows a function to modify a Global Variable.

The variable a is declared outside the function.

Since the function only reads the variable, the global keyword is not required.

The assignment a = 20 creates a new Local Variable.

The Global Variable remains unchanged.

Therefore, the function prints 20, but outside the function the value is still 10.

The statement global a informs Python that the variable belongs to the Global Scope.

Now the assignment updates the original Global Variable instead of creating a Local Variable.

Therefore, both statements print 20.

The Global Variable count is updated every time the function is called.

Since the same Global Variable is modified, the final value becomes 3.

Python provides the built-in globals() function.

This function returns a Dictionary containing all Global Variables available in the current module.

The Dictionary keys represent variable names, and the values represent the corresponding Global Variable values.

The globals() function returns a Dictionary.

Besides user-defined Global Variables, the Dictionary also contains several built-in objects created by Python.

For simplicity, only user-defined variables are shown in the sample output.

The globals() function returns a Dictionary.

Dictionary indexing can be used to access any Global Variable by its name.

Since globals() returns the Global Namespace Dictionary, changing its value updates the original Global Variable.

global Keyword	globals() Function
Used inside a function.	Can be used anywhere.
Declares a variable as Global.	Returns the Global Namespace Dictionary.
Mainly used to modify Global Variables.	Used to view or access all Global Variables.
Keyword.	Built-in Function.

• Maintaining application-wide counters.
• Updating global configuration values.
• Managing shared application state.
• Accessing global settings across multiple functions.
• Debugging by inspecting the Global Namespace.

Concept	Description
global	Allows modification of Global Variables inside a function.
globals()	Returns the Global Namespace Dictionary.
Without global	A new Local Variable is created during assignment.
With global	The original Global Variable is modified.

• Reading a Global Variable inside a function does not require the global keyword.
• Modifying a Global Variable inside a function requires the global keyword.
• Without global, Python creates a new Local Variable when an assignment is made.
• globals() returns a Dictionary containing all Global Variables.
• Global Variables can be accessed using dictionary indexing on the result of globals().
• global is a keyword, whereas globals() is a built-in function.
• Excessive use of Global Variables can make programs difficult to maintain, so they should be used carefully.

In the previous sections, we learned how one function can call another function.

Python also allows a function to call itself.

A function that calls itself is called a Recursive Function.

The process of a function calling itself repeatedly until a specific condition is satisfied is known as Recursion.

Recursion is a powerful programming technique used to solve problems that can be divided into smaller versions of the same problem.

A Recursive Function is a function that calls itself either directly or indirectly until a terminating condition is reached.

The terminating condition is called the Base Case.

Many real-world problems are naturally recursive.

Instead of writing complicated loops, recursion provides a cleaner and easier solution.

It is especially useful when solving problems that involve repeated subdivision into smaller sub-problems.

Common examples include:

• Factorial Calculation
• Fibonacci Series
• Tree Traversal
• Directory/File Traversal
• Binary Search
• Tower of Hanoi

Every recursive function contains two important parts:

1. Base Case
2. Recursive Case

The Recursive Case keeps calling the function repeatedly.

The Base Case stops further recursive calls and prevents infinite recursion.

Component	Purpose
Base Case	Stops the recursion.
Recursive Case	Calls the function again.

The function display() calls itself continuously.

Since there is no Base Case, the recursive calls never stop.

Python keeps creating new function calls until the maximum recursion depth is exceeded.

Finally, Python raises a RecursionError.

Infinite recursion occurs when a recursive function has no terminating condition.

Every function call creates another function call.

Eventually, Python runs out of available call stack space.

To prevent this situation, every recursive function must include a Base Case.

The function starts with the value 5.

Each recursive call decreases the value of n by 1.

When n becomes 0, the Base Case executes and recursion stops.

Function Call	Output
display(5)	5
display(4)	4
display(3)	3
display(2)	2
display(1)	1
display(0)	Stops

Step	Action
1	Function is called.
2	Base Case is checked.
3	If Base Case is false, the function calls itself.
4	Each recursive call receives a smaller problem.
5	When the Base Case becomes true, recursion stops.

Normal Function	Recursive Function
Does not call itself.	Calls itself.
Usually uses loops for repetition.	Uses repeated function calls.
Generally easier for simple repetitive tasks.	Better for problems that can be divided into smaller sub-problems.

• Factorial calculation.
• Fibonacci sequence.
• Binary Search.
• Tree Traversal.
• Graph Traversal.
• Directory and File System Traversal.
• Tower of Hanoi.

Concept	Description
Recursive Function	A function that calls itself.
Base Case	Stops recursion.
Recursive Case	Calls the function again.
Without Base Case	RecursionError occurs.
Main Use	Solving recursive problems.

• A Recursive Function calls itself.
• Every recursive function must contain a Base Case.
• The Base Case prevents infinite recursion.
• If no Base Case exists, Python raises RecursionError.
• Each recursive call should reduce the problem size.
• Recursive functions are widely used for mathematical and tree-based algorithms.

The Factorial of a positive integer is the product of all positive integers from 1 to that number.

Factorial is represented by the symbol !.

It is one of the most common examples used to understand Recursion because the problem can be divided into smaller versions of itself.

The mathematical formula for factorial is:

No output captured.

The recursive definition of factorial is:

No output captured.

The recursion must stop when the value becomes 0 or 1.

Both 0! and 1! are equal to 1.

The function receives a number from the user.

If the number becomes 0, the Base Case executes and returns 1.

Otherwise, the function calls itself with n-1.

Each recursive call multiplies the current number with the factorial of the next smaller number.

Finally, all recursive calls return one by one and the final factorial value is produced.

Function Call	Status
factorial(5)	Calls factorial(4)
factorial(4)	Calls factorial(3)
factorial(3)	Calls factorial(2)
factorial(2)	Calls factorial(1)
factorial(1)	Calls factorial(0)
factorial(0)	Returns 1 (Base Case)

Recursive Call	Returned Value
factorial(0)	1
factorial(1)	1
factorial(2)	2
factorial(3)	6
factorial(4)	24
factorial(5)	120

Step	Operation
1	factorial(5) is called.
2	It calls factorial(4).
3	Each function keeps calling the next smaller value.
4	When factorial(0) is reached, 1 is returned.
5	Each pending function multiplies its value while returning.
6	The final answer becomes 120.

• Every recursive function must contain a Base Case.
• The Base Case prevents infinite recursion.
• Each recursive call should reduce the problem size.
• The recursive calls are stored in the Call Stack.
• After reaching the Base Case, the Call Stack starts returning values one by one.
• The factorial program is one of the best examples for understanding recursion.

Recursive functions provide an elegant and efficient solution for many problems that can be divided into smaller sub-problems.

Instead of writing long and complex iterative code, recursion often produces shorter and easier-to-understand programs.

Some important advantages of recursion are listed below.

• Produces shorter and cleaner code.
• Makes programs easier to understand for recursive problems.
• Suitable for mathematical problems such as Factorial and Fibonacci.
• Very useful for Tree Traversal and Graph Traversal.
• Reduces the complexity of solving divide-and-conquer problems.
• Used extensively in searching and sorting algorithms.
• Improves readability for naturally recursive problems.

Although recursion is powerful, it also has some limitations.

Each recursive function call creates a new stack frame in memory.

If recursion continues for many levels, more memory is consumed and the program becomes slower.

• Consumes more memory because of the Call Stack.
• Slower than loops for many simple problems.
• Improper Base Case causes infinite recursion.
• May generate RecursionError.
• Debugging recursive functions is more difficult than loops.
• Not suitable for every programming problem.

Recursion should be used only when it makes the solution simpler and more natural.

Some common situations where recursion is preferred are:

• Factorial Calculation
• Fibonacci Series
• Tree Traversal
• Directory Traversal
• Binary Search
• Depth First Search (DFS)
• Tower of Hanoi
• Merge Sort and Quick Sort

Recursion should generally be avoided when:

• A simple loop can solve the problem easily.
• The recursion depth may become very large.
• Memory usage is an important concern.
• Performance is more important than code simplicity.

Recursion	Loop
Function calls itself.	Repeats statements using loops.
Uses Call Stack.	Does not create recursive stack frames.
Consumes more memory.	Consumes less memory.
Usually slower.	Usually faster.
Code is shorter for recursive problems.	Code may become longer for recursive problems.
Needs a Base Case.	Needs a Loop Condition.
Best for divide-and-conquer problems.	Best for repetitive tasks.

Normal Function	Recursive Function
Does not call itself.	Calls itself.
Usually uses loops.	Uses recursive calls.
Consumes less memory.	Consumes more memory.
Easy to debug.	Comparatively difficult to debug.
Suitable for simple iterative tasks.	Suitable for recursive problems.

Recursion is widely used in modern software development.

• Binary Search Algorithms
• Tree Traversal (Preorder, Inorder, Postorder)
• Graph Traversal (DFS)
• Merge Sort
• Quick Sort
• File and Directory Traversal
• Artificial Intelligence Search Algorithms
• Dynamic Programming Problems
• Expression Evaluation
• Compiler Design

Topic	Description
Recursive Function	A function that calls itself.
Base Case	Stops recursion.
Recursive Case	Calls the function again.
Call Stack	Stores pending recursive function calls.
Factorial	Classic example of recursion.
Infinite Recursion	Occurs when the Base Case is missing.
RecursionError	Raised when recursion exceeds the maximum recursion depth.
Advantages	Cleaner code for recursive problems.
Disadvantages	Higher memory usage and slower execution.
Applications	Trees, Graphs, Sorting, Searching, AI, File Systems.

1. What is a Recursive Function?
2. What is the Base Case?
3. Why is the Base Case necessary?
4. What is Infinite Recursion?
5. What is Call Stack?
6. Explain the execution of the Factorial Program.
7. Differentiate between Recursion and Loop.
8. What are the advantages and disadvantages of recursion?
9. When should recursion be preferred over loops?
10. Explain RecursionError with an example.

• A Recursive Function calls itself.
• Every recursive function must contain a Base Case.
• The Base Case prevents infinite recursion.
• Recursive calls are managed using the Call Stack.
• Each recursive call should reduce the problem size.
• Without a Base Case, Python raises RecursionError.
• Recursion generally consumes more memory than loops.
• Loops are usually faster for simple repetitive tasks.
• Recursion is ideal for divide-and-conquer algorithms.
• Tree Traversal and Graph Traversal are common recursive applications.

In the previous sections, we learned how to create functions using the def keyword.

Python also provides another way to create functions called Lambda Functions.

A Lambda Function is a small anonymous function that can be created without using the def keyword.

These functions are generally used when a function is required only for a short period of time.

Because they do not have a function name, they are also called Anonymous Functions.

A Lambda Function is an anonymous function created using the lambda keyword.

It can have any number of parameters but can contain only one expression.

The value of that expression is automatically returned.

Sometimes we need a function only once in a program.

Creating a complete function using def for such small tasks increases the amount of code.

Lambda Functions provide a simple and compact way to write these small functions.

They are commonly used with built-in functions like:

• map()
• filter()
• reduce()
• sorted()

• Created using the lambda keyword.
• Do not have a function name.
• Also called Anonymous Functions.
• Can accept any number of parameters.
• Can contain only one expression.
• Automatically return the result of the expression.
• Generally used for short and simple operations.

Part	Description
lambda	Keyword used to create an anonymous function.
arguments	Input parameters for the function.
expression	The expression whose result is automatically returned.

The Lambda Function receives one parameter x.

The expression x * x is evaluated.

The calculated value is automatically returned.

Unlike a normal function, no explicit return statement is required.

Both functions produce the same output.

The Lambda Function requires fewer lines of code.

It is suitable for simple operations.

Step	Action
1	Arguments are passed to the Lambda Function.
2	The expression is evaluated.
3	The result is automatically returned.

• Can contain only one expression.
• Cannot contain multiple statements.
• Cannot directly use loops like for or while.
• Not suitable for writing complex business logic.
• Mainly used for small operations.

• Sorting custom objects.
• Data transformation.
• Filtering collections.
• Data analysis.
• Machine Learning preprocessing.
• Using map(), filter(), and reduce().

Concept	Description
Lambda Function	Anonymous function.
Keyword	lambda
Name	Not required.
Statements	Only one expression.
Return	Automatic.

• Lambda Functions are also called Anonymous Functions.
• They are created using the lambda keyword.
• They can accept any number of parameters.
• Only one expression is allowed inside a Lambda Function.
• The expression result is returned automatically.
• No explicit return statement is required.
• Lambda Functions are commonly used with map(), filter(), and reduce().

In the previous section, we learned how to create simple Lambda Functions.

In this section, we will learn how Lambda Functions work with multiple parameters, conditional expressions, and various practical examples.

Since Lambda Functions automatically return the value of a single expression, they are widely used for short calculations.

A Lambda Function can accept any number of arguments.

All arguments are separated by commas, just like normal function parameters.

The Lambda Function accepts two parameters a and b.

The expression a + b is evaluated and the result is automatically returned.

The Lambda Function uses Python's conditional expression.

If a is greater than b, it returns a; otherwise, it returns b.

Lambda Functions can also return Boolean values.

This is useful when checking conditions.

Step	Description
1	Arguments are passed to the Lambda Function.
2	The expression is evaluated.
3	The result is returned automatically.

• Lambda Functions can accept zero, one, or many arguments.
• Only one expression is allowed.
• The expression may contain arithmetic, logical, comparison, or conditional operators.
• The evaluated result is returned automatically.
• Complex business logic should be written using normal functions.

• Simple mathematical calculations.
• Conditional expressions.
• Sorting collections.
• Data transformation.
• Filtering records.
• Quick helper functions.

Feature	Description
Multiple Arguments	Supported.
Return Value	Returned automatically.
Conditional Expression	Supported.
Boolean Result	Supported.
String Operations	Supported.
Maximum Statements	Only one expression.

• Lambda Functions automatically return the expression result.
• They can accept any number of parameters.
• Conditional expressions can be used inside Lambda Functions.
• Boolean values can be returned directly.
• Lambda Functions are ideal for short and simple operations.
• Multiple statements are not allowed inside a Lambda Function.

Python provides two ways to create functions:

1. Normal Functions using the def keyword.
2. Lambda (Anonymous) Functions using the lambda keyword.

Both perform the same task of executing reusable code, but they differ in syntax, complexity, and use cases.

Normal Functions are suitable for large programs, whereas Lambda Functions are ideal for short, single-expression operations.

Both functions produce the same output.

The Lambda Function requires fewer lines of code because it automatically returns the expression result.

For simple operations, Lambda Functions make the code shorter and easier to read.

Normal Function	Lambda Function
Created using the def keyword.	Created using the lambda keyword.
Has a function name.	Usually anonymous (no function name).
Can contain multiple statements.	Can contain only one expression.
Requires an explicit return statement to return a value.	Automatically returns the expression result.
Suitable for large and complex logic.	Suitable for small and simple operations.
Supports loops, conditions, exception handling, and multiple statements.	Cannot directly contain loops, multiple statements, or exception handling.
Easier to maintain for complex programs.	Useful for quick, temporary helper functions.

• Short and concise syntax.
• Requires fewer lines of code.
• No explicit return statement is needed.
• Ideal for one-time or temporary functions.
• Works well with built-in functions like map(), filter(), and reduce().
• Improves readability for simple operations.
• Commonly used in Data Science and Machine Learning code.

• Only one expression is allowed.
• Cannot contain multiple statements.
• Cannot directly use loops such as for and while.
• Not suitable for large business logic.
• Can become difficult to read if the expression is too complex.
• Less suitable for debugging than Normal Functions.

Lambda Functions are recommended when:

• A function is required only once.
• The operation is very small.
• Working with map(), filter(), or reduce().
• Sorting collections using a custom key.
• Writing short callback functions.

Normal Functions are recommended when:

• The logic is complex.
• Multiple statements are required.
• The function needs loops or exception handling.
• The function will be reused many times.
• Better readability and maintainability are required.

• Sorting objects using custom keys.
• Data filtering.
• Data transformation.
• Machine Learning preprocessing.
• Data Analysis with Pandas.
• GUI callback functions.
• Functional programming.

Topic	Description
Lambda Function	An anonymous function created using the lambda keyword.
Anonymous Function	A function without a predefined name.
Arguments	Can accept any number of arguments.
Expression	Only one expression is allowed.
Return Value	Automatically returned.
Main Uses	map(), filter(), reduce(), sorting, callbacks.
Best For	Short and simple functions.
Avoid For	Complex business logic.

1. What is a Lambda Function?
2. Why is a Lambda Function called an Anonymous Function?
3. What is the syntax of a Lambda Function?
4. How many expressions are allowed inside a Lambda Function?
5. Can Lambda Functions have multiple parameters?
6. Differentiate between Normal Functions and Lambda Functions.
7. What are the advantages of Lambda Functions?
8. What are the disadvantages of Lambda Functions?
9. Where are Lambda Functions commonly used?
10. Why are Lambda Functions frequently used with map(), filter(), and reduce()?

• Lambda Functions are anonymous functions.
• They are created using the lambda keyword.
• They can accept any number of arguments.
• Only one expression is allowed.
• The expression result is returned automatically.
• No explicit return statement is required.
• Lambda Functions are ideal for small operations.
• Normal Functions are better for large and reusable code.
• Lambda Functions are widely used in Functional Programming and Data Science.

The filter() function is one of Python's built-in functions.

It is used to select elements from an iterable (such as a list, tuple, or set) based on a given condition.

Instead of modifying the original collection, filter() creates a new iterator that contains only the elements that satisfy the specified condition.

In Python, filter() is commonly used together with Lambda Functions to write short and efficient code.

The filter() function filters elements from an iterable by applying a function to each element.

If the function returns True, the element is included in the result.

If the function returns False, the element is discarded.

Suppose we have a list containing hundreds of numbers.

If we want only the even numbers, we would normally use a loop with an if statement.

The filter() function performs this task in a much shorter and cleaner way.

It helps improve code readability and reduces the amount of code.

Parameter	Description
function	A function that returns either True or False.
iterable	The collection whose elements will be filtered.

The filter() function returns a filter object.

This filter object is an iterator.

To display the filtered values, it is usually converted into a list, tuple, or set.

The Lambda Function checks whether each number is greater than 20.

If the condition is True, the element is selected.

Initially, filter() returns a filter object.

After converting it into a list using list(), the filtered values become visible.

The Lambda Function checks whether the remainder after dividing by 2 is equal to 0.

If the condition is true, the number is included in the result.

Instead of using a Lambda Function, a Normal Function can also be passed to filter().

The function should always return True or False.

Element	Condition	Included?
10	True	✔ Yes
15	False	✘ No
20	True	✔ Yes
25	False	✘ No
30	True	✔ Yes

Step	Description
1	Read one element from the iterable.
2	Pass the element to the function.
3	If the function returns True, keep the element.
4	If the function returns False, discard the element.
5	Return the filtered iterator.

• Simple and readable code.
• Reduces the need for loops.
• Works efficiently with Lambda Functions.
• Useful for selecting required data.
• Returns an iterator, making it memory efficient.

Concept	Description
Function	filter()
Purpose	Select elements that satisfy a condition.
Returns	Filter Object (Iterator)
Common Partner	Lambda Function
Output Conversion	list(), tuple(), set()

• filter() is a built-in Python function.
• It selects elements based on a condition.
• The supplied function must return True or False.
• It returns a filter object (iterator).
• Convert the filter object using list(), tuple(), or set() to view the filtered elements.
• It is commonly used with Lambda Functions.

In the previous section, we learned the basics of the filter() function.

In this section, we will explore more practical examples using different types of data.

These examples demonstrate how filter() can be used to filter numbers, strings, and other collections efficiently.

The Lambda Function checks whether each number is greater than 0.

Only positive numbers satisfy the condition and are included in the result.