Functions

A function is a named block of code that you write or obtain once and then run many times just by using its name. Python gives you three kinds. The board asks you to name all three, so learn the labels and not merely the idea.

1. Built-in functions — supplied by Python itself and available the moment the program starts. No import needed. Examples: len(), max(), min(), sum(), round(), type(), int(), print(), input().
2. Functions defined in a module — they live in a module, which is a library of ready-made code kept outside your program. You must import the module first, then reach the function through the module name. Examples: math.sqrt(), random.randint(), statistics.mean().
3. User-defined functions — the ones you write yourself with def. Everything from the next section onwards is about these.

Every module on this syllabus comes bundled with Python, so there is nothing to install. Where a module physically sits varies and does not matter to you: statistics and random are ordinary .py files in Python’s library folder, while math has no .py file at all because it is compiled into the interpreter itself. The distinction that does matter is simpler — did you have to import it, and did you write it?

Built-in functions first. Note that type() is itself listed among Python’s built-in functions, and it reports what something is.

marks = [78, 92, 65, 88, 55]
print(len(marks))
print(max(marks))
print(min(marks))
print(sum(marks))
print(round(sum(marks) / len(marks), 2))
print(type(marks))

Output:

5
92
55
378
75.6

Now module functions. The random.seed(7) line is there only so that the number printed below is the same one you will get; remove it and randint gives a fresh value on every run.

import math
import random

print(math.sqrt(144))
print(math.floor(87.9), math.ceil(87.1))
print(math.pow(2, 10))

random.seed(7)
print(random.randint(1, 6))

Output:

12.0
87 88
1024.0
3

Two things worth noticing. First, math.sqrt(144) gives 12.0 and not 12, because sqrt and pow hand back floats. Do not turn that into a rule about the whole module, though: math.floor and math.ceil return plain integers, which is exactly why the second line of output reads 87 88 rather than 87.0 88.0. The same is true of math.factorial and math.gcd. Check the one function you are using rather than assuming.

Second, forgetting the import does not produce any special “module missing” error. As far as the program is concerned the name math was simply never created, so you get an ordinary NameError:

print(math.sqrt(144))

Output:

NameError: name 'math' is not defined. Did you forget to import 'math'?

That second sentence is a hint Python 3.12 and later attach to the error. On an older lab machine you will see only NameError: name 'math' is not defined, and that shorter form is what an exam answer should give. Keep it separate in your mind from ModuleNotFoundError: No module named 'xyz', which is what happens when you do write an import but name a module that does not exist.

Finally, a user-defined function. GST at 18% on a purchase of Rs 1200:

def gst_amount(price, rate):
    return price * rate / 100

print(gst_amount(1200, 18))
print(gst_amount(45000, 5))

Output:

216.0
2250.0

One warning before you leave this section, because it is a trap students fall into. type() tells you what kind of object a name holds, but it is not a test of which of the three categories a function belongs to:

import builtins
import math
import statistics

def gst_amount(price, rate):
    return price * rate / 100

print(type(len))
print(type(math.sqrt))
print(type(statistics.mean))
print(type(gst_amount))
print(len(dir(builtins)))

Output:

160

len and math.sqrt both report builtin_function_or_method because both are written in C. But statistics.mean reports function — identical to the gst_amount you wrote yourself — because the statistics module is itself written in ordinary Python. So type() is telling you what language a function was written in, not whether it is built-in, imported or yours. Classify by the table instead.

That last line counts the names Python hands you for free in this version (Python 3.13). The exact figure changes between versions, so never memorise it — the point is that the built-in namespace is a fixed, modest list, and everything else you must either import or write.

Worked example — all three types in one program

A CGPA helper for a Class 12 marksheet: built-ins do the counting, two module functions do the arithmetic, and one function of your own holds the rule that is specific to your school.

import math
import statistics

def cgpa(marks):
    return round(statistics.mean(marks) / 9.5, 2)

marks = [88, 92, 76, 95, 84]

print("count   :", len(marks))
print("highest :", max(marks))
print("mean    :", statistics.mean(marks))
print("sqrt sum:", math.sqrt(sum(marks)))
print("cgpa    :", cgpa(marks))

Output:

count   : 5
highest : 95
mean    : 87
sqrt sum: 20.85665361461421
cgpa    : 9.16

The mean prints as 87 and not 87.0 because the five marks add up to 435, which divides exactly by 5, and statistics.mean keeps an exact whole answer as an int. Look also at what cgpa() does inside its own body: it calls a module function and a built-in. Functions calling other functions is completely normal, and understanding the exact order in which that happens is the subject of the next section.

The syntax has five parts and every one of them is examinable.

