Functions

Read this before you spend time here. Chapter 7 of your NCERT Class 11 book teaches user-defined functions. User-defined functions are not part of the CBSE Class 11 Computer Science (083) exam syllabus for 2025-26. They moved to Class 12, where Unit 1 opens with "Revision of Python topics covered in Class XI" and then teaches Functions. So nothing on this page can be asked in your Class 11 annual examination or school unit tests. (Class 11 has no board paper at all — the board exam comes at the end of Class 12.)

Two honest conclusions follow. First, if Unit 2 (Computational Thinking and Programming-1) is not yet solid — lists, tuples, dictionaries, strings, loops, the built-in methods — go and revise that first, because that is where your marks are. Second, once Unit 2 is solid, this chapter is a genuine head start: every single thing on this page is examinable next year, and students who arrive in Class 12 already comfortable with def find the whole year easier.

You have been using functions since day one. Every time you wrote len(marks) or max(marks) you called a function. Someone wrote that code once, and you reuse it by name.

marks = [78, 91, 65, 88]
print(len(marks))
print(max(marks))
print(sum(marks))
print(round(sum(marks) / len(marks), 2))

Output:

4
91
322
80.5

A user-defined function is the same idea, except you write the reusable block yourself.

The problem functions solve. Suppose a shop bills three orders, each with 18% GST:

amount = 250 * 3
print("Payable: Rs", round(amount + amount * 0.18, 2))

amount = 1499 * 2
print("Payable: Rs", round(amount + amount * 0.18, 2))

amount = 80 * 12
print("Payable: Rs", round(amount + amount * 0.18, 2))

Output:

Payable: Rs 885.0
Payable: Rs 3537.64
Payable: Rs 1132.8

The logic is written three times. If GST changes to 12%, you must edit three places and you will miss one. That is the real cost of copy-paste: not typing effort, but the bugs that appear when one copy is updated and the others are not.

Writing your first function. The header is def name(parameters): — the keyword def, a name that follows the same rules as a variable name, brackets, and a compulsory colon. Everything indented under the header is the function body.

def greet():
    print("Namaste, welcome to Class 11 CS")

greet()
greet()

Output:

Namaste, welcome to Class 11 CS
Namaste, welcome to Class 11 CS

Notice that greet without brackets would not print anything — the brackets are what actually run the function. greet is the function; greet() is the act of running it.

WORKED EXAMPLE — the GST bill as a function. The first line inside the body is a docstring: a string in triple quotes that says what the function does. Python stores it, and you can read it back later.

def bill_total(price, qty):
    """Print the amount payable including 18% GST."""
    amount = price * qty
    gst = amount * 0.18
    print("Item amount : Rs", amount)
    print("GST @18%    : Rs", round(gst, 2))
    print("Payable     : Rs", round(amount + gst, 2))

print("--- Order 1 ---")
bill_total(250, 3)
print("--- Order 2 ---")
bill_total(1499, 2)

Real output:

--- Order 1 ---
Item amount : Rs 750
GST @18%    : Rs 135.0
Payable     : Rs 885.0
--- Order 2 ---
Item amount : Rs 2998
GST @18%    : Rs 539.64
Payable     : Rs 3537.64

Now the GST rate lives in exactly one line. Change 0.18 once and every bill in the program is correct.

Flow of execution. This trips up almost everyone. The def block does not run when Python reads it — it only creates the function and moves on. The body runs only when you call it.

print("Line 1: before the def")

def show():
    print("Line 3: inside the function")

print("Line 2: after the def, before the call")
show()
print("Line 4: after the call")

Output:

Line 1: before the def
Line 2: after the def, before the call
Line 3: inside the function
Line 4: after the call

Because the function is created only when the def line executes, calling it earlier fails. This program:

show()

def show():
    print("Hello")

ends with (last line of the traceback):

NameError: name 'show' is not defined

A function body can never be empty. If you want to write the header now and the logic later, put pass in the body:

def not_written_yet():
    pass

print(not_written_yet())
print(type(not_written_yet))

Output:

None

Two useful facts fall out of that output. A function that does not send anything back gives you None, and a function is itself a kind of object with a type, just like an int or a list.

A function that always prints the same thing is not very useful. Parameters let you hand data in.

Get the vocabulary right, because CBSE asks for the difference directly — in the Class 12 paper, not in Class 11, where none of this is examined. In def fare(km, rate): the names km and rate are parameters — they appear in the definition. In the call fare(400, 1.25) the values 400 and 1.25 are arguments — they appear at the call. Parameters are empty boxes; arguments are what you put in them.

