Class 12 CBSE Computer Science: Python Functions Study Notes

1. Fundamentals of Functions

Definition and Role

In Python, functions are sub-programs—modular segments of a larger program designed to execute specific, well-defined tasks. The fundamental philosophy is Modularity and Reusability, summarized by the mantra: “Write Once, Use Many Times.”

The “Zero-Mark” Paradox (Exam Strategy)

Board Consultant Insight: Students often neglect this chapter because direct questions may account for very few marks in the theory section. However, this is a dangerous oversight. Functions are the technical backbone of the Class 12 syllabus. You cannot successfully implement File Handling (4–5 marks), Data Structures/Stacks (3–4 marks), or Database Connectivity without total mastery of functional programming.

Core Syntax

Python uses the def keyword to define a function. A colon and indentation are mandatory to define the function’s scope.

def function_name(parameter1, parameter2):
    # Function Body (Indented)
    pass  # Placeholder for logic
    return result # Optional

2. Classification of Python Functions

Python functions are categorized into three types. Understanding these synonyms is vital for MCQ sections.

Type	Also Known As	Definition	Examples
Built-in Functions	Library or Pre-defined Functions	Already defined in the interpreter; available for immediate use.	print(), input(), len(), type(), id()
Module-Defined	—	Defined in specific files; requires an import statement.	math.sqrt(), random.randint()
User-Defined (UDF)	—	Created by the programmer to perform custom tasks.	def calculate_si(), def check_prime()

[!CAUTION] BOARD ALERT: The “T20” Tuple Trap In the 1-mark MCQ section, the board often tests your knowledge of return types.

• t = (20) \rightarrow Python treats this as an Integer (int).
• t = (20,) \rightarrow The comma makes this a Tuple. This distinction is crucial when functions return single values vs. collections.

Naming Rules (Identifiers)

Functions must follow the same rules as variables:

1. Must start with a letter (A-Z, a-z) or underscore (_).
2. Cannot start with a digit.
3. Cannot be a Python keyword (e.g., def, while, if).

3. Anatomy of Function Execution

The Logical __main__ Section

Every Python program has a logical entry and exit point called __main__. While function definitions appear at the top, they are “ignored” by the interpreter until the execution flow reaches a Function Call located in the __main__ section.

Flow of Execution (Active Command)

Follow this sequence to trace any “Find the Output” question: Calling Place \rightarrow Jump to Definition \rightarrow Execute Body \rightarrow Return to Calling Place.

Indentation and Scope

Indentation is not just for readability; it defines the scope. When the indentation level drops back to the level of the def keyword, the function block ends.

4. Arguments and Parameters: The Technical Distinction

Term	Location	Description
Actual Arguments	Function Call	The real values or variables passed to the function.
Formal Parameters	Function Header	The variables defined to receive those values.

Argument Mapping

• Positional Arguments: The default behavior where values are mapped based on order (1st to 1st, 2nd to 2nd).
• Keyword (Named) Arguments: You can bypass order by specifying the parameter name (e.g., add(b=10, a=5)).

def add(a, b):          # 'a' and 'b' are Formal Parameters
    return a + b

# --- __main__ ---
x, y = 10, 20
result = add(x, y)      # 'x' and 'y' are Actual Arguments

5. Structural Categories of Functions

1. No Argument, No Return: The function handles input, logic, and output internally.
2. With Argument, No Return: Receives data but prints results internally.
3. No Argument, With Return: Uses internal data to send a result back to the caller.
4. With Argument, With Return: The most standard structure; receives data and sends back a result.

Returning Multiple Values

Unique to Python, a function can return more than one value using return val1, val2. Exam Fact: When a function returns multiple values, Python automatically packs them into a Tuple.

6. Advanced Argument Handling: Default and Optional

Default Arguments

You can assign “backup” values to parameters. If the caller provides no value, the default is used.

[!IMPORTANT] The “Right-to-Left” Thumb Rule Once you provide a default value to a parameter, all subsequent parameters to its right must also have default values.

Example Header	Validity	Reason
def func(a, b=5, c=10):	Valid	Defaults are on the right.
def func(a=5, b, c):	Invalid	Non-default parameters b and c cannot follow default a.
def func(a, b=5, c):	Invalid	c is a non-default parameter following a default b.

7. Variable Scope and Lifetime (LEGB)

Scope determines the “visibility” of a variable.

Scope	Analogy	Description
Local	“Gully Ka Gunda”	A variable defined inside a function. It is a “boss” inside its own alley (function) but has no power (cannot be accessed) outside.
Global	“National Leader”	Defined in __main__ or top-level. Accessible throughout the entire program.

The global Keyword

To modify a global variable from within a local function scope, you must declare it using the global keyword. Without this, Python creates a new local variable of the same name instead of updating the global one.

The LEGB Priority Rule

When resolving a variable name, Python searches in this order:

1. Local: Inside the current function.
2. Enclosed: Inside nested/outer functions.
3. Global: At the top level of the script.
4. Built-in: Python’s internal pre-defined names (like len).

8. Board Examination Pitfalls (Common Errors)

The None Output Trap

If a function does not have a return statement and you try to print its call, Python returns None.

Example Question: What is the output of the following?

def demo():
    print("Hello")

print(demo())

Correct Two-Line Output:

Hello
None

“Find the Error” Checklist

In 2-mark “Rewrite the following code” questions, always look for:

1. Missing Colons: Check the end of def, if, for, and while lines.
2. Indentation Errors: Ensure the function body is consistently indented.
3. Default Argument Order: Ensure all default values are on the right side.
4. Missing Initializations: Look for accumulators like s=0 or count=0 before a loop starts. If missing, it’s a logical/syntax error.
5. Range Boundary Errors: To include n in a loop, you must use range(1, n + 1). range(1, n) only goes up to n-1.