Python Programming
Complete Course Notes

Table of Contents

I. Python Environment Setup & Language Basics

1.1 What is Python?

Python is a high-level, interpreted, general-purpose, dynamically typed programming language created by Guido van Rossum and first released in 1991. It emphasises code readability through significant whitespace (indentation) and a clean, minimal syntax.

Key Features of Python

1.2 Python Versions

Two major families exist: Python 2.x (legacy, end-of-life since January 2020) and Python 3.x (current). All new development uses Python 3. Important differences:

1.3 Installing Python on Windows

1. Visit https://www.python.org/downloads and download the latest Python 3 installer (.exe).
2. Run the installer. Critically, tick “Add Python to PATH” before clicking Install Now.
3. Choose Customize installation if you want to change the install directory or add optional features (pip, IDLE, documentation).
4. Wait for the setup to complete, then click Close.
5. Verify by opening Command Prompt and typing:

   python --version
   pip --version

6. If python is not recognised, add the installation folder (e.g. C:\Python312\) and its Scripts subfolder to the Path environment variable manually.

1.4 Anaconda Distribution

Anaconda is a free distribution that bundles Python together with 250+ scientific packages (NumPy, pandas, matplotlib, scikit-learn) and the conda package manager, plus Jupyter Notebook and Spyder. It is preferred for data-science work because dependency conflicts are resolved automatically.

• Download from https://anaconda.org/anaconda/python or anaconda.com.
• Includes conda for environment management: conda create -n myenv python=3.12
• Launch tools via Anaconda Navigator or the Anaconda Prompt.

1.5 Modes of Running Python

1.6 Your First Program — “Hello World”

# hello.py
# This is a comment - the interpreter ignores it.
print("Hello, World!")
print("Welcome to INT108 - Python Programming")

Run it with python hello.py. Output:

Hello, World!
Welcome to INT108 - Python Programming

# Program: greet the user and show the Python version
import sys

name = input("Enter your name: ")
print("Hello,", name)
print("You are running Python", sys.version.split()[0])

1.7 Comments and Indentation

• Single-line comment: starts with # and extends to the end of the line.
• Multi-line comment / docstring: triple-quoted string """ ... """ used as documentation.
• Indentation: Python uses indentation (conventionally 4 spaces) to define blocks instead of braces. Inconsistent indentation raises IndentationError.

# Correct indentation
if 10 > 5:
    print("Ten is greater")   # 4 spaces - part of the if-block
print("Done")                 # back to column 0 - outside the block

1.8 The Python Execution Model

When you run python file.py:

1. The source file is read and tokenised.
2. It is parsed into an Abstract Syntax Tree (AST).
3. The AST is compiled to bytecode (.pyc files inside __pycache__).
4. The Python Virtual Machine (PVM) executes the bytecode line by line.

II. Variables, Expressions, Statements & Data Types

2.1 Variables and Naming

A variable is a name that refers to a value stored in memory. In Python, assignment creates the variable automatically — no declaration keyword is required.

x = 10              # x refers to the integer object 10
message = "Hello"   # message refers to a string object
pi = 3.14159        # pi refers to a float object
is_valid = True     # is_valid refers to a bool object

Rules for Naming Variables (Identifiers)

Python Keywords (reserved words — cannot be used as identifiers)

False   None    True    and     as      assert  async   await
break   class   continue def    del     elif    else    except
finally for     from    global  if      import  in      is
lambda  nonlocal not    or      pass    raise   return  try
while   with    yield

# Broken version
print(score)        # NameError: name 'score' is not defined

# Corrected version
score = 0
print(score)        # 0

2.2 Values and Types

A value is a fundamental unit of data such as a number or a string. Every value belongs to a type (class). Use the built-in type() function to inspect it.

print(type(10))        # <class 'int'>
print(type(3.14))      # <class 'float'>
print(type("hi"))      # <class 'str'>
print(type(True))      # <class 'bool'>
print(type([1,2]))     # <class 'list'>

2.3 Expressions and Statements

• Expression: a combination of values, variables and operators that produces a single value — e.g. 3 + 4, x * y, len("abc").
• Statement: a complete instruction that performs an action — e.g. x = 5, print(x), if x > 0:.
• Operand: a value on which an operator acts. In a + b, a and b are operands.

length = 12
breadth = 8
area = length * breadth          # expression evaluated, result stored
print("Area =", area)            # Area = 96

2.4 Type Conversion

Python performs implicit conversion (automatic type promotion) and supports explicit conversion (type casting) through constructor functions.

print(3 + 4.5)      # 7.5   (int promoted to float)
print(2 + 3j)       # (2+3j) (int promoted to complex)
print(int("10") + 5)  # 15  (explicit conversion of string)

2.5 Input and Output

input() always returns a string. Convert it explicitly when numeric input is needed.

name = input("Enter your name: ")           # string
age  = int(input("Enter your age: "))       # convert to int
cgpa = float(input("Enter your CGPA: "))    # convert to float

print("Name:", name, "Age:", age, "CGPA:", cgpa)

Formatted Output — f-strings (recommended)

x = 12.34567
print(f"Value rounded to 2 decimals: {x:.2f}")   # 12.35
print(f"{'Python':>10}")                          #     Python
print(f"{255:b} {255:o} {255:x}")                 # 11111111 377 ff

2.6 Multiple and Simultaneous Assignment

a, b, c = 1, 2, 3          # multiple assignment
x = y = z = 0              # chained assignment
p, q = q, p                # swap without a temporary variable

a = int(input("a = "))
b = int(input("b = "))

a, b = b, a                # tuple packing / unpacking

print("After swap: a =", a, "b =", b)

import math

r = float(input("Radius: "))
area = math.pi * r ** 2
circumference = 2 * math.pi * r

print(f"Area = {area:.2f}")
print(f"Circumference = {circumference:.2f}")

III. Operators, Operands & Precedence

An operator is a symbol that performs a computation on one or more operands. Python classifies operators into seven families.

3.1 Arithmetic Operators

3.2 Relational (Comparison) Operators

They return a Boolean value True or False.

Python also supports chained comparisons: 0 < x < 100 is equivalent to 0 < x and x < 100.

3.3 Logical Operators

Truth Table

3.4 Assignment Operators

3.5 Bitwise Operators

Operate on the binary representation of integers.

3.6 Membership and Identity Operators

3.7 Operator Precedence and Associativity

Precedence decides which operator binds tighter. Higher rows bind first.

result = 2 + 3 * 4 ** 2 // 8 - 1
print(result)

n = int(input("Enter an integer: "))
print("Even" if n % 2 == 0 else "Odd")
print("Positive" if n > 0 else ("Negative" if n < 0 else "Zero"))

n = int(input("n = "))
is_power_of_two = (n > 0) and (n & (n - 1)) == 0
print(is_power_of_two)

a, b, c = 4, 9, 2
print(a + b * c ** 2 % 5)
# 2**2 = 4 ; 9*4 = 36 ; 36%5 = 1 ; 4+1 = 5
print((a < b) and (b > c) or (a == c))
# (True) and (True) or (False) => True

