Chapter 3: Functions

by

Scene: The Computer Lab – The “Copy-Paste” Crisis

Chaitanya is slumped over his keyboard, looking defeated. His screen is filled with hundreds of lines of identical code. Aditi Ma’am walks in, holding a steaming cup of tea. She glances at his screen and raises an eyebrow.

Aditi Ma’am: Chaitanya, you look like you’re doing manual labor. What is all this?

Chaitanya: I’m writing the code for the “School Annual Report.” Every time I need to print the school’s header—the name, address, and logo—I copy and paste these five lines of code.

Python

print('---------------------------')
print('   ST. PYTHON HIGH SCHOOL  ')
print('   123, Syntax Avenue      ')
print('   New Delhi, India        ')
print('---------------------------')

Chaitanya: But Ma’am, we have 50 students. I’ve pasted this block 50 times. My file is huge! And now the Principal wants to change the address to “124, Logic Lane.” I have to change it in 50 different places!

Aditi Ma’am: Stop. Delete it all. You are violating the Golden Rule of Programming: DRY (Don’t Repeat Yourself).

Chaitanya: But I need the header 50 times.

Aditi Ma’am: Then you need a Function. Think of a function as a “Mini-Program” within your program. Instead of rewriting the instructions every time, you give the instructions a name—like a shortcut—and you just call that name whenever you need it.

Defining Your First Function (def)

Aditi Ma’am: In the School System, think of a function as a Standard Operating Procedure (SOP) filed in the Principal’s office.

  1. Define it once: Write the instructions down and file them away.
  2. Call it many times: Just say “Execute SOP #1.”

Chaitanya: How do I write an SOP in Python?

Aditi Ma’am: We use the def statement. Let’s define a function called school_header().

Python

def school_header():
    print('---------------------------')
    print('   ST. PYTHON HIGH SCHOOL  ')
    print('   123, Syntax Avenue      ')
    print('---------------------------')

Aditi Ma’am: This is the Function Definition.

  • The def keyword tells Python: “I am defining a function.”
  • The name school_header is what we will call it later.
  • The parentheses () are empty for now (we’ll fill them later).
  • The colon : marks the start of the code block.
  • The indented lines are the Body of the function.

Chaitanya: I typed it in, but nothing happened. It didn’t print anything.

Aditi Ma’am: That’s because you only Defined it. You filed the SOP in the cabinet. You haven’t Called it yet. To make it run, you have to type its name with parentheses.

Python

school_header()
school_header()
school_header()

Chaitanya: Whoa! I wrote school_header() three times, and it printed the whole block three times.

Aditi Ma’am: Exactly. And if the Principal changes the address, you only update it in one place (the definition), and it updates everywhere instantly. That is the power of functions. They make your code Modular and Maintainable.Image of Python function flow diagram

Shutterstock

Parameters and Arguments (Passing Notes)

Chaitanya: That works great for the header because it’s the same for everyone. But what if I want to say “Hello, Chaitanya” to one student and “Hello, Rahul” to another? I can’t write a separate function for every single student!

Aditi Ma’am: No, you don’t. You make the function flexible by using Parameters. Think of a parameter as a “Fill-in-the-Blank” slot in your SOP form.

Chaitanya: So I leave a blank space for the name?

Aditi Ma’am: Yes. In the parentheses (), you define a variable that will catch the incoming data.

Python

def greet_student(name):
    print('Hello, ' + name + '!')
    print('Welcome to the computer lab.')

Aditi Ma’am: Here, name is the Parameter. It is a local variable that only exists inside this function. When you define the function, name has no value. It is waiting for one.

Chaitanya: How do I give it a value?

Aditi Ma’am: You provide it when you call the function. The value you send is called an Argument.

Python

greet_student('Chaitanya')
greet_student('Rahul')

Aditi Ma’am:

  1. When you call greet_student('Chaitanya'), the string 'Chaitanya' is assigned to the variable name.
  2. The function runs using name = 'Chaitanya'.
  3. When the function finishes, the variable name is destroyed (forgotten).