Positional arguments. By default Python matches arguments to parameters left to right, by position. Nothing checks that they make sense:

def student_row(name, marks):
    print(name, "scored", marks)

student_row("Ananya", 92)
student_row(92, "Ananya")

Output:

Ananya scored 92
92 scored Ananya

The second call is nonsense but Python runs it happily. This is why order matters and why a wrong-order call is such a nasty bug — there is no error message, just a wrong answer.

Keyword arguments. You can name the parameter at the call. Then order stops mattering:

def student_row(name, marks):
    print(name, "scored", marks)

student_row(marks=92, name="Ananya")
student_row("Rahul", marks=77)

Output:

Ananya scored 92
Rahul scored 77

You may mix the two, but all positional arguments must come before all keyword arguments. Writing func(a=3, 7) stops the program before it starts:

SyntaxError: positional argument follows keyword argument

WORKED EXAMPLE — default parameters, IRCTC style. Give a parameter a value in the header and it becomes optional. Here the standard sleeper rate is Rs 1.25 per km and AC costs 50% more:

def fare(km, rate=1.25, ac=False):
    cost = km * rate
    if ac:
        cost = cost * 1.5
    print("Distance", km, "km -> Rs", round(cost, 2))

fare(400)
fare(400, 2.0)
fare(400, ac=True)
fare(400, 2.0, True)

Real output:

Distance 400 km -> Rs 500.0
Distance 400 km -> Rs 800.0
Distance 400 km -> Rs 750.0
Distance 400 km -> Rs 1200.0

Read the third call carefully. To change ac while leaving rate alone, you must name it — fare(400, True) would have set rate = True, which is 1, and quietly given a wrong fare. Defaults plus keyword arguments together are what make a function comfortable to call.

The ordering rule for defaults. Every parameter with a default must come after every parameter without one. Otherwise Python cannot decide what a lone positional argument means. This definition never even runs:

def fare(rate=1.25, km):
    print(km * rate)

SyntaxError: parameter without a default follows parameter with a default

Note that this is a SyntaxError, not a runtime error — the whole file is rejected, even the parts that are fine.

The classic NCERT trace. Three parameters, two with defaults, three different calling styles:

def func(a, b=5, c=10):
    print('a is', a, 'and b is', b, 'and c is', c)

func(3, 7)
func(25, c=24)
func(c=50, a=100)

Real output:

a is 3 and b is 7 and c is 10
a is 25 and b is 5 and c is 24
a is 100 and b is 5 and c is 50

Trace it: in call 1, 3 and 7 fill a and b by position, c keeps its default. In call 2, 25 fills a, c is named, b keeps its default. In call 3, both are named, order is irrelevant, and b again keeps its default.

Wrong number of arguments. Python counts. Too few:

def fare(km, rate):
    print(km * rate)

fare(400)

TypeError: fare() missing 1 required positional argument: 'rate'

Too many:

fare(400, 1.25, True)

TypeError: fare() takes 2 positional arguments but 3 were given

Both are TypeError and both happen at the call, not at the definition — so a badly-called function can sit undetected in your code until that branch actually runs.

So far the functions have printed. Printing puts characters on the screen and then the value is gone — you cannot add it to something, store it in a list, or compare it. return sends the value back to the line that called the function, where you can do anything you like with it.

WORKED EXAMPLE — print versus return. This one example fixes the single most common confusion in the whole chapter:

def area_print(side):
    print(side * side)

def area_return(side):
    return side * side

area_print(5)
a = area_return(5)
print(a + 100)

b = area_print(5)
print(b)

Real output:

25
125
25
None

Line by line: area_print(5) prints 25 and gives nothing back. area_return(5) prints nothing but hands 25 back, so a + 100 is 125. The last two lines are the trap — b = area_print(5) prints 25 as a side effect, but the value stored in b is None, because a function with no return returns None. If you had written b * 2 you would have got a TypeError.

Rule of thumb: a function that computes something should return; a function whose entire job is to display something may print. Do not mix the two jobs in one function.

return ends the function at once. Nothing after it in that path ever runs:

def test(n):
    print("start")
    if n > 0:
        return "positive"
        print("this line never runs")
    print("end")
    return "not positive"

print(test(5))
print(test(-5))

Output:

start
positive
start
end
not positive