def function_name(parameters):
    """Optional docstring saying what it returns."""
    statements
    return value

• def is the keyword that begins a definition.
• The name follows the same rules as a variable name: letters, digits and underscores, not starting with a digit, and not a Python keyword.
• The brackets are compulsory even when there are no parameters, as in def start():.
• The colon at the end of the header is compulsory.
• The body must be indented — four spaces is the convention — and every line of the body must be indented by the same amount.

The single most important idea in this whole chapter: the def statement does not run the body. It only creates the function and attaches the name to it. The body runs later, and only when you call the function with brackets. You can watch this happen.

print("before def")

def greet(name):
    print("inside greet, name =", name)

print("after def")
greet("Ananya")
print("after call")

Output:

before def
after def
inside greet, name = Ananya
after call

Read that output carefully. after def appears before anything from inside greet. Python walked past the whole definition without executing a single line of the body. Only the call on the next line made the body run.

Flow of execution

Flow of execution simply means the order in which statements actually run. Without functions it is top to bottom. A function call changes it in a very specific way: control jumps into the function body, runs it to the end or to a return, and then comes back to the exact point immediately after the call. The caller waits the whole time — nothing runs in parallel.

Rather than take that on trust, number the print statements and read the order off the screen.

def fees(base):
    print("  2. fees starts, base =", base)
    t = tax(base)
    print("  5. back in fees, tax =", t)
    return base + t

def tax(amount):
    print("    3. tax starts")
    print("    4. tax returns")
    return amount * 0.18

print("1. main starts")
total = fees(10000)
print("6. main got", total)

Output:

1. main starts
  2. fees starts, base = 10000
    3. tax starts
    4. tax returns
  5. back in fees, tax = 1800.0
6. main got 11800.0

The numbers came out in order 1 to 6, and the indentation of the output shows the depth. Step 5 is the proof that matters: after tax finished, control did not restart fees from the top and did not jump to the end of the program — it resumed at the very next line inside fees.

The one ordering rule you must respect

Because def is a statement that has to execute before the name exists, calling a function above its definition fails:

print(mystery(3))

def mystery(x):
    return x * x

Output:

NameError: name 'mystery' is not defined

But a function may call another function that is defined below it, because the body is not executed at definition time — by the time the body actually runs, both def statements have finished. That is precisely why fees above was allowed to call tax:

def outer():
    return helper() * 2

def helper():
    return 21

print(outer())

Output:

42

Worked example — the docstring and return ending a function

The first string in a function body is its docstring; Python stores it and you can read it back. And return does not merely hand back a value, it ends the function on the spot.

def area_rect(l, b):
    """Return area of a rectangle with length l and breadth b."""
    return l * b

def check(n):
    if n > 0:
        return "positive"
    print("this line runs only for n <= 0")
    return "not positive"

print(area_rect(12, 5))
print(area_rect.__doc__)
print(area_rect.__name__)
print(check(5))
print(check(-5))

Output:

60
Return area of a rectangle with length l and breadth b.
area_rect
positive
this line runs only for n <= 0
not positive

For check(5) the print line never ran at all — the return inside the if ended the function immediately. For check(-5) the condition was false, so control fell through to the print and then to the second return. A function with no docstring has __doc__ equal to None.

Two words that the board treats as a definition question. A parameter (also called a formal parameter) is the name written in the def header. An argument (also called an actual parameter) is the value you supply at the call. In def interest(p, r, t) the names p, r and t are parameters; in the call interest(50000, 8.5, 3) the numbers are the arguments.

Positional arguments

By default, arguments are matched to parameters strictly left to right. Get the order wrong and Python cannot help you, because nothing is illegal — you simply get a wrong answer, which is far more dangerous than an error.

def scored(got, total):
    return round(got / total * 100, 2)

print(scored(72, 80))
print(scored(80, 72))

Output:

90.0
111.11

A student scoring 72 out of 80 got 90%. Swapping the two arguments claims 111.11% and Python reports no problem at all.

Keyword arguments

Naming the arguments at the call makes the order irrelevant, and makes the call readable:

print(scored(total=80, got=72))
print(scored(72, total=80))

Output:

90.0
90.0

You may mix the two, but every positional argument must come before every keyword argument. Writing scored(got=72, 80) is a SyntaxError: positional argument follows keyword argument. Supplying the same parameter twice, as in scored(72, got=72), gives TypeError: scored() got multiple values for argument 'got'.

Supplying the wrong count is also an error, and the message names the missing parameter:

scored(72)

Output:

TypeError: scored() missing 1 required positional argument: 'total'

Default parameters

Give a parameter a value in the header and it becomes optional at the call. This is how you encode the common case — GST is usually 18%, discount is usually zero — without forcing the caller to repeat it.

