PART 3 • LEVEL 09

🧩 Functions & Recursion

Organise programs into reusable units, pass information through parameters, return results and solve self-similar problems recursively.

⏱ 105–120 minutes📚 8 concepts💻 5 programs🧠 6-question quiz

Start Lesson ↓Jump to Problems

factorial.pyPython 3

def factorial(number):
    if number <= 1:
        return 1
    return number * factorial(number - 1)

result = factorial(5)
print("Factorial =", result)

OUTPUTFactorial = 120

LEARNING OUTCOMES

By the End of This Level

You will be able to design reusable and well-structured Python solutions.

Define and call functions with clear responsibilities.

Use positional, keyword and default arguments correctly.

Return values and reason about local and global scope.

Build safe recursive solutions with a base case.

REUSABLE LOGIC

Function Fundamentals

A function is a named block of reusable code that performs one focused task.

Define a function with def, give it a meaningful name, place its body inside an indented block and call it using parentheses.

Function call

An expression or statement that transfers control to a function and starts executing its body.

1DefineCreate named logic

→

2CallRequest execution

→

3ExecuteRun function body

→

4ResumeContinue caller

EXAMPLE 1

Define and Call a Function

def show_message():
    print("Learn. Practice. Build.")

show_message()

Output

Learn. Practice. Build.

PASS INFORMATION

Parameters and Arguments

Parameters are names in a function definition; arguments are the actual values supplied during a call.

Term	Location	Example
Parameter	Function definition	`def greet(name):`
Argument	Function call	`greet("Bhavya")`
Positional argument	Matched by order	`area(8, 5)`
Keyword argument	Matched by name	`area(width=5, length=8)`

Clear calls

Use keyword arguments when names make a call easier to understand, especially when several parameters have similar value types.

SEND A RESULT BACK

Return Values

return ends the current function call and sends a result back to the caller.

EXAMPLE 2

Calculate and Return Area

def rectangle_area(length, width):
    return length * width

area = rectangle_area(8, 5)
print("Area =", area)

Output

Area = 40

Display now

print() sends text to the output; it does not automatically make that value reusable.

RETURN

Reuse later

return gives the result to the caller so it can be stored, compared or used in another expression.

FLEXIBLE CALLS

Default and Keyword Arguments

A default parameter supplies a value when the caller omits that argument.

EXAMPLE 3

Power with a Default Exponent

def power(base, exponent=2):
    return base ** exponent

print(power(6))
print(power(exponent=3, base=2))

Output

36
8

Parameter order

Parameters without defaults must appear before parameters with defaults in a function definition.

WHERE NAMES LIVE

Local and Global Scope

Scope determines where a variable name can be accessed.

LOCAL

Inside one call

A parameter or variable created inside a function normally exists only during that function call.

def calculate(value):
    result = value * 2
    return result

GLOBAL

Module level

A name defined outside functions belongs to the global scope and can be read by functions.

course = "Python"

def show_course():
    print(course)

Best practice

Prefer parameters and return values over changing global variables. This keeps functions predictable and easier to test.

SOLVE IN PARTS

Function Decomposition

Break a large task into small functions with one clear responsibility each.

🧭

Readable

Names explain the program’s major steps.

♻️

Reusable

One implementation can serve many calls.

🧪

Testable

Each unit can be checked independently.

🛠️

Maintainable

Changes remain focused and safer.

Large requirement	Possible functions
Student result report	`total_marks()`, `average()`, `grade()`
Shopping bill	`subtotal()`, `discount()`, `final_bill()`
Number analysis	`is_prime()`, `digit_sum()`, `reverse_number()`

FUNCTION CALLS ITSELF

Recursion Fundamentals

Recursion solves a problem by reducing it to a smaller version of the same problem.

RULE 1

Base Case

Stop immediately for the smallest known input.

if number <= 1:
    return 1

RULE 2

Recursive Case

Move toward the base case with a smaller input.

return number * factorial(number - 1)

Safety rule

Every recursive path must eventually reach a base case. Otherwise calls continue until Python raises RecursionError.

CALLS AND RETURNS

Recursive Call Stack

Each recursive call gets its own local frame. Results are produced while those frames return in reverse order.

1factorial(4)Wait for 3!

→

2factorial(3)Wait for 2!

→

3factorial(2)Wait for 1!

→

4factorial(1)Return base value

The stack first grows: 4 → 3 → 2 → 1. It then unwinds: 1 → 2 → 6 → 24. A recursive function therefore has a calling phase and a returning phase.

COMMON MISTAKES

Function Errors to Avoid

Calling before definition

At runtime, Python must execute the def statement before it reaches the call.

Printing instead of returning

A displayed value cannot replace a required return value in another calculation.

Wrong argument count

Supply every required argument exactly once unless a parameter has a default.

Missing base case

Recursive calls must reduce the problem and eventually stop.

QUICK REVISION

📌 Functions & Recursion — Quick Revision

Review these rules before attempting the quiz and programming problems.

def creates a function definition.

Calling uses the function name followed by parentheses.

Parameters receive arguments supplied by the caller.

Positional arguments are matched by order.

Keyword arguments are matched by parameter name.

A default value makes an argument optional.

return ends a call and sends back a result.

Local variables belong to one function call.

Recursion requires a reachable base case.

Recursive results unwind in reverse call order.

KNOWLEDGE CHECK

🧠 Functions & Recursion Quiz

Choose one answer for each question, then check your score.

1. Which keyword defines a Python function?

function def method

2. What does `return` do?

Ends the call and sends back a value Displays a value only Repeats the function forever

3. Which call uses keyword arguments?

area(8, 5) area() area(width=5, length=8)

4. Where does a parameter normally exist?

In every program automatically In that function call’s local scope Only inside comments