The string this line never runs is absent from the output, which proves the point.

Early return makes grading code clean. Because return exits immediately, you do not need elif chains:

def grade(marks):
    if marks >= 90:
        return "A1"
    if marks >= 80:
        return "A2"
    if marks >= 70:
        return "B1"
    if marks >= 33:
        return "Pass"
    return "Needs Improvement"

for m in [95, 82, 71, 40, 12]:
    print(m, "->", grade(m))

Output:

95 -> A1
82 -> A2
71 -> B1
40 -> Pass
12 -> Needs Improvement

Once marks >= 90 is true, the function is over — so the later tests can be written as if the earlier ones already failed.

Returning more than one value. Python lets you list several values after return. It packs them into a tuple:

def divide(a, b):
    q = a // b
    r = a % b
    return q, r

result = divide(47, 5)
print(result)
print(type(result))

quotient, remainder = divide(47, 5)
print("Quotient:", quotient, "Remainder:", remainder)

Output:

(9, 2)

Quotient: 9 Remainder: 2

Nothing new is happening — this is exactly the tuple packing and unpacking you already learnt in Unit 2. return q, r builds the tuple (9, 2), and quotient, remainder = ... unpacks it.

A bare return — the word alone, no value — ends the function and gives back None. It is used to bail out of a bad case.

Returned values compose. Because a call is an expression, you can use it anywhere a value fits — inside arithmetic, inside another call, inside a condition:

import math

def hypotenuse(a, b):
    return math.sqrt(a * a + b * b)

def perimeter(a, b):
    return a + b + hypotenuse(a, b)

print(round(hypotenuse(3, 4), 2))
print(round(perimeter(3, 4), 2))
print(round(hypotenuse(5, 12) + hypotenuse(8, 15), 2))

Output:

5.0
12.0
30.0

Check the last line by hand: 5-12-13 and 8-15-17 are Pythagorean triples, so 13 + 17 = 30. That is what composition buys you — perimeter did not have to know any geometry, it just used hypotenuse.

Scope means: from which parts of the program is this name visible? Python has two you need here — local (inside one function call) and global (at the top level of the file).

A variable assigned inside a function is local. It is created when the function starts and destroyed when it ends:

def compute():
    total = 100
    print("Inside :", total)

compute()
print("Outside:", total)

Output:

Inside : 100

then the program stops with (last line of the traceback):

NameError: name 'total' is not defined

This is a feature, not a nuisance. It means you can use i, total or temp inside a function without worrying whether some other part of a 500-line program already uses those names.

A global variable can be read inside a function with no special keyword:

gst_rate = 0.18

def show_rate():
    print("Rate used inside function:", gst_rate)

show_rate()
print("Rate outside:", gst_rate)

Output:

Rate used inside function: 0.18
Rate outside: 0.18

Python looks for gst_rate locally first, does not find it, then looks globally and finds it.

WORKED EXAMPLE — the shadowing surprise. Now watch what happens when you assign to a name that also exists globally:

count = 10

def change():
    count = 99
    print("Inside :", count)

change()
print("Outside:", count)

Real output:

Inside : 99
Outside: 10

The global count is untouched. The assignment did not modify the global — it created a brand-new local variable that happens to have the same name. The local hides, or shadows, the global for the duration of the call. This is deliberate: a function should not be able to wreck the rest of your program just because it reused a common name.

The global keyword is how you say "I really do mean the outer one":

count = 10

def change():
    global count
    count = 99
    print("Inside :", count)

print("Before :", count)
change()
print("After  :", count)

Output:

Before : 10
Inside : 99
After  : 99

Use it sparingly. A function that quietly rewrites globals is hard to test and hard to debug, because reading its call site tells you nothing about what it changed. Returning a value is almost always the better design.

The half-and-half error. This one confuses everybody the first time. Reading a global is fine, and assigning creates a local — so what happens if you do both?

count = 10

def bump():
    print(count)
    count = count + 1

bump()

Output (last line of the traceback):

UnboundLocalError: cannot access local variable 'count' where it is not associated with a value

Python scans the whole function body before running it. It sees count = ... somewhere in the body, and decides then and there that count is a local name for this entire function. So the earlier print(count) is asking for a local that has not been given a value yet. The fix is one line: add global count at the top of the function, or better, pass count in and return the new value.

Parameters are local too. A parameter is just a local variable that starts out holding the argument:

def double(n):
    n = n * 2
    print("Inside :", n)