def bill(amount, gst=18, discount=0):
    net = amount - discount
    return round(net + net * gst / 100, 2)

print(bill(1000))
print(bill(1000, 5))
print(bill(1000, discount=100))
print(bill(1000, 12, 200))

Output:

1180.0
1050.0
1062.0
896.0

The third call is the reason keyword arguments matter: to change discount while leaving gst alone, you must name it, since positionally the second slot belongs to gst.

All default parameters must come after all non-default ones. Python cannot allow otherwise, because it would then be unable to decide which parameter a lone positional argument belongs to:

def f(a=1, b):
    return a + b

Output:

SyntaxError: parameter without a default follows parameter with a default

This is a SyntaxError, caught when the file is compiled, so the program never runs at all — not a TypeError raised at call time. Board papers test that distinction.

Worked example — the mutable default trap

This is the subtlest thing in the chapter and it is worth the effort. A default value is evaluated once, at the instant the def line executes — not afresh on each call. For a number or a string that makes no visible difference. For a list it changes everything, because every call shares the same list object.

def add_marks(mark, sheet=[]):
    sheet.append(mark)
    return sheet

print(add_marks(78))
print(add_marks(92))
print(add_marks(65))
print(add_marks.__defaults__)

Output:

[78]
[78, 92]
[78, 92, 65]
([78, 92, 65],)

Each call was supposed to start with an empty sheet, and instead the function is quietly accumulating marks across calls. The last line shows why: __defaults__ holds the actual default object, and that one list has been growing all along. The fix is to use None as the default and build a fresh list inside the body:

def add_marks_safe(mark, sheet=None):
    if sheet is None:
        sheet = []
    sheet.append(mark)
    return sheet

print(add_marks_safe(78))
print(add_marks_safe(92))
print(add_marks_safe(65))

Output:

[78]
[92]
[65]

The same once-only rule shows up with an ordinary variable too. Changing the variable after the def does not change the default that was already captured:

step = 10

def jump(n, by=step):
    return n + by

step = 1000
print(jump(5))
print(jump(5, step))

Output:

15
1005

jump(5) still adds 10, because the default was fixed at 10 when the def ran. Only the explicit argument sees the new value of 1000.

print and return are not alternatives and confusing them costs marks every year. print writes characters to the screen for a human to read. return hands a value back to the calling code so the program can store it, test it or calculate with it. Only return produces something the rest of the program can use.

def show_total(a, b):
    print(a + b)

def give_total(a, b):
    return a + b

x = show_total(40, 60)
y = give_total(40, 60)
print("x =", x)
print("y =", y)
print(type(x), type(y))

Output:

100
x = None
y = 100
 

Both functions computed 100. The first one showed it and threw it away, so x is None. The second one handed it back, so y is genuinely the integer 100.

That None is not harmless — the moment you try to calculate with it, the program stops:

print(show_total(40, 60) + 1)

Output:

100
TypeError: unsupported operand type(s) for +: 'NoneType' and 'int'

Notice the 100 still printed first — the function ran, printed, and then returned None, and the addition is what failed. When you see NoneType in an error message, look for a function that forgot to return.

Three ways to end up with None

def a1():
    return

def a2():
    pass

def a3(n):
    if n > 0:
        return "pos"

print(a1(), a2(), a3(5), a3(-5))

Output:

None None pos None

A bare return, falling off the end of the body, and a return that sits in only one branch of an if. The third is the dangerous one, because it works for some inputs and silently returns None for the rest. Always ask what your function gives back when the condition is false.

Returning more than one value

Write several expressions after return, separated by commas. Python does not literally return three things — it packs them into one tuple and returns that.

def stats(marks):
    return max(marks), min(marks), round(sum(marks) / len(marks), 2)

result = stats([78, 92, 65, 88, 55])
print(result)
print(type(result))

high, low, avg = stats([78, 92, 65, 88, 55])
print("high =", high, "low =", low, "avg =", avg)

Output:

(92, 55, 75.6)

high = 92 low = 55 avg = 75.6

You may catch the tuple whole and index it as result[0], or unpack it into separate names as shown. If you unpack, the count of names must match the count of values exactly — and the two ways of getting it wrong give two different messages, so quote whichever one the question actually produces. Too few names:

p, q = stats([1, 2, 3])

Output:

ValueError: too many values to unpack (expected 2)

Too many names:

p, q, r, s = stats([1, 2, 3])

Output:

ValueError: not enough values to unpack (expected 4, got 3)

To return a list instead of a tuple, build a list explicitly with square brackets — or return something that is already a list, as split() does:

def split_name(full):
    return full.split()