Chaitanya: Can I have more than one blank slot? Like Name and Grade?

Aditi Ma’am: Yes. Just separate them with commas.

Python

def report_card(name, grade):
    print('Student: ' + name)
    print('Grade: ' + str(grade))
    
report_card('Chaitanya', 95)

Chaitanya: Wait, what happens if I call it without an argument? report_card('Chaitanya')?

Aditi Ma’am: Python will throw a TypeError. It expects two arguments because you defined two parameters. It’s like submitting a form with a blank page—the system rejects it.

Return Values (The Report Card)

Chaitanya: Ma’am, print() just shows text on the screen. It’s like a loudspeaker. But what if I want the function to calculate a student’s final percentage and give it back to me so I can save it in the database?

Aditi Ma’am: For that, you need a Return Statement.

  • print() sends data to the User (the screen).
  • return sends data back to the Program (the code that called it).

Aditi Ma’am: Let’s write a function that calculates a “House Point” bonus. It doesn’t print the bonus; it returns it.

Python

import random

def get_bonus_points(house_name):
    if house_name == 'Red':
        return 50
    elif house_name == 'Blue':
        return 30
    elif house_name == 'Green':
        return 40
    else:
        return 10

Chaitanya: Okay, I typed it. Now what?

Aditi Ma’am: Now you call it and Store the result in a variable.

Python

my_points = get_bonus_points('Red')
print('Red House gets: ' + str(my_points))

Chaitanya: So get_bonus_points('Red') actually becomes the number 50?

Aditi Ma’am: Precisely! When the function hits the return keyword, it stops immediately and “turns into” that value.

  • The expression get_bonus_points('Red') evaluates to 50.
  • So the line becomes my_points = 50.

Aditi Ma’am: Think of it like a vending machine. You put in a coin (Argument), and the machine gives you a soda (Return Value). You don’t want the machine to just yell “SODA!” (Print)—you want it to give you the soda.

The None Value (The Empty Desk)

Chaitanya: What if I write a function that doesn’t have a return statement? Like my school_header() function?

Aditi Ma’am: In Python, every function returns something. If you don’t tell it what to return, it secretly returns a special value called None.

Chaitanya: Is None like zero?

Aditi Ma’am: No.

  • 0 is a number.
  • ' ' is an empty string.
  • False is a boolean.
  • None is a specific data type (NoneType) that means “Nothingness.” It represents the absence of a value.

Aditi Ma’am: In fact, print() itself returns None.

Python

>>> spam = print('Hello!')
Hello!
>>> print(spam)
None

Chaitanya: That’s weird. Why would I ever use None?

Aditi Ma’am: It is very useful as a default value. Imagine a variable winner. Before the Sports Day race starts, there is no winner. You can’t set it to ' ' (empty string) because that looks like a name. You set winner = None. Later, you can check:

Python

if winner == None:
    print('The race has not finished yet.')

Chaitanya: I see. It’s a placeholder.

Keyword Arguments and print() Tricks

Chaitanya: Ma’am, I noticed something annoying. print() always starts a new line.

Python

print('Hello')
print('World')

Output:

Hello
World

Chaitanya: Can I make it stop doing that? I want “Hello World” on one line, but from two different print statements.

Aditi Ma’am: Yes. You can change the default behavior using Keyword Arguments. The print() function has a hidden parameter called end. By default, it is set to \n (newline character). You can change it.

Python

print('Hello', end=' ')
print('World')

Output: Hello World

Aditi Ma’am: You replaced the newline with a space.

Chaitanya: What about separating items?

Python

print('cats', 'dogs', 'mice')

Output: cats dogs mice

Aditi Ma’am: You can use the sep keyword to change the separator.

Python

print('cats', 'dogs', 'mice', sep=',')

Output: cats,dogs,mice

Chaitanya: This is great for formatting CSV files!

Aditi Ma’am: Exactly. Now, Chaitanya, go take a break. When you come back, we will tackle the most confusing topic in this chapter: Scope (Local vs. Global Variables). That’s where things get tricky.