n = 5
double(n)
print("Outside:", n)

Output:

Inside : 10
Outside: 5

The two ns are different variables that share a name. Reassigning the parameter never touches the caller's variable.

Summary table.

Scope explains what happens to names. This section explains what happens to objects, which is where the last real surprise lives.

WORKED EXAMPLE — lists change, integers do not. The same-looking code behaves differently for a list and an int:

def add_bonus(marks_list, bonus):
    marks_list.append(bonus)
    print("Inside :", marks_list)

def add_number(x, bonus):
    x = x + bonus
    print("Inside :", x)

scores = [78, 91, 65]
add_bonus(scores, 5)
print("Outside:", scores)

total = 234
add_number(total, 5)
print("Outside:", total)

Real output:

Inside : [78, 91, 65, 5]
Outside: [78, 91, 65, 5]
Inside : 239
Outside: 234

The list changed outside the function. The integer did not. The reason is the mutable / immutable distinction from Unit 2: the parameter always receives a reference to the same object the caller has. For a list you can modify that shared object with append, sort, remove or lst[0] = ..., and the caller sees it. An int, str, float or tuple cannot be modified at all, so x = x + bonus can only build a new object and point the local name at it.

Rebinding versus mutating. The distinction is not "list versus int", it is "changing the object versus changing the name":

def replace(lst):
    lst = [1, 2, 3]
    print("Inside :", lst)

def modify(lst):
    lst[0] = 999
    print("Inside :", lst)

a = [10, 20, 30]
replace(a)
print("Outside:", a)

b = [10, 20, 30]
modify(b)
print("Outside:", b)

Output:

Inside : [1, 2, 3]
Outside: [10, 20, 30]
Inside : [999, 20, 30]
Outside: [999, 20, 30]

Both parameters are lists. replace pointed its local name at a different list and the caller's list was untouched. modify changed the shared list itself and the caller saw it. Remember it as: assignment moves the label, methods change the object.

WORKED EXAMPLE — a complete marksheet program. Three small functions, each doing one job, plus the statistics module you already know:

import statistics

def percentage(marks):
    """Return the average of a list of marks, rounded to 2 places."""
    return round(sum(marks) / len(marks), 2)

def grade(pct):
    """Return the CBSE-style grade for a percentage."""
    if pct >= 90:
        return "A1"
    elif pct >= 80:
        return "A2"
    elif pct >= 70:
        return "B1"
    elif pct >= 33:
        return "Pass"
    else:
        return "ER"

def report(name, marks):
    pct = percentage(marks)
    print(name.ljust(8), str(pct).rjust(6), grade(pct))

names = ["Ananya", "Rahul", "Fatima", "Vikram"]
sheet = [[92, 88, 95, 90, 91],
         [67, 72, 58, 80, 74],
         [45, 38, 51, 40, 47],
         [30, 25, 41, 28, 33]]

print("Name        Pct  Grade")
all_pct = []
for i in range(len(names)):
    report(names[i], sheet[i])
    all_pct.append(percentage(sheet[i]))

print("Class mean   :", round(statistics.mean(all_pct), 2))
print("Class median :", statistics.median(all_pct))
print("Topper       :", names[all_pct.index(max(all_pct))], max(all_pct))

Real output:

Name        Pct  Grade
Ananya     91.2 A1
Rahul      70.2 B1
Fatima     44.2 Pass
Vikram     31.4 ER
Class mean   : 59.25
Class median : 57.2
Topper       : Ananya 91.2

Look at what the layering bought. report calls percentage and grade but contains no arithmetic and no grade boundaries of its own. If the school changes the A1 cut-off to 91, you edit one line in grade and nothing else. If the average is wrong, there is exactly one function to check. That is the actual reason professional code is written in functions — not to save typing, but to shrink the area you have to search when something breaks.

The docstring is retrievable, which is how help() works for built-in functions too:

def percentage(marks):
    """Return the average of a list of marks, rounded to 2 places."""
    return round(sum(marks) / len(marks), 2)

print(percentage.__doc__)
print(type(percentage))

Output:

Return the average of a list of marks, rounded to 2 places.

Mistakes worth memorising now.

What Class 12 adds on top of this. Everything above is the foundation. Next year you will also meet functions that call themselves (recursion), functions used with files and databases, and the __name__ == '__main__' idiom. None of that makes sense without def, arguments, return and scope — so if the five sections on this page are comfortable, you are genuinely ahead.