Python Fundamentals

What Python is, how a program runs, and how to write your very first lines of code — starting from absolutely nothing.

1.1 What is Python?

Concept. Python is a programming language — a set of words and rules you use to give instructions to a computer. You write the instructions in plain-ish English-like text, and Python carries them out one line at a time.

Simple explanation. Think of the computer as a very fast but very literal helper. It will do exactly what you say, in the order you say it, and nothing more. Python is the language you use to talk to that helper.

Python is interpreted (it runs your code line by line, not all at once after translating), high-level (close to human language, far from machine 0s and 1s), and dynamically typed (you don't have to announce in advance whether something is a number or text).

1.2 How a Python program runs

When you run a Python file, the Python interpreter reads your code from top to bottom and executes each statement in order. This top-to-bottom order is called the flow of control, and it's the foundation of everything later (conditions and loops just change this flow).

1.3 Your first program

Syntax — the print function displays something on the screen:

print("text you want to show")

Example.

# My first Python program
print("Hello, CBSE!")
print("I am learning Python.")

Line-by-line explanation

1.4 Comments & indentation

Comments start with #. Everything after # on that line is ignored. Use them to explain why your code does something.

Indentation (the spaces at the start of a line) is not decoration in Python — it is grammar. Python uses indentation to know which lines belong together. You'll see this the moment you reach if and loops.

1.5 Quick Quiz

1.6 What did you learn?

1.7 CBSE-style questions

1.8 Challenge

print("CBSE", 2026)
print("Marks:", 70 + 30)

Variables & Data Types

How Python stores information in memory, the built-in data types you must know for boards, and the mutable-vs-immutable idea that trips up half of all students.

2.1 What is a variable?

Concept. A variable is a name that refers to a value stored in the computer's memory. You "assign" a value to a name using =.

Syntax

variable_name = value

Example

name = "Ahana"
age = 17
marks = 95.5
print(name, age, marks)

Line-by-line

2.2 Rules for naming variables (identifiers)

2.3 Core data types (must know for boards)

You can check any value's type with the built-in type() function:

print(type(70))
print(type(95.5))
print(type("CBSE"))
print(type(True))

2.4 Mutable vs Immutable — the big idea

Concept. Mutable means "can be changed after it is created." Immutable means "cannot be changed — any 'change' actually makes a new object."

# List is mutable — item changes in place
marks = [90, 80, 70]
marks[0] = 100
print(marks)

# String is immutable — this line ERRORS
name = "CBSE"
# name[0] = "X"  ->  TypeError

2.5 Type conversion

Convert between types with int(), float(), str(). This matters hugely for input(), which always returns a string.

a = "25"          # a is a STRING
b = int(a)         # now an INTEGER
print(b + 5)         # 30
print(str(b) + "5")  # "255" (string joining)

2.6 Quick Quiz

2.7 Output prediction (mini-set)

2.8 Debugging drill

1marks = 50
print(1marks)

2.9 What did you learn?

2.10 CBSE-style questions

Operators

The symbols that make Python do things — arithmetic, comparison, logic, assignment — plus the operator-precedence rules that decide output-prediction questions.

3.1 What is an operator?

Concept. An operator is a symbol that performs an operation on values. The values it works on are called operands. In 7 + 3, the + is the operator and 7 and 3 are operands.

3.2 Arithmetic operators

a = 17
print(a / 5)   # 3.4
print(a // 5)  # 3
print(a % 5)   # 2
print(a ** 2)  # 289

3.3 Relational (comparison) operators

These compare two values and always give a Boolean (True/False).

3.4 Logical operators

Combine Boolean conditions: and, or, not.

3.5 Assignment operators

Shorthand that updates a variable using its own current value.

3.6 Operator precedence (who goes first)

When several operators appear together, Python follows a priority order. Higher rows run first.

print(2 + 3 * 4)      # 14, not 20
print((2 + 3) * 4)    # 20
print(2 ** 3 * 2)     # 16 (** first -> 8*2)

3.7 Quick Quiz

3.8 Output prediction

3.9 Debugging drill

age = 18
if age = 18:
    print("adult")

3.10 What did you learn?

3.11 CBSE-style questions

3.12 Challenge

Input & Output

How to read data from the user with input() and display results neatly with print() — including the single most common beginner bug in all of CBSE Python.

4.1 Taking input

Concept. input() pauses the program, waits for the user to type something and press Enter, then hands that text back to your program as a string.

Syntax

variable = input("prompt message")

name = input("Enter your name: ")
print("Hello,", name)

a = input("num: ")   # a is "5" (string)
print(a + 1)         # TypeError!

The correct pattern

a = int(input("First number: "))
b = int(input("Second number: "))
print("Sum =", a + b)

4.2 Producing output with print()

print() can display many items, separated by a space by default.

Useful options: sep and end

print("2026", "03", "14", sep="-")
print("Loading", end="...")
print("done")

4.3 Quick Quiz

4.4 Output prediction

4.5 Debugging drill

num = input("Enter marks: ")
avg = num / 2
print(avg)

4.6 What did you learn?

4.7 CBSE-style questions

a = float(input("a: "))
b = float(input("b: "))
print("Average =", (a + b) / 2)

Conditional Statements

Teaching your program to make decisions — if, if-else, if-elif-else, and nesting — where indentation stops being optional and becomes everything.

5.1 The idea of a decision

Concept. Until now, code ran straight top-to-bottom. A conditional statement lets the program choose whether to run a block, based on whether a condition is True or False.

5.2 The if statement

Syntax

if condition:
    statement      # runs only if condition is True
    statement      # (same indentation = same block)

age = 20
if age >= 18:
    print("You can vote")
print("Program ends")

Line-by-line: the indented print belongs to the if and runs only when the condition is true. The non-indented print is outside the if, so it always runs.

5.3 if-else

Do one thing when the condition is true, another when it's false.

n = 7
if n % 2 == 0:
    print("Even")
else:
    print("Odd")

5.4 if-elif-else — many choices

Use elif (else-if) to check several conditions in order. Python runs the first true branch and skips the rest.

marks = 82
if marks >= 90:
    print("A")
elif marks >= 75:
    print("B")
elif marks >= 60:
    print("C")
else:
    print("D")

5.5 Nested if

An if inside another if. The inner one is only checked when the outer condition is true.

num = 10
if num >= 0:
    if num == 0:
        print("Zero")
    else:
        print("Positive")
else:
    print("Negative")

5.6 Quick Quiz

5.7 Output prediction

5.8 Debugging drill

marks = 40
if marks >= 33
print("Pass")
else:
print("Fail")

marks = 40
if marks >= 33:
    print("Pass")
else:
    print("Fail")

5.9 What did you learn?

5.10 CBSE-style questions

n = int(input("Enter a number: "))
if n > 0:
    print("Positive")
elif n < 0:
    print("Negative")
else:
    print("Zero")

5.11 Challenge

a = int(input())
b = int(input())
c = int(input())
if a >= b and a >= c:
    print(a)
elif b >= c:
    print(b)
else:
    print(c)

Loops

Making the computer repeat work — for, while, range(), nested loops, and the break/continue controls that turn up in almost every board paper.

6.1 Why loops?

Concept. A loop repeats a block of code many times so you don't have to write it out by hand. Printing 1 to 100 with 100 print lines is madness; a loop does it in two.

6.2 The for loop with range()

A for loop repeats a known number of times. It usually walks over a sequence produced by range().

How range() works — memorise this

Example — sum of first 5 numbers

total = 0
for i in range(1, 6):
    total = total + i
    print("Added", i, "-> total =", total)
print("Final sum:", total)

Line-by-line

6.3 The while loop

A while loop repeats as long as a condition stays true. Use it when you don't know the count in advance.

n = 5
while n > 0:
    print(n)
    n = n - 1     # update — or it loops forever!
print("Lift off")

6.4 break and continue

for i in range(1, 6):
    if i == 3:
        continue       # skip printing 3
    if i == 5:
        break          # stop before 5
    print(i)

Why: 3 is skipped by continue; the loop stops entirely at 5 due to break, so 5 never prints.

6.5 Nested loops

A loop inside a loop. The inner loop finishes completely for each single step of the outer loop. Essential for pattern-printing questions.

for i in range(1, 4):
    for j in range(i):
        print("*", end="")
    print()   # move to next line

6.6 Quick Quiz

6.7 Output prediction

6.8 Debugging drill

i = 1
while i <= 5:
    print(i)

6.9 What did you learn?

6.10 CBSE-style questions

n = int(input("Number: "))
for i in range(1, 11):
    print(n, "x", i, "=", n * i)

6.11 Challenge

for i in range(1, 5):
    for j in range(1, i + 1):
        print(j, end=" ")
    print()

Strings

Text data — indexing, slicing, the methods CBSE loves, and the immutability rule that produces so many output-prediction questions.

7.1 What is a string?

Concept. A string is a sequence of characters written inside quotes: 'hi' or "hi". Each character has a position number called an index.

Indexing — positive and negative

For the string "PYTHON":

s = "PYTHON"
print(s[0])    # P
print(s[-1])   # N (last char)
print(len(s))   # 6

7.2 Slicing — the exam favourite

Syntax: s[start : stop : step]. It returns the characters from start up to but not including stop.

s = "PYTHON"
print(s[0:3])    # PYT
print(s[2:])     # THON
print(s[:4])     # PYTH
print(s[::2])    # PTO
print(s[::-1])   # NOHTYP (reversed!)

7.3 Strings are immutable

s = "cat"
# s[0] = "b"   ->  TypeError
s = "b" + s[1:]   # make a NEW string instead
print(s)

7.4 Important string methods (must-know)

7.5 Looping over a string

s = "CBSE"
for ch in s:
    print(ch, end="-")

7.6 Quick Quiz

7.7 Output prediction

7.8 Debugging drill

s = "data"
s[0] = "D"
print(s)

7.9 What did you learn?

7.10 CBSE-style questions

s = input("Enter text: ").lower()
count = 0
for ch in s:
    if ch in "aeiou":
        count += 1
print("Vowels:", count)

7.11 Challenge

w = input("Word: ").lower()
if w == w[::-1]:
    print("Palindrome")
else:
    print("Not a palindrome")

Lists

Python's workhorse container — an ordered, changeable collection. Indexing, slicing, the methods you must know, and the mutability behaviour that catches students out.

8.1 What is a list?

Concept. A list stores many values in one variable, in order, inside square brackets [ ]. Unlike a string, a list is mutable — you can change, add, and remove items.

marks = [90, 85, 70, 95]
print(marks[0])    # 90
print(marks[-1])   # 95
print(len(marks))  # 4
marks[2] = 75       # change works (mutable!)
print(marks)

8.2 Slicing lists

Exactly like strings: L[start:stop:step], stop excluded.

L = [10, 20, 30, 40, 50]
print(L[1:4])   # [20, 30, 40]
print(L[:2])    # [10, 20]
print(L[::-1])  # [50, 40, 30, 20, 10]

8.3 List methods (must-know for boards)

8.4 Looping over a list

marks = [40, 55, 70]
total = 0
for m in marks:
    total += m
print("Sum:", total)
print("Average:", total / len(marks))

8.5 Quick Quiz

8.6 Output prediction

8.7 Debugging drill

L = [3, 1, 2]
biggest = L.sort()
print(biggest[-1])

8.8 What did you learn?

8.9 CBSE-style questions

L = [40, 12, 88, 5, 63]
big = small = L[0]
for x in L:
    if x > big:
        big = x
    if x < small:
        small = x
print("Largest:", big, "Smallest:", small)

8.10 Challenge

nums = [4, 7, 10, 15, 22]
evens = []
for n in nums:
    if n % 2 == 0:
        evens.append(n)
print(evens)   # [4, 10, 22]

Tuples

Like lists, but locked. An ordered collection you cannot change — why that matters, how it differs from a list, and the packing/unpacking tricks CBSE tests.

9.1 What is a tuple?

Concept. A tuple is an ordered collection of values inside round brackets ( ). It behaves like a list for reading, but it is immutable — once created, you cannot change, add, or remove items.

t = (10, 20, 30, 40)
print(t[0])    # 10
print(t[-1])   # 40
print(t[1:3])  # (20, 30)
print(len(t))   # 4

9.2 The single-element trap

a = (5)      # NOT a tuple — just the number 5
b = (5,)     # a tuple with one element
print(type(a))  # <class 'int'>
print(type(b))  # <class 'tuple'>

9.3 Trying to change a tuple

t = (1, 2, 3)
# t[0] = 99   ->  TypeError: cannot change a tuple
print(t)

9.4 Tuple methods & operations

Because tuples can't change, they only have two methods: count() and index(). But the usual operations still work.

9.5 Packing and unpacking (very examinable)

t = (18, "Ahana", 95.5)   # packing
age, name, marks = t          # unpacking
print(name, age, marks)

9.6 Quick Quiz

9.7 Output prediction

9.8 Debugging drill

t = (10, 20, 30)
t.append(40)
print(t)

9.9 What did you learn?

9.10 CBSE-style questions

9.11 Challenge

t = (12, 8, 20, 4)
print("Sum:", sum(t))
print("Average:", sum(t) / len(t))

Dictionaries

Storing data as key–value pairs — the structure behind so many CBSE case-based questions. Creating, accessing, updating, and looping through dictionaries.

10.1 What is a dictionary?

Concept. A dictionary stores data as key : value pairs inside curly brackets { }. Instead of finding items by position (0, 1, 2…), you find them by their key.

student = {"name": "Ahana", "age": 18, "marks": 95}
print(student["name"])    # Ahana
print(student["marks"])   # 95

10.2 Adding & updating

d = {"a": 1, "b": 2}
d["c"] = 3      # new key -> ADD
d["a"] = 99     # existing key -> UPDATE
print(d)

10.3 Accessing safely with get()

d = {"x": 10}
# print(d["y"])       -> KeyError (crash)
print(d.get("y"))        # None (no crash)
print(d.get("y", 0))     # 0 (default if missing)

10.4 Important dictionary methods

10.5 Looping through a dictionary

marks = {"Maths": 95, "CS": 98, "Eng": 88}
for subject, score in marks.items():
    print(subject, "->", score)

10.6 Quick Quiz

10.7 Output prediction

10.8 Debugging drill

d = {"name": "Ravi"}
print(d["age"])

10.9 What did you learn?

10.10 CBSE-style questions

s = "banana"
freq = {}
for ch in s:
    if ch in freq:
        freq[ch] += 1
    else:
        freq[ch] = 1
print(freq)

10.11 Challenge

marks = {"Maths": 95, "CS": 98, "Eng": 88}
top = ""
best = -1
for subject, score in marks.items():
    if score > best:
        best = score
        top = subject
print("Highest:", top, best)

Functions

Reusable blocks of code you define once and call many times — parameters, return values, default arguments, and the built-in functions CBSE expects you to know cold.

11.1 What is a function?

Concept. A function is a named block of code that performs a task. You define it once, then call it whenever you need it — avoiding repetition and keeping programs organised.

Three types of functions in the CBSE syllabus

11.2 Defining and calling

Syntax

def function_name(parameters):
    # body (indented)
    statement

def greet(name):
    print("Hello,", name)

greet("Ahana")     # call 1
greet("Ravi")      # call 2

11.3 Parameters and arguments

Parameter = the variable named in the definition. Argument = the actual value you pass when calling.

def add(a, b):      # a, b are PARAMETERS
    print(a + b)

add(10, 20)         # 10, 20 are ARGUMENTS

11.4 Return values — the big idea

return sends a value back to whoever called the function, so the result can be stored and reused. Printing shows a value; returning gives it back.

def square(n):
    return n * n

result = square(5)   # store the returned value
print(result)         # 25
print(square(3) + square(4))  # 9 + 16 = 25

11.5 Default parameters

Give a parameter a default so the caller may skip it.

def power(base, exp=2):   # exp defaults to 2
    return base ** exp

print(power(5))      # 25 (uses default exp=2)
print(power(5, 3))   # 125 (overrides default)

11.6 Using library functions (modules)

import math
print(math.sqrt(16))    # 4.0
print(math.pi)         # 3.14159...

import random
print(random.randint(1, 6))  # a dice roll 1-6

11.7 Quick Quiz

11.8 Output prediction

11.9 Debugging drill

def total(a, b):
    sum = a + b

x = total(3, 4)
print(x * 2)

11.10 What did you learn?

11.11 CBSE-style questions

def is_prime(n):
    if n < 2:
        return False
    for i in range(2, n):
        if n % i == 0:
            return False
    return True

print(is_prime(7))   # True
print(is_prime(9))   # False

11.12 Challenge

def factorial(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

print(factorial(5))   # 120

Scope of Variables

Where a variable "lives" and where it can be seen — local vs global, why a function can read a global but not change it by default, and the global keyword.

12.1 What is scope?

Concept. Scope is the region of a program where a variable can be used. A variable created inside a function is local — it exists only while that function runs. A variable created outside all functions is global — visible throughout the file.

12.2 Local variables

def show():
    x = 10       # x is LOCAL to show()
    print(x)

show()
# print(x)    ->  NameError: x not defined out here

12.3 Global variables

count = 100          # GLOBAL

def display():
    print(count)     # can READ the global

display()
print(count)

12.4 The key rule — read yes, change no

A function can read a global variable freely. But if you try to assign to it inside the function, Python creates a new local variable instead — the global is untouched.

x = 5

def change():
    x = 99       # makes a NEW local x, not the global
    print("inside:", x)

change()
print("outside:", x)   # global unchanged

12.5 The global keyword

To actually change a global from inside a function, declare it global first.

x = 5

def change():
    global x       # now x refers to the global
    x = 99
    print("inside:", x)

change()
print("outside:", x)   # now really changed

12.6 Quick Quiz

12.7 Output prediction

12.8 Debugging drill

def setValue():
    result = 42

setValue()
print(result)

12.9 What did you learn?

12.10 CBSE-style questions

File Handling — The Big Picture

Why programs need files, the three file types in the CBSE syllabus, file modes, and the safe with pattern that every file program should use.

13.1 Why do we need files?

Concept. Variables live in memory (RAM) and vanish when the program ends. A file stores data on disk permanently, so it's still there next time you run the program. This permanence is called persistence.

13.2 The three file types (know these cold)

13.3 Opening and closing a file

To use a file you open it (getting a file object), work with it, then close it to save changes and free the resource.

Syntax

f = open("filename.txt", "mode")
# ... use f ...
f.close()

13.4 File modes — the master table

13.5 The safe way — with

The with statement opens a file and closes it automatically, even if an error occurs. This is the recommended, exam-safe pattern.

with open("notes.txt", "w") as f:
    f.write("Hello file")
# file is closed automatically here

13.6 Quick Quiz

13.7 What did you learn?

13.8 CBSE-style questions

Text Files

Reading and writing plain-text files — the read methods, the write methods, the newline gotcha, and the standard "count words / lines" programs CBSE asks every year.

14.1 Writing to a text file

with open("notes.txt", "w") as f:
    f.write("Line one\n")   # \n = newline
    f.write("Line two\n")

14.2 Reading a text file — three methods

with open("notes.txt", "r") as f:
    data = f.read()
print(data)

The cleanest way to read line by line

with open("notes.txt", "r") as f:
    for line in f:          # loop directly over the file
        print(line.strip())   # strip() removes the trailing \n

14.3 Appending to a text file

with open("notes.txt", "a") as f:
    f.write("Line three\n")   # old lines stay, this is added

14.4 The classic CBSE text-file programs

(a) Count the number of lines

count = 0
with open("notes.txt", "r") as f:
    for line in f:
        count += 1
print("Lines:", count)

(b) Count words

words = 0
with open("notes.txt", "r") as f:
    for line in f:
        words += len(line.split())   # split on spaces
print("Words:", words)

(c) Count lines starting with a particular letter

count = 0
with open("notes.txt", "r") as f:
    for line in f:
        if line[0] == "T":
            count += 1
print(count)

14.5 Quick Quiz

14.6 Output prediction

14.7 Debugging drill

f = open("data.txt", "w")
data = f.read()
print(data)

14.8 What did you learn?

14.9 CBSE-style questions

count = 0
with open("notes.txt", "r") as f:
    for line in f:
        for word in line.split():
            if word[0].lower() in "aeiou":
                count += 1
print("Words starting with a vowel:", count)

14.10 Challenge

with open("source.txt", "r") as src:
    text = src.read()

with open("dest.txt", "w") as dst:
    dst.write(text.upper())

Binary Files

Storing real Python objects — lists, dictionaries — exactly as they are, using the pickle module. The dump/load pair and the record-update pattern CBSE asks for.

15.1 Why binary files?

Concept. A binary file stores data as raw bytes, keeping the exact structure of a Python object. A text file would turn a list into plain characters and lose its "list-ness"; a binary file keeps a list a list, a dictionary a dictionary.

15.2 The pickle module

Python's pickle module does the conversion. Two functions do all the work:

15.3 Writing an object

import pickle

student = {"name": "Ahana", "marks": 95}

with open("student.dat", "wb") as f:
    pickle.dump(student, f)
print("Saved!")

15.4 Reading it back

import pickle

with open("student.dat", "rb") as f:
    data = pickle.load(f)

print(data)
print(data["name"])   # works — it's a real dict again

15.5 Storing many records

A common pattern: store a list of records, or dump each record one by one and read them in a loop until the file ends.

import pickle

records = [
    {"roll": 1, "name": "A"},
    {"roll": 2, "name": "B"},
]

with open("data.dat", "wb") as f:
    pickle.dump(records, f)       # store whole list at once

with open("data.dat", "rb") as f:
    back = pickle.load(f)
    for r in back:
        print(r["roll"], r["name"])

15.6 Reading until end-of-file (multiple dumps)

If you dump records one at a time, reading past the end raises EOFError. Catch it to stop cleanly.

import pickle
with open("data.dat", "rb") as f:
    while True:
        try:
            rec = pickle.load(f)
            print(rec)
        except EOFError:
            break       # reached end — stop

15.7 Quick Quiz

15.8 Behaviour prediction

15.9 Debugging drill

import pickle
with open("d.dat", "rb") as f:
    data = pickle.dump(f)

15.10 What did you learn?

15.11 CBSE-style questions

import pickle
students = [
    {"roll": 1, "name": "Amit"},
    {"roll": 2, "name": "Bina"},
    {"roll": 3, "name": "Chetan"},
]
with open("stu.dat", "wb") as f:
    pickle.dump(students, f)
with open("stu.dat", "rb") as f:
    for s in pickle.load(f):
        print(s["roll"], s["name"])

15.12 Challenge

import pickle
with open("emp.dat", "rb") as f:
    emps = pickle.load(f)

for e in emps:
    e["salary"] = e["salary"] * 1.1

with open("emp.dat", "wb") as f:
    pickle.dump(emps, f)

CSV Files

Comma-separated tables — the format that opens in Excel. Using the csv module to write and read rows, with the newline detail that CBSE loves to test.

16.1 What is a CSV file?

Concept. CSV stands for Comma-Separated Values. Each line is one row of a table, and commas separate the columns. It's plain text, so it opens in Notepad or Excel.

Roll,Name,Marks
1,Ahana,95
2,Ravi,88

16.2 The csv module

You import csv, then use a writer to save rows and a reader to read them.

16.3 Writing a CSV file

import csv

with open("marks.csv", "w", newline="") as f:
    w = csv.writer(f)
    w.writerow(["Roll", "Name", "Marks"])   # header
    w.writerow([1, "Ahana", 95])
    w.writerow([2, "Ravi", 88])

16.4 Reading a CSV file

import csv

with open("marks.csv", "r") as f:
    r = csv.reader(f)
    for row in r:
        print(row)

16.5 Skipping the header

import csv
with open("marks.csv", "r") as f:
    r = csv.reader(f)
    next(r)               # skip the header row
    for row in r:
        print(row[1], "scored", row[2])

16.6 Quick Quiz

16.7 Behaviour prediction

16.8 Debugging drill

import csv
with open("m.csv", "r") as f:
    r = csv.reader(f)
    total = 0
    for row in r:
        total += row[2]
    print(total)

16.9 What did you learn?

16.10 CBSE-style questions

import csv
total = 0
n = 0
with open("marks.csv", "r") as f:
    r = csv.reader(f)
    next(r)                 # skip header
    for row in r:
        total += int(row[2])
        n += 1
print("Average:", total / n)

16.11 Challenge

import csv
with open("marks.csv", "r") as f:
    rows = list(csv.reader(f))

header = rows[0]
data = rows[1:]

with open("toppers.csv", "w", newline="") as f:
    w = csv.writer(f)
    w.writerow(header)
    for row in data:
        if int(row[2]) > 90:
            w.writerow(row)

Exception Handling

Stopping your program from crashing when something goes wrong — try, except, else, finally, and the common exceptions CBSE expects you to name.

17.1 What is an exception?

Concept. An exception is an error that occurs while the program is running (a runtime error). Normally it crashes the program. Exception handling lets you catch the error and respond gracefully instead of crashing.

17.2 Common exceptions to know

17.3 The try–except block

Syntax

try:
    # risky code that might fail
except ErrorType:
    # runs only if that error happens

try:
    a = int(input("Number: "))
    print(100 / a)
except ZeroDivisionError:
    print("Cannot divide by zero")
except ValueError:
    print("Please enter a valid number")

17.4 else and finally

try:
    x = 10 / 2
except ZeroDivisionError:
    print("Error")
else:
    print("Success:", x)      # no error -> runs
finally:
    print("Done (always runs)")

17.5 Quick Quiz

17.6 Output prediction

17.7 Debugging drill

try:
    n = int(input())
print(10 / n)

try:
    n = int(input())
    print(10 / n)
except (ValueError, ZeroDivisionError):
    print("Invalid input")

17.8 What did you learn?

17.9 CBSE-style questions

try:
    a = int(input("a: "))
    b = int(input("b: "))
    print("Result:", a / b)
except ValueError:
    print("Enter valid integers")
except ZeroDivisionError:
    print("b cannot be zero")
finally:
    print("Program finished")

17.10 Challenge

try:
    with open("notes.txt", "r") as f:
        print(f.read())
except FileNotFoundError:
    print("File not found — please check the name.")

Data Structures: Stack

The one data structure named in the CBSE syllabus — a Last-In-First-Out (LIFO) stack built with a Python list. Push, pop, peek, and the classic applications examiners ask about.

18.1 What is a stack?

Concept. A stack is a collection where you add and remove items from one end only, called the top. The last item you put in is the first one you take out — this rule is called LIFO (Last In, First Out).

18.2 Stack operations

18.3 Push and pop in action

stack = []

stack.append(10)   # push 10
stack.append(20)   # push 20
stack.append(30)   # push 30
print("Stack:", stack)

top = stack.pop()  # pop -> removes 30 (last in)
print("Popped:", top)
print("Now:", stack)
print("Top now:", stack[-1])  # peek

18.4 The empty-stack trap

stack = []
# stack.pop()   -> IndexError: pop from empty list

if len(stack) == 0:
    print("Stack is empty (underflow)")
else:
    print(stack.pop())

18.5 A menu-driven stack (exam pattern)

def push(stack, item):
    stack.append(item)

def pop(stack):
    if len(stack) == 0:
        return "Underflow"
    return stack.pop()

def peek(stack):
    if len(stack) == 0:
        return "Empty"
    return stack[-1]

s = []
push(s, 5)
push(s, 8)
print(peek(s))   # 8
print(pop(s))    # 8
print(pop(s))    # 5
print(pop(s))    # Underflow

18.6 Quick Quiz

18.7 Output prediction

18.8 Debugging drill

stack = []
stack.append(5)
print(stack.pop())
print(stack.pop())   # crash?

18.9 What did you learn?

18.10 CBSE-style questions

def push(stack, x):
    stack.append(x)

def pop(stack):
    if len(stack) == 0:
        print("Underflow")
        return None
    return stack.pop()

s = "PYTHON"
stack = []
for ch in s:
    stack.append(ch)      # push each char

rev = ""
while len(stack) > 0:
    rev += stack.pop()      # pop reverses order
print(rev)                 # NOHTYP

18.11 Challenge

expr = "(a+b)"
stack = []
balanced = True
for ch in expr:
    if ch == "(":
        stack.append(ch)
    elif ch == ")":
        if len(stack) == 0:
            balanced = False
        else:
            stack.pop()
if balanced and len(stack) == 0:
    print("Balanced")
else:
    print("Not balanced")

Searching & Sorting

Two everyday algorithm tasks — finding an item (linear search) and arranging items in order (bubble and insertion sort). Understand how each works step by step, not just the code.

19.1 Linear search

Concept. Linear search checks each element one by one, from the start, until it finds the target or reaches the end. Simple, and works on any list (sorted or not).

def linear_search(L, target):
    for i in range(len(L)):
        if L[i] == target:
            return i          # found — return position
    return -1                 # not found

nums = [4, 9, 2, 7, 5]
print(linear_search(nums, 7))   # 3
print(linear_search(nums, 8))   # -1

19.2 Bubble sort

Concept. Bubble sort repeatedly compares adjacent pairs and swaps them if they're in the wrong order. After each full pass, the largest remaining value "bubbles" to the end.

def bubble_sort(L):
    n = len(L)
    for i in range(n - 1):            # number of passes
        for j in range(n - 1 - i):     # compare pairs
            if L[j] > L[j + 1]:
                L[j], L[j + 1] = L[j + 1], L[j]  # swap
    return L

print(bubble_sort([5, 1, 4, 2]))

Trace of pass 1 on [5, 1, 4, 2]

After pass 1, the largest value (5) is at the end. Later passes sort the rest.

19.3 Insertion sort

Concept. Insertion sort builds the sorted list one item at a time: take each element and insert it into its correct place among the already-sorted items to its left.

def insertion_sort(L):
    for i in range(1, len(L)):
        key = L[i]
        j = i - 1
        while j >= 0 and L[j] > key:
            L[j + 1] = L[j]   # shift right
            j -= 1
        L[j + 1] = key       # place key
    return L

print(insertion_sort([3, 1, 2]))

19.4 Quick Quiz

19.5 Output / trace prediction

19.6 Debugging drill

def search(L, x):
    for i in range(len(L)):
        if L[i] == x:
            return i
        else:
            return -1

19.7 What did you learn?

19.8 CBSE-style questions

def search_count(L, x):
    count = 0
    for i in range(len(L)):
        count += 1
        if L[i] == x:
            return i, count
    return -1, count

print(search_count([4, 9, 2, 7], 7))  # (3, 4)

19.9 Challenge

def bubble_desc(L):
    n = len(L)
    for i in range(n - 1):
        for j in range(n - 1 - i):
            if L[j] < L[j + 1]:   # flipped > to <
                L[j], L[j + 1] = L[j + 1], L[j]
    return L

print(bubble_desc([5, 1, 4, 2]))  # [5, 4, 2, 1]

SQL / Python Connectivity

Connecting a Python program to a MySQL database — the connector module, cursor, running queries, and fetching results. The exact steps and vocabulary CBSE expects.

20.1 Why connect Python to a database?

Concept. A database (MySQL) stores data in tables, safely and permanently. Connectivity lets a Python program talk to that database — insert records, search, update, and read — so your program and your stored data work together.

20.2 The interface module

Python uses the mysql.connector module to talk to MySQL. You import it first.

import mysql.connector

20.3 The five steps of connectivity

Every database program in CBSE follows the same sequence. Memorise these five steps.

20.4 Making the connection

import mysql.connector

con = mysql.connector.connect(
    host="localhost",
    user="root",
    passwd="yourpassword",
    database="school"
)

if con.is_connected():
    print("Connected successfully")

The four connection parameters

20.5 Creating a cursor and running a query

The cursor is the object that carries your SQL to the database and holds the results that come back.

cur = con.cursor()                     # step 3
cur.execute("SELECT * FROM student")   # step 4

rows = cur.fetchall()                  # step 5: get all rows
for row in rows:
    print(row)

20.6 The three fetch methods

20.7 Inserting data — and why commit() matters

cur = con.cursor()
sql = "INSERT INTO student VALUES (3, 'Meera', 91)"
cur.execute(sql)
con.commit()          # SAVE the change permanently
print(cur.rowcount, "record inserted")

20.8 Parameterised queries (safer inserts)

Instead of gluing values into the SQL string, use %s placeholders and pass a tuple. This avoids quoting mistakes.

roll = 4
name = "Sara"
marks = 87

sql = "INSERT INTO student VALUES (%s, %s, %s)"
cur.execute(sql, (roll, name, marks))
con.commit()

20.9 Closing the connection

con.close()   # release the connection when done

20.10 Full example — search by condition

import mysql.connector

con = mysql.connector.connect(
    host="localhost", user="root",
    passwd="pass", database="school")

cur = con.cursor()
cur.execute("SELECT * FROM student WHERE marks > 90")

for row in cur.fetchall():
    print("Roll:", row[0], "Name:", row[1])

con.close()

20.11 Quick Quiz

20.12 Behaviour prediction

20.13 Debugging drill

cur = con.cursor()
cur.execute("DELETE FROM student WHERE roll=2")
print("Deleted")
con.close()

20.14 What did you learn?

20.15 CBSE-style questions

import mysql.connector
con = mysql.connector.connect(
    host="localhost", user="root",
    passwd="pass", database="library")
cur = con.cursor()
cur.execute("SELECT * FROM books")
for row in cur.fetchall():
    print(row)
con.close()

20.16 Challenge

import mysql.connector
con = mysql.connector.connect(
    host="localhost", user="root",
    passwd="pass", database="school")
cur = con.cursor()

r = int(input("Enter roll number: "))
cur.execute("SELECT * FROM student WHERE roll = %s", (r,))

row = cur.fetchone()
if row:
    print(row)
else:
    print("No such student")
con.close()

Master Python Cheat Sheet

Everything from all 20 chapters on one scannable page. Use it for last-minute revision and to look things up while you practise. Print it or keep it open beside your code.

1. Core syntax

2. Data types & mutability

3. Operators

4. Control flow

if cond:
    ...
elif cond2:
    ...
else:
    ...

for i in range(start, stop, step):
    ...
while cond:
    ...        # remember to update!
# break = exit loop | continue = skip iteration

5. String methods

6. List methods

7. Tuples

8. Dictionary methods

9. Functions

def name(param, default=2):
    return value    # exits + sends back

name(argument)       # call