Scene: The “Black Box” Concept

Aditi Ma’am draws a large rectangle on the whiteboard. She labels it “FUNCTION.” Inside, she draws a smaller box.

Aditi Ma’am: Chaitanya, imagine a function is a sealed classroom with frosted glass windows. When you are inside that room, you can see the clock on the wall outside (Global). But the Principal standing in the hallway cannot see what you are writing in your notebook (Local). This concept is called Scope.

Chaitanya: Scope? You mean like a sniper scope?

Aditi Ma’am: I mean “Visibility.” In Python, variables are not always visible to every part of the program.

  1. Global Scope: Variables created outside of all functions. (The Hallway).
  2. Local Scope: Variables created inside a function. (The Classroom).

Chaitanya: Why does this matter? Can’t I just make everything Global?

Aditi Ma’am: If you do that, your program becomes a mess. Imagine if every student in the school wrote their grades on the main notice board in the hallway. If two students named “Rahul” wrote “Math: 90,” how would we know which Rahul it refers to? Scopes keep data organized and private.

The Four Rules of Scope

Aditi Ma’am: There are four absolute laws of Scope in Python. Let’s test them.

Rule 1: Local Variables Cannot Be Used in the Global Scope

Aditi Ma’am: I want you to write a function that defines a variable inside it, and then try to print that variable from outside.

Chaitanya: Easy.

Python

def spam():
    eggs = 31337  # This is Local
    
spam()
print(eggs)

Chaitanya: (Runs code) Hey! It gave me a NameError: name 'eggs' is not defined. But I defined it right there!

Aditi Ma’am: You defined it inside spam(). That variable eggs only exists while spam() is running. The moment the function finishes, the “Classroom” is cleaned, and eggs is destroyed. The Global scope (the main program) has no idea what eggs is.

Rule 2: Local Scopes Cannot Use Variables in Other Local Scopes

Aditi Ma’am: Now, create two functions: spam() and bacon(). Try to use a variable from spam inside bacon.

Python

def spam():
    eggs = 99
    bacon()
    print(eggs)

def bacon():
    ham = 101
    eggs = 0  # A different 'eggs'
    
spam()

Chaitanya: Wait. spam() sets eggs to 99. Then it calls bacon(), which sets eggs to 0. So when spam() prints eggs at the end, it should print 0, right?

Aditi Ma’am: Run it.

Output: 99

Chaitanya: What? Why didn’t bacon() change it?

Aditi Ma’am: Because bacon() has its own local scope. The eggs inside bacon() is a completely different variable from the eggs inside spam(). It’s like two different students in two different classrooms both having a notebook labeled “Math.” Writing in one notebook doesn’t change what’s written in the other.

Rule 3: Global Variables Can Be Read from a Local Scope

Aditi Ma’am: Now, define a variable outside the function and try to print it inside.

Python

def spam():
    print(eggs)

eggs = 42
spam()

Output: 42

Chaitanya: That worked!

Aditi Ma’am: Yes. Because there was no local variable named eggs, Python looked “out the window” to the Global scope, found eggs, and used it.

Rule 4: The “Shadowing” Problem (Local and Global with the Same Name)

Aditi Ma’am: This is where it gets dangerous, Chaitanya. You are allowed to have a Local variable with the exact same name as a Global variable.

Chaitanya: Won’t Python get confused?

Aditi Ma’am: No. Python follows a strict hierarchy: Local First. If a local variable exists, Python uses it. If not, it looks Global.

Python

def spam():
    eggs = 'spam local'
    print(eggs)    # Prints 'spam local'

def bacon():
    eggs = 'bacon local'
    print(eggs)    # Prints 'bacon local'
    spam()
    print(eggs)    # Prints 'bacon local'

eggs = 'global'
bacon()
print(eggs)        # Prints 'global'

Chaitanya: My head hurts. There are three eggs?