IV. Conditional Statements

Conditional (selection) statements let a program choose between alternative paths of execution based on a Boolean condition. Python provides if, if-else, if-elif-else, nested if, and the conditional (ternary) expression.

4.1 The if Statement

if condition:
    statement_block

The block executes only when condition evaluates to True. A colon : and indentation are mandatory.

marks = int(input("Enter marks: "))
if marks >= 40:
    print("Pass")
print("Result declared")   # always executes

4.2 The if-else Statement

if condition:
    block_A       # executed when condition is True
else:
    block_B       # executed when condition is False

n = int(input("Enter a number: "))
if n % 2 == 0:
    print(n, "is even")
else:
    print(n, "is odd")

4.3 The if-elif-else Ladder

Used when there are more than two mutually exclusive alternatives. Conditions are tested top to bottom; the first true branch executes and the rest are skipped.

if condition1:
    block1
elif condition2:
    block2
elif condition3:
    block3
else:
    default_block

marks = float(input("Enter marks (0-100): "))

if marks >= 90:
    grade = "A+"
elif marks >= 80:
    grade = "A"
elif marks >= 70:
    grade = "B"
elif marks >= 60:
    grade = "C"
elif marks >= 40:
    grade = "D"
else:
    grade = "F (Fail)"

print("Grade:", grade)

4.4 Nested if Statements

An if inside another if — used when a second decision depends on the outcome of the first.

a = int(input("a = "))
b = int(input("b = "))
c = int(input("c = "))

if a > b:
    if a > c:
        print("Largest is", a)
    else:
        print("Largest is", c)
else:
    if b > c:
        print("Largest is", b)
    else:
        print("Largest is", c)

if a >= b and a >= c:
    print("Largest is", a)
elif b >= a and b >= c:
    print("Largest is", b)
else:
    print("Largest is", c)

4.5 The Conditional (Ternary) Expression

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

# Nested ternary
x = 0
label = "Positive" if x > 0 else ("Negative" if x < 0 else "Zero")
print(label)           # Zero

4.6 Truthiness of Values

Any object can be used as a condition. The following are falsy; everything else is truthy.

items = []
if items:
    print("Non-empty")
else:
    print("Empty list")     # prints this

4.7 Worked Program — Leap Year

year = int(input("Enter a year: "))

if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print(year, "is a leap year")
else:
    print(year, "is not a leap year")

4.8 Worked Program — Simple Calculator

a = float(input("First number: "))
op = input("Operator (+,-,*,/): ")
b = float(input("Second number: "))

if op == "+":
    print("Result =", a + b)
elif op == "-":
    print("Result =", a - b)
elif op == "*":
    print("Result =", a * b)
elif op == "/":
    if b == 0:
        print("Error: division by zero")
    else:
        print("Result =", a / b)
else:
    print("Invalid operator")

V. Iterative Statements & Random Numbers

An iterative statement (loop) repeats a block of statements. Python offers two loops — while (condition-controlled) and for (collection-controlled) — plus the break, continue and else control statements.

5.1 The while Loop

while condition:
    body          # repeats while condition is True
    update        # must eventually make condition False

n = int(input("n = "))
i, total = 1, 0
while i <= n:
    total += i
    i += 1
print("Sum =", total)

5.2 The for Loop

Iterates over the items of any iterable — string, list, tuple, set, dictionary, range, file, etc.

for variable in iterable:
    body

The range() Function

list(range(5))          # [0, 1, 2, 3, 4]
list(range(2, 8))       # [2, 3, 4, 5, 6, 7]
list(range(1, 10, 2))   # [1, 3, 5, 7, 9]
list(range(10, 0, -2))  # [10, 8, 6, 4, 2]

n = int(input("Table of: "))
for i in range(1, 11):
    print(f"{n} x {i} = {n * i}")

5.3 Choosing Between for and while

5.4 Nested Loops

A loop inside another loop. For an outer loop of \(m\) iterations and an inner loop of \(n\) iterations, the inner body executes \(m \times n\) times.

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

*
**
***
****
*****

for n in range(2, 6):
    print(f"--- Table of {n} ---")
    for i in range(1, 11):
        print(f"{n} x {i} = {n * i}")
    print()

rows = 4
num = 1
i = 1
while i <= rows:
    j = 1
    while j <= i:
        print(num, end=" ")
        num += 1
        j += 1
    print()
    i += 1

1
2 3
4 5 6
7 8 9 10

5.5 Loop Control — break, continue, else

n = int(input("Enter a number: "))

if n < 2:
    print("Not prime")
else:
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            print(n, "is not prime")
            break
    else:
        print(n, "is prime")

for i in range(1, 11):
    if i % 2 == 0:
        continue
    print(i, end=" ")
# Output: 1 3 5 7 9

5.6 Random Numbers in Loops

The random module generates pseudo-random numbers, essential for simulations, games and testing.

import random

random.seed(1)              # reproducible results
counts = [0] * 7

for _ in range(1000):
    roll = random.randint(1, 6)     # simulate one dice throw
    counts[roll] += 1

for face in range(1, 7):
    print(f"Face {face}: {counts[face]} times")

import random

secret = random.randint(1, 50)
attempts = 0

while True:
    guess = int(input("Guess a number (1-50): "))
    attempts += 1
    if guess < secret:
        print("Too low!")
    elif guess > secret:
        print("Too high!")
    else:
        print(f"Correct! You took {attempts} attempts.")
        break

5.7 Encapsulation and Generalization

These are two fundamental program-design techniques introduced with loops and reused throughout the course.

# Specific: prints only the table of 5, only 10 rows
for i in range(1, 11):
    print(5 * i)

# Generalized: any number, any number of rows, reusable
def print_table(n, upto=10):
    """Print the multiplication table of n up to 'upto'."""
    for i in range(1, upto + 1):
        print(f"{n} x {i} = {n * i}")

print_table(5)
print_table(7, 5)

n = int(input("How many terms? "))
a, b = 0, 1
for _ in range(n):
    print(a, end=" ")
    a, b = b, a + b
print()

n = int(input("Enter a number: "))
total = 0
for i in range(1, n):
    if n % i == 0:
        total += i

if total == n:
    print(n, "is a perfect number")
else:
    print(n, "is not a perfect number")

n = int(input("Enter a number: "))
digits = len(str(n))
total = 0
temp = n

while temp > 0:
    digit = temp % 10
    total += digit ** digits
    temp //= 10

print(n, "is Armstrong" if total == n else "is not Armstrong")

VI. Strings — A Compound Data Type

A string is a sequence of characters enclosed in single, double or triple quotes. It is a compound data type — built from smaller pieces (characters) — and it is immutable: once created, its characters cannot be changed in place.

s1 = 'hello'
s2 = "Python"
s3 = """A multi-line
string literal"""
s4 = str(1234)      # '1234'

6.1 Length, Indexing and Negative Indexing

The built-in len() function returns the number of characters. Indexing accesses a single character; indices start at 0 and negative indices count from the end.

