FSc Part 1 Computer Science Chapter 2 Complete Guide Book — Python Programming

Think of a computer as a very obedient but very literal helper. It cannot guess what you mean — it only does exactly what it is told. Computer programming is the job of writing that set of instructions in a language the computer can understand and run. Python is one such language, and beginners love it because its sentences look almost like plain English, so you can spend your energy on the idea instead of fighting complicated punctuation.

Writing a program always follows four plain steps. First you write the code, a set of instructions in Python. Then the code is compiled or interpreted — translated into a form the computer understands (Python uses an interpreter, which reads and runs your code line by line). Next the computer executes it, carrying out each instruction. Finally you get the output: a message on the screen, a calculation, or some action the program performs.

Before you can write anything, you must set up a Python development environment — that is just a fancy way of saying "prepare your computer so it can write, run and debug Python code". You download Python from python.org and install it, then pick an IDE (Integrated Development Environment), an editor that colours your code, points out mistakes and runs programs with one click. One small tip from the book's "Tidbits" box is worth remembering: while installing, tick the box that says "Add Python to PATH". That puts Python on a list your computer checks whenever you type a command, so you can run Python easily from the command line. If installing feels like a hurdle, online services also let you write and run Python in a browser with nothing to install.

The book opens with the shortest possible proof that Python is friendly. Here is the whole program:

print("This is my first page")

Run it and the screen shows This is my first page. Nothing else happens, and that is the point. print() is a built-in function — a ready-made tool — whose job is to display whatever you put inside its brackets. The message sits inside double quotation marks because it is text, and Python must be told "treat this as words, not as instructions". Notice there is no full stop at the end of the line, no special word to start the program, and no brackets wrapping everything: that bare simplicity is Python's syntax, the set of rules for how code must be written.

Real programs also carry comments: lines the interpreter completely ignores, written for the human reader. A comment explains why a tricky line exists, so that future-you — or a classmate — can understand the code months later. A single-line comment starts with # and runs to the end of that line. A multi-line comment is written between triple quotes, ''' at the start and ''' at the end, and can stretch over several lines:

# This is a single-line comment
print("K2 is the second-highest mountain in the world")
'''
This is a multi-line comment.
It can span multiple lines.
'''
print("Edhi Foundation is the largest volunteer ambulance network.")

Only the two print lines run; the comments never reach the screen. A good habit: comment the reason, not the obvious — "calculate average marks" helps, while "print the result" next to a print line adds nothing.

A variable is a labelled container in the computer's memory. You put a value inside it, and later you can take the value out, look at it, or replace it with something new. That last part matters: unlike a constant, a variable's value can change while the program runs. In Python you create one simply by writing a name, an equals sign, and a value — no declaration ceremony is needed:

age = 17
print("Age is:", age)   # Output: Age is: 17
age = 18
print("Age is:", age)   # Output: Age is: 18

The first print shows 17; after the second assignment the same box holds 18, so the second print shows 18. The equals sign here does not mean "equal to" as in mathematics — it means "store the right-hand value into the left-hand name".

Names must follow four rules. A name must start with a letter (a–z, A–Z) or an underscore (_). After that it may contain letters, digits (0–9) or underscores. Names are case-sensitive, so age and Age are two completely different boxes. And Python's reserved keywords — words like for, while, if — cannot be used as names, because Python already uses them for its own grammar. The book adds a style tip worth adopting early: use meaningful, lowercase names with underscores between words, like student_name instead of a. A reader should guess what a box holds just by reading its label.

Python sorts values into data types. An integer (int) holds whole numbers, like age = 17. A floating-point number (float) holds decimals, like price = 19.99. A string (str) holds text in quotes, like name = "Ali". A Boolean (bool) holds only True or False, like is_student = True — note the capital T, because Python's True is a keyword, not the English word.

A program that only talks to itself is a lonely thing. Input and output are how a program talks to the user: input takes data in, output sends information out. For input Python gives you input(). It prints a message on the screen, then waits patiently until the user types something and presses Enter, and whatever was typed is stored in a variable:

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

If the user types Ali, the second line prints Hello, Ali! Here the + joins two strings together. For output, print() takes one or more arguments and displays them, separated by spaces when you pass several values with commas.

Now the trap every beginner meets: input() always returns text, even when the user types digits. If you write age = input("Enter your age: ") and the user types 17, then age holds the string "17", not the number 17 — and "17" + 1 would be an error, not 18. The fix is to convert immediately, wrapping the input in int() for whole numbers or float() for decimals:

# Integer input
user_age = int(input("Enter your age: "))
print("Your age is:", user_age)
# Float input
user_height = float(input("Enter your height in meters: "))
print("Your height is:", user_height, "meter")

Type 17 for age and 1.68 for height, and you get proper numbers you can actually calculate with. Rule of thumb: whenever a number will be used in maths, convert it at the very moment you take it in — never later, when the mistake is harder to spot.