Aditi Ma’am: Yes.

  1. One in spam‘s classroom.
  2. One in bacon‘s classroom.
  3. One in the Global hallway. Aditi’s Advice: Avoid using the same name for different variables. It’s technically legal, but it’s bad practice. Just name them local_eggs and global_eggs to save your sanity.

The global Statement

Chaitanya: Ma’am, what if I want to change a Global variable from inside a function? Say I have a variable student_count and I want a function new_admission() to increase it?

Aditi Ma’am: If you just write student_count = student_count + 1 inside the function, Python will think you are trying to create a new local variable. To tell Python “I mean the global one,” you use the global statement.

Python

def spam():
    global eggs
    eggs = 'spam'

eggs = 'global'
spam()
print(eggs)

Output: spam

Aditi Ma’am: See? Because we wrote global eggs at the top of the function, Python knew that eggs = 'spam' was an assignment to the Global variable, not a new local one.

Exception Handling (The Safety Net)

Aditi Ma’am: Let’s switch gears. Write a program that calculates the average marks for a student.

Chaitanya: Simple math.

Python

def average(total_marks, subject_count):
    return total_marks / subject_count

print(average(400, 5))
print(average(200, 0))

Aditi Ma’am: Run it.

Output:

80.0
Traceback (most recent call last):
  File "grades.py", line 4, in <module>
    print(average(200, 0))
  File "grades.py", line 2, in average
    return total_marks / subject_count
ZeroDivisionError: division by zero

Chaitanya: It crashed! “ZeroDivisionError.”

Aditi Ma’am: In a real School System, if a data entry operator accidentally enters 0 for subjects, we don’t want the entire server to crash. We want to catch the error and handle it gracefully. We use try and except.

Chaitanya: Like “Try to do this, but if you fail…”?

Aditi Ma’am: Exactly.

Python

def average(total_marks, subject_count):
    try:
        return total_marks / subject_count
    except ZeroDivisionError:
        print('Error: Invalid Subject Count.')
        return None  # Return something safe

print(average(200, 0))
print(average(300, 3))

Output:

Error: Invalid Subject Count.
None
100.0

Aditi Ma’am: Notice that the program didn’t stop? It printed the error message for the bad data, but then it continued to the next line and calculated the average for 300/3 correctly.

Chaitanya: So except is like a backup generator?

Aditi Ma’am: It’s an error handler. You can catch specific errors like ZeroDivisionError, ValueError (if someone types text instead of numbers), or just catch everything.

A Short Program: The Zigzag

Aditi Ma’am: To wrap up Chapter 3, let’s build something visual. We will use functions, loops, and the time module to create a “Zigzag” animation.

Chaitanya: Is this for the school?

Aditi Ma’am: No, this is for fun. But it demonstrates how a while loop interacts with if/else logic to create animation.

Python

import time, sys
indent = 0 # How many spaces to indent.
indentIncreasing = True # Whether the indentation is increasing or not.

try:
    while True: # The main program loop.
        print(' ' * indent, end='')
        print('********')
        time.sleep(0.1) # Pause for 1/10 of a second.

        if indentIncreasing:
            # Increase the number of spaces:
            indent = indent + 1
            if indent == 20:
                # Change direction:
                indentIncreasing = False
        else:
            # Decrease the number of spaces:
            indent = indent - 1
            if indent == 0:
                # Change direction:
                indentIncreasing = True

except KeyboardInterrupt:
    sys.exit()

Aditi Ma’am:

  • time.sleep(0.1): This slows the program down so your eyes can follow it.
  • indentIncreasing: This boolean variable acts as a “Switch.” When it hits 20 spaces, the switch flips to False, and the zigzag starts moving left. When it hits 0, it flips back to True.
  • KeyboardInterrupt: This catches the error when you press Ctrl+C to stop the program, so it exits cleanly without showing a messy traceback.

Chaitanya: (Watching the screen) It’s mesmerizing.

Aditi Ma’am: That is the power of a simple loop and a little bit of logic. Now, pack up. Tomorrow we start Chapter 4: Lists. You’re going to need them, because your variables are about to get out of control.

Leave a Comment

💬 Join Telegram