(a) Hello World (b) Hello Python (c) Error (d) None

False. A function in Python does not have to return a value. If no return statement is present, the function returns None by default.

False. A local variable is accessible only within the function where it is defined. It cannot be accessed from outside.

True. import math makes all functions and constants in the math module available, accessed as math.function_name().

True. In Python, parameters with default values must be placed after parameters without default values. def f(a, b=5) is valid; def f(a=5, b) is not.

False. math.sqrt() always returns a float, even if the result is a perfect square. For example, math.sqrt(25) returns 5.0, not 5.

True. Without a base case, the function calls itself infinitely, eventually causing a RecursionError. The base case provides the condition to stop recursion.

False. The * wildcard imports all functions and constants from the module. from math import sqrt would import only the sqrt function.

A function is a named, reusable block of code that performs a specific task. Functions help organise code, avoid repetition, and make programs easier to read and debug.

def greet(name):
    print("Hello,", name + "! Welcome to Python.")

greet("Ravi")   # Output: Hello, Ravi! Welcome to Python.
greet("Priya")  # Output: Hello, Priya! Welcome to Python.

def add(a, b):   # a, b are parameters
    return a + b

result = add(5, 3)   # 5, 3 are arguments

A module is a Python file (.py) containing functions, classes, and variables that can be reused in other programs.

Three ways to import a module:

# Method 1: Import entire module
import math
print(math.sqrt(25))  # Access with module prefix

# Method 2: Import specific function
from math import sqrt
print(sqrt(25))       # No prefix needed

# Method 3: Import everything
from math import *
print(pi)             # All names available directly

x = 10  # Global variable

def my_function():
    y = 5  # Local variable
    print("Inside:", x, y)  # Can access both x and y

my_function()
print("Outside:", x)  # Can access x
# print(y)  # Error! y is not defined outside the function

Function Definition: A function is a named block of reusable code that performs a specific task. It helps in:

• Code reusability (write once, use many times)
• Modularity (break complex programs into smaller parts)
• Readability (easier to understand)

Types of Functions:

Function Syntax:

def function_name(parameters):
    """Docstring (optional)"""
    # Function body
    return value  # Optional

Function Components:

• def keyword — starts the function definition
• Function name — follows Python naming rules
• Parameters — optional, input values in parentheses
• Function body — indented block of code
• return — optional, sends a value back to the caller

Examples:

# 1. Function without parameters and without return
def greet():
    print("Hello, Welcome!")

greet()  # Call the function

# 2. Function with parameters and without return
def display(name, age):
    print("Name:", name)
    print("Age:", age)

display("Ravi", 16)

# 3. Function with parameters and return value
def add(a, b):
    return a + b

result = add(10, 20)
print("Sum =", result)  # Output: Sum = 30

# 4. Function with default parameter
def power(base, exp=2):
    return base ** exp

print(power(5))     # 25 (uses default exp=2)
print(power(5, 3))  # 125 (uses provided exp=3)

Program: Factorial using function

# Program to find factorial using a function
def factorial(n):
    """Calculate factorial of a non-negative integer."""
    if n < 0:
        return "Factorial not defined for negative numbers"
    fact = 1
    for i in range(1, n + 1):
        fact = fact * i
    return fact

# Main program
num = int(input("Enter a number: "))
result = factorial(num)
print("Factorial of", num, "=", result)

Output:

Recursion: Recursion is a technique where a function calls itself to solve a problem by breaking it into smaller sub-problems.

Key Components of a Recursive Function: 1. Base Case: The condition that stops the recursion. Without it, the function calls itself infinitely. 2. Recursive Case: The part where the function calls itself with a smaller input, moving toward the base case.

How Recursion Works:

# Simple recursive function: Calculate power
def power(base, exp):
    if exp == 0:           # Base case
        return 1
    else:                  # Recursive case
        return base * power(base, exp - 1)

print(power(2, 3))  # Output: 8
# Trace: 2 * power(2,2) → 2 * 2 * power(2,1) → 2 * 2 * 2 * power(2,0) → 2 * 2 * 2 * 1 = 8

Example: Recursive factorial

def factorial(n):
    if n == 0 or n == 1:    # Base case
        return 1
    else:                    # Recursive case
        return n * factorial(n - 1)

print(factorial(5))  # Output: 120
# Trace: 5 * f(4) → 5 * 4 * f(3) → 5 * 4 * 3 * f(2) → 5 * 4 * 3 * 2 * f(1) → 5 * 4 * 3 * 2 * 1 = 120

Example: Recursive Fibonacci

The Fibonacci series: 0, 1, 1, 2, 3, 5, 8, 13, 21, ... Each number is the sum of the two preceding numbers.

# Program to print Fibonacci series using recursion
def fibonacci(n):
    """Return the nth Fibonacci number."""
    if n <= 0:           # Base case 1
        return 0
    elif n == 1:         # Base case 2
        return 1
    else:                # Recursive case
        return fibonacci(n - 1) + fibonacci(n - 2)

# Print first N Fibonacci numbers
N = int(input("Enter number of terms: "))
print("Fibonacci series:")
for i in range(N):
    print(fibonacci(i), end=" ")

Output:

Advantages of Recursion:

• Simplifies complex problems (e.g., tree traversal, factorial)
• Code is shorter and more elegant
• Naturally fits problems defined recursively

Disadvantages of Recursion:

• Uses more memory (call stack)
• Slower than iterative solutions for large inputs
• Risk of stack overflow if base case is missing

What is a Module? A module is a Python file (.py) containing functions, classes, and variables. Modules help organise code into reusable components.

Importing Modules:

Built-in Modules:

math module examples:

import math

print(math.sqrt(25))      # 5.0 — Square root
print(math.ceil(4.2))     # 5   — Round up
print(math.floor(4.8))    # 4   — Round down
print(math.pow(2, 3))     # 8.0 — 2 raised to 3
print(math.fabs(-7))      # 7.0 — Absolute value (float)
print(math.gcd(12, 18))   # 6   — Greatest common divisor
print(math.pi)            # 3.141592653589793
print(math.e)             # 2.718281828459045
print(math.factorial(5))  # 120 — Factorial

random module examples:

import random

print(random.randint(1, 10))    # Random integer from 1 to 10 (inclusive)
print(random.random())           # Random float between 0.0 and 1.0
print(random.uniform(1, 10))     # Random float between 1 and 10
print(random.choice(["a", "b", "c"]))  # Random item from list

Program: Using math and random modules together

import math
import random

# Program: Random circle area and statistics
print("=== Circle Area Calculator ===")
r = float(input("Enter radius of circle: "))
area = math.pi * math.pow(r, 2)
circumference = 2 * math.pi * r
print(f"Area of circle = {area:.2f}")
print(f"Circumference = {circumference:.2f}")

print("\n=== Random Number Game ===")
target = random.randint(1, 100)
print("I'm thinking of a number between 1 and 100!")
guess = int(input("Guess the number: "))

if guess == target:
    print("Congratulations! You guessed it right!")
else:
    print("Wrong! The number was", target)
    print("Your guess was off by", math.fabs(guess - target))

Output:

Creating a user-defined module:

# Save this as mymodule.py
def add(a, b):
    return a + b

def greet(name):
    return "Hello, " + name + "!"

PI = 3.14159

# In another Python file
import mymodule

print(mymodule.add(5, 3))     # 8
print(mymodule.greet("Ravi")) # Hello, Ravi!
print(mymodule.PI)             # 3.14159