An operator is a symbol that does something to values — it is the verb of a program. An expression is a combination of values, variables and operators that produces a result, like 3 + 4, which evaluates to 7. Python's arithmetic operators cover everything you met in maths class, plus two you probably did not:

# Define variables
a = 10
b = 3
print(a, "+", b, "=", a + b)    # Output: 10 + 3 = 13
print(a, "*", b, "=", a * b)    # Output: 10 * 3 = 30
print(a, "/", b, "=", a / b)    # Output: 10 / 3 = 3.3333333333333335
print(a, "//", b, "=", a // b)  # Output: 10 // 3 = 3
print(a, "%", b, "=", a % b)    # Output: 10 % 3 = 1
print(a, "**", b, "=", a ** b)  # Output: 10 ** 3 = 1000

Walk through them slowly. + adds, − subtracts, * multiplies. Plain division / always gives a decimal answer, even for a clean-looking division — 10 / 3 is a long decimal, not 3. Floor division // throws away the fractional part and keeps only the whole part, so 10 // 3 is 3. Modulus % keeps only the remainder, so 10 % 3 is 1, because 3 goes into 10 three times (9) and 1 is left over — this is the operator you reach for when checking "even or odd" or "divisible by". Finally exponentiation ** raises to a power: 10 ** 3 means 10 × 10 × 10 = 1000. A small warning: ** is power in Python; the caret ^ means something entirely different, so never write 10^3 expecting 1000.

Comparison operators do not calculate a number — they ask a question, and the answer is always a Boolean: True or False. That simple fact makes them the engine of every decision a program takes later in this chapter. With x = 10 and y = 5, the book's example runs through all six:

x, y = 10, 5
print(x, ">", y, "=", x > y)    # Output: 10 > 5 = True
print(x, "<", y, "=", x < y)    # Output: 10 < 5 = False
print(x, "==", y, "=", x == y)  # Output: 10 == 5 = False
print(x, "!=", y, "=", x != y)  # Output: 10 != 5 = True
print(x, ">=", y, "=", x >= y)  # Output: 10 >= 5 = True
print(x, "<=", y, "=", x <= y)  # Output: 10 <= 5 = False

Read each line as a sentence: "Is 10 greater than 5?" Yes — True. "Is 10 less than 5?" No — False. Two operators deserve a second look because beginners mix them up. == (two equals signs) compares two values, while = (one equals sign) stores a value — writing if x = 10: when you meant a comparison is one of the most common early errors, and Python will refuse it. And != means "not equal to": it is True exactly when the two sides differ. The last two combine ideas: >= means "greater than or equal to" (10 >= 5 is True, and 5 >= 5 would also be True), while <= is its mirror image.

You already know the plain assignment operator =: it stores the right-hand value into the left-hand variable. Compound assignment operators go one step further — they first do an arithmetic operation using the variable's current value, then store the result back into the same variable. They are shorthand, and shorthand you will see in almost every real program, especially inside loops where a counter keeps growing.

Here is the idea, written so that each line is easy to check. Start with a = 10, b = 5, and run the lines one after another, carrying the new value of a forward each time:

a = 10
b = 5
a += b   # a = a + b = 10 + 5 = 15
a -= b   # a = a - b = 15 - 5 = 10
a *= b   # a = a * b = 10 * 5 = 50
a /= b   # a = a / b = 50 / 5 = 10.0
a %= b   # a = a % b = 10.0 % 5 = 0.0
a **= b  # a = a ** b = 0.0 ** 5 = 0.0
print(a)  # Output: 0.0

Each line reads naturally: a += b means "add b to a and keep the result in a". The same pattern holds for −=, *=, /=, %= and **=. Notice that after /= the value becomes a float (10.0), and everything after that stays float — that is why the final answer is 0.0, not 0.

⚠ Book warning — read this before copying the book's outputs. The book prints a different set of results for this same block (after addition 15, after subtraction 5, after multiplication 50, after division 2.0, after modulus 2, after exponentiation 100000). Those numbers do not come from running the lines straight through one after another: most of them match starting fresh from a = 10 each time (10 − 5 = 5, 10 × 5 = 50, 10 / 5 = 2.0, 10 ** 5 = 100000), while the modulus figure 2 only fits if a is still 2.0 from the division line. In other words, the book's printed outputs mix two different ways of running the code. Trust the step-by-step trace above — run it yourself and you will get 15, 10, 50, 10.0, 0.0, 0.0 — and remember the lesson hidden inside the confusion: in a compound assignment, the variable's current value is always the starting point.

Comparison operators ask one question at a time. Logical operators let you combine several questions into one bigger question, and the answer is still just True or False. There are three. and is True only when both sides are True — like needing both a ticket and an ID card to enter. or is True when at least one side is True — like being allowed in with a ticket or a pass. not flips a value: not True is False, and not False is True.

x = True
y = False
logical_and = x and y
print(x, "and", y, "=", logical_and)  # Output: True and False = False
logical_or = x or y
print(x, "or", y, "=", logical_or)    # Output: True or False = True
logical_not = not x
print("not", x, "=", logical_not)     # Output: not True = False

Small note on the book here: the comment printed beside the or line in the book reads "True and False = True", but that wording is a slip — the line is an or, so the correct comment is "True or False = True", as shown above. The result itself, True, is right.

An expression, remember, is any combination of values, variables and operators that produces a result. 3 + 4 is an expression with the result 7. Bigger expressions use parentheses () to force an order, exactly as in maths:

result = (3 + 4) * 2   # result is 14

Without the brackets, 3 + 4 * 2 would be 11, because multiplication is done first. With the brackets, the addition happens first (7), and 7 × 2 = 14. Brackets are not decoration — they change the answer, and the next section explains the full pecking order.

When an expression has several operators, Python does not simply work left to right. It follows operator precedence — a fixed pecking order, the same idea as BODMAS in maths. From highest to lowest, the order the book teaches is:

1. Parentheses () — whatever is inside brackets is done first. (3 + 2) * 4 = 20, because 5 × 4 follows the bracket. 2. Exponentiation ** — powers come next; 2 ** 3 = 8. 3. Multiplication *, division / and modulus % — these share a level and are done left to right; 4 * 3 = 12, 10 / 2 = 5.0, 11 % 3 = 2. 4. Addition + and subtraction − — the lowest of the four levels; 5 + 2 = 7, 10 − 4 = 6.

The book's own practice expressions show why this matters. Take 10 + 3 * 2 ** 2 − 5 / 5. First the power: 2 ** 2 = 4. Then multiplication and division, left to right: 3 * 4 = 12 and 5 / 5 = 1.0. That leaves 10 + 12 − 1.0 = 21.0. Now take (10 + 3) * (2 ** (2 − 1)) / 5: brackets first, (10 + 3) = 13 and (2 − 1) = 1, so 2 ** 1 = 2; then 13 * 2 = 26; then 26 / 5 = 5.2. Same digits, different brackets, completely different answers — and the book's advice is exactly right: when in doubt, add brackets to make your intended order obvious.

Class activity — BMI, solved correctly. The book asks for a program that takes weight and height, computes Body Mass Index and shows its classification. ⚠ Book warning: the formula printed in the book reads BMI = weight / height, with no square — that is an error. The correct definition is BMI = weight / (height × height), with weight in kilograms and height in metres. With that correction:

weight = float(input("Enter weight in kg: "))
height = float(input("Enter height in meters: "))
bmi = weight / (height ** 2)
print("Your BMI is:", bmi)
if bmi < 18.5:
    print("Classification: Underweight")
elif bmi < 25:
    print("Classification: Normal")
elif bmi < 30:
    print("Classification: Overweight")
else:
    print("Classification: Obese")

Try weight 70 and height 1.75: height squared is 3.0625, and 70 / 3.0625 = 22.86, which falls in the Normal band. (The classification bands themselves are the standard health bands; the book asks for a classification but does not print the bands, so those ranges are supplied here and labelled as such.) If you had used the book's printed formula instead, you would have got 70 / 1.75 = 40 — a wildly wrong "Obese" for a healthy person, which is exactly why checking a formula matters more than copying it.

So far every program you have seen runs straight from top to bottom, like a train that never changes track. Real programs need to control the flow: sometimes they must choose between two paths, sometimes they must repeat a job many times. Python gives two families of control structures for this. Decision making picks a path based on a condition, and looping repeats a block of code. This section and the next few cover decisions; loops follow after.

The simplest decision is the if statement: "if this condition is true, run this block of code; otherwise skip it entirely". Its shape is:

if condition:
    # code to run if the condition is true

Two details in that shape are non-negotiable. The line ends with a colon, which is Python's way of saying "a block follows". And the block underneath is indented — pushed in by four spaces — because indentation is how Python knows which lines belong inside the if. Forget the colon or the indent and Python stops with an error. The book's example makes it concrete:

temperature = 35
if temperature > 30:
    print("It is a hot day")

Here 35 > 30 is True, so the message prints. Change temperature to 25 and the condition becomes False — the print line is skipped silently and the program simply carries on. An if statement never explains itself when it skips; if you want a message for the "otherwise" case too, you need if-else, which is next.

An if on its own handles the "yes" case and stays silent otherwise. Very often you want the "no" case to do something too. That is the if-else statement: one block runs if the condition is true, and a different block runs if it is false. Exactly one of the two blocks runs, never both, never neither:

temperature = 15
if temperature > 30:
    print("It's a hot day")
else:
    print("It's not a hot day")

Since 15 > 30 is False, the else block runs and you get It's not a hot day. Notice the shape again: else: sits at the same indentation as the if, with its own colon and its own indented block. If you indent the else by mistake, Python no longer recognises it as the partner of that if.

When both blocks are just one short action each, Python lets you squeeze the whole decision onto a single line — the short-hand if-else, sometimes called a ternary expression:

temperature = 15
m = "It's a hot day" if (temperature > 30) else "It's not a hot day"
print(m)  # Output: It's not a hot day

Read it in English order: "take the first value if the condition holds, else take the second". The result is stored in m and printed. Short-hand is neat for simple choices, but it turns unreadable the moment the actions get long — then the full if-else block is the kinder choice for whoever reads your code next.

Class activity — even or odd, both ways. The book asks for an if-else and a short-hand version that check whether a number is even or odd. A number is even when dividing it by 2 leaves no remainder, which is exactly what % 2 == 0 tests:

# Full if-else version
number = int(input("Enter a number: "))
if number % 2 == 0:
    print("Even number")
else:
    print("Odd number")
# Short-hand version
message = "Even number" if (number % 2 == 0) else "Odd number"
print(message)

Enter 8 and both versions say Even; enter 7 and both say Odd. Same logic, two shapes — pick the shape that reads most clearly for the job.

Life rarely offers just two options, and neither does programming. When you need to check several conditions in order, you use the if-elif-else statement — a ladder of checks where Python walks down the rungs and stops at the first one that is true. (A small bookkeeping note: the book numbers both the short-hand if-else and this statement "2.4.1.3"; that repeated number is a printing slip, and the ladder itself is what matters.)

weather = "cloudy"
if weather == "sunny":
    print("Wear sunglasses")
elif weather == "rainy":
    print("Take an umbrella")
else:
    print("Enjoy your day!")

Follow the ladder with weather = "cloudy". The first check, "cloudy" == "sunny", is False, so Python steps down. The second, "cloudy" == "rainy", is also False, so it steps down again. With no condition left true, the else at the bottom catches everything else and prints Enjoy your day! Change weather to "rainy" and the ladder stops at the second rung — the else is never reached. Two rules govern the ladder: only the first true block runs, even if a later condition would also be true, and the final else is optional but useful as a safety net for "anything else".

Class activity — positive, negative or zero. The book asks for exactly this ladder applied to a number:

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

Enter 5 and you get Positive; −3 gives Negative; 0 falls through both checks into the else and gives Zero. Note the order matters here too: had the first check been "number != 0", zero's case would never have been reached cleanly — always put the most specific checks first.

Loops exist so you never have to write the same instruction twenty times. A while loop repeats a block as long as a condition stays true, checking that condition before every single repetition — including the first one, which means the block might run zero times if the condition is already false. The book's example adds 1 to a number until it reaches 10:

number = 1
while number < 10:
    print(number)
    number += 1

Trace it like a careful accountant. number starts at 1: 1 < 10 is True, so print 1, then number becomes 2. 2 < 10 is True, print 2, become 3. This continues — 3, 4, 5, 6, 7, 8, 9 — until number becomes 10. Now 10 < 10 is False, and the loop stops. Output: 1 2 3 4 5 6 7 8 9, each on its own line. The line number += 1 is the hero of this story: without it, number would stay 1 forever, the condition would never turn false, and you would have an infinite loop — a program that never stops. Every while loop needs something inside it that moves the condition towards false.

Class activity — evens printed, odds counted, 1 to 20. The book asks for a while loop that prints the even numbers from 1 to 20 and counts the odd ones:

number = 1
odd_count = 0
while number <= 20:
    if number % 2 == 0:
        print(number)
    else:
        odd_count += 1
    number += 1
print("Total odd numbers:", odd_count)

The evens printed are 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, and the final line reports Total odd numbers: 10 — because exactly half of 1–20, the numbers 1, 3, 5, …, 19, are odd. Notice the counter pattern: start a counting variable at 0 outside the loop, add 1 inside whenever the thing you are counting happens, and report it after the loop ends.

While a while loop repeats "until something changes", a for loop repeats "for each item in a collection" — it is the natural choice when you already know what you want to walk through, like a list, a tuple or a string. Its shape is:

for variable in sequence:
    # code to run for each element in the sequence

The book's first example greets every friend in a list:

friends = ["Ahmad", "Ali", "Hassan"]
for friend in friends:
    print("Hello", friend)

On the first round, friend holds "Ahmad" and the screen shows Hello Ahmad. On the second round friend becomes "Ali", then "Hassan". Three items, three rounds, then the loop ends by itself — no counter to update, no condition to remember, and therefore no risk of an infinite loop from a forgotten update. That safety is the for loop's quiet advantage.

But what if you want numbers rather than items from a list? That is what range() is for: it produces a sequence of numbers on demand. range(5) gives 0, 1, 2, 3, 4 (it stops before 5). range(2, 11, 2) starts at 2, steps by 2, and stops before 11, giving 2, 4, 6, 8, 10. Note carefully: range() creates a sequence of numbers for looping — it does not print anything by itself, and it is not a list (a point the book's exercise key gets wrong, as flagged in the exercise below).

Class activities, solved. (1) Even numbers from 2 to 10 with range():

for number in range(2, 11, 2):
    print(number)  # 2, 4, 6, 8, 10

(2) The first 10 multiples of 3 with a for loop and range():

for number in range(3, 31, 3):
    print(number)  # 3, 6, 9, 12, 15, 18, 21, 24, 27, 30

The stop value is 31, not 30, because range() always stops before its end value — the single most common range() mistake, and the one to watch for in your own code.

A function is a named, reusable block of code: you write a job once, give it a name, and then run that job whenever you like simply by calling the name. Without functions, a program that greets ten people would repeat the greeting code ten times; with a function, you write it once and call it ten times. Functions are defined with the def keyword, a name, parentheses that may hold parameters (the inputs the function expects), a colon, and an indented body:

def greet(name):
    print("Hello", name)
# Function invoking means call the function by name
greet('Ali')  # Output: Hello Ali

Defining a function does nothing by itself — the body only runs when the function is called. In the call, the value you pass ("Ali") is called an argument; inside the function it arrives as the parameter name. Keep the two words straight: parameters are the labelled slots in the definition, arguments are the actual values in the call.

Some functions do not just print — they hand a result back. return sends a value out of the function to whoever called it:

def add(a, b):
    return a + b
print(add(4, 6))   # Output: 10
print(add(20, 5))  # Output: 25

The same code serves both calls with different inputs — that reuse is the whole point, and the book's "Do You Know?" box says exactly this: call a function many times with different arguments and the same code does different jobs. A function can also carry a default parameter: a value used automatically when the caller provides nothing:

def greet(name = "Student"):
    return "Hello" + name + "!"
print(greet())         # Output: Hello,Student!
print(greet("Umer"))   # Output: Hello, Umer!

The first call passes nothing, so name quietly becomes "Student" and you get "Hello,Student!" — note the missing space, because the book's code joins "Hello" directly to the name without a space; adding a space after Hello, as in "Hello " + name, is the tidier version. The second call passes "Umer", which replaces the default, giving "Hello, Umer!" — the space there comes from the argument itself in the book's printout, another small reason to write the space into your own code rather than relying on the caller.

Class activity — maximum of a list. The book asks for a function that takes a list of numbers and returns the maximum value. Writing it by hand (rather than calling Python's built-in max) shows the logic clearly:

def find_max(numbers):
    largest = numbers[0]
    for number in numbers:
        if number > largest:
            largest = number
    return largest
print(find_max([4, 9, 2, 15, 7]))  # Output: 15

Start by assuming the first item is the largest, then compare every item against it, replacing it whenever a bigger one appears. (The function is named find_max here rather than max, so it does not hide Python's own built-in max function — a naming kindness worth copying.)

Python's great strength is that you rarely start from zero. A module is a file of ready-made Python code, and a library is a collection of such modules — toolboxes full of tools other people already built and tested, so you can solve a problem without building everything from scratch. Python ships with a huge standard library, and many more third-party libraries can be added later. You bring a module into your program with import, then use its tools with a dot: module name, dot, tool name.

Random numbers come from the random module. random.randint(1, 10) picks a whole number between 1 and 10, both ends included — run it twice and you will very likely get two different answers, which is the whole point:

import random
# Generate a random number between 1 and 10
number = random.randint(1, 10)
print("The random number is:", number)

Dates and times come from datetime. datetime.datetime.now() returns the current date and time at the moment it runs:

import datetime
# Get the current date and time
current_time = datetime.datetime.now()
print("Current date and time:", current_time)

Averages come from statistics. Its mean() adds a list of numbers and divides by how many there are:

import statistics
# Calculate the mean of a list of numbers
data = [23, 45, 67, 89, 12, 44, 56]
mean_value = statistics.mean(data)
print("The mean value is:", mean_value)  # Output: 48.0

Check that last one by hand: the numbers add to 336, and 336 ÷ 7 = 48.0 exactly. When your hand calculation and the library agree, you know you used the tool correctly — a habit worth keeping for every library call you ever make.

When a project grows large, related modules are grouped into a package: simply a folder (directory) holding related module files. The book's example imagines an online shop with a package called ecommerce containing products.py, customers.py and orders.py. Inside ecommerce/products.py sits a function:

# In ecommerce/products.py:
def list_products():
    return ["Laptop", "Mobile", "Tablet"]

And in the main script you import that one module out of the package:

# In your main script
from ecommerce import products
available_products = products.list_products()
print(available_products)
# Output: ['Laptop', 'Mobile', 'Tablet']

The book's "Tidbits" box puts it nicely: organising modules into packages is like organising books into sections of a library — it makes finding and maintaining your code far easier as a project grows.

A list is Python's most everyday container: an ordered collection of items, written inside square brackets [ ] with commas between items. Unlike a single variable, a list holds many values at once — numbers, strings, even other lists — and you can change it after creating it. The book starts with favourite fruits:

fruits = ["Mango", "Apple", "Banana"]
print(fruits)  # Output: ['Mango', 'Apple', 'Banana']

To reach one item you use its index — its position number — and Python counts positions from 0, not 1. So fruits[0] is "Mango", fruits[1] is "Apple" (the second item), and fruits[2] is "Banana":

fruits = ["Mango", "Apple", "Banana"]
print(fruits[1])  # Output: Apple

Changing a list is just as direct. Assign to a position to replace that item, and use append() to add an item at the end:

fruits = ["Mango", "Apple", "Banana"]
fruits[0] = "Orange"
fruits.append("Pineapple")
print(fruits)  # Output: ['Orange', 'Apple', 'Banana', 'Pineapple']

Lists also come with built-in methods — tools that belong to the list itself and are called with a dot. append(item) adds to the end. remove(item) takes out the first occurrence of that value. sort() arranges the list in ascending order (alphabetical for words). reverse() flips the order. The book's sorting example shows append and sort working together:

students = ["Ahmed", "Sara", "Ali"]
students.append("Hina")
students.sort()
print(students)  # Output: ['Ahmed', 'Ali', 'Hina', 'Sara']

Finally, lists support two handy operations. Slicing takes a portion: numbers[1:4] takes items at positions 1, 2 and 3 (the end position is not included). Concatenation with + joins two lists into one:

numbers = [1, 2, 3, 4, 5]
slice = numbers[1:4]  # Gets items from index 1 to 3
extra_numbers = [6, 7]
combined = slice + extra_numbers
print(combined)  # Output: [2, 3, 4, 6, 7]

And sorting plus removing, as in the book's second example: sort ["Ahmed", "Sara", "Ali", "Hina"] alphabetically, then remove "Sara", and you are left with ['Ahmed', 'Ali', 'Hina'].

Class activity — favourite books, all five tasks. Start with ["To Kill a Mockingbird", "1984", "The Great Gatsby", "Pride and Prejudice"], then: (1) append "Moby Dick"; (2) replace "1984" with "Brave New World" by assigning to its index (position 1); (3) remove "The Great Gatsby"; (4) merge with ["War and Peace", "Hamlet"] using +; (5) print the result:

books = ["To Kill a Mockingbird", "1984", "The Great Gatsby", "Pride and Prejudice"]
books.append("Moby Dick")
books[1] = "Brave New World"
books.remove("The Great Gatsby")
books = books + ["War and Peace", "Hamlet"]
print(books)
# Output: ['To Kill a Mockingbird', 'Brave New World', 'Pride and Prejudice', 'Moby Dick', 'War and Peace', 'Hamlet']

A tuple looks like a list's close cousin: it stores an ordered collection of items, and you read items from it by index exactly as with a list. The difference — and it is the whole reason tuples exist — is that a tuple is immutable, meaning its values cannot be changed after creation. No replacing an item, no appending, no removing. That sounds like a limitation, but it is actually a promise: when a tuple is passed around a program, nobody can accidentally rewrite it, so it is the right container for data that must stay fixed, like the days of the week or the coordinates of a point.

Tuples are written in round brackets ( ) instead of square ones:

# Creating a tuple
my_tuple = (1, 2, 3, "Hello", 4.5)
# Accessing elements by index
print(my_tuple[0])  # Output: 1
print(my_tuple[3])  # Output: Hello
# Tuple length
print(len(my_tuple))  # Output: 5

Indexing works from 0 as usual: my_tuple[0] is the first item, 1, and my_tuple[3] is the fourth item, "Hello". len() counts the items and reports 5 — there are five values inside, even though they mix numbers and text, which is perfectly fine. Try my_tuple[0] = 99 and Python will stop you with an error, and that error is the point: the tuple refused to change, exactly as designed. So the rule of thumb is simple — if the collection should grow or change, use a list; if it must stay exactly as it was made, use a tuple.

Indexing and slicing are the two techniques for reaching inside any sequence — a list, a tuple or a string — and pulling out exactly the part you want. Indexing takes one element: Python counts from the front starting at 0, so the first element has index 0, the second has index 1, and so on. Slicing takes a whole portion, using the pattern sequence[start:stop:step], where start is the first index you want, stop is the index you stop before (it is not included), and step is the size of each jump (leave it out and the step is 1).

Then comes the elegant part: negative indices count from the end. −1 means the last element, −2 the second-last, and so on. You never need to know how long a sequence is just to grab its last item. The book's example shows positive and negative indexing and slicing side by side:

# Create a list of fruits
fruits = ["Apple", "Banana", "Cherry", "Date", "Elderberry"]
# Indexing
print("First fruit:", fruits[0])    # Positive index → Apple
print("Last fruit:", fruits[-1])    # Negative index → Elderberry
# Slicing with positive indices
print("Fruits from index 1 to 3:", fruits[1:4])    # Banana, Cherry, Date
# Slicing with negative indices
print("Fruits from index -4 to -1:", fruits[-4:-1])  # Banana, Cherry, Date

Notice the last two lines give the same result by two different routes: fruits[1:4] counts from the front, fruits[−4:−1] counts from the back, and both stop before the final element. That symmetry is a good self-check: if the two routes disagree, one of your numbers is wrong.

Class activity — list, tuple and string, all five tasks. The book gives a list [10, 20, 30, 40, 50, 60, 70, 80], a tuple of subjects, and the string "Python Programming". ⚠ One printing slip to correct first: the book's tuple is printed as ("Math" "Science", "English", "History", "Geography") with the comma after "Math" missing — written that way, Python would glue the first two words into one string, "MathScience". The corrected tuple below restores the comma:

numbers = [10, 20, 30, 40, 50, 60, 70, 80]
subjects = ("Math", "Science", "English", "History", "Geography")
text = "Python Programming"
# 1. Third element of each (index 2)
print(numbers[2], subjects[2], text[2])        # 30 English t
# 2. Slice index 2 to 5 from list and tuple
print(numbers[2:5], subjects[2:5])             # [30, 40, 50] ('English', 'History', 'Geography')
# 3. String characters from index 7 to the end
print(text[7:])                                # Programming
# 4. Last two elements with negative indexing
print(numbers[-2:], subjects[-2:])            # [70, 80] ('History', 'Geography')
# 5. Negative slicing: second-last to last character of string
print(text[-2:])                               # ng

Check task 3 by counting the string: P(0) y(1) t(2) h(3) o(4) n(5) space(6) P(7) — so index 7 begins "Programming". And task 5: the string ends …n(…, g), so the last two characters are "ng".

Modular programming is the habit of breaking a large program into smaller, manageable, reusable pieces called modules, instead of writing one enormous file where everything is tangled together. The payoff is practical: different parts can be built and tested independently, a piece written for one project can be reused in another, and when something breaks, you know which small piece to look inside. It is the same idea as the packages in section 16, applied to your own code rather than to library code.

Every well-organised Python program also has a clear starting point, and that is the main function. By convention it is a function called main(), placed inside a block that checks whether the script is being run directly or merely imported as a module by someone else:

# main.py
def main():
    print("This is the main function.")
if __name__ == "__main__":
    main()

Here is what happens. Every Python file carries a built-in variable called __name__. When you run the file directly, Python sets __name__ to the special string "__main__", so the check passes and main() runs. But when another file imports this file to borrow its functions, __name__ becomes the file's module name instead, the check fails, and main() politely stays quiet — importing a toolbox should not set off the toolbox's own demo. That distinction is the whole trick, and it is what makes modules safe to share between projects.

Class activity — a calculator module and a main script. The book asks for a module calculator.py with add and subtract functions, and a main.py that imports it, adds 15 and 8, and subtracts 10 from 25 (that is, computes 25 − 10):

# calculator.py
def add(a, b):
    return a + b
def subtract(a, b):
    return a - b
# main.py
import calculator
print(calculator.add(15, 8))       # Output: 23
print(calculator.subtract(25, 10))  # Output: 15

Run main.py and verify both outputs yourself — 15 + 8 = 23 and 25 − 10 = 15 — because the book's own instruction for this activity is to run the script and check that the output is correct, and checking is a habit, not an afterthought.

Object-Oriented Programming (OOP) is a way of designing and organising code so that it mirrors the real world: instead of separate piles of data and separate functions, you bundle data and the actions on that data together into objects. A class is the template for creating things, and an object is an actual thing created from that template. The book's toy-car picture explains it better than any definition: to make a toy car you first need a blueprint describing how it should look and work — its colour, its size, its number of wheels, its type of material. That blueprint is not itself a toy car; it is only a plan, and it represents the class. From that one plan you can build many toy cars, each an instance of the class, each following the plan while having its own specific characteristics.

In code, a class is defined with the class keyword, and its special __init__ method runs automatically whenever a new object is created, setting up that object's attributes (its data). A method is simply a function that belongs to a class. The word self is the convention for referring to the particular object inside its own methods — "this car, not cars in general":

# Define a class called ToyCar
class ToyCar:
    # The __init__ method initializes the object with specific attributes
    def __init__(self, color, size, wheels):
        self.color = color   # Color of the toy car
        self.size = size     # Size of the toy car
        self.wheels = wheels  # Number of wheels in the toy car
    # Method to describe the toy car
    def describe(self):
        return f"This toy car is {self.color}, size {self.size}, and has {self.wheels} wheels."
# Create objects of the ToyCar class
car1 = ToyCar("red", "small", 4)
car2 = ToyCar("blue", "large", 6)
# Print descriptions of the toy cars
print(car1.describe())
print(car2.describe())

Follow it through. ToyCar("red", "small", 4) calls __init__ with those three values, which stores them as car1's own colour, size and wheels. car2 gets a completely separate set: blue, large, 6. The outputs are therefore This toy car is red, size small, and has 4 wheels. and This toy car is blue, size large, and has 6 wheels. The class is one blueprint; the two objects are two different cars built from it, each carrying its own data and sharing the same describe method. That — one template, many independent objects — is the whole idea of OOP in one example.

Two skills separate a beginner's program from a robust one: surviving errors gracefully, and remembering data after the program ends. Exception handling manages errors that occur while a program runs, so the program can either carry on or stop politely with a message instead of crashing. File handling reads from and writes to files, which is how data is stored persistently — it is still there tomorrow, when the program's memory is long gone. (Bookkeeping note: the book numbers these subsections 2.9.1.1, then jumps to 2.9.1.4, 2.9.1.5 and 2.9.1.6 — the missing numbers are a printing slip; nothing is missing from the content.)

The tool for handling errors is the try-except block. Code that might fail goes in the try block; if a particular error occurs, Python jumps to the matching except block instead of crashing. The book's example divides 10 by a number the user provides — dangerous, because dividing by zero is an error:

# Input a number from the user
a = int(input("Enter a number: "))
try:
    result = 10 / a  # This line creates an error if the value of 'a' is 0
except ZeroDivisionError:
    print("You can't divide by zero!")

⚠ Scan note: the first line of this example is cut off at the top of the printed page in the scan, so the input line above is reconstructed from the code's own logic (a must come from the user for the division to make sense) and is labelled here as derived, not quoted. With a = 2, result becomes 5.0 and nothing is printed by the except block; with a = 0, Python raises ZeroDivisionError, the except block catches exactly that error, and the screen shows You can't divide by zero! instead of a crash. Catching the specific error name matters: a bare catch-all would also swallow mistakes you actually want to see.

For files, the pattern has three steps: open the file with open(), read or write, then close it to free resources. The with statement does the closing for you automatically, even if an error occurs in between — which is why every example below uses it. To read, open in "r" (read) mode and use read():

# Open and read a file
with open("example.txt", "r") as file:
    content = file.read()
    print(content)

The with statement guarantees the file is properly closed after its block finishes, so you never have to remember to close it yourself. To write, open in "w" mode — warning: this overwrites anything already in the file — and use write(). To append, open in "a" mode, which adds to the end without touching what is already there:

# Writing to a file
with open("example.txt", "w") as file:
    file.write("As-Salaam-Alaikum, World!\n")
# Appending to a file
with open("example.txt", "a") as file:
    file.write("Appending new line.\n")

After both blocks, example.txt contains two lines: "As-Salaam-Alaikum, World!" followed by "Appending new line." The one-letter mode is the whole difference between keeping old data and destroying it, so read the mode letter twice before you run a write.

A program is not finished when it runs once — it is finished when it runs correctly on the inputs it will actually meet. Testing is running your code with various inputs to check that it behaves as expected, with the goal of finding and fixing problems before the code is used in the real world. The book names four types, and each answers a different question. Unit testing tests individual parts — a single function or class — in isolation, and Python's unittest module is commonly used for it. Integration testing checks how different parts work together: a function may be perfect alone and still fail when it meets another part. Functional testing validates that the software behaves as expected from the user's perspective — does the whole thing do what the user asked for? Regression testing makes sure that new changes do not break functionality that already worked — after every fix, re-run the old tests, because fixes have a habit of breaking something else.

Debugging is the other half: the process of finding and fixing errors (bugs) in your code, which means identifying the root cause of a problem and making the necessary changes — not just patching the symptom. The book lists three everyday techniques. Print statements: add temporary prints to check the values of variables at different stages of the code, so you can see where reality first departs from what you expected. Debugging tools: use tools like pdb (Python Debugger) to step through the code line by line, inspect variables, and understand the flow of execution. Error messages: read and interpret the error message itself to locate the source of the problem — Python's messages usually name the file, the line number and the error type, and that trio is often enough to find the bug in seconds. Beginners tend to fear error messages; experienced programmers read them first, because the message is the program telling you exactly where it hurt.