s = "PYTHON"
# index :  0   1   2   3   4   5
# char  :  P   Y   T   H   O   N
# neg   : -6  -5  -4  -3  -2  -1

print(len(s))     # 6
print(s[0])       # P
print(s[5])       # N
print(s[-1])      # N
print(s[-6])      # P
# print(s[6])     # IndexError: string index out of range

6.2 String Traversal

Traversal means visiting each character in turn, using either a while loop with an index or a for loop directly.

s = "Python"

# Using while + index
i = 0
while i < len(s):
    print(s[i], end="-")
    i += 1
print()

# Using for (Pythonic)
for ch in s:
    print(ch, end="-")
print()

# Using enumerate to get index and character
for idx, ch in enumerate(s):
    print(idx, ch)

6.3 Slicing

6.4 Immutability

s = "hello"
# s[0] = 'H'        # TypeError: 'str' object does not support item assignment

s = 'H' + s[1:]     # build a NEW string instead
print(s)            # Hello

6.5 String Operators

6.6 Comparing Strings

Comparison uses lexicographic (dictionary) order based on the Unicode code point of each character. Uppercase letters have smaller code points than lowercase letters.

print("apple" < "banana")      # True  ('a' < 'b')
print("Apple" < "apple")       # True  ('A'=65 < 'a'=97)
print("abc" == "ABC")          # False
print("abc" < "abd")           # True  (first difference at index 2)
print("ab" < "abc")            # True  (shorter prefix is smaller)

6.7 The find() Function and Searching

def count_occurrences(text, sub):
    """Count how many times 'sub' appears in 'text' (non-overlapping)."""
    count = 0
    start = 0
    while True:
        pos = text.find(sub, start)
        if pos == -1:
            break
        count += 1
        start = pos + len(sub)
    return count

print(count_occurrences("banana", "na"))   # 2
print(count_occurrences("aaaa", "aa"))     # 2

6.8 Common String Methods

6.9 String Formatting

price = 1234.5678
print(f"Price: {price:.2f}")        # Price: 1234.57
print(f"{'Item':<10}{'Qty':>5}")    # Item      Qty
print(f"{0.75:.1%}")                # 75.0%

6.10 Worked Programs on Strings

s = input("Enter a string: ").lower().replace(" ", "")
rev = ""
for ch in s:                 # build the reversed string with a loop
    rev = ch + rev

if s == rev:
    print("Palindrome")
else:
    print("Not a palindrome")

text = input("Enter a line of text: ")

vowels = consonants = upper = lower = digits = 0
for ch in text:
    if ch.isupper():
        upper += 1
    if ch.islower():
        lower += 1
    if ch.isdigit():
        digits += 1
    if ch.isalpha():
        if ch.lower() in "aeiou":
            vowels += 1
        else:
            consonants += 1

print("Vowels     :", vowels)
print("Consonants :", consonants)
print("Uppercase  :", upper)
print("Lowercase  :", lower)
print("Digits     :", digits)

text = "python programming is fun"
words = text.split()
result = " ".join(w[0].upper() + w[1:] for w in words)
print(result)      # Python Programming Is Fun

s = "programming"
seen = ""
for ch in s:
    if ch not in seen:
        print(ch, ":", s.count(ch))
        seen += ch

VII. Lists — Mutable Sequences

A list is an ordered, mutable collection of items enclosed in square brackets. Items may be of mixed types, and lists may be nested.

numbers   = [10, 20, 30, 40]
mixed     = [1, "two", 3.0, True, None]
nested    = [[1, 2], [3, 4], [5, 6]]
empty     = []
from_range = list(range(5))        # [0, 1, 2, 3, 4]
chars      = list("abc")           # ['a', 'b', 'c']

7.1 Indexing, Slicing and Length

Lists behave exactly like strings for indexing and slicing — but they are mutable, so slice assignment and item assignment are allowed.

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

L[0] = 99                 # item assignment - allowed!
print(L)                  # [99, 20, 30, 40, 50]

L[1:3] = [200, 300, 400]  # slice assignment - length may change
print(L)                  # [99, 200, 300, 400, 40, 50]

7.2 Nested Lists (Matrices)

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

print(matrix[1][2])       # 6  (row 1, column 2)

for row in matrix:
    for value in row:
        print(value, end=" ")
    print()

7.3 Traversal and Membership

fruits = ["apple", "banana", "cherry"]

for fruit in fruits:               # direct traversal
    print(fruit)

for i in range(len(fruits)):       # index-based traversal
    print(i, fruits[i])

print("banana" in fruits)          # True
print("grape" not in fruits)       # True

7.4 List Operations

7.5 List Methods — Insertion, Deletion, Substitution

L = [10, 20, 30, 40, 50]

L.append(60)          # insertion at end
L.insert(0, 5)        # insertion at index 0
print(L)              # [5, 10, 20, 30, 40, 50, 60]

L[2] = 200            # substitution
print(L)              # [5, 10, 200, 30, 40, 50, 60]

L.remove(200)         # deletion by value
del L[0]              # deletion by index
popped = L.pop()      # delete and return last
print(L, "| popped:", popped)

7.6 Aliasing versus Copying

A = [1, 2, 3]
B = A                # ALIAS - same object
B.append(4)
print(A)             # [1, 2, 3, 4]  (A changed too!)

C = A.copy()         # SHALLOW COPY - new object
C.append(5)
print(A)             # [1, 2, 3, 4]  (unchanged)
print(C)             # [1, 2, 3, 4, 5]

D = A[:]             # another way to copy
E = list(A)          # another way to copy

For nested lists, a shallow copy still shares the inner lists. Use copy.deepcopy() for a fully independent copy.

import copy
deep = copy.deepcopy(nested)

7.7 List Comprehension

squares = [x ** 2 for x in range(1, 6)]
print(squares)                       # [1, 4, 9, 16, 25]

evens = [x for x in range(20) if x % 2 == 0]
print(evens)                         # [0, 2, 4, ..., 18]

words = ["hello", "world"]
upper = [w.upper() for w in words]   # ['HELLO', 'WORLD']

matrix = [[1,2],[3,4]]
flat = [n for row in matrix for n in row]   # [1, 2, 3, 4]

7.8 Worked Programs on Lists

nums = [45, 12, 89, 33, 67, 89, 5]

largest = max(nums)
smallest = min(nums)

unique = sorted(set(nums), reverse=True)
second = unique[1] if len(unique) > 1 else None

print("Largest :", largest)
print("Smallest:", smallest)
print("Second largest:", second)

data = [1, 3, 2, 3, 5, 1, 4]
result = []
for x in data:
    if x not in result:
        result.append(x)
print(result)          # [1, 3, 2, 5, 4]

A = [[1, 2], [3, 4]]
B = [[5, 6], [7, 8]]
C = []

for i in range(len(A)):
    row = []
    for j in range(len(A[0])):
        row.append(A[i][j] + B[i][j])
    C.append(row)

print(C)               # [[6, 8], [10, 12]]

stack = []

