For the SMIS system extended in Chapter 6 let us do the following: 7.1 Convert all the functionality in Chapte

Case Study-based Question · Q1

Q. For the SMIS system extended in Chapter 6 let us do the following: 7.1 Convert all the functionality in Chapter 5 and 6 using user defined functions.

Uttarakhand UbseTextbookSubjective· 5mImportance★★★★★est

70% · 28/40 Questions

✓ Free question

Concept understanding — User Defined Functions

User Defined Functions: The Intuition

Imagine you're cooking a dish. You follow a recipe: chop onions, sauté them, add spices, cook for ten minutes. Now imagine you need to make that same dish three times in a week. Would you rewrite the entire recipe each time? No — you'd just say "make the dish" and everyone knows what that means.

A function in programming is exactly that: a named recipe. You write the steps once, give it a name, and then call it by name whenever you need it.

But here's the key insight: a function is not just a shortcut. It's a way to give a name to a process — to turn a sequence of actions into a single, reusable idea. When you write print("Hello"), you're not thinking about how the computer sends characters to the screen. You're thinking "print this message." That's the power of abstraction.

The Precise Statement

A user-defined function is a block of reusable code that:

Has a name you choose
Takes inputs (called parameters or arguments) — possibly zero
Performs a specific task
Optionally returns a result

The syntax in Python looks like this:

def function_name(parameter1, parameter2):
    """Optional docstring explaining what this does"""
    # body of the function
    result = parameter1 + parameter2
    return result

Important

The def keyword tells Python "I am defining a function now." Everything indented under it is the function's body — the recipe steps. The return statement sends a value back to where the function was called.

Why "User Defined"?

The phrase "user defined" distinguishes these from built-in functions like print(), len(), or max() that Python already knows. You, the user, are defining new ones because the built-in ones don't do exactly what you need.

A Concrete Example

Suppose you need to calculate the area of a circle many times. Instead of writing 3.14 * radius * radius everywhere:

def circle_area(radius):
    """Returns area of a circle given its radius"""
    pi = 3.14159
    area = pi * radius ** 2
    return area

# Now use it:
area1 = circle_area(5)    # 78.53975
area2 = circle_area(10)   # 314.159

The function circle_area encapsulates the formula. If you later need more precision for pi, you change it in one place, not everywhere.

Note

The variable radius inside the function is a parameter — it's a placeholder. When you call circle_area(5), the value 5 gets assigned to radius inside the function. This is called passing an argument.

The Two Key Ideas

Abstraction: You don't need to know how the function works to use it. You just need to know what it does and what inputs it expects. This is why you can use print() without understanding screen drivers.

Reusability: Write once, use many times. Change the implementation in one place, and every call automatically uses the new version.

Common Mistake to Avoid

def add(a, b):
    result = a + b
    # Missing return statement!

x = add(3, 4)
print(x)  # Prints None, not 7

Watch out

If a function doesn't have a return statement, it returns None by default. The function still runs and does its work, but it doesn't send a value back. If you need a result, you must explicitly return it.

The Big Picture

Functions are the fundamental building block of organized code. They let you:

Break a complex problem into smaller, manageable pieces
Give meaningful names to operations
Avoid repeating yourself
Test and debug parts of your program independently

Every program you'll ever write — from a simple calculator to a web server — is built from functions calling other functions, each doing one thing well.

Refactor the SMIS menu program of Chapters 5–6 so each menu action becomes a user-defined function — input, computation and display are separated and the menu loop only dispatches calls.

def getStudentData():
    rec = {"rollno": int(input("Roll number: ")), "name": input("Name: ")}
    rec["marks"] = [float(input("Marks in subject " + str(i) + ": ")) for i in range(1, 6)]
    return rec

def percentage(marks):
    return sum(marks) / len(marks)

def grade(per):
    if per >= 90: return "A"
    elif per >= 75: return "B"
    elif per >= 60: return "C"
    elif per >= 40: return "D"
    else: return "E"

def displayStudent(rec):
    per = percentage(rec["marks"])
    print(rec["rollno"], rec["name"], "| %:", round(per, 2), "| Grade:", grade(per))

A while True menu then calls getStudentData() / displayStudent() per the user's choice. Same behaviour as before, but each feature is now reusable and testable on its own.