5. What prevents infinite recursion?

A reachable base case A global variable A print statement

6. What is the value of `factorial(4)`?

4 10 24

PROGRAMMING PROBLEMS

💻 CodeBhavya Function Challenges

Write and run each program in the browser. The checker uses the displayed sample input and exact expected output.

📈 Functions Practice Progress

Solved independently0 / 5

Completed with solution0

Best score0 / 500

Progress0%

1. Personalised Welcome

Read a name, pass it to a function and return a complete welcome message.

Sample input: BhavyaExpected output: Welcome, Bhavya!

Official Python Program

def welcome(name):
    return "Welcome, " + name + "!"

student = input()
print(welcome(student))

2. Rectangle Report

Use separate functions to return a rectangle’s area and perimeter.

Sample input: 8, 5Expected output: Area = 40 and Perimeter = 26

Official Python Program

def area(length, width):
    return length * width

def perimeter(length, width):
    return 2 * (length + width)

length = int(input())
width = int(input())
print("Area =", area(length, width))
print("Perimeter =", perimeter(length, width))

3. Classify a Number

Return Positive, Negative or Zero from a decision-making function.

Sample input: -7Expected output: Result = Negative

💡 Use early return statements inside if and elif branches.

Official Python Program

def classify(number):
    if number > 0:
        return "Positive"
    elif number < 0:
        return "Negative"
    return "Zero"

number = int(input())
print("Result =", classify(number))

4. Recursive Factorial

Read a non-negative integer and calculate its factorial recursively.

Sample input: 5Expected output: Factorial = 120

💡 Return 1 for values at or below one; otherwise multiply by the factorial of one less.

Official Python Program

def factorial(number):
    if number <= 1:
        return 1
    return number * factorial(number - 1)

number = int(input())
print("Factorial =", factorial(number))

5. Recursive Digit Sum

Read a positive integer and return the sum of its digits using recursion.

Sample input: 472Expected output: Digit Sum = 13

Official Python Program

def digit_sum(number):
    if number == 0:
        return 0
    return number % 10 + digit_sum(number // 10)

number = int(input())
print("Digit Sum =", digit_sum(number))

KEY TAKEAWAY

🎯 Build Small Functions with Clear Contracts

1Define Purpose

Give one function one responsibility.

→

2Receive Inputs

Use meaningful parameters.

→

3Return Result

Send reusable data to the caller.

→

4Recurse Safely

Reduce toward a base case.

Functions improve structure through reuse and separation of concerns. Recursion is powerful when the problem naturally becomes a smaller version of itself and every path reaches a base case.

INTERACTIVE LEARNING

🎬 Function Call — Visual Flow

Follow arguments into a function and observe how a returned value reaches the caller.

PROGRAM TRACING

🔎 Program Tracing — Recursive Factorial

Trace factorial(4) as calls build and returned values unwind.

INTERVIEW PREPARATION

🎤 Functions & Recursion — Interview Questions

Answer aloud before opening each explanation.

What is the difference between a parameter and an argument?

What is the difference between print() and return?

print() displays information. return ends the function call and gives a value back to the caller for further use.

What is local scope?

Why should global-variable modification be limited?

What are the two essential parts of recursion?

When is iteration preferable to recursion?

EXTRA TIPS

💡 Functions & Recursion — Extra Tips

01
Name functions with verbs such as calculate_total() or is_prime().
02
Keep one function focused on one clear responsibility.
03
Prefer returned values when a result must be reused or tested.
04
Place required parameters before parameters that have defaults.
05
Trace small recursive inputs manually before testing larger values.
06
Check both the base case and the step that moves toward it.

EXTRA PRACTICE

✍️ Functions & Recursion — Extra Practice Questions

Write a function that returns the largest of three numbers.
Create a function with a default tax percentage and return the final bill.
Return whether a supplied number is prime.
Build separate functions for total, average and grade.
Write a recursive function to calculate a number raised to a power.
Find the greatest common divisor recursively.
Return the nth Fibonacci number recursively.
Reverse a string using recursion.
Count the digits of a positive integer recursively.
Explain the call stack for factorial(5).

LEVEL 9 CHECKPOINT

Functions & Recursion Complete

When you can design clear functions, return reusable values, explain scope and trace recursive calls safely, mark this level complete and continue.

Continue to Level 10 →

🧩 Functions & Recursion

By the End of This Level

Function Fundamentals

Define and Call a Function

Parameters and Arguments

Return Values

Calculate and Return Area

Display now

Reuse later

Default and Keyword Arguments

Power with a Default Exponent

Local and Global Scope

Inside one call

Module level

Function Decomposition

Readable

Reusable

Testable

Maintainable

Recursion Fundamentals

Base Case

Recursive Case

Recursive Call Stack

Function Errors to Avoid

📌 Functions & Recursion — Quick Revision

🧠 Functions & Recursion Quiz

1. Which keyword defines a Python function?

2. What does return do?

3. Which call uses keyword arguments?

4. Where does a parameter normally exist?

5. What prevents infinite recursion?

6. What is the value of factorial(4)?

💻 CodeBhavya Function Challenges

Python Code Editor

Program Output

Test Case

Python Code Editor

Program Output

Test Case

Python Code Editor

Program Output

Test Case

Python Code Editor

Program Output

Test Case

Python Code Editor

Program Output

Test Case

🎯 Build Small Functions with Clear Contracts

🎬 Function Call — Visual Flow

🧩 How a Function Call Works

1. Define the Function

🔎 Program Tracing — Recursive Factorial

🎤 Functions & Recursion — Interview Questions

💡 Functions & Recursion — Extra Tips

✍️ Functions & Recursion — Extra Practice Questions

Functions & Recursion Complete

2. What does `return` do?

6. What is the value of `factorial(4)`?