def push(item):
    stack.append(item)
    print(f"Pushed {item}")

def pop_item():
    if not stack:
        print("Stack underflow")
        return None
    return stack.pop()

def peek():
    return stack[-1] if stack else None

push(10); push(20); push(30)
print("Top:", peek())
print("Popped:", pop_item())
print("Stack now:", stack)

marks = [78, 92, 65, 88, 54]
total = sum(marks)
average = total / len(marks)
print(f"Total = {total}, Average = {average:.2f}")

VIII. Tuples — Immutable Sequences

A tuple is an ordered, immutable sequence enclosed in parentheses. Once created, its elements cannot be added, removed or replaced. Tuples are faster and safer than lists when the data must not change.

point   = (3, 5)
rgb     = (255, 128, 0)
mixed   = (1, "two", 3.0)
nested  = ((1, 2), (3, 4))
empty   = ()
single  = (42,)        # NOTE the trailing comma!
not_a_tuple = (42)     # this is just the integer 42
from_list = tuple([1, 2, 3])

8.1 Accessing Elements

t = (10, 20, 30, 40, 50)

print(t[0])        # 10
print(t[-1])       # 50
print(t[1:4])      # (20, 30, 40)
print(t[::-1])     # (50, 40, 30, 20, 10)
print(len(t))      # 5
print(20 in t)     # True

# t[0] = 99        # TypeError: 'tuple' object does not support item assignment

8.2 Tuple Assignment, Packing and Unpacking

# Packing
person = "Aarav", 19, "CSE"

# Unpacking
name, age, branch = person
print(name, age, branch)      # Aarav 19 CSE

# Swapping via tuple packing
a, b = 1, 2
a, b = b, a
print(a, b)                   # 2 1

# Starred unpacking
first, *middle, last = (1, 2, 3, 4, 5)
print(first, middle, last)    # 1 [2, 3, 4] 5

8.3 Tuples as Return Values

A function can return several values at once by returning a tuple.

def min_max(numbers):
    return min(numbers), max(numbers)

low, high = min_max([4, 9, 1, 7])
print("Min:", low, "Max:", high)      # Min: 1 Max: 9

8.4 Tuple Methods and Operations

8.5 Tuple versus List

locations = {
    (28.61, 77.21): "Delhi",
    (19.07, 72.87): "Mumbai",
    (12.97, 77.59): "Bengaluru"
}
print(locations[(28.61, 77.21)])   # Delhi

votes = ("A", "B", "A", "C", "A", "B")
for candidate in set(votes):
    print(candidate, "->", votes.count(candidate), "votes")

IX. Dictionaries — Key–Value Mapping

A dictionary is an unordered (insertion-ordered since Python 3.7), mutable collection of key–value pairs. Keys must be unique and hashable (immutable types); values may be of any type.

student = {"name": "Aarav", "age": 19, "cgpa": 8.7}
empty   = {}
from_pairs = dict([("a", 1), ("b", 2)])
squares = {x: x ** 2 for x in range(1, 5)}   # {1:1, 2:4, 3:9, 4:16}

9.1 Accessing and Modifying Values

student = {"name": "Aarav", "age": 19}

student["cgpa"] = 8.7              # add a new key
student["age"] = 20                # update an existing key

print(student.get("name"))         # Aarav
print(student.get("city", "N/A"))  # N/A  (no KeyError)
print(len(student))                # 3

del student["age"]
print(student)                     # {'name': 'Aarav', 'cgpa': 8.7}

9.2 Dictionary Views and Traversal

marks = {"Maths": 92, "Physics": 85, "Python": 98}

for subject in marks.keys():
    print(subject)

for score in marks.values():
    print(score)

for subject, score in marks.items():        # most common pattern
    print(f"{subject}: {score}")

9.3 Nested Dictionaries

students = {
    "S101": {"name": "Aarav", "marks": [88, 92, 79]},
    "S102": {"name": "Diya",  "marks": [95, 81, 90]}
}

for roll, info in students.items():
    avg = sum(info["marks"]) / len(info["marks"])
    print(roll, info["name"], f"Average = {avg:.2f}")

9.4 Worked Programs on Dictionaries

text = "programming"
freq = {}

for ch in text:
    freq[ch] = freq.get(ch, 0) + 1

print(freq)
# {'p': 1, 'r': 2, 'o': 1, 'g': 2, 'a': 1, 'm': 2, 'i': 1, 'n': 1}

sentence = "the quick brown fox jumps over the lazy dog the fox"
words = sentence.split()
counts = {}

for w in words:
    counts[w] = counts.get(w, 0) + 1

for word, n in sorted(counts.items(), key=lambda kv: (-kv[1], kv[0])):
    print(f"{word:<8} {n}")

marks = {"Aarav": 88, "Diya": 95, "Kabir": 72, "Meera": 60}

topper = max(marks, key=marks.get)
average = sum(marks.values()) / len(marks)

print("Topper :", topper, marks[topper])
print(f"Average: {average:.2f}")
print("Passed :", [n for n, m in marks.items() if m >= 40])

d1 = {"a": 1, "b": 2}
d2 = {"b": 20, "c": 30}

merged = {**d1, **d2}       # d2 overwrites duplicate keys
print(merged)               # {'a': 1, 'b': 20, 'c': 30}

d1.update(d2)               # in-place merge
print(d1)                   # {'a': 1, 'b': 20, 'c': 30}

X. Sets — Unordered Unique Collections

A set is an unordered, mutable collection of unique, hashable elements. Duplicate values are automatically discarded. Sets are implemented with hash tables, giving average \(O(1)\) membership testing.

s1 = {1, 2, 3, 4}
s2 = set([3, 4, 5, 6])
empty = set()            # NOTE: {} creates an empty DICT, not a set
chars = set("banana")    # {'b', 'a', 'n'}

print({1, 2, 2, 3, 3, 3})   # {1, 2, 3} - duplicates removed

10.1 Set Operations

10.2 Set Methods

10.3 Frozenset

An immutable version of a set. Because it is hashable, it can be used as a dictionary key or as an element of another set.

fs = frozenset([1, 2, 3])
# fs.add(4)        # AttributeError: 'frozenset' object has no attribute 'add'

permissions = {frozenset({"read", "write"}): "editor"}

10.4 Worked Programs on Sets

data = [1, 2, 2, 3, 4, 4, 5, 1]
unique = list(set(data))
print(unique)        # order not guaranteed, e.g. [1, 2, 3, 4, 5]

aarav = {"Maths", "Physics", "Python", "Chemistry"}
diya  = {"Python", "Chemistry", "Biology", "English"}

print("Common  :", aarav & diya)
print("All     :", aarav | diya)
print("Only Aarav:", aarav - diya)
print("Not common :", aarav ^ diya)

Common  : {'Python', 'Chemistry'}
All     : {'Maths', 'Physics', 'Python', 'Chemistry', 'Biology', 'English'}
Only Aarav: {'Maths', 'Physics'}
Not common : {'Maths', 'Physics', 'Biology', 'English'}