✓Final answer

Every Chapter 5-6 feature (accept details, compute percentage, grade, display report) becomes its own user-defined function, and the menu loop simply calls them — identical functionality, modular structure.

Take the monolithic SMIS menu code built in Chapters 5–6 and wrap each piece of functionality (input student data, compute percentage, assign grade, display report) in its own user-defined function, leaving the menu loop as a thin dispatcher.

The idea. Chapters 5 and 6 built the Student Management Information System as straight-line code with if ladders and loops. Chapter 7's lesson is modularity: each task becomes a named, reusable function — easier to read, test, and extend (which Question 7.2 immediately exploits by adding one more function).

A model refactoring (a worked example of the conversion — your own SMIS may have slightly different fields, the structure is what matters):

# SMIS - Student Management Information System (functions version)

def getStudentData():
    """Accept one student's details and return them as a dictionary."""
    record = {}
    record["rollno"] = int(input("Enter roll number: "))
    record["name"] = input("Enter name: ")
    record["marks"] = []
    for i in range(1, 6):
        m = float(input("Enter marks in subject " + str(i) + ": "))
        record["marks"].append(m)
    return record

def percentage(marks):
    """Return the percentage for a list of marks (each out of 100)."""
    return sum(marks) / len(marks)

def grade(per):
    """Return the grade for a percentage."""
    if per >= 90:
        return "A"
    elif per >= 75:
        return "B"
    elif per >= 60:
        return "C"
    elif per >= 40:
        return "D"
    else:
        return "E"

def displayStudent(record):
    """Display the report card for one student."""
    per = percentage(record["marks"])
    print("Roll No   :", record["rollno"])
    print("Name      :", record["name"])
    print("Marks     :", record["marks"])
    print("Percentage:", round(per, 2))
    print("Grade     :", grade(per))

def menu():
    record = None
    while True:
        print()
        print("--- SMIS MENU ---")
        print("1. Enter student data")
        print("2. Display report card")
        print("3. Exit")
        choice = int(input("Enter your choice: "))
        if choice == 1:
            record = getStudentData()
        elif choice == 2:
            if record is None:
                print("No data yet - choose option 1 first.")
            else:
                displayStudent(record)
        elif choice == 3:
            print("Goodbye!")
            break
        else:
            print("Invalid choice, please try again.")

menu()

Expected output — sample run:

--- SMIS MENU ---
1. Enter student data
2. Display report card
3. Exit
Enter your choice: 1
Enter roll number: 12
Enter name: Asha
Enter marks in subject 1: 92
Enter marks in subject 2: 85
Enter marks in subject 3: 78
Enter marks in subject 4: 88
Enter marks in subject 5: 90

--- SMIS MENU ---
1. Enter student data
2. Display report card
3. Exit
Enter your choice: 2
Roll No   : 12
Name      : Asha
Marks     : [92.0, 85.0, 78.0, 88.0, 90.0]
Percentage: 86.6
Grade     : B

--- SMIS MENU ---
1. Enter student data
2. Display report card
3. Exit
Enter your choice: 3
Goodbye!

Why this is better than the Chapter 5–6 version

Each function does one job (single responsibility) and can be tested alone — e.g. grade(86.6) → "B".
percentage()/grade() return values instead of printing, so other features (like the attendance check added next in 7.2) can reuse them.
The menu loop shrinks to a readable dispatcher.

✓Final answer

The SMIS functionality of Chapters 5-6 is converted into user-defined functions — getStudentData(), percentage(), grade(), displayStudent() — driven by a menu() loop; behaviour is unchanged but the program is now modular and extensible.

←Previous questionQ8 — Write a program that creates a GK quiz consisting of any five question…→Next questionQ2 — For the SMIS system extended in Chapter 6 let us do the following: 7.2…

Q.For the SMIS system extended in Chapter 6 let us do the following: 7.1 Convert all the functionality in Chapter 5 and 6 using user defined functions.

🎓Unlock everything free for 14 days

Q.For the SMIS system extended in Chapter 6 let us do the following:
7.1 Convert all the functionality in Chapter 5 and 6 using user defined functions.

Unlock everything free for 14 days