print(split_name("Ananya Sharma Iyer"))
print(type(split_name("Ananya Sharma Iyer")))

Output:

['Ananya', 'Sharma', 'Iyer']

Worked example — return ends everything, including a loop

A return inside a loop does not just break the loop; it ends the entire function. Here is a check for the first failing subject in a marksheet, with a trace so you can see how far the loop actually got.

def first_fail(marks):
    for i, m in enumerate(marks):
        print("  checking", m)
        if m < 33:
            return i
    return -1

print(first_fail([78, 45, 20, 90]))

Output:

  checking 78
  checking 45
  checking 20
2

The 90 was never examined and the final return -1 was never reached. The function stopped the instant it found 20 and reported its index, 2. That trailing return -1 still matters though: it is what runs when no subject fails, and without it the function would return None for a fully passing marksheet — exactly the trap from earlier in this section.

The scope of a variable is the region of the program in which its name is usable. Python gives you two that this syllabus cares about.

• Local scope — a name created by an assignment inside a function, including its parameters. It exists only while that call is running.
• Global scope — a name assigned at the top level of the file, outside every function. It exists for the whole run of the program.

A local name genuinely disappears when the function ends:

def f():
    inside = 99
    print("inside f:", inside)

f()
print(inside)

Output:

inside f: 99
NameError: name 'inside' is not defined

Reading a global is allowed; assigning is a different matter

Inside a function you may read a global variable with no ceremony at all:

school = "Kendriya Vidyalaya"

def who():
    print("reading global:", school)

who()

Output:

reading global: Kendriya Vidyalaya

But the moment you assign to a name inside a function, Python treats that name as a brand-new local variable, and the global of the same name is left completely untouched:

count = 10

def bump():
    count = 999
    print("inside bump, count =", count)

bump()
print("outside, count =", count)

Output:

inside bump, count = 999
outside, count = 10

UnboundLocalError — the error this rule creates

Here is the part that catches everybody. Python decides whether a name is local or global by scanning the entire function body before running any of it. If the name is assigned anywhere in the function, it is local everywhere in that function — including on lines above the assignment.

total = 100

def add_gst():
    total = total + 18
    return total

print(add_gst())

Output:

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

The assignment on the left makes total local. So the total on the right is the local one too — and it has no value yet. Python is not reading the global 100 at all.

To see that the whole body is scanned in advance, put the read on a line strictly before the assignment. It still fails:

price = 500

def show():
    print(price)
    price = 1

show()

Output:

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

The print comes first in the text and would have worked on its own. It is the assignment on the next line that retroactively makes price local for the whole function.

The global keyword, and why it is usually the wrong fix

Declaring global name at the top of the function tells Python that assignments to that name should affect the global variable instead of creating a local one:

counter = 0

def hit():
    global counter
    counter = counter + 1

hit()
hit()
hit()
print("counter =", counter)

Output:

counter = 3

The declaration must come before any use of that name in the function; writing global counter after a line that already reads counter is a SyntaxError: name 'counter' is used prior to global declaration.

It works, and you must know it for the exam. But reach for it last, because a function that edits globals can no longer be read on its own — to know what hit() does you must also know the state of the rest of the file, and any other function may have changed counter in between. The alternative is almost always better: take the value in as a parameter, send the answer back with return, and let the caller decide what to store.

def add_gst_clean(amount, rate=18):
    return amount + amount * rate / 100

total = 100
total = add_gst_clean(total)
print("total =", total)

Output:

total = 118.0

This version has no hidden dependencies. Give it 100 and it returns 118.0, every time, regardless of what the rest of the program is doing.

Worked example — mutating a global is not the same as rebinding it

This distinction decides whether you need global at all. Changing the contents of a global list is not an assignment to the name, so no keyword is needed. Pointing the name at a new list is an assignment, so it creates a local.

scores = [10, 20]

def push(v):
    scores.append(v)

def replace():
    scores = [0]
    print("  inside replace:", scores)

push(30)
print("scores =", scores)
replace()
print("scores after replace =", scores)

Output:

scores = [10, 20, 30]
  inside replace: [0]
scores after replace = [10, 20, 30]

push changed the global list without any global declaration, because append modifies the existing object. replace changed nothing outside itself, because = merely created a local name that died with the call.

One last hazard: built-in names live in their own outer scope, and a global of the same name hides them for the rest of the program.

marks = [1, 2, 3]
print(len(marks))
len = 5
print(len(marks))

Output:

3
TypeError: 'int' object is not callable

Never name a variable len, list, sum, max, str or type. The error appears far away from the line that caused it, which makes it painful to find. Doing the same thing inside a function is less damaging, because the shadowing name is local and dies with the call — but it still breaks the built-in for the rest of that function.