vowels = set("aeiou")
word = "programming"
found = {ch for ch in word if ch in vowels}
print(found)         # {'o', 'a', 'i'}

all_rolls = set(range(1, 11))
present   = {1, 2, 4, 5, 7, 10}

absent = all_rolls - present
print("Absent:", sorted(absent))     # [3, 6, 8, 9]

XI. Functions, Parameters, Arguments & Recursion

A function is a named block of reusable code that performs a specific task. Functions support code reuse, modularity, readability and easier debugging.

11.1 Defining and Calling a Function

def greet(name):
    """Return a greeting message for the given name."""
    return f"Hello, {name}!"

message = greet("Aarav")
print(message)          # Hello, Aarav!

11.2 Parameters versus Arguments

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

print(add(3, 5))    # 3, 5 are ARGUMENTS

11.3 Types of Arguments

def power(base, exponent=2):
    return base ** exponent

print(power(5))            # 25  (default exponent)
print(power(2, 10))        # 1024
print(power(exponent=3, base=4))   # 64 (keyword arguments)

def total(*numbers):
    return sum(numbers)

print(total(1, 2, 3, 4))   # 10

def profile(**info):
    for k, v in info.items():
        print(f"{k}: {v}")

profile(name="Aarav", age=19, branch="CSE")

11.4 Return Values

• return immediately exits the function and passes a value back.
• A function without return (or with bare return) returns None.
• A function may return multiple values, packed as a tuple.

def divide(a, b):
    if b == 0:
        return None          # explicit "no result"
    return a / b

print(divide(10, 2))         # 5.0
print(divide(10, 0))         # None

def statistics(nums):
    return min(nums), max(nums), sum(nums) / len(nums)

lo, hi, avg = statistics([4, 8, 15, 16, 23, 42])
print(lo, hi, avg)

11.5 Scope of Variables — the LEGB Rule

Python resolves names in this order: Local → Enclosing → Global → Built-in.

counter = 0                # global

def increment():
    global counter         # declare intent to modify the global
    counter += 1

increment(); increment()
print(counter)             # 2

def outer():
    x = 10
    def inner():
        nonlocal x         # refers to outer's x, not a new local
        x += 5
    inner()
    return x

print(outer())             # 15

11.6 Lambda Functions

A lambda is a small anonymous function written as a single expression.

square = lambda x: x * x
print(square(6))                 # 36

add = lambda a, b: a + b
print(add(3, 4))                 # 7

# Commonly used with sorted(), map(), filter()
nums = [5, 2, 9, 1]
print(sorted(nums, key=lambda n: -n))      # [9, 5, 2, 1]

print(list(map(lambda x: x ** 2, nums)))   # [25, 4, 81, 1]
print(list(filter(lambda x: x > 3, nums)))# [5, 9]

11.7 Recursion

def factorial(n):
    if n <= 1:              # base case
        return 1
    return n * factorial(n - 1)   # recursive case

print(factorial(5))         # 120
print(factorial(0))         # 1

def fib(n):
    if n <= 1:              # base cases: fib(0)=0, fib(1)=1
        return n
    return fib(n - 1) + fib(n - 2)

for i in range(8):
    print(fib(i), end=" ")   # 0 1 1 2 3 5 8 13

def digit_sum(n):
    if n == 0:
        return 0
    return n % 10 + digit_sum(n // 10)

print(digit_sum(12345))     # 15

def binary_search(arr, low, high, target):
    if low > high:
        return -1
    mid = (low + high) // 2
    if arr[mid] == target:
        return mid
    elif arr[mid] < target:
        return binary_search(arr, mid + 1, high, target)
    else:
        return binary_search(arr, low, mid - 1, target)

data = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]
print(binary_search(data, 0, len(data) - 1, 23))   # 5

Recursion versus Iteration

XII. Object-Oriented Programming in Python

Object-Oriented Programming (OOP) organises a program around objects — self-contained entities that combine data (attributes) and behaviour (methods). Python supports all four pillars: encapsulation, abstraction, inheritance and polymorphism.

12.1 Classes and Objects

class Student:
    """Represents a student with a name and marks."""

    def __init__(self, name, marks):     # constructor
        self.name = name                 # instance attribute
        self.marks = marks

    def average(self):                   # instance method
        return sum(self.marks) / len(self.marks)

    def display(self):
        print(f"{self.name}: average = {self.average():.2f}")

# Creating objects
s1 = Student("Aarav", [88, 92, 79])
s2 = Student("Diya",  [95, 81, 90])

s1.display()        # Aarav: average = 86.33
s2.display()        # Diya: average = 88.67

print(s1.name)      # accessing an attribute -> Aarav

12.2 The __init__ Constructor

__init__ is a special (dunder) method that runs automatically when an object is created. It initialises instance attributes. It does not return a value.

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def distance_from_origin(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5

    def __str__(self):                  # string representation
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(p)                        # Point(3, 4)
print(p.distance_from_origin()) # 5.0

12.3 Instance Variables versus Class Variables

class Employee:
    company = "LPU Tech"          # class variable (shared)

    def __init__(self, name):
        self.name = name          # instance variable (per object)

e1 = Employee("Aarav")
e2 = Employee("Diya")

print(e1.company, e2.company)     # LPU Tech LPU Tech
Employee.company = "LPU Innovations"
print(e1.company)                 # LPU Innovations (both changed)

12.4 Methods: Instance, Class and Static

class Circle:
    pi = 3.14159

    def __init__(self, radius):
        self.radius = radius

    def area(self):                       # instance method
        return Circle.pi * self.radius ** 2

    @classmethod
    def from_diameter(cls, diameter):     # alternate constructor
        return cls(diameter / 2)

    @staticmethod
    def is_valid_radius(r):               # utility
        return r > 0

c = Circle.from_diameter(10)
print(c.radius)                  # 5.0
print(Circle.is_valid_radius(3)) # True

12.5 Encapsulation and Data Hiding

Encapsulation bundles data and the methods that operate on it, and restricts direct access from outside. Python uses naming conventions rather than strict keywords.

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance          # private attribute

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

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            return True
        return False

    def get_balance(self):                # controlled accessor
        return self.__balance

acc = BankAccount("Aarav", 5000)
acc.deposit(2500)
acc.withdraw(1000)
print(acc.get_balance())          # 6500

# print(acc.__balance)            # AttributeError
print(acc._BankAccount__balance)  # 6500 - name mangling still allows access

12.6 Inheritance

Inheritance lets a class (child/derived) acquire the attributes and methods of another class (parent/base), promoting code reuse and an “is-a” relationship.

Types of Inheritance

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return "Some generic sound"

    def info(self):
        print(f"I am {self.name}")

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)        # call parent constructor
        self.breed = breed

    def speak(self):                  # override
        return "Woof!"

d = Dog("Bruno", "Labrador")
d.info()               # I am Bruno
print(d.speak())       # Woof!
print(isinstance(d, Animal))   # True

class Vehicle:
    def __init__(self, brand):
        self.brand = brand
    def describe(self):
        print(f"Brand: {self.brand}")

