Programming fundamentals

3.1Programming paradigmOften examined

A programming paradigm is a style or method of writing and organising program code. It decides how the code is structured, how control flows from one statement to the next, and how data is managed. In other words, it is a particular methodology for using a programming language to solve a problem.

A programmer may create his own functions and structures inside a language, but these are not a paradigm. The paradigm comes from the language itself: the language gives guidelines, tools and features that tell the programmer what to build and how to build it. For example, Python supports both the functional and the object-oriented paradigms, while SQL follows the declarative (query) style.

Why paradigms are important

• Complexity reduction: a paradigm breaks a big, complex problem into smaller parts (functions or objects) that are easier to understand and solve.
• Structure: code, program flow and data are organised in a standard, predictable way, so the program is easier to read, test and maintain.
• Standard tools: each paradigm comes with well-known techniques that many programmers already use, so a team can work together more easily.
• Focus: the developer concentrates on the task in hand instead of reinventing a way to organise the program.

3.1.1Functional programmingOften examined

Functional programming is a paradigm in which the program is divided into functions according to their functionality. The solution of the problem is broken into segments and each segment is handled by a function. Every step of the solution is mapped to a group of functions.

In functional programming the developer focuses on what is to be achieved rather than how to achieve it. Functions take inputs and return outputs and, ideally, do not change any value outside themselves (they have no side effects and do not change the program's state). This is why the MCQ phrase "uses functions without changing state" means functional programming.

Pure function

A function whose result depends only on its inputs and which does not change any variable outside itself. Calling it twice with the same input always gives the same output.

Higher-order function

A function that takes another function as an argument or returns a function, for example Python's $\text{map()}$ and $\text{filter()}$.

Lambda

A small nameless function written in one line, such as $\text{lambda }\text{n: }\text{n }\text{* }\text{2}$.

If the flow of the solution is clear, functional programming makes the work easier. Updating the code for any change is simple, because only the particular function that is affected needs to be modified; the whole program does not need to be read and understood again.

# Functional style: small pure functions, no global state is changed
def square(n):
    return n * n

def is_even(n):
    return n % 2 == 0

marks = [3, 8, 5, 10, 6]

squares = list(map(square, marks))           # apply square() to every item
evens = list(filter(is_even, marks))          # keep only the even items
total = sum(map(lambda n: n * 2, marks))      # lambda = small nameless function

print("Original list:", marks)
print("Squares:", squares)
print("Even marks:", evens)
print("Sum of doubled marks:", total)

Original list: [3, 8, 5, 10, 6]
Squares: [9, 64, 25, 100, 36]
Even marks: [8, 10, 6]
Sum of doubled marks: 64

For comparison, the same total written in the ordinary step-by-step (imperative) style changes the variable $\text{total}$ in every pass of the loop:

# Imperative (procedural) style: a variable is changed step by step
marks = [3, 8, 5, 10, 6]
total = 0
for m in marks:
    total = total + m * 2      # state (total) changes in every pass
print("Sum of doubled marks:", total)

Sum of doubled marks: 64

3.1.2Object oriented programmingOften examined

Object oriented programming (OOP) is a software development paradigm based on data and objects. An object contains attributes (data that describe its properties) and methods (functions that define its behaviour). Programs are built around objects that copy real-world things, such as a car, a fruit or a bank account, so developers understand the problem more naturally.

The main advantage of OOP is that the emphasis in problem solving is on objects and not on the logic. OOP is implemented through classes: first a class defines the object and its functions, and later actual instances (objects) are created when they are needed in the program. OOP limits direct access to data, which gives safety and reliability of data and programs. It is very useful for complex systems in which developers map real objects and their relationships.

Key concepts: class and object

Class

An object creation stencil or template. It specifies the attributes (variables or properties) and methods (functions) that its objects will hold.

Object

An instance of a class that denotes a real thing, such as a person, a car or a bank account. Every object has its own attribute values but uses the methods defined in the class.

Instance

Creating an object from a class is called instantiation; the object is an instance of that class.

A class is like the map of a house; each house (object) built from that map has particular properties such as size, colour or number of rooms. All objects share the basic structure defined by the class but have their own values. In the book's example the class $\text{StationaryItem}$ is the stencil for every stationery item in a bookshop:

class StationaryItem:
    def __init__(self, name, price, color, brand):   # constructor: runs when an object is made
        self.name = name          # attributes (data)
        self.price = price
        self.color = color
        self.brand = brand

    def get_price(self):          # method (behaviour)
        return self.price

    def set_price(self, new_price):
        self.price = new_price

pen = StationaryItem("Pen", 200, "Blue", "XYZ")        # object 1
pencil = StationaryItem("Pencil", 100, "Red", "ABC")   # object 2

print(pen.name, pen.color, pen.get_price())
print(pencil.name, pencil.color, pencil.get_price())
pencil.set_price(120)
print("New price of pencil:", pencil.get_price())

Pen Blue 200
Pencil Red 100
New price of pencil: 120

Encapsulation

Encapsulation is information hiding: the data (attributes) and the methods that operate on the data are combined into a single unit, the class. Direct access to some components is not allowed; they are reached only through designated methods. The internal working of the object stays hidden. Encapsulation protects data from unwanted access or changes and makes code modular and easier to read.

In a bank, the holder's name, account number and balance are critical. Instead of changing the balance directly, $\text{deposit(amount)}$ adds to it, $\text{withdraw(amount)}$ subtracts from it and $\text{get\_balance()}$ reads it without changing it.

class BankAccount:
    def __init__(self, holder, balance):
        self.holder = holder
        self.__balance = balance          # two underscores: hidden (private) attribute

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Insufficient balance")

    def get_balance(self):
        return self.__balance

acc = BankAccount("Ayesha", 5000)
acc.deposit(1500)
acc.withdraw(10000)
acc.withdraw(2000)
print("Balance:", acc.get_balance())
try:
    print(acc.__balance)                  # direct access is blocked
except AttributeError:
    print("Direct access to __balance is not allowed")

Insufficient balance
Balance: 4500
Direct access to __balance is not allowed

Abstraction

Abstraction shows only the necessary information and hides the background details or implementation. A driver uses start, stop and accelerate, but how the engine burns fuel and how gears shift are hidden. In code, the user of a class only needs to know the names of its methods, not how they are written.

Inheritance

Inheritance lets you create new classes (subclasses or derived classes) from existing parent classes. A subclass inherits the attributes and methods of its parent, which reduces repetition of code and extends existing structures efficiently. A $\text{Vehicle}$ has speed, colour, wheels and the operations $\text{accelerate()}$ and $\text{brake()}$. A $\text{Car}$ is a type of vehicle, so it inherits all these and adds its own, such as $\text{seatingCapacity}$ and $\text{openSunroof()}$.

class Vehicle:                          # parent (base) class
    def __init__(self, color, wheels):
        self.color = color
        self.wheels = wheels
        self.speed = 0

    def accelerate(self, amount):
        self.speed += amount

    def brake(self):
        self.speed = 0

class Car(Vehicle):                     # child (derived) class inherits Vehicle
    def __init__(self, color, seating_capacity):
        super().__init__(color, 4)      # reuse the parent constructor
        self.seating_capacity = seating_capacity

    def open_sunroof(self):             # extra behaviour only a Car has
        return "Sunroof opened"

c = Car("White", 5)
c.accelerate(60)                        # inherited method
print("Colour:", c.color, "| Wheels:", c.wheels, "| Speed:", c.speed)
print("Seats:", c.seating_capacity, "|", c.open_sunroof())
c.brake()
print("Speed after brake:", c.speed)

Colour: White | Wheels: 4 | Speed: 60
Seats: 5 | Sunroof opened
Speed after brake: 0

Polymorphism

Polymorphism ("many forms") allows objects of different classes to be treated as instances of a common type, although each class implements the common operation in its own way. It allows generic code that works with many kinds of objects. A triangle, a rectangle and a circle are all shapes, but the area of a triangle needs base and height, a rectangle needs length and width, and a circle needs the radius. Instead of three differently named methods, each class has an $\text{area()}$ method and the same instruction gives the correct result for each object.

import math

class Shape:
    def area(self):
        return 0

class Triangle(Shape):
    def __init__(self, base, height):
        self.base, self.height = base, height
    def area(self):                       # same method name, own formula
        return 0.5 * self.base * self.height

class Rectangle(Shape):
    def __init__(self, length, width):
        self.length, self.width = length, width
    def area(self):
        return self.length * self.width

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return round(math.pi * self.radius ** 2, 2)

shapes = [Triangle(6, 4), Rectangle(5, 3), Circle(2)]
for s in shapes:                          # one instruction, three behaviours
    print(type(s).__name__, "area =", s.area())

Triangle area = 12.0
Rectangle area = 15
Circle area = 12.57

3.2Python building blocks (revision)

Unit 3 uses Python constructs from Grade 11 in every program. This short revision collects them so that the programs in the rest of the unit are easy to follow.

Data types and operators

age = 17                 # int: whole number
height = 5.6             # float: number with a decimal point
name = "Hina"            # str: text
passed = True            # bool: True or False
print(type(age), type(height), type(name), type(passed))
print(7 / 2, 7 // 2, 7 % 2, 2 ** 5)       # division, floor division, remainder, power
print(10 > 3 and 2 > 5, not passed)       # logical operators
print("Py" + "thon", "ab" * 3)            # string joining and repetition

<class 'int'> <class 'float'> <class 'str'> <class 'bool'>
3.5 3 1 32
False False
Python ababab

Control structures

Selection ($\text{if}$, $\text{elif}$, $\text{else}$) chooses one path. Repetition ($\text{for}$, $\text{while}$) repeats statements. $\text{break}$ leaves a loop and $\text{continue}$ skips to the next pass. Python marks a block by indentation (4 spaces), not by braces.

marks = [45, 78, 91, 33]
for m in marks:                     # for loop: repeats once for each item
    if m >= 80:                     # if-elif-else: choose one path
        grade = "A"
    elif m >= 50:
        grade = "B"
    elif m >= 40:
        grade = "C"
    else:
        grade = "Fail"
    print(m, grade)

n = 1
while n <= 16:                      # while loop: repeats while the condition is True
    print(n, end=" ")
    n = n * 2
print()
for i in range(1, 10):
    if i == 4:
        continue                    # skip the rest of this pass
    if i == 7:
        break                       # leave the loop completely
    print(i, end=" ")

45 C
78 B
91 A
33 Fail
1 2 4 8 16 
1 2 3 5 6 

Functions

A function is a named block of code that does one job. It is defined with $\text{def}$, receives values through parameters, and sends a result back with $\text{return}$. Functions let us reuse code and split a big problem into small parts, which is the basis of complexity reduction.

def area_of_rectangle(length, width=1):     # width has a default value
    """Return the area of a rectangle."""
    return length * width

def describe(n):
    if n % 2 == 0:
        return "even"
    return "odd"

a = area_of_rectangle(4, 5)     # arguments 4 and 5 go to length and width
b = area_of_rectangle(7)        # width uses its default value 1
print(a, b)
print(9, "is", describe(9))

20 7
9 is odd

Strings

A string is a sequence of characters. Characters are numbered from index 0; a negative index counts from the end. Strings are immutable, so methods such as $\text{upper()}$ return a new string.

s = "Programming Fundamentals"
print(len(s))               # number of characters
print(s[0], s[-1])          # first and last character (index starts at 0)
print(s[0:11])              # slicing: characters 0 to 10
print(s.upper())
print(s.lower().count("a"))
print(s.split())            # break into a list of words
print(s.replace("Fundamentals", "Basics"))
print("gram" in s)

24
P s
Programming
PROGRAMMING FUNDAMENTALS
3
['Programming', 'Fundamentals']
Programming Basics
True

3.2.1ListOften examined

A list is a basic data structure in Python that holds a group of elements in a sequence. It is written in square brackets, for example $\text{[85, }\text{92, }\text{78]}$. Lists are flexible: one list may hold elements of different data types (integers, strings, booleans and so on).

• Ordered: the order in which items are added is kept. Index 0 holds the first item, index 1 the second, and so on. This lets us retrieve an item by its position.
• Mutable and dynamic: items can be added, changed or removed at any time, so the size of a list changes as needed.
• Duplicates allowed: the same value may appear more than once.

student_grades = [85, 92, 78, 95, 82]

student_grades.insert(2, 90)
print("Grades after adding a new grade:", student_grades)
student_grades.append(100)
print("Grades after adding another new grade:", student_grades)

student_grades.remove(78)
print("Grades after removing a grade:", student_grades)
lowest_grade = student_grades.pop(2)
print("Grades after removing the grade on index 2:", student_grades)

if 88 in student_grades:
    student_grades.remove(88)
else:
    print("Grade 88 not found in the list")

average_grade = sum(student_grades) / len(student_grades)
print("Average grade:", {average_grade})

Grades after adding a new grade: [85, 92, 90, 78, 95, 82]
Grades after adding another new grade: [85, 92, 90, 78, 95, 82, 100]
Grades after removing a grade: [85, 92, 90, 95, 82, 100]
Grades after removing the grade on index 2: [85, 92, 95, 82, 100]
Grade 88 not found in the list
Average grade: {90.8}

student_grades = [85, 92, 78, 95, 82]
student_grades.insert(2, 90)
student_grades.append(100)
print("List before:", student_grades)

odd_numbers = [g for g in student_grades if g % 2 != 0]   # find the odd items
print("Odd numbers found:", odd_numbers)
for g in odd_numbers:
    student_grades.remove(g)                              # remove each one
print("List after removing odd numbers:", student_grades)

List before: [85, 92, 90, 78, 95, 82, 100]
Odd numbers found: [85, 95]
List after removing odd numbers: [92, 90, 78, 82, 100]

3.2.2Tuples

A tuple is written with round brackets, for example $\text{(85, }\text{92, }\text{78)}$. It is a special type of list with one feature: it is immutable, so its contents cannot be updated once it is created. We can read the items and their arrangement but cannot add, remove or rearrange them. Tuples are used when a set of values must stay in order and unchanged throughout the program, for example the days of the week or geographical coordinates (latitude, longitude).

grades = (85, 92, 78, 92, 85, 95)
print(grades)
print("First grade:", grades[0])
print("Third grade:", grades[2])
if 92 in grades:
    print("Student got 92")
print(grades.count(92))
new_grades = grades + (88, 90)
print(new_grades)

(85, 92, 78, 92, 85, 95)
First grade: 85
Third grade: 78
Student got 92
2
(85, 92, 78, 92, 85, 95, 88, 90)

Trying to change a tuple stops the program with an error:

days = ("Monday", "Tuesday", "Wednesday")
days[0] = "Sunday"

Traceback (most recent call last):
  File "prog.py", line 2, in <module>
    days[0] = "Sunday"
    ~~~~^^^
TypeError: 'tuple' object does not support item assignment

3.2.3Sets

A set is written with curly brackets, for example $\text{{85, }\text{92, }\text{78}}$. It is a collection of unique and unordered elements: a set cannot hold duplicate values, and if the same value is added twice only one copy is kept. Because it is unordered, a set has no index. Sets are used to store unique usernames, product IDs and so on, and the $\text{in}$ operator checks very quickly whether an element is present.

grades = {85, 92, 78, 92, 85, 95}
print(grades)
grades.add(88)
print(grades)
if 92 in grades:
    print("Student has 92 among the grades.")

{92, 85, 78, 95}
{78, 85, 88, 92, 95}
Student has 92 among the grades.

Sets also support the mathematical operations union, intersection and difference:

a = {1, 2, 3, 4}
b = {3, 4, 5}
print(a | b)        # union: items in either set
print(a & b)        # intersection: items in both sets
print(a - b)        # difference: items in a but not in b
a.discard(1)        # remove an item (no error if missing)
print(a, len(a))

{1, 2, 3, 4, 5}
{3, 4}
{1, 2}
{2, 3, 4} 3

3.2.4DictionaryOften examined

A dictionary stores data as key-value pairs, written as $\text{{key: }\text{value}}$. Each key is linked with one value, just like a phone book where the person's name (key) is linked with the phone number (value). A list is searched by index, while a dictionary is searched by its key.

• Keys must be unique and unchangeable (immutable) types such as strings, integers or tuples. A duplicate key is not created; assigning to an existing key updates its value.
• Values can be any type: text, numbers, lists and even other dictionaries.
• Dictionaries keep the link between keys and values (for example usernames and passwords) and, in Python 3.7 and later, remember the order in which keys were inserted.

student_grades = {
    'Amir': 90,
    'Bilal': 85,
    'Dilawar': 92
}

for student, grade in student_grades.items():
    print(f"{student}: {grade}")

student_grades['Zaid'] = 88
student_grades['Bilal'] = 87

del student_grades['Dilawar']

if 'Dilawar' in student_grades:
    print(f"\n Dilawar's grade:", student_grades['Dilawar'], "\n")
else:
    print("Student Dilawar not found \n")

for student, grade in student_grades.items():
    print(f"{student}: {grade}")

Amir: 90
Bilal: 85
Dilawar: 92
Student Dilawar not found 

Amir: 90
Bilal: 87
Zaid: 88

Amir: 90
Bilal: 85
Dilawar: 92

 Dilawar's grade: 92 

Amir: 90
Bilal: 87
Dilawar: 92
Zaid: 88

student_test_number = {}
while True:
    name = input("Enter student name (or 'q' to quit): ")
    if name.lower() == 'q':
        break
    grade = float(input("Enter Test-Number for {}: ".format(name)))
    student_test_number[name] = grade

name = input("Enter student name to view test-number: ")
if name in student_test_number:
    print(f"{name}'s test-number: {student_test_number[name]}")
else:
    print(f"Student '{name}' not found.")

Enter student name (or 'q' to quit): Amir
Enter Test-Number for Amir: 90
Enter student name (or 'q' to quit): Bilal
Enter Test-Number for Bilal: 87
Enter student name (or 'q' to quit): Dilawar
Enter Test-Number for Dilawar: 92
Enter student name (or 'q' to quit): Zaid
Enter Test-Number for Zaid: 88
Enter student name (or 'q' to quit): q
Enter student name to view test-number: Bilal
Bilal's test-number: 87.0

Finding a value in a dictionary versus a list

Searching a dictionary takes much less time than searching a list. To find a value in a list, Python checks the items one by one (linear search), so the time grows with the size of the list. A dictionary uses the key to jump directly to the value (hashing), so the time stays almost the same however large it is. The book tested this with 1 lakh (100 000) random 4-character entries; the program below repeats the experiment.

import random, string, time

# 1 lakh (100000) random 4-letter strings in a list, and the same strings as dictionary keys
words = [''.join(random.choices(string.ascii_lowercase, k=4)) for i in range(100000)]
table = {w: n for n, w in enumerate(words)}
target = words[-1]                      # worst case for the list: the last item

start = time.perf_counter()
found_in_list = target in words         # list: checks items one by one
list_time = (time.perf_counter() - start) * 1000

start = time.perf_counter()
found_in_dict = target in table         # dictionary: jumps straight to the key
dict_time = (time.perf_counter() - start) * 1000

print("Searching for:", target, found_in_list, found_in_dict)
print(f"List search time: {list_time:.4f} msec")
print(f"Dictionary search time: {dict_time:.4f} msec")
print("Dictionary is faster:", dict_time < list_time)

Searching for: nyss True True
List search time: 0.7784 msec
Dictionary search time: 0.0014 msec
Dictionary is faster: True

student_grades = {'Amir': 90, 'Bilal': 85, 'Dilawar': 92}

name = input("Enter student name to search: ")
if name in student_grades:
    print(f"{name}'s grade: {student_grades[name]}")
else:
    choice = input(f"{name} not found. Add this student? (y/n): ")
    if choice.lower() == 'y':
        grade = int(input(f"Enter grade for {name}: "))
        student_grades[name] = grade
        print(f"{name} added.")

for student, grade in student_grades.items():
    print(f"{student}: {grade}")

Enter student name to search: Sana
Sana not found. Add this student? (y/n): y
Enter grade for Sana: 77
Sana added.
Amir: 90
Bilal: 85
Dilawar: 92
Sana: 77

3.2.5Nested listOften examined

A nested list is a list of lists: its elements (inner lists or sub-lists) are themselves lists, which may contain further lists. Nested lists are very useful for complex data such as matrices, where each inner list holds one row. The element in row $r$ and column $c$ is reached with two indexes: $\text{matrix[r][c]}$.

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]
print(matrix)

for i in matrix:
    print(i)

for row in range(len(matrix)):
    for col in range(len(matrix)):
        print(matrix[row][col], end=', ')

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
1, 2, 3, 4, 5, 6, 7, 8, 9, 

To print the elements in matrix form with the nested loop (the book leaves this as an activity), print a new line after each row:

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for row in range(len(matrix)):
    for col in range(len(matrix[row])):
        print(matrix[row][col], end="  ")
    print()                  # new line after each row

1  2  3  
4  5  6  
7  8  9  

Transpose of a matrix

The transpose of a matrix swaps rows and columns: the element at row $r$, column $c$ moves to row $c$, column $r$. So in the program the indexes of the transpose are reversed: $\text{trans[col][row] }\text{= }\text{matrix[row][col]}$.

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print('Matrix is: ', matrix)
for i in matrix:
    print(i)

trans = [
    [0, 0, 0],
    [0, 0, 0],
    [0, 0, 0]
]

for row in range(len(matrix)):
    for col in range(len(matrix)):
        trans[col][row] = matrix[row][col]

print('Transpose of the Matrix is: ', trans)
for j in trans:
    print(j)

Matrix is:  [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]
Transpose of the Matrix is:  [[1, 4, 7], [2, 5, 8], [3, 6, 9]]
[1, 4, 7]
[2, 5, 8]
[3, 6, 9]

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
trans = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
for row in range(len(matrix)):
    for col in range(len(matrix)):
        trans[row][col] = matrix[row][col]     # indices NOT swapped: a copy, not a transpose
print('Transpose of the Matrix is: ', trans)

Transpose of the Matrix is:  [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
for row in range(len(matrix)):
    for col in range(len(matrix[row])):
        if matrix[row][col] % 2 != 0:          # odd value: invert the sign
            matrix[row][col] = -matrix[row][col]
        else:                                  # even value: multiply by 2
            matrix[row][col] = matrix[row][col] * 2

for r in matrix:
    print(r)

[-1, 4, -3]
[8, -5, 12]
[-7, 16, -9]

def transpose(m):
    n = len(m)
    t = [[0] * n for i in range(n)]
    for row in range(n):
        for col in range(n):
            t[col][row] = m[row][col]
    return t

def is_symmetric(m):
    return m == transpose(m)          # symmetric if X equals its transpose

X = [[1, 7, 3],
     [7, 4, 5],
     [3, 5, 6]]
Y = [[1, 2, 3],
     [4, 5, 6],
     [7, 8, 9]]
print("X is symmetric:", is_symmetric(X))
print("Y is symmetric:", is_symmetric(Y))

X is symmetric: True
Y is symmetric: False

3.2.6List as a value in dictionary

A dictionary holds one value per key, but that value can be a list, so several values can be stored under a single key. For example, each student's record can be stored with the student's name as the key and a list holding the registration number and marks as the value.

students = {
    "Sara": ["345", 85, 90, 78],
    "Jamal": ["678", 75, 88, 92],
    "Zaid": ["912", 80, 79, 95]
}

sara_reg_num = students["Sara"][0]
print("Sara's Reg. No.: ", sara_reg_num)
jamal_marks = students["Jamal"][1]
print("Jamal's Marks for first subject are: ", jamal_marks)

students["Azra"] = ["234", 78, 85, 90]
print(students, "\n")

student_name = "Azra"
subject_index = 2
new_mark = 100
if student_name in students:
    students[student_name][subject_index] = new_mark
    print(f"*** Marks updated for {student_name} at index {subject_index} \n")
else:
    print("Student not found \n")

for name, details in students.items():
    print(f"Name: {name}")
    print(f"Registration Number: ", {details[0]})
    print(f"Marks: [", end='')
    print(details[1], ',', details[2], ',', details[3], "]\n")

Sara's Reg. No.:  345
Jamal's Marks for first subject are:  75
{'Sara': ['345', 85, 90, 78], 'Jamal': ['678', 75, 88, 92], 'Zaid': ['912', 80, 79, 95], 'Azra': ['234', 78, 85, 90]} 

*** Marks updated for Azra at index 2 

Name: Sara
Registration Number:  {'345'}
Marks: [85 , 90 , 78 ]

Name: Jamal
Registration Number:  {'678'}
Marks: [75 , 88 , 92 ]

Name: Zaid
Registration Number:  {'912'}
Marks: [80 , 79 , 95 ]

Name: Azra
Registration Number:  {'234'}
Marks: [78 , 100 , 90 ]

# Each class studies 8 subjects and each teacher teaches 2 of them,
# so every class has 8 / 2 = 4 teachers stored in a list.
school = {
    "Class 1": ["Ms. Amna", "Mr. Bilal", "Ms. Sadia", "Mr. Kamran"],
    "Class 2": ["Ms. Hina", "Mr. Tariq", "Ms. Nida", "Mr. Usman"],
}
school["Class 3"] = ["Ms. Rabia", "Mr. Faisal", "Ms. Sana", "Mr. Imran"]   # add a class
school["Class 2"][1] = "Mr. Waqas"                                       # replace one teacher

for cls, teachers in school.items():
    print(cls, "->", ", ".join(teachers), f"({len(teachers)} teachers)")

Class 1 -> Ms. Amna, Mr. Bilal, Ms. Sadia, Mr. Kamran (4 teachers)
Class 2 -> Ms. Hina, Mr. Waqas, Ms. Nida, Mr. Usman (4 teachers)
Class 3 -> Ms. Rabia, Mr. Faisal, Ms. Sana, Mr. Imran (4 teachers)

3.2.7Files in PythonOften examined

Importance of disk I/O

Disk input/output (disk I/O) means reading data from, and writing data to, a storage device such as a hard disk (HDD) or SSD. Disk I/O is the bridge between the CPU and the disk: relevant data is passed from the disk to the CPU for processing and is later stored back on permanent storage. Almost every computer operation depends on this continuous exchange: launching programs, opening files and saving the changes made by the user. Fast, efficient disk I/O is therefore vital for good system performance.

Variables live in RAM and are lost when a program ends. A file stores data permanently on the disk, so a program can save results and read them again later. Reading a file from the hard disk is an example of disk I/O; storing a value in a variable is not.

Types of files

File handling methods and operations

Data in a file is brought from the storage device into RAM, where the file can be created, read, updated and closed. Python's file handling methods are:

• open() gives access to a file. It takes 2 arguments: the file name (with the complete path if it is in another folder) and the mode of operation (reading, writing, appending and so on). It returns a file handler (file object) that is used for every later operation.
• read() extracts the contents of a file opened in read mode; the complete contents are returned as one string. $\text{readline()}$ reads one line and $\text{readlines()}$ returns a list of lines.
• write() adds new material to a file opened in write or append mode.
• close() closes the file when work is finished. This guarantees data integrity (all data is really saved) and releases the system memory used by the file.

new_file = open("abc.txt", "w")
new_file.write("The quick brown fox jumps over the lazy dog !!!")

print("File created and written to successfully!")
new_file.close()

File created and written to successfully!

The quick brown fox jumps over the lazy dog !!!

with open("abc.txt", "w") as file:
    file.write("The quick brown fox jumps over the lazy dog")

print("File created and written to successfully!")

File created and written to successfully!

The quick brown fox jumps over the lazy dog

with open("abc.txt", "r") as file:
    for char in file.read():
        print(char, end="")
print("\nFile read character by character successfully!")

The quick brown fox jumps over the lazy dog
File read character by character successfully!

Handling file errors with try-except

Errors may arise while working with files, for example opening a file that does not exist, reading from a file, or problems when writing data. Such an error normally ends the program abnormally. To avoid this, file operations are placed in a try block and particular exceptions such as FileNotFoundError, PermissionError or IOError are handled in except blocks.

try:
    with open("abc.txt", "r") as file:
        for char in file.read():
            print(char, end="")
    print("\nFile read successfully")
except FileNotFoundError:
    print("Error: The file does not exist.")
except IOError:
    print("Error: An issue occurred while reading the file.")

The quick brown fox jumps over the lazy dog
File read successfully

Error: The file does not exist.

Appending and reading line by line

with open("notes.txt", "w") as f:            # "w" creates the file (or empties it)
    f.write("Line 1: Lists\n")
with open("notes.txt", "a") as f:            # "a" adds at the end, old text is kept
    f.write("Line 2: Files\n")
    f.write("Line 3: Databases\n")

with open("notes.txt", "r") as f:
    print(f.readline(), end="")              # readline(): one line
    rest = f.readlines()                     # readlines(): list of the remaining lines
print(rest)

Line 1: Lists
['Line 2: Files\n', 'Line 3: Databases\n']

A binary file is opened with a "b" in the mode, and Python reads and writes bytes instead of text:

data = bytes([72, 105, 33, 0, 255])          # five raw byte values 0 to 255
with open("data.bin", "wb") as f:            # "wb": write binary
    f.write(data)
with open("data.bin", "rb") as f:            # "rb": read binary
    content = f.read()
print(content)
print(list(content), len(content), "bytes")

b'Hi!\x00\xff'
[72, 105, 33, 0, 255] 5 bytes

try:
    with open("abc.txt", "r") as source, open("xyz.txt", "w") as target:
        count = 0
        for char in source.read():       # read character by character
            target.write(char)           # write each character to xyz.txt
            count += 1
    print(count, "characters copied from abc.txt to xyz.txt")
    with open("xyz.txt", "r") as check:
        print("xyz.txt contains:", check.read())
except FileNotFoundError:
    print("Error: abc.txt does not exist.")

43 characters copied from abc.txt to xyz.txt
xyz.txt contains: The quick brown fox jumps over the lazy dog

3.2.8GUI in Python

A graphical user interface (GUI) lets the user work with a program through windows, menus, text fields and buttons, instead of typing commands as in a command-line interface (CLI). A GUI improves usability and accessibility.

Tkinter is Python's built-in library for creating GUIs. It handles common tasks such as taking user input and deciding what happens when a button is clicked. With Tkinter programmers build desktop applications (word processors, media players, basic utilities) and simple 2D games. The arrangement of GUI components and the logic behind them are generally kept separate in the code.

Widget

A basic component of the interface: labels, buttons, text boxes (Entry), check boxes. Widgets are arranged and modified to get the required layout.

Event handling

Writing code that responds to events such as mouse clicks, key presses and window resizing. A Button's $\text{command}$ names the function to run when it is clicked.

Main loop

$\text{mainloop()}$ keeps the window open, waiting for and handling events. Without it the window would just flash and disappear.

Simple number adder with GUI

Steps to create an adder that takes two numbers and shows their sum when the Add button is pressed:

1. Import the library: $\text{import }\text{tkinter }\text{as }\text{tk}$.
2. Define $\text{add\_numbers()}$: read both boxes with $\text{get()}$, convert them to numbers and show the sum in the result label; if the user types letters, a ValueError is caught and an error message is shown.
3. Define $\text{clear\_fields()}$: delete the text of both boxes from position 0 to the end and reset the label.
4. Create the main window: $\text{root }\text{= }\text{tk.Tk()}$ and $\text{root.title("Simple }\text{Adder")}$.
5. Create two Entry boxes, 10 characters wide, in row 0 (columns 0 and 1) with 5 pixels of padding ($\text{padx}$, $\text{pady}$).
6. Add the buttons in row 1: "Add" calls $\text{add\_numbers}$ and "Clear" calls $\text{clear\_fields}$.
7. Add the result label in row 2, spread across both columns with $\text{columnspan=2}$.
8. Run the GUI with $\text{root.mainloop()}$.

import tkinter as tk

def add_numbers():
    try:
        num1 = float(entry1.get())
        num2 = float(entry2.get())
        result_label.config(text=f"Sum: {int(num1 + num2)}")
    except ValueError:
        result_label.config(text="Invalid input. Please enter numbers.")

def clear_fields():
    entry1.delete(0, tk.END)
    entry2.delete(0, tk.END)
    result_label.config(text="Result will be displayed here.")

root = tk.Tk()
root.title("Simple Adder")

entry1 = tk.Entry(root, width=10)
entry1.grid(row=0, column=0, padx=5, pady=5)

entry2 = tk.Entry(root, width=10)
entry2.grid(row=0, column=1, padx=5, pady=5)

add_button = tk.Button(root, text="Add", command=add_numbers)
add_button.grid(row=1, column=0, padx=5, pady=5)

clear_button = tk.Button(root, text="Clear", command=clear_fields)
clear_button.grid(row=1, column=1, padx=5, pady=5)

result_label = tk.Label(root, text="Result will be displayed here.")
result_label.grid(row=2, column=0, columnspan=2, padx=5, pady=5)

root.mainloop()

Developing a game using tkinter: the colour game

The word shown is the name of one colour, but it is displayed in a different (random) colour to confuse the player. The player must type the colour of the text, spelled correctly. Only a correct colour increases the score.

1. Create a Python file and import $\text{tkinter}$ and $\text{random}$.
2. Set a list of colours.
3. Game logic: set $\text{score = 0}$. $\text{new\_round()}$ picks a random word $\text{color\_to\_guess}$ and a random display colour $\text{random\_color}$, shows the word in that colour and clears the entry. $\text{check\_answer()}$ compares the player's input with $\text{random\_color}$; if correct the score increases, otherwise "(Incorrect)" is shown; then a new round starts.
4. GUI: main window titled "Color Game", a label for the word, an entry for the answer, a Check button and a score label.
5. Start: call $\text{new\_round()}$ for the first round, then $\text{window.mainloop()}$.

import tkinter as tk
import random

window = tk.Tk()
window.title("Color Game")
score = 0
colors = ["red", "blue", "green", "yellow", "pink", "black",
          "orange", "purple", "brown"]

def new_round():
    global score
    global color_to_guess, random_color
    color_to_guess = random.choice(colors)
    random_color = random.choice(colors)
    label.config(text=color_to_guess, fg=random_color)
    entry.delete(0, tk.END)

def check_answer():
    global score
    user_input = entry.get().lower()
    if user_input == random_color:
        score += 1
        score_label.config(text="Score: " + str(score))
    else:
        score_label.config(text="Score: " + str(score) + " (Incorrect)")
    new_round()

label = tk.Label(window, font=("Arial", 24))
label.pack(pady=20)

entry = tk.Entry(window, font=("Arial", 18))
entry.pack()

check_button = tk.Button(window, text="Check", command=check_answer)
check_button.pack(pady=10)

score_label = tk.Label(window, text="Score: 0")
score_label.pack()

new_round()
window.mainloop()

Output: a window titled "Color Game" shows a colour name (for example "pink") written in another colour, an entry box, a Check button and the score line, such as "Score: 1 (Incorrect)" after a wrong answer. The keyword $\text{global}$ is needed because the functions change variables created outside them.

Pygame

Pygame is a Python library (installed with $\text{pip }\text{install }\text{pygame}$) mainly used for 2D games. It opens a window, draws shapes and images, and reads keyboard and mouse events inside a game loop that runs many times per second. The steps for a Pygame GUI program are: import and initialise ($\text{pygame.init()}$), create the window ($\text{pygame.display.set\_mode()}$), run the game loop (handle events, update, draw), refresh the screen ($\text{pygame.display.flip()}$) and finally $\text{pygame.quit()}$. A complete Pygame program is given in the answers to ERQ 7 and Mini project 1.

3.2.9DatabasesOften examined

A database is a set of data organised in a systematic manner, usually in a computer system. It stores, retrieves and handles a large number of records for multiple users, and lets users find specific information quickly and accurately. A database is the central source of data for almost every software program: when a user logs in, shops online or makes a transaction, the database saves the relevant data (login time, items purchased, account used) so it can be retrieved later.

Why databases are used

• They remove the redundancy (repetition) and inconsistency that are common in manual record keeping.
• They ensure the reliability of data.
• They allow concurrent access: several users can work on the same data at the same time.
• They provide security measures to protect sensitive information from unwanted access.
• They give effective information retrieval and help in data analysis.

Types of databases

Key concepts

Table

The fundamental structure of a relational database, made of rows and columns. Each row is a record and each column is a field.

Record

A single row of a table holding information about one entity; for example a client record with name, address and telephone number.

Field

A piece of data within a record that defines the information placed in one column; for example a Name field stores text and an Age field stores a number.

Data integrity

The accuracy and consistency of data in a database, so that the data is correct, dependable and fit for use.

Primary and secondary keys

Keys uniquely identify records and create links among tables. The most common keys used in normalization are:

Primary key

A minimal set of attributes that uniquely identifies each record of a table. It can be one attribute or a combination of attributes. It cannot be empty (NULL) or repeated. Example: $\text{C\_ID}$ in the Customer table.

Candidate key

A single attribute or set of attributes that can identify a record uniquely. A table may have several candidate keys; one is chosen as the primary key and the rest are called secondary (alternate) keys. Example: in a Student table both RollNo and CNIC are candidate keys.

Foreign key

A field in one table that refers to the primary key of another table, creating a relationship between them. Example: $\text{C\_ID}$ in the Order table refers to the Customer table.

Composite key

A key made of two or more attributes that together identify a row uniquely. Example: (OrderID, L_ID) when one order can contain several laptops.

Data normalization

Data normalization is a database design technique that organises data into smaller, inter-linked tables to reduce redundancy (duplicate storage of the same data) and dependency. Redundant data causes problems in keeping data consistent and increases the chance of mistakes during updates. For example, if a customer's address is stored in many rows, every address change must be made in many places; missing one leaves the data inconsistent. Normalization stores the address once, in a Customer table, linked to other tables by a key such as the customer ID. Every table then represents one entity and keys define the relationships.

Worked example: a laptop shop database

Step 1: identify the entities and their attributes. Customer: C_ID, C_Name, C_Address, C_Phone. Laptop: L_ID, L_Name, L_Price, L_Brand. Order: OrderID, OrderDate, C_ID, L_ID, Quantity.

Step 2: the unnormalized data in one table. Customer and laptop details repeat in every order:

Step 3: 1NF. The repeating groups are the customer information and the laptop information repeated for each order. They are moved to separate tables: Customer(C_ID, C_Name, C_Address, C_Phone), Laptop(L_ID, L_Name, L_Price, L_Brand) and Order(OrderID, OrderDate, C_ID, L_ID, Quantity).

Step 4: 2NF. An order may contain several laptops, so a row of the Order table is identified by the composite key (OrderID, L_ID). OrderDate depends only on OrderID, which is part of the key: a partial dependency. It is moved to a new table OrderDetails(OrderID, OrderDate), and the Order table keeps (OrderID, C_ID, L_ID, Quantity).

Step 5: 3NF. In the original table, L_Name, L_Price and L_Brand depend on L_ID, and L_ID depends on the order: a transitive dependency (OrderID $\to$ L_ID $\to$ L_Price). The same is true of the customer details through C_ID. In the tables above the Order table only references L_ID and C_ID (foreign keys) and every laptop or customer detail is stored once, so the four tables Customer, Laptop, Order and OrderDetails are in 3NF.

Database tools

Advantages of SQLite: it occupies little space, so it suits applications with limited resources; it is easily integrated into applications, so it is easy to use and deploy; it has a serverless architecture that removes unnecessary dependencies; and the complete database is saved in a single file.

3.2.10Create a database with SQLiteOften examined

1. Installation of SQLite

Download SQLite (DB Browser for SQLite) for your Windows version from the official website (https://sqlitebrowser.org/dl/). The download is a compressed (ZIP) file: right-click it and choose "Extract All" to get a folder of ready-to-use files. To check the installation, open the Command Prompt (type cmd in the Windows search bar), move to the extracted folder with the $\text{cd}$ command (for example $\text{cd }\text{C:Downloadssqlite}$), type $\text{sqlite3}$ and press Enter. If SQLite's own prompt appears, it is installed.

2. Database creation

Open the terminal, type $\text{sqlite3}$ and press Enter to enter the SQLite shell. The command $\text{.open }\text{NBF.db}$ creates a new database file NBF.db in the current folder (or opens it if it exists).

C:\Downloads\sqlite> sqlite3
sqlite> .open NBF.db

3. Creating a table

$\text{CREATE }\text{TABLE}$ takes the table name, the column names and their data types. The table Laptop has four columns: L_ID (text, primary key), L_Name (text), L_Price (integer) and L_Brand (text). $\text{NOT NULL}$ means the column cannot be left empty. At this stage only the schema (structure) exists; the table has no records.

CREATE TABLE Laptop (
    L_ID TEXT PRIMARY KEY,
    L_Name TEXT NOT NULL,
    L_Price INTEGER NOT NULL,
    L_Brand TEXT NOT NULL
);

4. Adding records

$\text{INSERT INTO}$ adds a row. It needs the table name, the column names and the values, in the same sequence as the columns.

INSERT INTO Laptop (L_ID, L_Name, L_Price, L_Brand)
VALUES ('L1', 'Dell XPS 13', 100000, 'Dell');

Several records can be added with a single $\text{INSERT INTO}$ command:

INSERT INTO Laptop (L_ID, L_Name, L_Price, L_Brand)
VALUES
    ('L2', 'MacBook Air', 90000, 'Apple'),
    ('L3', 'HP Spectre x360', 120000, 'HP');

L_ID  L_Name           L_Price  L_Brand
----  ---------------  -------  -------
L1    Dell XPS 13      100000   Dell
L2    MacBook Air      90000    Apple
L3    HP Spectre x360  120000   HP

CREATE TABLE Customer (C_ID TEXT PRIMARY KEY, C_Name TEXT NOT NULL, C_Address TEXT, C_Phone TEXT);
CREATE TABLE OrderDetails (OrderID INTEGER PRIMARY KEY, OrderDate TEXT NOT NULL);
CREATE TABLE "Order" (OrderID INTEGER, C_ID TEXT, L_ID TEXT, Quantity INTEGER,
    PRIMARY KEY (OrderID, L_ID),
    FOREIGN KEY (OrderID) REFERENCES OrderDetails(OrderID),
    FOREIGN KEY (C_ID) REFERENCES Customer(C_ID));

INSERT INTO Customer VALUES
    ('C1', 'Qamar', 'House: 123', '123-4567'),
    ('C2', 'Mahtab', 'House: 456', '987-6543'),
    ('C3', 'Chaand', 'House: 789', '543-2109');
INSERT INTO OrderDetails VALUES
    (1, '20-11-2024'), (2, '21-11-2024'), (3, '22-11-2024'), (4, '23-11-2024'), (5, '24-11-2024');
INSERT INTO "Order" VALUES
    (1, 'C1', 'L1', 1), (2, 'C2', 'L2', 2), (3, 'C1', 'L3', 1), (4, 'C2', 'L1', 1), (5, 'C3', 'L2', 2);

SELECT o.OrderID, d.OrderDate, c.C_Name, o.L_ID, o.Quantity
FROM "Order" o
JOIN OrderDetails d ON o.OrderID = d.OrderID
JOIN Customer c ON o.C_ID = c.C_ID;

OrderID  OrderDate   C_Name  L_ID  Quantity
-------  ----------  ------  ----  --------
1        20-11-2024  Qamar   L1    1
2        21-11-2024  Mahtab  L2    2
3        22-11-2024  Qamar   L3    1
4        23-11-2024  Mahtab  L1    1
5        24-11-2024  Chaand  L2    2

5. Querying records with SELECT

$\text{SELECT}$ is the most used query. $\text{*}$ means all columns; alternatively list the column names to show only those columns. A $\text{WHERE}$ clause adds a condition, so only the matching record(s) are fetched.

SELECT * FROM Customer;

C_ID  C_Name  C_Address   C_Phone
----  ------  ----------  --------
C1    Qamar   House: 123  123-4567
C2    Mahtab  House: 456  987-6543
C3    Chaand  House: 789  543-2109

SELECT * FROM Customer
WHERE C_ID = 'C2';

C_ID  C_Name  C_Address   C_Phone
----  ------  ----------  --------
C2    Mahtab  House: 456  987-6543

SELECT L_Name, L_Price FROM Laptop
WHERE L_Price >= 100000;

L_Name           L_Price
---------------  -------
Dell XPS 13      100000
HP Spectre x360  120000

6. Update record

$\text{UPDATE }\text{... }\text{SET }\text{... }\text{WHERE}$ changes a record or a column. Good practice: first run a SELECT with the same WHERE clause to see which record will change, then run the UPDATE. Without WHERE, every row would be updated.

UPDATE Customer
SET C_Address = 'New Address'
WHERE C_ID = 'C1';

C_ID  C_Name  C_Address    C_Phone
----  ------  -----------  --------
C1    Qamar   New Address  123-4567
C2    Mahtab  House: 456   987-6543
C3    Chaand  House: 789   543-2109

7. Use of ORDER BY clause

$\text{ORDER BY}$ displays the result in sorted order, ascending by default. The keyword $\text{DESC}$ sorts in descending order.

SELECT * FROM Customer
ORDER BY C_Name;

C_ID  C_Name  C_Address    C_Phone
----  ------  -----------  --------
C3    Chaand  House: 789   543-2109
C2    Mahtab  House: 456   987-6543
C1    Qamar   New Address  123-4567

SELECT * FROM Customer
ORDER BY C_Name DESC;

C_ID  C_Name  C_Address    C_Phone
----  ------  -----------  --------
C1    Qamar   New Address  123-4567
C2    Mahtab  House: 456   987-6543
C3    Chaand  House: 789   543-2109

8. Deletion of records

$\text{DELETE FROM}$ removes one or more records. The table structure stays in the database. Like SELECT, it works on all records if there is no WHERE clause, and only on the selected records with a WHERE clause. $\text{IN}$ matches any value in a list. The name Order is written in quotes because ORDER is an SQL keyword.

DELETE FROM "Order" WHERE L_ID IN ('L1', 'L2', 'L3');

OrderID  C_ID  L_ID  Quantity
-------  ----  ----  --------
(no rows)

Connecting Python to a database

Python's built-in $\text{sqlite3}$ module lets a program use a database directly. The steps are: connect, create a cursor, execute SQL, commit the changes, fetch results and close the connection. The $\text{?}$ placeholders pass values safely into the SQL command.

import sqlite3

conn = sqlite3.connect("school.db")          # 1. connect (creates the file if needed)
cur = conn.cursor()                          # 2. cursor: sends SQL to the database

cur.execute("""CREATE TABLE IF NOT EXISTS Student (
                   RollNo INTEGER PRIMARY KEY,
                   Name TEXT NOT NULL,
                   Marks INTEGER)""")        # 3. run SQL commands
cur.execute("INSERT INTO Student VALUES (?, ?, ?)", (1, "Ali", 78))
cur.execute("INSERT INTO Student VALUES (?, ?, ?)", (2, "Sana", 91))
conn.commit()                                # 4. save the changes permanently

cur.execute("SELECT * FROM Student")
for row in cur.fetchall():                   # 5. fetch the result rows
    print(row)
conn.close()                                 # 6. close the connection

(1, 'Ali', 78)
(2, 'Sana', 91)

3.3Techniques for testing and debuggingOften examined

Testing checks whether a program gives the correct results; it ensures the correctness of code. Debugging is the process of analysing the code to find the bugs (errors) that testing reveals, locating them and fixing them, so that the error-free program runs smoothly and gives the desired results.

3.3.1DebuggingOften examined

Debugging with print statements

The simplest debugging method is to add print statements to check whether the program is behaving as expected. This does not mean a print after every line. Wherever a formula, an expression or a critical value update occurs, a print statement shows whether that variable, line or block is working as desired. Each print is labelled so we know which one produced the output.

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transpose = []

for col in range(len(matrix[0])):
    new_row = []
    print('Print1-Outer Loop: ', new_row)
    for row in range(len(matrix)):
        new_row.append(matrix[col][row])
        print('Print2-Inner Loop: row: ', row, '- col: ', col)
    print('Print3-Outer Loop: ', new_row)
    transpose.append(new_row)
for row in transpose:
    print(row)

Print1-Outer Loop:  []
Print2-Inner Loop: row:  0 - col:  0
Print2-Inner Loop: row:  1 - col:  0
Print2-Inner Loop: row:  2 - col:  0
Print3-Outer Loop:  [1, 2, 3]
Print1-Outer Loop:  []
Print2-Inner Loop: row:  0 - col:  1
Print2-Inner Loop: row:  1 - col:  1
Print2-Inner Loop: row:  2 - col:  1
Print3-Outer Loop:  [4, 5, 6]
Print1-Outer Loop:  []
Print2-Inner Loop: row:  0 - col:  2
Print2-Inner Loop: row:  1 - col:  2
Print2-Inner Loop: row:  2 - col:  2
Print3-Outer Loop:  [7, 8, 9]
[1, 2, 3]
[4, 5, 6]
[7, 8, 9]

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
transpose = []

for col in range(len(matrix[0])):
    new_row = []
    for row in range(len(matrix)):
        new_row.append(matrix[row][col])     # bug fixed: row first, then col
    transpose.append(new_row)
for row in transpose:
    print(row)

[1, 4, 7]
[2, 5, 8]
[3, 6, 9]

Advanced debugging: breakpoints and watchpoints

Advanced debugging uses tools of an IDE (such as Visual Studio, VS Code or the online IDE Replit) instead of print commands:

Breakpoint

A marker placed on a line of code. When the program is run in debug mode, it pauses just before that line, so the programmer can inspect the current values of variables and data structures.

Watchpoint (watch)

Set on a variable, expression or formula. The debugger shows its current value every time the program pauses, and can flag when it changes or differs from the expected value.

Stepping

Running the paused program one line at a time (step over, step into) to follow its flow.

Several breakpoints and watchpoints can be placed in one program; these methods are especially useful for complex problems. In Fig. 3.28 the transpose code is run in Replit's debugger with a breakpoint on line 7. At each pause the Variables panel shows col, row, new_row, matrix and transpose, which helps analyse the data and the behaviour of the program.

3.3.2Python unit testOften examined

Unit testing checks small, isolated parts (units) of a program, such as a single function or method, to see that each works correctly. Instead of running the program by hand and checking values each time (which becomes difficult as the code grows), we write small tests once and run them again whenever the code changes. Python's built-in unittest framework supports this.

For a function that performs some operation, we write another function (a test function) that calls it with chosen inputs and uses assertions to compare the actual output with the expected output. The statement $\text{assert }\text{condition, }\text{message}$ does nothing if the condition is True; if it is False it stops the program with an AssertionError that shows the message.

def add(a, b):                  # Function to be tested
    return a + b

def test_add():                 # Test function
    result = add(2, 3)          # Test case 1: Check if 2 + 3 equals 5
    assert result == 5, f"Test failed: Expected 5 but got {result}"

    result = add(0, 0)          # Test case 2: Check if 0 + 0 equals 0
    assert result == 0, f"Test failed: Expected 0 but got {result}"

    result = add(-1, 1)         # Test case 3: Check if -1 + 1 equals 0
    assert result == 0, f"Test failed: Expected 0 but got {result}"

    print("All tests passed!")

test_add()                      # Run the test function

All tests passed!

Now suppose the expected result on line 12 is wrongly written as 2 (the negative value on line 11 was overlooked). The test fails:

def add(a, b):                  # Function to be tested
    return a + b

def test_add():                 # Test function
    result = add(2, 3)          # Test case 1: Check if 2 + 3 equals 5
    assert result == 5, f"Test failed: Expected 5 but got {result}"

    result = add(0, 0)          # Test case 2: Check if 0 + 0 equals 0
    assert result == 0, f"Test failed: Expected 0 but got {result}"

    result = add(-1, 1)         # Test case 3: Check if -1 + 1 equals 0
    assert result == 2, f"Test failed: Expected 2 but got {result}"

    print("All tests passed!")

test_add()                      # Run the test function

Traceback (most recent call last):
  File "prog.py", line 16, in <module>
    test_add()                      # Run the test function
    ^^^^^^^^^^
  File "prog.py", line 12, in test_add
    assert result == 2, f"Test failed: Expected 2 but got {result}"
           ^^^^^^^^^^^
AssertionError: Test failed: Expected 2 but got 0

To investigate, the book places breakpoints on lines 6, 9 and 12 and adds the variable $\text{result}$ as a watch (Fig. 3.30). At the first breakpoint the watch shows result = 5 (as expected, Fig. 3.31) and at the second result = 0 (as expected, Fig. 3.32). At the third breakpoint the watch shows result = 0 while line 12 expects 2, so the debugger flags the mismatch and points to the bug (Fig. 3.33).

def multiply(a, b):
    return a * b

def test_multiply():
    result = multiply(2, 3)
    assert result == 6, f"Test failed: Expected 6 but got {result}"

    result = multiply(4, 0)
    assert result == 1, f"Test failed: Expected 1 but got {result}"

    result = multiply(-1, -1)
    assert result == 1, f"Test failed: Expected 1 but got {result}"

    print("All tests passed!")

test_multiply()

Traceback (most recent call last):
  File "prog.py", line 16, in <module>
    test_multiply()
  File "prog.py", line 9, in test_multiply
    assert result == 1, f"Test failed: Expected 1 but got {result}"
           ^^^^^^^^^^^
AssertionError: Test failed: Expected 1 but got 0

The unittest module

The unittest framework groups tests into a class derived from $\text{unittest.TestCase}$. Each method whose name starts with $\text{test\_}$ is one test case, and methods such as $\text{assertEqual()}$ compare actual and expected results. $\text{unittest.main()}$ runs all tests and reports which passed or failed.

import unittest

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

class TestAdd(unittest.TestCase):          # a group of test cases
    def test_positive(self):
        self.assertEqual(add(2, 3), 5)

    def test_zero(self):
        self.assertEqual(add(0, 0), 0)

    def test_negative(self):
        self.assertEqual(add(-1, 1), 0)

unittest.main(verbosity=2)                 # finds and runs every test_ method

test_negative (__main__.TestAdd.test_negative) ... ok
test_positive (__main__.TestAdd.test_positive) ... ok
test_zero (__main__.TestAdd.test_zero) ... ok

----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK

Key terms

Programming paradigm

A style or methodology of writing and organising program code that decides its structure, flow and data management.

Complexity reduction

Breaking a complex problem into simpler parts (functions, objects, modules) that are easier to understand and solve.

Functional programming

A paradigm in which the program is built from functions; it focuses on what to compute and avoids changing state.

Object oriented programming (OOP)

A paradigm based on objects that combine data (attributes) and behaviour (methods), created from classes.

Class

A template or stencil that defines the attributes and methods of its objects.

Object

An instance of a class with its own attribute values, representing a real-world thing.

Attribute

A variable that stores a property (data) of an object.

Method

A function defined inside a class that describes the behaviour of its objects.

Encapsulation

Bundling data and the methods that use it into one class and restricting direct access to the data.

Abstraction

Showing only the essential features of an object and hiding the implementation details.

Inheritance

Creating a new (derived) class from an existing (parent) class so that it reuses the parent's attributes and methods.

Polymorphism

The ability of objects of different classes to respond to the same method call in their own way.

List

An ordered, mutable collection of items written in square brackets and accessed by index.

Tuple

An ordered, immutable collection written in round brackets; it cannot be changed after creation.

Set

An unordered collection of unique elements written in curly brackets; duplicates are removed automatically.

Dictionary

A collection of key-value pairs in which every key is unique and immutable and is used to look up its value.

Nested list

A list whose elements are lists; used to represent matrices and tables.

Transpose

A matrix obtained by swapping the rows and columns of another matrix.

Disk I/O

Reading data from and writing data to a storage disk; the bridge between the CPU and permanent storage.

Text file

A file that stores readable characters, with lines ended by an end-of-line marker.

Binary file

A file that stores raw bytes (0s and 1s), such as images, audio, video and programs.

File handler

The file object returned by open(), used for reading, writing and closing the file.

File mode

The second argument of open() that states the operation: r, w, a, x, r+, or their binary forms rb, wb, ab.

Exception

An error that occurs while a program runs, such as FileNotFoundError; handled with try-except.

GUI

Graphical user interface: interaction through windows, buttons, text fields and menus instead of typed commands.

Tkinter

Python's built-in library for creating GUI applications.

Widget

A basic GUI component such as a label, button, entry box or check box.

Pygame

A Python library used mainly for 2D games; it draws graphics and handles keyboard and mouse events.

Database

An organised collection of data that stores, retrieves and manages many records for multiple users.

Relational database

A database that stores data in tables of rows and columns linked by keys.

NoSQL database

A database without a fixed table structure, for large unstructured or semi-structured data.

Table

The basic structure of a relational database, made of rows (records) and columns (fields).

Record

One row of a table, holding information about one entity.

Field

One column of a table; a single piece of data in a record.

Data integrity

The accuracy and consistency of data in a database.

Primary key

A minimal set of attributes that uniquely identifies each record of a table; never repeated or empty.

Candidate key

An attribute or set of attributes that can uniquely identify a record; one is chosen as the primary key.

Secondary key

A candidate key that was not chosen as the primary key.

Foreign key

A field in one table that refers to the primary key of another table and links the two.

Composite key

A key made of two or more attributes that together identify a row uniquely.

Data normalization

Organising data into smaller related tables to reduce redundancy and dependency.

Redundancy

Unnecessary repetition of the same data in a database.

1NF

First normal form: every cell holds a single atomic value; repeating groups are removed.

2NF

Second normal form: 1NF plus every non-key attribute depends on the whole primary key.

3NF

Third normal form: 2NF plus no non-key attribute depends on another non-key attribute (no transitive dependency).

SQLite

A lightweight, serverless database system that stores the whole database in a single file.

SQL

Structured Query Language, used to create tables and to insert, select, update and delete records.

Testing

Running a program or part of it to check that it gives correct results.

Unit test

A test of one small, isolated unit of code such as a single function or method.

Assertion

A statement (assert) that checks a condition and stops with an AssertionError if it is false.

Debugging

Finding, locating and fixing bugs (errors) in a program.

Breakpoint

A marker on a line of code where the debugger pauses the program.

Watchpoint

A variable or expression whose value the debugger shows and monitors while the program runs.

FBISE 2026 questions

Questions from the FBISE HSSC-II 2026 (1st Annual) papers that belong to this unit, answered the way an examiner expects.

f = open("marks.txt", "w")      # open: returns a file object
f.write("Ali 85\n")
f.close()                       # close: saves data, frees memory

with open("marks.txt", "r") as f:   # opened here ...
    print(f.read(), end="")
# ... and closed automatically here

Ali 85

def square(n):
    return n * n

print(list(map(square, [1, 2, 3, 4])))

[1, 4, 9, 16]

CREATE TABLE Customer (C_ID TEXT PRIMARY KEY, C_Name TEXT, C_Phone TEXT);

class Car:
    def __init__(self, color):
        self.color = color
    def start(self):
        return self.color + " car started"

c = Car("Red")
print(c.start())

Red car started

int a = 5, b = 10, c;
c = a++ * --b;
cout << c;

#include <iostream>
using namespace std;
int main() {
    int a = 5, b = 10, c;
    c = a++ * --b;
    cout << c << endl;
    cout << "a = " << a << ", b = " << b << endl;
    return 0;
}

45
a = 6, b = 9

#include <iostream>
using namespace std;
int main() {
    int a = 12, b;
    b = a++;
    cout << "b = " << b << ", a = " << a << endl;
    cout << "sizeof(float) = " << sizeof(float) << endl;
    return 0;
}

b = 12, a = 13
sizeof(float) = 4

#include <iostream>
using namespace std;
int main() {
    int A[10] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
    int x = 5;
    cout << A[++x] << endl;      // x becomes 6 first: A[6] is the 7th element
    return 0;
}

70

#include <iostream>
using namespace std;
int main() {
    cout << "Line 1\nLine 2" << endl;     // \n: new line
    cout << "ABC\bD" << endl;             // \b: backspace, D overwrites C on screen
    cout << "\a" << "Beep!" << endl;      // \a: alert (bell sound)
    return 0;
}

Line 1
Line 2
ABC<BS>D
Beep!

break;

#include <iostream>
using namespace std;
int main() {
    for (int i = 1; i <= 10; i++) {
        if (i == 5)
            break;              // leave the loop when i is 5
        cout << i << " ";
    }
    cout << endl << "Loop ended";
    return 0;
}

1 2 3 4 
Loop ended

#include <iostream>
using namespace std;
class Demo {
public:
    Demo()  { cout << "Constructor called" << endl; }
    ~Demo() { cout << "Destructor called" << endl; }
};
int main() {
    {
        Demo d;                 // object created: constructor runs
        cout << "Inside block" << endl;
    }                           // object goes out of scope: destructor runs
    cout << "After block" << endl;
    return 0;
}

Constructor called
Inside block
Destructor called
After block

cout<<p;
cout<<*p;

#include <iostream>
using namespace std;
int main() {
    int n = 25;
    int *p = &n;          // p stores the address of n
    cout << (p == &n) << endl;   // cout << p would print this address, e.g. 0x7ffd...
    cout << *p << endl;          // value stored at that address
    return 0;
}

1
25

#include <iostream>
using namespace std;
int main() {
    int marks[2][3] = {{85, 90, 78}, {70, 88, 92}};          // integer 2D array
    float temp[2][2] = {{30.5, 31.2}, {28.4, 29.9}};         // float 2D array

    cout << "Marks:" << endl;
    for (int r = 0; r < 2; r++) {
        for (int c = 0; c < 3; c++)
            cout << marks[r][c] << " ";
        cout << endl;
    }
    cout << "Temperatures:" << endl;
    for (int r = 0; r < 2; r++) {
        for (int c = 0; c < 2; c++)
            cout << temp[r][c] << " ";
        cout << endl;
    }
    return 0;
}

Marks:
85 90 78 
70 88 92 
Temperatures:
30.5 31.2 
28.4 29.9 

#include <iostream>
using namespace std;
int main() {
    int x = 5, y = 15, n = 10;
    int A = (x > 0) && (y < 10);
    int S = 13 + 21 % 4;
    n *= 2;
    cout << "A = " << A << endl << "S = " << S << endl << "n = " << n << endl;
    return 0;
}

A = 0
S = 14
n = 20

if (condition)
{
    // statements when condition is true
}
else
{
    // statements when condition is false
}

#include <iostream>
using namespace std;
int main() {
    int marks = 72;
    if (marks >= 40)
        cout << "Pass";
    else
        cout << "Fail";
    return 0;
}

Pass

#include <iostream>
using namespace std;
class Box {                         // class: the design
public:
    int length;
};
int main() {
    Box b1, b2;                     // objects: real boxes made from the design
    b1.length = 10;
    b2.length = 25;
    cout << b1.length << " " << b2.length << endl;
    return 0;
}

10 25

#include <iostream>
using namespace std;
class Vehicle {                     // base class
public:
    int wheels;
    void start() { cout << "Vehicle started" << endl; }
};
class Car : public Vehicle {        // derived class
public:
    int seats;
};
int main() {
    Car c;
    c.wheels = 4;                   // inherited member
    c.seats = 5;
    c.start();                      // inherited function
    cout << c.wheels << " wheels, " << c.seats << " seats" << endl;
    return 0;
}

Vehicle started
4 wheels, 5 seats

char c = 'A';
do
{
    cout << c << "\t";
    c = c + 2;
}
while (c <= 'K');

#include <iostream>
using namespace std;
int main() {
    char c = 'A';
    do
    {
        cout << c << "\t";
        c = c + 2;
    } while (c <= 'K');
    return 0;
}

A	C	E	G	I	K	

int x = 5;
do {
    cout << x << " ";
    x++;
} while (x < 8);

#include <iostream>
using namespace std;
int main() {
    int x = 5;
    do {
        cout << x << " ";
        x++;
    } while (x < 8);
    return 0;
}

5 6 7 

cout<<(((num%2)==0)?"Even\n":"Odd\n");

if ((num % 2) == 0)
    cout << "Even\n";
else
    cout << "Odd\n";

#include <iostream>
using namespace std;
int main() {
    int num = 7;
    if ((num % 2) == 0)
        cout << "Even\n";
    else
        cout << "Odd\n";
    return 0;
}

Odd

#include <iostream>
using namespace std;
int main() {
    const float PI = 3.14159;    // constant: cannot be changed
    int radius = 2;              // variable: can be changed
    radius = 3;
    cout << PI * radius * radius << endl;
    return 0;
}

28.2743

#include <iostream>
using namespace std;
int main() {
    int marks[10];
    cout << sizeof(int) << " " << sizeof(char) << " " << sizeof(double) << endl;
    cout << sizeof(marks) << endl;       // 10 elements x 4 bytes
    return 0;
}

4 1 8
40

#include <iostream>
using namespace std;
void addBonus(int &m) {       // m is a reference (another name) for the argument
    m = m + 5;
}
int main() {
    int marks = 70;
    int &r = marks;           // r refers to marks
    r = 80;                   // changes marks
    addBonus(marks);
    cout << marks << endl;
    return 0;
}

85

#include <iostream>
using namespace std;
void counter() {
    int local = 0;           // created again on every call
    static int total = 0;    // created once, keeps its value between calls
    local++;
    total++;
    cout << "local = " << local << ", static = " << total << endl;
}
int main() {
    counter();
    counter();
    counter();
    return 0;
}

local = 1, static = 1
local = 1, static = 2
local = 1, static = 3

#include <iostream>
using namespace std;
int sum(int a, int b) {          // a and b: formal parameters
    return a + b;
}
int main() {
    int x = 4, y = 6;
    cout << sum(x, y) << endl;   // x and y: actual parameters (arguments)
    return 0;
}

10

int a (10), i;
cout>>"enter ten numbers";
for(i=0; i<10; i--)
cin << a(i);

int a[10], i;
cout << "enter ten numbers";
for (i = 0; i < 10; i++)
    cin >> a[i];

#include <iostream>
using namespace std;
int main() {
    int a[10], i;
    cout << "enter ten numbers";
    for (i = 0; i < 10; i++)
        cin >> a[i];
    cout << endl << "First: " << a[0] << ", last: " << a[9] << endl;
    return 0;
}

enter ten numbers
First: 1, last: 10

#include <iostream>
#include <string>
using namespace std;
int main() {
    int marks[3] = {80, 75, 90};     // array: many values of one type
    string name = "Ayesha";          // string: sequence of characters
    char city[] = "Lahore";          // C-string: char array ending in '\0'
    cout << marks[1] << " " << name.length() << " " << sizeof(city) << endl;
    return 0;
}

75 6 7

#include <iostream>
#include <string>
using namespace std;

class Student {
public:                         // public data members
    int rollNo;
    string name;
    float marks;

    void get() {                // member function to input the data
        cin >> rollNo >> name >> marks;
    }
    void show() {
        cout << rollNo << " " << name << " " << marks << endl;
    }
};

int main() {
    Student s;                  // object of class Student
    s.get();
    s.show();
    return 0;
}

12 Hina 88.5

#include <iostream>
using namespace std;
int area(int side) { return side * side; }                   // square
int area(int l, int w) { return l * w; }                     // rectangle
double area(double r) { return 3.14 * r * r; }               // circle
int main() {
    cout << area(4) << " " << area(5, 3) << " " << area(2.0) << endl;
    return 0;
}

16 15 12.56

Exam focus

1. What is functional programming? Two pros and two cons (and its drawbacks). (long)
   Asked in 2026 Set B Section C (5 marks) and Set D Q.2 OR; learn Table 3.1.
   Go to answer
2. What is OOP? Two pros and two cons; four pillars with examples. (long)
   2026 Set D Section C (5 marks) and MCQs on inheritance and OOP concepts in both sets.
   Go to answer
3. Data normalization and 1NF, 2NF, 3NF with an example. (short)
   2026 Set B Q.2 (vi); book SRQ 9; a natural long question.
   Go to answer
4. Primary, candidate, foreign and composite keys. (short)
   2026 Set D Q.2 (vi) and book exercise MCQs 8 and 10.
   Go to answer
5. Text versus binary files; opening and closing a file; file modes. (short)
   2026 Set D Q.2 (xi) OR, Set B Q.2 (ix) OR, old syllabus Q.2 (iii); book SRQs 5 and 6.
   Go to answer
6. File programs: write then read data.txt, append a line, count letters, copy a file. (long)
   Book ERQs 5, 6, 9 and 13; the most likely write-a-program questions.
   Go to answer
7. List, tuple, set and dictionary operations and outputs (insert, append, remove, pop, del, KeyError). (short)
   Book exercise MCQs 16 and 17 and SRQs 11 and 12 test predicting output.
   Go to answer
8. Nested lists: matrix printing, transpose, symmetric matrix. (long)
   Book ERQ 8 and Activities 3 and 4; trace tables earn marks.
   Go to answer
9. Python sqlite3 program: insert, update, retrieve; SQL commands. (long)
   Book ERQ 10 and the whole of Section 3.2.10.
   Go to answer
10. Unit testing with assert and unittest; breakpoints and watchpoints. (long)
    Book ERQ 11, SRQ 10 and the Fig. 3.34 question on which test fails.
    Go to answer
11. Class programs such as Rectangle with area and perimeter. (long)
    Book ERQ 2; old-syllabus paper also asked for a Student class.
    Go to answer