class Car(Vehicle):
    def __init__(self, brand, seats):
        super().__init__(brand)
        self.seats = seats
    def describe(self):
        super().describe()
        print(f"Seats: {self.seats}")

class ElectricCar(Car):
    def __init__(self, brand, seats, range_km):
        super().__init__(brand, seats)
        self.range_km = range_km
    def describe(self):
        super().describe()
        print(f"Range: {self.range_km} km")

e = ElectricCar("Tesla", 5, 500)
e.describe()

Brand: Tesla
Seats: 5
Range: 500 km

class Flyer:
    def move(self):
        return "flies"

class Swimmer:
    def move(self):
        return "swims"

class Duck(Flyer, Swimmer):
    pass

d = Duck()
print(d.move())            # flies  (Flyer comes first in MRO)
print(Duck.__mro__)        # (Duck, Flyer, Swimmer, object)

12.7 Polymorphism

Polymorphism means “many forms” — the same interface behaves differently for different types.

(a) Method Overriding (Runtime Polymorphism)

class Shape:
    def area(self):
        raise NotImplementedError

class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self): return 3.14159 * self.r ** 2

class Rectangle(Shape):
    def __init__(self, l, b): self.l, self.b = l, b
    def area(self): return self.l * self.b

for shape in (Circle(5), Rectangle(4, 6)):
    print(f"{shape.__class__.__name__}: {shape.area():.2f}")

Circle: 78.54
Rectangle: 24.00

(b) Operator Overloading (Compile-time style)

Dunder methods let user-defined objects respond to built-in operators.

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __str__(self):
        return f"Vector({self.x}, {self.y})"

v = Vector(1, 2) + Vector(3, 4)
print(v)                # Vector(4, 6)

12.8 Abstraction with Abstract Classes

from abc import ABC, abstractmethod

class Payment(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

class CreditCard(Payment):
    def pay(self, amount):
        print(f"Paid Rs.{amount} by credit card")

class UPI(Payment):
    def pay(self, amount):
        print(f"Paid Rs.{amount} via UPI")

for method in (CreditCard(), UPI()):
    method.pay(1500)

An abstract class cannot be instantiated; it only declares the interface that subclasses must implement.

XIII. File Handling — Text & Binary Files

Files provide persistent storage: data survives after the program terminates. Python's built-in open() function returns a file object used for reading and writing.

13.1 File Modes

13.2 Reading from a Text File

# Method 1: read everything
f = open("data.txt", "r")
content = f.read()
print(content)
f.close()

# Method 2: line by line (memory-efficient) - recommended
with open("data.txt", "r") as f:
    for line in f:
        print(line.rstrip())        # rstrip() removes the newline

# Method 3: readlines()
with open("data.txt", "r") as f:
    lines = f.readlines()
print(len(lines), "lines")

13.3 Writing to a Text File

# Write (overwrites)
with open("output.txt", "w") as f:
    f.write("First line\n")
    f.write("Second line\n")
    f.writelines(["Third\n", "Fourth\n"])

# Append
with open("output.txt", "a") as f:
    f.write("Fifth line (appended)\n")

13.4 File Position — tell() and seek()

with open("data.txt", "r") as f:
    print(f.tell())        # 0  - at the start
    first = f.read(5)
    print(f.tell())        # 5  - after reading 5 characters
    f.seek(0)              # move back to the beginning
    print(f.read(5))       # reads the same first 5 characters

13.5 Binary Files and the pickle Module

Binary files store data in bytes. Python's pickle module serialises (converts) Python objects into a byte stream and back.

import pickle

# --- Writing records ---
records = [("Aarav", 101), ("Diya", 102), ("Kabir", 103)]

with open("students.dat", "wb") as f:
    pickle.dump(records, f)

# --- Searching for a roll number ---
roll_to_find = int(input("Enter roll number to search: "))

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

found = False
for name, roll in data:
    if roll == roll_to_find:
        print("Name:", name)
        found = True
        break

if not found:
    print("Roll number not found")

13.6 Worked File-Handling Programs

with open("sample.txt", "r") as f:
    for line_no, line in enumerate(f, start=1):
        print(f"{line_no}: {line.rstrip()}")

vowels = consonants = upper = lower = 0

with open("sample.txt", "r") as f:
    text = f.read()

for ch in text:
    if ch.isupper():
        upper += 1
    if ch.islower():
        lower += 1
    if ch.isalpha():
        if ch.lower() in "aeiou":
            vowels += 1
        else:
            consonants += 1

print("Vowels     :", vowels)
print("Consonants :", consonants)
print("Uppercase  :", upper)
print("Lowercase  :", lower)

with open("source.txt", "r") as fin, open("target.txt", "w") as fout:
    for line in fin:
        if "a" not in line:
            fout.write(line)

print("Lines containing 'a' were removed.")

with open("sample.txt", "r") as f:
    for line in f:
        words = line.split()
        print("#".join(words))

freq = {}

with open("phishing.txt", "r") as f:
    for line in f:
        for word in line.lower().split():
            word = word.strip(".,!?;:()\"'")
            if word:
                freq[word] = freq.get(word, 0) + 1

most_common = max(freq, key=freq.get)
print("Most common word:", most_common, "->", freq[most_common])

try:
    with open("data.txt", "r") as f:
        print(f.read())
except FileNotFoundError:
    print("The file does not exist.")
except PermissionError:
    print("Access denied.")
finally:
    print("Operation attempted.")

XIV. Regular Expressions & Pattern Matching

A regular expression (regex) is a sequence of characters that defines a search pattern. Python's re module provides the tools to search, match, extract and replace text using these patterns.

import re

14.1 Metacharacters

14.2 Special Sequences

14.3 The re Module Functions

14.4 Match Object Methods

14.5 Worked Examples

import re

text = "My phone number is 9876543210 and office is 011-2345678"

print(re.findall(r"\d{10}", text))
# ['9876543210']

print(re.search(r"\d+", text).group())
# 9876543210

print(re.match(r"My", text) is not None)   # True
print(re.match(r"phone", text) is None)    # True (not at the start)

import re

pattern = r"^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$"

emails = ["aarav@lpu.in", "bad@@mail", "diya.s@co.org", "no-at-sign.com"]

for e in emails:
    status = "Valid" if re.match(pattern, e) else "Invalid"
    print(f"{e:<20} {status}")

aarav@lpu.in         Valid
bad@@mail            Invalid
diya.s@co.org        Valid
no-at-sign.com       Invalid

import re

pattern = r"^[6-9]\d{9}$"      # starts with 6-9, then exactly 9 digits

for number in ["9876543210", "1234567890", "98123", "9999999999"]:
    print(number, "->", bool(re.match(pattern, number)))

9876543210 -> True
1234567890 -> False
98123 -> False
9999999999 -> True

import re

log = "2024-08-15 10:32:45 ERROR Disk full"
pattern = r"(\d{4})-(\d{2})-(\d{2})\s+(\d{2}):(\d{2}):(\d{2})\s+(\w+)"

m = re.search(pattern, log)
if m:
    year, month, day, hh, mm, ss, level = m.groups()
    print("Date :", f"{day}-{month}-{year}")
    print("Time :", f"{hh}:{mm}:{ss}")
    print("Level:", level)

Date : 15-08-2024
Time : 10:32:45
Level: ERROR

import re

text = "Python   is    fun"

# Collapse multiple spaces into one
clean = re.sub(r"\s+", " ", text)
print(clean)                     # Python is fun

# Mask all digits
print(re.sub(r"\d", "#", "PIN is 4321"))   # PIN is ####

# Split on any non-alphanumeric run
print(re.split(r"\W+", "a,b;c d"))          # ['a', 'b', 'c', 'd']

import re
from collections import Counter

with open("sample.txt", "r") as f:
    text = f.read().lower()

words = re.findall(r"\b[a-z]+\b", text)     # only alphabetic words
common = Counter(words).most_common(5)

for word, count in common:
    print(f"{word}: {count}")

XV. Sorting, Searching & Data Processing

CO4 requires you to “store, process and sort the data”. Python provides built-in sorting tools, and understanding the underlying algorithms is frequently examined.

15.1 sort() versus sorted()

15.2 Sorting with key and reverse

words = ["banana", "apple", "cherry"]
print(sorted(words))                          # alphabetical
print(sorted(words, key=len))                 # by length
print(sorted(words, reverse=True))            # descending

students = [("Aarav", 88), ("Diya", 95), ("Kabir", 72)]
print(sorted(students, key=lambda s: s[1]))            # by marks asc
print(sorted(students, key=lambda s: s[1], reverse=True))  # desc

records = [{"name": "A", "cgpa": 8.7},
           {"name": "B", "cgpa": 9.2},
           {"name": "C", "cgpa": 8.1}]
records.sort(key=lambda r: r["cgpa"])
print(records)

15.3 Bubble Sort

Repeatedly compare adjacent elements and swap them if they are out of order.

def bubble_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        swapped = False
        for j in range(n - 1 - i):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        if not swapped:          # already sorted - early exit
            break
    return arr

print(bubble_sort([64, 34, 25, 12, 22, 11, 90]))
# [11, 12, 22, 25, 34, 64, 90]

15.4 Selection Sort

def selection_sort(arr):
    n = len(arr)
    for i in range(n - 1):
        min_idx = i
        for j in range(i + 1, n):
            if arr[j] < arr[min_idx]:
                min_idx = j
        arr[i], arr[min_idx] = arr[min_idx], arr[i]
    return arr

15.5 Insertion Sort

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

15.6 Comparison of Sorting Algorithms

15.7 Searching

Linear Search — \(O(n)\)

def linear_search(arr, target):
    for i, value in enumerate(arr):
        if value == target:
            return i
    return -1

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

Binary Search — \(O(\log n)\), requires a sorted array

def binary_search(arr, target):
    low, high = 0, len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

data = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]
print(binary_search(data, 23))    # 5

students = [
    ("Aarav", "CSE", 88),
    ("Diya",  "ECE", 95),
    ("Kabir", "CSE", 95),
    ("Meera", "ECE", 88),
]

# Secondary key first: name ascending
students.sort(key=lambda s: s[0])
# Primary key: marks descending (stable keeps name order within equal marks)
students.sort(key=lambda s: s[2], reverse=True)

for name, branch, marks in students:
    print(f"{name:<7} {branch}  {marks}")

Diya    ECE  95
Kabir   CSE  95
Aarav   CSE  88
Meera   ECE  88

XVI. Summary & Quick Reference Sheet

16.1 Built-in Function Reference

16.2 Data Structure Cheat Sheet

16.3 Key Syntax Summary

16.4 Complexity Quick Reference

16.5 Common Exceptions Reference

XVII. Exam Tips & Practice Questions

Top 10 Exam Tips

1. Indentation is syntax. A missing or extra space in a block changes the program's meaning or breaks it. Use exactly 4 spaces consistently.
2. Colons after every block header. if x > 0:, for i in range(5):, def f():, class C:, else:, try:.
3. input() returns a string. Wrap it with int() or float() when arithmetic is required.
4. Remember that ranges exclude the stop value. range(1, n) runs from 1 to n−1; use range(1, n+1) for 1…n.
5. Strings and tuples are immutable. Never write s[0] = 'X'; build a new object instead.
6. = is assignment, == is comparison. Confusing them is the most common logic error in if statements.
7. Close files or use with. Examiners award marks for resource management.
8. Trace recursive functions by hand. Write the call stack for at least two levels to prove you understand the base case.
9. State complexity where relevant. Linear search \(O(n)\), binary search \(O(\log n)\), bubble sort \(O(n^2)\), built-in sort \(O(n\log n)\).
10. Comment your logic. Even one line per block demonstrates understanding and can earn partial credit when output is wrong.

Practice Questions

XVIII. Full Solutions to Practice Questions

Solution 1 — Arithmetic operations

a = int(input("Enter first number : "))
b = int(input("Enter second number: "))

print("Addition       :", a + b)
print("Subtraction    :", a - b)
print("Multiplication :", a * b)
print("Division       :", a / b)
print("Floor Division :", a // b)
print("Modulus        :", a % b)
print("Exponent       :", a ** b)

Sample (a=7, b=2): 9, 5, 14, 3.5, 3, 1, 49.

Solution 2 — Perfect number

n = int(input("Enter a number: "))

if n < 2:
    print(n, "is not a perfect number")
else:
    divisor_sum = 0
    for i in range(1, n):
        if n % i == 0:
            divisor_sum += i

    if divisor_sum == n:
        print(n, "is a perfect number")
    else:
        print(n, "is not a perfect number")

Trace for n = 28: divisors 1, 2, 4, 7, 14 → sum = 28 → perfect. For n = 12: 1+2+3+4+6 = 16 ≠ 12 → not perfect.

Solution 3 — Armstrong number

n = int(input("Enter a number: "))
num_digits = len(str(n))
temp = n
total = 0

while temp > 0:
    digit = temp % 10
    total += digit ** num_digits
    temp //= 10

if total == n:
    print(n, "is an Armstrong number")
else:
    print(n, "is not an Armstrong number")

Trace for n = 153: digits = 3. 3³ = 27, 5³ = 125, 1³ = 1 → 27+125+1 = 153 → Armstrong.

Solution 4 — Fibonacci (iteration and recursion)

# --- Iterative version ---
def fib_iter(n):
    a, b = 0, 1
    for _ in range(n):
        print(a, end=" ")
        a, b = b, a + b
    print()

# --- Recursive version ---
def fib_rec(n):
    if n <= 1:
        return n
    return fib_rec(n - 1) + fib_rec(n - 2)

terms = int(input("How many terms? "))
fib_iter(terms)

print("Recursive:", end=" ")
for i in range(terms):
    print(fib_rec(i), end=" ")
print()

For terms = 8: 0 1 1 2 3 5 8 13 from both versions. The iterative version is \(O(n)\); the naive recursive version is \(O(2^n)\).

Solution 5 — Palindrome without slicing

s = input("Enter a string: ").lower()
reversed_s = ""

for ch in s:
    reversed_s = ch + reversed_s

if s == reversed_s:
    print("Palindrome")
else:
    print("Not a palindrome")

Trace for "madam": reversed_s builds m → am → dam → adam → madam. Equal → Palindrome.

Solution 6 — Character analysis of a file

vowels = consonants = upper = lower = digits = 0
vowel_set = set("aeiouAEIOU")

with open("sample.txt", "r") as f:
    for line in f:
        for ch in line:
            if ch.isdigit():
                digits += 1
            if ch.isalpha():
                if ch in vowel_set:
                    vowels += 1
                else:
                    consonants += 1
                if ch.isupper():
                    upper += 1
                else:
                    lower += 1

print("Vowels     :", vowels)
print("Consonants :", consonants)
print("Uppercase  :", upper)
print("Lowercase  :", lower)
print("Digits     :", digits)

Solution 7 — Binary file with search

import pickle

def write_records(filename):
    n = int(input("How many records? "))
    records = []
    for i in range(n):
        name = input(f"Name {i+1}: ")
        roll = int(input(f"Roll {i+1}: "))
        records.append((roll, name))
    with open(filename, "wb") as f:
        pickle.dump(records, f)
    print("Records saved.")

def search_record(filename, target_roll):
    try:
        with open(filename, "rb") as f:
            records = pickle.load(f)
    except FileNotFoundError:
        print("File not found.")
        return

    for roll, name in records:
        if roll == target_roll:
            print(f"Roll {roll} -> {name}")
            return
    print(f"Roll number {target_roll} not found.")

write_records("students.dat")
search_record("students.dat", int(input("Search roll number: ")))

Key points: binary mode 'wb' / 'rb', pickle.dump / pickle.load, and a clear “not found” message.

Solution 8 — Encapsulated BankAccount

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.__balance = balance          # private

    def deposit(self, amount):
        if amount <= 0:
            print("Deposit amount must be positive.")
            return
        self.__balance += amount
        print(f"Deposited Rs.{amount}. Balance = Rs.{self.__balance}")

    def withdraw(self, amount):
        if amount <= 0:
            print("Withdrawal amount must be positive.")
        elif amount > self.__balance:
            print("Insufficient balance.")
        else:
            self.__balance -= amount
            print(f"Withdrew Rs.{amount}. Balance = Rs.{self.__balance}")

    def get_balance(self):
        return self.__balance

acc = BankAccount("Aarav", 5000)
acc.deposit(2500)
acc.withdraw(1000)
acc.withdraw(100000)
print("Final balance:", acc.get_balance())

Encapsulation demonstrated: __balance is inaccessible as acc.__balance; all modification goes through validated methods.

Solution 9 — Regex validation and extraction

import re

text = """
Contact aarav.sharma@lpu.in or diya@example.org for details.
Call +91-9876543210 or +91-9123456789 between 10am and 5pm.
Invalid: bad@@mail, +91-12345
"""

# --- Email validation ---
email_pattern = r"[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}"
emails = re.findall(email_pattern, text)
print("Emails found:", emails)

# --- Phone number extraction ---
phone_pattern = r"\+91-\d{10}"
phones = re.findall(phone_pattern, text)
print("Phone numbers:", phones)

# --- Validate one email strictly ---
candidate = "aarav.sharma@lpu.in"
strict = r"^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$"
print("Valid email?", bool(re.match(strict, candidate)))

Emails found: ['aarav.sharma@lpu.in', 'diya@example.org']
Phone numbers: ['+91-9876543210', '+91-9123456789']
Valid email? True

Solution 10 — Duplicates, sorting, second largest

numbers = []
for i in range(10):
    numbers.append(int(input(f"Enter number {i+1}: ")))

unique = list(set(numbers))          # remove duplicates
unique.sort(reverse=True)            # descending order

print("Sorted unique list:", unique)

if len(unique) >= 2:
    print("Second largest:", unique[1])
else:
    print("Not enough distinct elements.")

Note: using set() loses the original order, which does not matter here because the list is sorted afterwards. If order preservation is required, use the loop-and-check method.

Solution 11 — Recursive digit sum with trace

def digit_sum(n):
    if n == 0:
        return 0
    return n % 10 + digit_sum(n // 10)

print(digit_sum(4729))     # 22

Recursion trace for n = 4729:

digit_sum(4729)
 = 9 + digit_sum(472)
 = 9 + (2 + digit_sum(47))
 = 9 + (2 + (7 + digit_sum(4)))
 = 9 + (2 + (7 + (4 + digit_sum(0))))
 = 9 + 2 + 7 + 4 + 0
 = 22

Solution 12 — Stack implementation

class Stack:
    def __init__(self):
        self.items = []

    def is_empty(self):
        return len(self.items) == 0

    def push(self, item):
        self.items.append(item)
        print(f"Pushed: {item}")

    def pop(self):
        if self.is_empty():
            print("Stack underflow - nothing to pop.")
            return None
        return self.items.pop()

    def peek(self):
        if self.is_empty():
            print("Stack is empty.")
            return None
        return self.items[-1]

    def size(self):
        return len(self.items)

s = Stack()
s.push(10); s.push(20); s.push(30)
print("Top element:", s.peek())      # 30
print("Popped     :", s.pop())       # 30
print("Size       :", s.size())      # 2

s.pop(); s.pop()
print("Popped from empty:", s.pop()) # underflow message

XIX. References, Key Takeaways & CO Mapping

19.1 Textbooks and References

19.2 Relevant Web Resources

19.3 Key Takeaways

1. Python is an interpreted, dynamically typed, high-level language; installation requires adding it to PATH, and Anaconda bundles it with data-science tooling.
2. Variables need no declaration; names must follow identifier rules and avoid the 35 reserved keywords. Using a name before assignment raises NameError.
3. Operators follow a strict precedence order; ** is right-associative, and parentheses always take priority.
4. if-elif-else selects exactly one branch; conditions should be ordered from most to least restrictive.
5. for iterates over collections, while repeats on a condition; break, continue and loop else control the flow.
6. Strings are immutable sequences supporting indexing, negative indexing, slicing, traversal, comparison and a rich method set.
7. Lists are mutable and support insertion, deletion, substitution, slicing, comprehension and in-place sorting; tuples are their immutable counterpart.
8. Dictionaries map unique keys to values with \(O(1)\) average lookup; sets store unique unordered elements with fast membership testing and full set algebra.
9. Functions promote reuse through parameters, default arguments, *args/**kwargs; recursion needs a base case and consumes stack space.
10. OOP in Python rests on classes, objects, encapsulation, inheritance and polymorphism; dunder methods enable operator overloading.
11. File handling uses open() with modes, and with guarantees closure; pickle handles binary object storage.
12. Regular expressions in the re module provide powerful pattern matching through metacharacters, character classes, quantifiers and groups.

19.4 CO Mapping

19.5 Practical List Coverage