Python Programming

Setting Up & Hello World

1.1 What is Python?

Python is a high-level, interpreted, general-purpose programming language created by Guido van Rossum in 1991. It emphasizes code readability with its clean syntax and indentation-based block structure. Python is used everywhere — web development (Django, Flask), data science (NumPy, Pandas), AI/ML (TensorFlow, PyTorch), automation, and more.

1.2 Python 2 vs Python 3

1.3 Installing Python on Windows

Command Prompt
# Verify Python installation
C:\> python --version
Python 3.12.4

# Verify pip (package installer)
C:\> pip --version
pip 24.0 from C:\Python312\Lib\site-packages\pip (python 3.12)

1.4 Your First Python Program

Create a file called hello.py and type:

Python
# hello.py — Your first Python program!
print("Hello, World!")

Run it from the terminal:

Command Prompt
C:\projects> python hello.py
Hello, World!

1.5 Ways to Run Python

1.6 The print() Function

Python
# Basic printing
print("Hello, World!")           # String
print(42)                         # Number
print(3.14)                       # Float
print(True)                       # Boolean

# Multiple values
print("Name:", "Alice", "Age:", 25)
# Output: Name: Alice Age: 25

# Custom separator and end
print("A", "B", "C", sep="-")     # Output: A-B-C
print("Hello", end=" ")             # No newline at end
print("World")                     # Output: Hello World

# Escape characters
print("Line1\nLine2")              # Newline
print("Tab\there")                 # Tab
print("She said \"hi\"")            # Escaped quotes

1.7 The input() Function

Python
# Get user input
name = input("What is your name? ")
print("Hello,", name)

# input() always returns a string!
age_str = input("Enter your age: ")    # Returns "25" (a string)
age = int(age_str)                       # Convert to integer
print("Next year you'll be", age + 1)

# Shortcut: convert inline
num = int(input("Enter a number: "))
print("Double:", num * 2)

Python
name = input("Enter your name: ")
age = int(input("Enter your age: "))
print(f"Hello {name}! You are {age} years old.")
print(f"In 5 years, you'll be {age + 5}.")

Python
length = float(input("Enter length: "))
width = float(input("Enter width: "))
area = length * width
perimeter = 2 * (length + width)
print(f"Area = {area}")
print(f"Perimeter = {perimeter}")

Python
import platform
import sys
import os
from datetime import datetime

# Automated Server Health Check Script
print("═" * 50)
print("🖥️  SERVER HEALTH CHECK REPORT")
print("═" * 50)
print(f"Python Version : {sys.version.split()[0]}")
print(f"OS             : {platform.system()} {platform.release()}")
print(f"Machine        : {platform.machine()}")
print(f"Hostname       : {platform.node()}")
print(f"Timestamp      : {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
print(f"CPU Count      : {os.cpu_count()}")
print("═" * 50)
print("✅ Status: All systems operational")

Variables, Expressions & Statements

2.1 Variables — Names for Values

A variable is a name that refers to a value stored in memory. Think of it as a label attached to a box, not the box itself.

Python
# Creating variables (no declaration needed!)
message = "Hello, Python!"
age = 21
pi = 3.14159
is_student = True

# Variables can change value AND type (dynamic typing)
x = 10          # x is an integer
x = "ten"      # x is now a string (no error!)
x = 10.0       # x is now a float

2.2 Naming Rules & Conventions

2.3 Avoiding NameError

Python
# NameError: using a variable before defining it
print(greeting)  # ❌ NameError: name 'greeting' is not defined

greeting = "Hello"
print(greeting)  # ✅ Works — defined before use

# Common mistake: typos
student_name = "Alice"
print(studnet_name)  # ❌ NameError (typo: studnet)

# Fix: Python is case-sensitive
Name = "Alice"
print(name)   # ❌ NameError — 'name' ≠ 'Name'

2.4 Values and Types

Every value in Python has a type. Use type() to check:

Python
print(type(42))          # <class 'int'>
print(type(3.14))        # <class 'float'>
print(type("hello"))     # <class 'str'>
print(type(True))        # <class 'bool'>
print(type(None))        # <class 'NoneType'>
print(type([1,2,3]))     # <class 'list'>

# Type conversion
x = "42"
y = int(x)       # String → Integer: 42
z = float(x)     # String → Float: 42.0
s = str(42)       # Integer → String: "42"
b = bool(0)       # Integer → Boolean: False
b = bool(1)       # Integer → Boolean: True

2.5 Python Keywords

Python
# View all 35 Python keywords
import keyword
print(keyword.kwlist)
# ['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']

2.6 Statements vs Expressions

An expression produces a value: 3 + 4, x * 2, len("hi"). A statement performs an action: x = 5, print("hi"), if x > 0:.

Python
# Expressions (produce values)
3 + 4              # → 7
len("hello")       # → 5
x * 2 + 1          # → depends on x

# Statements (perform actions)
x = 10             # Assignment statement
print(x)           # Print statement
import math        # Import statement
del x              # Delete statement

2.7 Comments

Python
# Single-line comment
x = 42  # Inline comment

# Multi-line comment (use # on each line)
# This is a longer comment
# that spans multiple lines

"""
Docstring — used for documentation.
Technically a string literal, not a comment.
Used for function/class documentation.
"""

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

Python
x = 5
y = x
x = 10
print(y)  # Output: 5 (y still refers to 5, not x)

Python
a = 10
b = 20
print(f"Before: a={a}, b={b}")
a, b = b, a  # Python's elegant swap!
print(f"After:  a={a}, b={b}")
# Output:
# Before: a=10, b=20
# After:  a=20, b=10

Python
# E-Commerce Shopping Cart Calculator
# Variables for product details
product_name = "Wireless Headphones"
unit_price = 2499.00
quantity = 2
tax_rate = 0.18          # 18% GST
discount_percent = 10     # 10% festival discount
coupon_flat = 200         # ₹200 coupon

# Expressions to calculate total
subtotal = unit_price * quantity
discount_amount = subtotal * (discount_percent / 100)
after_discount = subtotal - discount_amount - coupon_flat
tax_amount = after_discount * tax_rate
final_total = after_discount + tax_amount

# Display invoice
print(f"Product  : {product_name}")
print(f"Price    : ₹{unit_price} × {quantity} = ₹{subtotal}")
print(f"Discount : -₹{discount_amount} (10% off)")
print(f"Coupon   : -₹{coupon_flat}")
print(f"Tax (18%): +₹{tax_amount:.2f}")
print(f"━━━━━━━━━━━━━━━━━━━━━━━━━━")
print(f"Total    : ₹{final_total:.2f}")

Operators & String Operations

3.1 Arithmetic Operators

Python supports all standard mathematical operators. These work with both integers and floats.

Python
# Arithmetic operators in action
a = 17
b = 5

print("Addition:      ", a + b)     # 22
print("Subtraction:   ", a - b)     # 12
print("Multiplication:", a * b)     # 85
print("Division:      ", a / b)     # 3.4
print("Floor Division:", a // b)    # 3
print("Modulus:       ", a % b)     # 2
print("Power:         ", a ** b)    # 1419857

3.2 Comparison Operators

Comparison operators compare two values and return a Boolean (True or False).

Python
x = 10
y = 20

print(x == y)    # False
print(x != y)    # True
print(x < y)     # True
print(x > y)     # False
print(x <= 10)  # True
print(x >= 15)  # False

# Chained comparisons (Python special!)
age = 25
print(18 <= age <= 30)   # True — is age between 18 and 30?

3.3 Assignment Operators

Assignment operators combine an operation with assignment for cleaner code.

Python
score = 100
score += 10    # score = 110
score -= 5     # score = 105
score *= 2     # score = 210
score //= 3    # score = 70
print(score)    # 70

3.4 Order of Operations (PEMDAS/BODMAS)

Python follows the standard mathematical order of operations. Use parentheses to override when needed.

Python
# Order of operations examples
result = 2 + 3 * 4           # 14, not 20 (multiplication first)
result = (2 + 3) * 4         # 20 (parentheses override)
result = 2 ** 3 ** 2          # 512 (** is right-associative: 2^(3^2) = 2^9)
result = 10 - 3 + 2           # 9 (left to right for same precedence)
result = 20 / 4 * 2           # 10.0 (left to right)
result = 2 + 3 * 4 ** 2      # 50 (4**2=16, 3*16=48, 2+48=50)

print(2 + 3 * 4)       # 14
print((2 + 3) * 4)     # 20

3.5 String Concatenation & Repetition

The + and * operators have special meaning when used with strings.

Python
# String concatenation with +
first = "Hello"
second = "World"
greeting = first + " " + second
print(greeting)    # Hello World

# String repetition with *
line = "=" * 30
print(line)        # ==============================

banner = "Ha" * 5
print(banner)      # HaHaHaHaHa

# Cannot concatenate string + number directly
# print("Age: " + 25)  ❌ TypeError
print("Age: " + str(25))   # ✅ Age: 25

3.6 String Indexing & Slicing

Strings are sequences of characters. Each character has an index (position), starting from 0. Negative indices count from the end.

Python
text = "PYTHON"
#        P  Y  T  H  O  N
#        0  1  2  3  4  5     ← positive index
#       -6 -5 -4 -3 -2 -1    ← negative index

print(text[0])      # P (first character)
print(text[5])      # N (last character)
print(text[-1])     # N (last character)
print(text[-2])     # O (second from end)

# Slicing: string[start:stop:step]
print(text[0:3])    # PYT (index 0, 1, 2 — stop is excluded)
print(text[2:5])    # THO
print(text[:3])     # PYT (start defaults to 0)
print(text[3:])     # HON (stop defaults to end)
print(text[:])      # PYTHON (full copy)
print(text[::-1])   # NOHTYP (reversed!)
print(text[0:6:2]) # PTO (every 2nd character)

3.7 Essential String Methods

Strings have many built-in methods. Since strings are immutable, these methods return new strings.

Case Methods

Python
text = "Hello, World!"

print(text.upper())        # HELLO, WORLD!
print(text.lower())        # hello, world!
print(text.title())        # Hello, World!
print(text.capitalize())    # Hello, world!
print(text.swapcase())      # hELLO, wORLD!

Search & Replace Methods

Python
text = "Python is awesome and Python is fun"

print(text.find("Python"))        # 0 (first occurrence index)
print(text.find("Python", 5))     # 22 (search from index 5)
print(text.find("Java"))          # -1 (not found)
print(text.count("Python"))       # 2
print(text.replace("Python", "Java"))
# Java is awesome and Java is fun
print(text.startswith("Python"))  # True
print(text.endswith("fun"))       # True

Strip, Split & Join

Python
# strip() — remove whitespace from both ends
messy = "   Hello World   "
print(messy.strip())       # "Hello World"
print(messy.lstrip())      # "Hello World   "
print(messy.rstrip())      # "   Hello World"

# split() — break string into a list
sentence = "Python is great"
words = sentence.split()
print(words)               # ['Python', 'is', 'great']

csv_data = "apple,banana,cherry"
fruits = csv_data.split(",")
print(fruits)              # ['apple', 'banana', 'cherry']

# join() — combine a list into a string
words = ["Python", "is", "fun"]
result = " ".join(words)
print(result)              # Python is fun

path = "/".join(["home", "user", "docs"])
print(path)                # home/user/docs

3.8 Composition of Expressions

Composition means combining simple expressions to build complex ones. You can use expressions anywhere a value is expected.

Python
# Composing expressions
x = 10
y = 3

# Nesting function calls
result = str(round(abs(x / y), 2))
print(result)    # "3.33"

# Combining string methods
name = "  john DOE  "
clean_name = name.strip().title()
print(clean_name)  # John Doe

# Using expressions in f-strings
radius = 5
print(f"Area = {3.14159 * radius ** 2:.2f}")   # Area = 78.54

# Expression as argument
print("Average:", (85 + 92 + 78) / 3)   # Average: 85.0

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

print(f"{a} + {b} = {a + b}")
print(f"{a} - {b} = {a - b}")
print(f"{a} * {b} = {a * b}")
print(f"{a} / {b} = {a / b}")
print(f"{a} // {b} = {a // b}")
print(f"{a} % {b} = {a % b}")
print(f"{a} ** {b} = {a ** b}")

Python
text = input("Enter a string: ").lower().strip()
reversed_text = text[::-1]

print(f"Original: {text}")
print(f"Reversed: {reversed_text}")

if text == reversed_text:
    print("It's a palindrome! ✅")
else:
    print("Not a palindrome ❌")

Python
# Given messy input, clean and format it
raw = "   jOhN   dOe   "

# Step 1: Strip whitespace
cleaned = raw.strip()

# Step 2: Normalize spaces (split and rejoin)
words = cleaned.split()
cleaned = " ".join(words)

# Step 3: Title case
formatted = cleaned.title()

print(f"Raw:       '{raw}'")
print(f"Formatted: '{formatted}'")
print(f"Length:     {len(formatted)}")
print(f"Initials:  {formatted.split()[0][0]}.{formatted.split()[1][0]}.")

Python
# Part 1: EMI Calculator (used in banking systems)
principal = 500000       # Loan amount ₹5,00,000
annual_rate = 8.5        # 8.5% annual interest
tenure_years = 5         # 5 years

# EMI Formula: P × r × (1+r)^n / ((1+r)^n - 1)
r = annual_rate / (12 * 100)    # Monthly interest rate
n = tenure_years * 12           # Total months
emi = principal * r * (1 + r) ** n / ((1 + r) ** n - 1)

print("═══ LOAN EMI CALCULATOR ═══")
print(f"Loan Amount  : ₹{principal:,}")
print(f"Interest Rate: {annual_rate}% per annum")
print(f"Tenure       : {tenure_years} years ({n} months)")
print(f"Monthly EMI  : ₹{emi:,.2f}")
print(f"Total Payment: ₹{emi * n:,.2f}")
print(f"Total Interest: ₹{(emi * n) - principal:,.2f}")

# Part 2: Customer Name Normalization (CRM System)
print("\n═══ CUSTOMER NAME NORMALIZATION ═══")
raw_names = ["  john DOE  ", "JANE   smith", "  bob WILSON  "]
for name in raw_names:
    clean = name.strip().title()
    parts = clean.split()
    normalized = " ".join(parts)
    print(f"'{name}' → '{normalized}'")

Conditional Statements

4.1 The Modulus Operator (%)

The modulus operator returns the remainder of division. It's incredibly useful for divisibility checks, cycling through values, and extracting digits.

Python
# Basic modulus usage
print(17 % 5)    # 2 (17 = 5*3 + 2)
print(20 % 4)    # 0 (perfectly divisible)
print(7 % 2)     # 1 (odd number)
print(8 % 2)     # 0 (even number)

# Practical uses
num = 42
if num % 2 == 0:
    print(f"{num} is even")
else:
    print(f"{num} is odd")

# Extract last digit
number = 12345
last_digit = number % 10
print(f"Last digit of {number}: {last_digit}")  # 5

# Check divisibility
print(15 % 3 == 0)   # True — 15 is divisible by 3
print(15 % 4 == 0)   # False — 15 is NOT divisible by 4

4.2 Random Numbers

The random module provides functions for generating random numbers — essential for games, simulations, and testing.

Python
import random

# randint(a, b) — random integer from a to b (inclusive)
dice = random.randint(1, 6)
print(f"Dice roll: {dice}")         # e.g., 4

# random() — random float between 0.0 and 1.0
prob = random.random()
print(f"Probability: {prob:.4f}")    # e.g., 0.7341

# choice() — pick a random element from a sequence
colors = ["red", "blue", "green", "yellow"]
pick = random.choice(colors)
print(f"Random color: {pick}")      # e.g., blue

# randrange(start, stop, step) — like range() but random
even = random.randrange(0, 100, 2)
print(f"Random even: {even}")       # e.g., 46

4.3 Boolean Expressions & Truthiness

A Boolean expression evaluates to either True or False. Python has a concept of truthiness — some values are considered "truthy" and others "falsy".

Python
# Truthiness examples
print(bool(0))        # False
print(bool(42))       # True
print(bool(""))       # False
print(bool("hello"))  # True
print(bool([]))       # False
print(bool([1,2]))   # True

# Practical use of truthiness
name = input("Enter your name: ")
if name:   # truthy if not empty
    print(f"Hello, {name}!")
else:
    print("You didn't enter a name!")

4.4 Logical Operators: and, or, not

Logical operators combine Boolean expressions.

Python
age = 25
has_license = True

# and — both must be True
can_drive = age >= 18 and has_license
print(f"Can drive: {can_drive}")    # True

# or — at least one must be True
is_weekend = False
is_holiday = True
day_off = is_weekend or is_holiday
print(f"Day off: {day_off}")        # True

# not — reverses the boolean
is_raining = False
go_outside = not is_raining
print(f"Go outside: {go_outside}")  # True

# Combined example
score = 85
attendance = 90
passed = score >= 50 and attendance >= 75
print(f"Passed: {passed}")          # True

4.5 if Statement

Python
# Simple if
temperature = 35
if temperature > 30:
    print("It's hot outside! 🔥")
    print("Stay hydrated!")

# if-else
age = int(input("Enter your age: "))
if age >= 18:
    print("You are an adult ✅")
else:
    print("You are a minor ❌")

4.6 if-elif-else Chains

Python
# Grade calculator
marks = int(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 >= 50:
    grade = "D"
else:
    grade = "F (Fail)"

print(f"Marks: {marks} → Grade: {grade}")

4.7 Nested Conditionals

Python
# Nested if — Ticket pricing system
age = int(input("Enter age: "))
is_student = input("Are you a student? (yes/no): ").lower()

if age < 12:
    price = 0
    category = "Child (Free)"
elif age < 18:
    price = 50
    category = "Teen"
elif age < 60:
    if is_student == "yes":
        price = 75
        category = "Student (discounted)"
    else:
        price = 100
        category = "Adult"
else:
    price = 60
    category = "Senior Citizen"

print(f"Category: {category}")
print(f"Ticket Price: ₹{price}")

4.8 Ternary Operator (Conditional Expression)

Python's ternary operator provides a one-line if-else:

Python
age = 20
status = "Adult" if age >= 18 else "Minor"
print(status)    # Adult

# Finding the maximum of two numbers
a, b = 15, 22
maximum = a if a > b else b
print(f"Max: {maximum}")    # Max: 22

# Even/Odd check
num = 7
result = "Even" if num % 2 == 0 else "Odd"
print(f"{num} is {result}")  # 7 is Odd

# Absolute value (manual)
x = -10
abs_val = x if x >= 0 else -x
print(f"Absolute: {abs_val}")  # Absolute: 10

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

if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
    print(f"{year} is a leap year ✅")
else:
    print(f"{year} is not a leap year ❌")

Python
a = float(input("Enter first number: "))
op = input("Enter operator (+, -, *, /): ")
b = float(input("Enter second number: "))

if op == "+":
    result = a + b
elif op == "-":
    result = a - b
elif op == "*":
    result = a * b
elif op == "/":
    if b != 0:
        result = a / b
    else:
        result = "Error: Division by zero!"
else:
    result = "Invalid operator!"

print(f"Result: {a} {op} {b} = {result}")

Python
import random

secret = random.randint(1, 10)
guess = int(input("Guess a number (1-10): "))

if guess == secret:
    print("🎉 Correct! You win!")
elif abs(guess - secret) <= 2:
    print(f"Close! The number was {secret}")
else:
    print(f"Wrong! The number was {secret}")

Python
# Credit Score-Based Loan Eligibility Checker
# Used by banks and fintech companies for instant decisions

applicant = "Priya Sharma"
cibil_score = 745
annual_income = 850000     # ₹8.5 Lakhs
existing_loans = 1
loan_amount = 500000       # Requested: ₹5 Lakhs

print("═══ LOAN ELIGIBILITY REPORT ═══")
print(f"Applicant    : {applicant}")
print(f"CIBIL Score  : {cibil_score}")
print(f"Annual Income: ₹{annual_income:,}")

if cibil_score >= 750 and annual_income >= 500000:
    interest_rate = 8.5
    status = "✅ APPROVED — Excellent Score"
    max_loan = annual_income * 5
elif cibil_score >= 650 and annual_income >= 400000:
    interest_rate = 11.5
    status = "✅ APPROVED — Good Score"
    max_loan = annual_income * 3
elif cibil_score >= 550:
    interest_rate = 16.0
    status = "⚠️ CONDITIONAL — Average Score"
    max_loan = annual_income * 1.5
else:
    interest_rate = 0
    status = "❌ REJECTED — Poor Score (below 550)"
    max_loan = 0

print(f"Status       : {status}")
if max_loan > 0:
    print(f"Max Eligible : ₹{max_loan:,.0f}")
    print(f"Interest Rate: {interest_rate}%")
    if loan_amount <= max_loan:
        print(f"Requested ₹{loan_amount:,} — ✅ Within limit")
    else:
        print(f"Requested ₹{loan_amount:,} — ❌ Exceeds limit")

Iterative Statements (Loops)

5.1 The while Loop

A while loop repeats a block of code as long as a condition is True. Be careful — if the condition never becomes False, you get an infinite loop!

Python
# Counter pattern — most common while loop
count = 1
while count <= 5:
    print(f"Count: {count}")
    count += 1    # Don't forget to update!

Python
# Sentinel loop — stops on a special value
total = 0
print("Enter numbers to add (type 0 to stop):")
while True:
    num = int(input("Number: "))
    if num == 0:
        break
    total += num
print(f"Total: {total}")

# Countdown
n = 5
while n > 0:
    print(n, end=" ")
    n -= 1
print("Blast off! 🚀")
# Output: 5 4 3 2 1 Blast off! 🚀

5.2 The for Loop & range()

The for loop iterates over a sequence. range() generates number sequences.

Python
# range(stop) — 0 to stop-1
for i in range(5):
    print(i, end=" ")    # 0 1 2 3 4
print()

# range(start, stop) — start to stop-1
for i in range(1, 6):
    print(i, end=" ")    # 1 2 3 4 5
print()

# range(start, stop, step)
for i in range(0, 20, 3):
    print(i, end=" ")    # 0 3 6 9 12 15 18
print()

# Counting backwards
for i in range(10, 0, -1):
    print(i, end=" ")    # 10 9 8 7 6 5 4 3 2 1
print()

5.3 Iterating Over Strings & Lists

Python
# Iterate over a string
for char in "PYTHON":
    print(char, end="-")   # P-Y-T-H-O-N-
print()

# Iterate over a list
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(f"I like {fruit}")

# Using enumerate() for index + value
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")
# 0: apple
# 1: banana
# 2: cherry

5.4 Nested Loops

A loop inside another loop. The inner loop completes all its iterations for each iteration of the outer loop.

Python
# Multiplication table (1 to 5)
for i in range(1, 6):
    for j in range(1, 6):
        print(f"{i*j:4}", end="")
    print()   # new line after each row

Python
# Right triangle star pattern
n = 5
for i in range(1, n + 1):
    print("* " * i)

Python
# Pyramid pattern
n = 5
for i in range(1, n + 1):
    spaces = " " * (n - i)
    stars = "* " * i
    print(spaces + stars)

5.5 break, continue, pass

Python
# break — exit when found
for num in range(1, 100):
    if num % 7 == 0 and num % 5 == 0:
        print(f"First number divisible by 7 and 5: {num}")
        break
# Output: First number divisible by 7 and 5: 35

# continue — skip odd numbers
print("Even numbers:", end=" ")
for i in range(1, 11):
    if i % 2 != 0:
        continue
    print(i, end=" ")
# Output: Even numbers: 2 4 6 8 10

# pass — placeholder for future code
for i in range(5):
    if i == 3:
        pass   # TODO: handle this case later
    print(i, end=" ")
# Output: 0 1 2 3 4 (pass does nothing)

5.6 for-else and while-else

Python's unique else clause on loops runs only if the loop completed without hitting a break.

Python
# Check if a number is prime
num = 17
for i in range(2, num):
    if num % i == 0:
        print(f"{num} is NOT prime (divisible by {i})")
        break
else:
    print(f"{num} IS prime ✅")
# Output: 17 IS prime ✅

5.7 Random Numbers in Loops

Python
import random

# Dice rolling simulation
rolls = 0
while True:
    dice = random.randint(1, 6)
    rolls += 1
    print(f"Roll {rolls}: {dice}")
    if dice == 6:
        print(f"Got a 6 after {rolls} rolls! 🎲")
        break

5.8 Encapsulation & Generalization

Encapsulation means wrapping a piece of code in a function. Generalization means replacing specific values with parameters to make the function more flexible.

Python
# Before: specific code
for i in range(1, 6):
    print("* " * i)

# After encapsulation: wrap in a function
def print_triangle():
    for i in range(1, 6):
        print("* " * i)

# After generalization: make size a parameter
def print_triangle(n, char="*"):
    """Print a right triangle of height n using char."""
    for i in range(1, n + 1):
        print((char + " ") * i)

print_triangle(4)           # default * character
print_triangle(3, "#")     # custom # character

Python
# Method 1: for loop
total = 0
for i in range(2, 101, 2):
    total += i
print(f"Sum of even numbers (1-100): {total}")

# Method 2: formula
print(f"Using formula: {sum(range(2, 101, 2))}")

Python
n = 5
for i in range(1, n + 1):
    # Print leading spaces
    print(" " * (n - i), end="")
    # Print numbers
    for j in range(1, i + 1):
        print(j, end=" ")
    print()

Python
import random

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

print("🎯 Guess the number (1-50)!")
print(f"You have {max_attempts} attempts.")

while attempts < max_attempts:
    guess = int(input("Your guess: "))
    attempts += 1

    if guess == secret:
        print(f"🎉 Correct in {attempts} attempts!")
        break
    elif guess < secret:
        print("Too low! ⬆️")
    else:
        print("Too high! ⬇️")

    remaining = max_attempts - attempts
    print(f"Attempts remaining: {remaining}")
else:
    print(f"💀 Game Over! The number was {secret}")

Python
# Server Log Analyzer — Count HTTP Status Codes
# Simulates real log analysis at tech companies

server_logs = [
    "2025-06-15 10:23:01 GET /home 200",
    "2025-06-15 10:23:05 GET /api/users 200",
    "2025-06-15 10:23:12 POST /login 200",
    "2025-06-15 10:23:18 GET /dashboard 404",
    "2025-06-15 10:23:25 GET /api/data 500",
    "2025-06-15 10:23:30 GET /home 200",
    "2025-06-15 10:23:35 DELETE /api/old 404",
    "2025-06-15 10:23:42 POST /api/save 500",
    "2025-06-15 10:23:50 GET /about 200",
    "2025-06-15 10:23:55 GET /contact 200",
]

# Count status codes using a loop
status_counts = {"200": 0, "404": 0, "500": 0, "other": 0}

for i, log in enumerate(server_logs, 1):
    status_code = log.split()[-1]   # Last word is the status
    if status_code in status_counts:
        status_counts[status_code] += 1
    else:
        status_counts["other"] += 1

# Generate report
total = len(server_logs)
print("═══ SERVER LOG ANALYSIS REPORT ═══")
print(f"Total Requests: {total}")
print(f"━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
for code, count in status_counts.items():
    pct = (count / total) * 100
    bar = "█" * int(pct / 5)
    if count > 0:
        print(f"  {code}: {count:3d} ({pct:5.1f}%) {bar}")

# Alert check
error_rate = (status_counts["500"] / total) * 100
if error_rate > 10:
    print("🚨 ALERT: Error rate exceeds 10%!")
else:
    print("✅ Server health: Normal")

Functions & Recursion

6.1 Built-in Functions

Python comes with many built-in functions that you can use without importing anything.

Python
# Common built-in functions
numbers = [4, 2, 9, 1, 7, 5]

print(len(numbers))       # 6 (length)
print(max(numbers))       # 9 (maximum)
print(min(numbers))       # 1 (minimum)
print(sum(numbers))       # 28 (total)
print(sorted(numbers))    # [1, 2, 4, 5, 7, 9]
print(abs(-42))           # 42 (absolute value)
print(round(3.14159, 2))  # 3.14 (round to 2 decimals)
print(pow(2, 10))         # 1024 (2^10)

6.2 Type Conversion Functions

Python
# Type conversion (casting)
print(int("42"))         # 42 (string → int)
print(int(3.99))         # 3 (truncates, not rounds!)
print(float("3.14"))     # 3.14 (string → float)
print(float(42))          # 42.0 (int → float)
print(str(42))            # "42" (int → string)
print(str(3.14))          # "3.14" (float → string)
print(bool(0))            # False
print(bool(1))            # True
print(list("hello"))      # ['h', 'e', 'l', 'l', 'o']
print(tuple([1,2,3]))    # (1, 2, 3)

6.3 The math Module

Python
import math

print(math.pi)               # 3.141592653589793
print(math.e)                # 2.718281828459045
print(math.sqrt(16))         # 4.0
print(math.ceil(3.2))        # 4 (round up)
print(math.floor(3.8))       # 3 (round down)
print(math.pow(2, 10))       # 1024.0
print(math.factorial(5))     # 120 (5! = 5×4×3×2×1)
print(math.log(100, 10))     # 2.0 (log base 10)
print(math.log2(8))          # 3.0 (log base 2)
print(math.gcd(12, 8))       # 4 (greatest common divisor)

# Practical example
radius = 7
area = math.pi * radius ** 2
print(f"Circle area: {area:.2f}")  # 153.94

6.4 Defining Functions

Python
# Basic function definition
def greet(name):
    """Return a greeting message."""
    return f"Hello, {name}! Welcome!"

# Call the function
message = greet("Alice")
print(message)    # Hello, Alice! Welcome!

# Function with no return (returns None)
def print_separator(char="-", width=40):
    """Print a separator line."""
    print(char * width)

print_separator()          # ----------------------------------------
print_separator("=", 30)  # ==============================

# Function with multiple return values
def min_max(numbers):
    """Return both minimum and maximum."""
    return min(numbers), max(numbers)

lo, hi = min_max([3, 7, 1, 9, 2])
print(f"Min: {lo}, Max: {hi}")  # Min: 1, Max: 9

6.5 Parameters & Arguments

Python
# Positional arguments — order matters
def power(base, exponent):
    return base ** exponent

print(power(2, 3))     # 8 (2^3)
print(power(3, 2))     # 9 (3^2) — order matters!

# Keyword arguments — order doesn't matter
print(power(exponent=3, base=2))  # 8

# Default arguments
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

print(greet("Bob"))                  # Hello, Bob!
print(greet("Bob", "Good morning"))  # Good morning, Bob!

# *args — variable number of positional arguments
def average(*args):
    """Calculate average of any number of values."""
    return sum(args) / len(args)

print(average(10, 20, 30))        # 20.0
print(average(5, 10, 15, 20))    # 12.5

# **kwargs — variable number of keyword arguments
def build_profile(**kwargs):
    for key, value in kwargs.items():
        print(f"  {key}: {value}")

build_profile(name="Alice", age=25, city="Delhi")

6.6 Variable Scope (LEGB Rule)

Python looks up variables in this order: Local → Enclosing → Global → Built-in.

Python
x = "global"     # Global scope

def outer():
    x = "enclosing"  # Enclosing scope

    def inner():
        x = "local"    # Local scope
        print("Inner:", x)    # local

    inner()
    print("Outer:", x)    # enclosing

outer()
print("Global:", x)   # global

# Using 'global' keyword to modify global variable
counter = 0
def increment():
    global counter
    counter += 1

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

6.7 Recursion

A recursive function calls itself. Every recursive function needs a base case (stopping condition) and a recursive case.

Python
# Factorial: n! = n × (n-1) × ... × 1
def factorial(n):
    """Calculate n! recursively."""
    if n <= 1:         # Base case
        return 1
    return n * factorial(n - 1)   # Recursive case

print(factorial(5))    # 120 (5 × 4 × 3 × 2 × 1)

# Fibonacci: F(n) = F(n-1) + F(n-2)
def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

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

# Sum of digits
def sum_digits(n):
    if n < 10:
        return n
    return n % 10 + sum_digits(n // 10)

print(sum_digits(12345))   # 15 (1+2+3+4+5)

# Power function
def power(base, exp):
    if exp == 0:
        return 1
    return base * power(base, exp - 1)

print(power(2, 10))   # 1024

6.8 Recursion vs Iteration

Python
# Factorial — iterative version for comparison
def factorial_iter(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

print(factorial_iter(5))   # 120 — same result, faster

Python
def is_prime(n):
    """Return True if n is prime, False otherwise."""
    if n < 2:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

# Test
for num in range(2, 20):
    if is_prime(num):
        print(num, end=" ")
# Output: 2 3 5 7 11 13 17 19

Python
def hanoi(n, source="A", target="C", auxiliary="B"):
    """Solve Tower of Hanoi for n disks."""
    if n == 1:
        print(f"Move disk 1 from {source} to {target}")
        return
    hanoi(n - 1, source, auxiliary, target)
    print(f"Move disk {n} from {source} to {target}")
    hanoi(n - 1, auxiliary, target, source)

hanoi(3)

Python
def statistics(*args):
    """Return count, sum, average, min, max."""
    n = len(args)
    total = sum(args)
    avg = total / n
    return {
        "count": n,
        "sum": total,
        "average": round(avg, 2),
        "min": min(args),
        "max": max(args)
    }

result = statistics(85, 92, 78, 96, 88)
for key, value in result.items():
    print(f"  {key}: {value}")

Python
import time
from functools import wraps

def rate_limiter(max_calls, period=60):
    """Decorator to limit function calls per time period"""
    calls = []    # Closure variable — tracks timestamps
    
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            now = time.time()
            # Remove calls outside the time window
            while calls and calls[0] < now - period:
                calls.pop(0)
            
            if len(calls) >= max_calls:
                wait = round(period - (now - calls[0]), 1)
                print(f"⛔ Rate limit exceeded! Retry in {wait}s")
                return None
            
            calls.append(now)
            print(f"✅ Call {len(calls)}/{max_calls} — {func.__name__}()")
            return func(*args, **kwargs)
        return wrapper
    return decorator

# Usage: Max 3 calls per 60 seconds
@rate_limiter(max_calls=3, period=60)
def get_user_data(user_id):
    return {"id": user_id, "name": f"User_{user_id}"}

# Simulate API calls
for i in range(1, 6):
    result = get_user_data(i)
    if result:
        print(f"   Data: {result}")

Strings

7.1 Strings as Sequences

A string is an ordered sequence of characters. Each character has an index, and you can access individual characters or subsequences using indexing and slicing.

Python
text = "Hello, Python!"

# Length of a string
print(len(text))     # 14

# Accessing characters
print(text[0])       # H (first character)
print(text[-1])      # ! (last character)
print(text[7])       # P

# Membership testing
print("Python" in text)      # True
print("Java" not in text)    # True

7.2 String Traversal

Python
word = "Python"

# Method 1: for loop (preferred)
for char in word:
    print(char, end=" ")    # P y t h o n
print()

# Method 2: while loop with index
i = 0
while i < len(word):
    print(word[i], end=" ")
    i += 1
print()

# Method 3: for loop with index
for i in range(len(word)):
    print(f"Index {i}: {word[i]}")

7.3 String Slicing (Deep Dive)

Python
s = "ABCDEFGHIJ"
#    0123456789

print(s[2:7])       # CDEFG
print(s[:5])        # ABCDE (first 5 chars)
print(s[5:])        # FGHIJ (from index 5 to end)
print(s[::-1])      # JIHGFEDCBA (reverse)
print(s[0:10:2])   # ACEGI (every 2nd character)
print(s[-3:])       # HIJ (last 3 characters)
print(s[1:-1])      # BCDEFGHI (remove first and last)

# Reversing a string
original = "racecar"
reversed_str = original[::-1]
print(f"'{original}' reversed = '{reversed_str}'")
print(f"Is palindrome: {original == reversed_str}")   # True

7.4 String Comparison

Strings are compared lexicographically (character by character using Unicode values).

Python
print("apple" < "banana")    # True (a < b)
print("abc" < "abd")       # True (c < d at position 2)
print("abc" < "abcd")      # True (shorter string is "less")
print("Zulu" < "alpha")     # True (uppercase < lowercase)

# Get Unicode value
print(ord("A"))     # 65
print(ord("a"))     # 97
print(ord("0"))     # 48
print(chr(65))      # A (number → character)

7.5 find() vs index()

Python
text = "Python programming is fun"

# find() — returns -1 if not found (safe)
print(text.find("gram"))      # 11
print(text.find("Java"))      # -1 (not found)

# index() — raises ValueError if not found (risky)
print(text.index("gram"))     # 11
# text.index("Java")          # ❌ ValueError!

# rfind() — search from the right
text2 = "abcabcabc"
print(text2.find("abc"))      # 0 (first occurrence)
print(text2.rfind("abc"))     # 6 (last occurrence)

7.6 Looping & Counting Characters

Python
# Count vowels in a string
text = "Hello World"
vowels = "aeiouAEIOU"
count = 0

for char in text:
    if char in vowels:
        count += 1

print(f"Vowels in '{text}': {count}")   # 3

# Using built-in count()
print(text.count("l"))   # 3
print(text.count("o"))   # 2

# Character frequency counter
sentence = "hello world"
freq = {}
for char in sentence:
    if char != " ":
        freq[char] = freq.get(char, 0) + 1
print(freq)   # {'h': 1, 'e': 1, 'l': 3, 'o': 2, 'w': 1, 'r': 1, 'd': 1}

7.7 String Formatting

Python
name = "Alice"
age = 25
gpa = 3.856

# Method 1: f-strings (Python 3.6+, RECOMMENDED)
print(f"Name: {name}, Age: {age}")
print(f"GPA: {gpa:.2f}")                  # GPA: 3.86
print(f"{'Python':>15}")                  # Right-aligned
print(f"{'Python':<15}")                  # Left-aligned
print(f"{'Python':^15}")                  # Center-aligned
print(f"{42:08d}")                         # 00000042 (zero-padded)

# Method 2: .format()
print("Name: {}, Age: {}".format(name, age))
print("Name: {n}, Age: {a}".format(n=name, a=age))

# Method 3: %-formatting (old style)
print("Name: %s, Age: %d, GPA: %.2f" % (name, age, gpa))

7.8 String Immutability

Strings in Python are immutable — you cannot change individual characters. To "modify" a string, you create a new one.

Python
text = "Hello"
# text[0] = "h"   ❌ TypeError: 'str' object does not support item assignment

# Create a new string instead
new_text = "h" + text[1:]
print(new_text)   # hello

# Or use replace()
new_text = text.replace("H", "h")
print(new_text)   # hello

7.9 String Testing Methods

Python
print("12345".isdigit())     # True
print("hello".isalpha())     # True
print("abc123".isalnum())    # True
print("HELLO".isupper())     # True
print("hello".islower())     # True
print("   ".isspace())        # True
print("Hello World".istitle()) # True

# Practical: validate input
pin = input("Enter 4-digit PIN: ")
if pin.isdigit() and len(pin) == 4:
    print("Valid PIN ✅")
else:
    print("Invalid PIN ❌")

Python
text = input("Enter a sentence: ")
words = len(text.split())
vowels = sum(1 for c in text.lower() if c in "aeiou")
consonants = sum(1 for c in text.lower() if c.isalpha() and c not in "aeiou")

print(f"Words: {words}")
print(f"Vowels: {vowels}")
print(f"Consonants: {consonants}")

Python
def caesar_encrypt(text, shift):
    """Encrypt text using Caesar cipher with given shift."""
    result = ""
    for char in text:
        if char.isalpha():
            base = ord("A") if char.isupper() else ord("a")
            result += chr(((ord(char) - base + shift) % 26) + base)
        else:
            result += char
    return result

message = "Hello World"
encrypted = caesar_encrypt(message, 3)
decrypted = caesar_encrypt(encrypted, -3)

print(f"Original:  {message}")
print(f"Encrypted: {encrypted}")
print(f"Decrypted: {decrypted}")

Python
students = [
    ("Alice", [85, 92, 78]),
    ("Bob", [90, 88, 95]),
    ("Charlie", [72, 68, 75]),
]

print(f"{' Student Report Card ':=^50}")
print(f"{'Name':<12} {'Math':>6} {'Sci':>6} {'Eng':>6} {'Avg':>8}")
print("-" * 50)

for name, marks in students:
    avg = sum(marks) / len(marks)
    print(f"{name:<12} {marks[0]:>6} {marks[1]:>6} {marks[2]:>6} {avg:>8.1f}")

Python
# Apache Log File Parser
# Extracts structured data from raw log lines

log_lines = [
    '192.168.1.105 - - [15/Jun/2025:10:23:01 +0530] "GET /api/users HTTP/1.1" 200 1234',
    '10.0.0.42 - admin [15/Jun/2025:10:23:05 +0530] "POST /login HTTP/1.1" 401 89',
    '172.16.0.8 - - [15/Jun/2025:10:23:12 +0530] "GET /static/logo.png HTTP/1.1" 404 0',
    '192.168.1.200 - - [15/Jun/2025:10:23:18 +0530] "DELETE /api/session HTTP/1.1" 500 56',
]

print("═══ APACHE LOG PARSER ═══")
print(f"{'IP':<18} {'Timestamp':<22} {'Method':<8} {'Path':<20} {'Status'}")
print("─" * 85)

for line in log_lines:
    # Extract IP address (first field)
    ip = line.split()[0]
    
    # Extract timestamp (between [ and ])
    ts_start = line.find("[") + 1
    ts_end = line.find("]")
    timestamp = line[ts_start:ts_end].split()[0]
    
    # Extract HTTP method and path (between quotes)
    q_start = line.find('"') + 1
    q_end = line.find('"', q_start)
    request = line[q_start:q_end]
    method, path, _ = request.split()
    
    # Extract status code (after closing quote)
    after_quote = line[q_end + 2:].strip()
    status = after_quote.split()[0]
    
    # Color-code status
    icon = "✅" if status.startswith("2") else "⚠️" if status.startswith("4") else "❌"
    print(f"{ip:<18} {timestamp:<22} {method:<8} {path:<20} {icon} {status}")

Lists

8.1 Creating Lists

A list is an ordered, mutable collection that can hold items of any type. Lists are one of Python's most versatile data structures.

Python
# Different ways to create lists
empty = []                                   # empty list
numbers = [1, 2, 3, 4, 5]                   # integers
fruits = ["apple", "banana", "cherry"]       # strings
mixed = [1, "hello", 3.14, True, None]     # mixed types

# Using list() constructor
chars = list("Python")
print(chars)    # ['P', 'y', 't', 'h', 'o', 'n']

# Using range()
nums = list(range(1, 6))
print(nums)     # [1, 2, 3, 4, 5]

evens = list(range(0, 20, 2))
print(evens)    # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

# Length
print(len(fruits))   # 3

8.2 Membership & Accessing Elements

Python
colors = ["red", "green", "blue", "yellow", "purple"]

# Membership testing
print("red" in colors)       # True
print("orange" not in colors) # True

# Accessing by index (positive and negative)
print(colors[0])       # red (first)
print(colors[2])       # blue (third)
print(colors[-1])      # purple (last)
print(colors[-2])      # yellow (second from end)

# Lists are MUTABLE — you can change elements
colors[1] = "lime"
print(colors)   # ['red', 'lime', 'blue', 'yellow', 'purple']

8.3 List Operations

Python
# Concatenation (+)
a = [1, 2, 3]
b = [4, 5, 6]
c = a + b
print(c)    # [1, 2, 3, 4, 5, 6]

# Repetition (*)
zeros = [0] * 5
print(zeros)   # [0, 0, 0, 0, 0]

# append() — add ONE item to the end
fruits = ["apple", "banana"]
fruits.append("cherry")
print(fruits)   # ['apple', 'banana', 'cherry']

# extend() — add ALL items from another list
fruits.extend(["date", "elderberry"])
print(fruits)   # ['apple', 'banana', 'cherry', 'date', 'elderberry']

# insert(index, item) — add at specific position
fruits.insert(1, "blueberry")
print(fruits)   # ['apple', 'blueberry', 'banana', 'cherry', ...]

8.4 List Slicing

Python
nums = [10, 20, 30, 40, 50, 60, 70, 80]

print(nums[2:5])      # [30, 40, 50]
print(nums[:3])       # [10, 20, 30] (first 3)
print(nums[5:])       # [60, 70, 80] (from index 5)
print(nums[::-1])     # [80, 70, 60, 50, 40, 30, 20, 10] (reversed)
print(nums[0:8:2])   # [10, 30, 50, 70] (every 2nd)

# Slice assignment (mutate in-place)
nums[1:3] = [200, 300]
print(nums)   # [10, 200, 300, 40, 50, 60, 70, 80]

8.5 Deleting Elements

Python
items = ["a", "b", "c", "d", "e"]

# del — delete by index
del items[0]
print(items)   # ['b', 'c', 'd', 'e']

# remove() — delete by value (first occurrence)
items.remove("c")
print(items)   # ['b', 'd', 'e']

# pop() — remove and return (by index, default last)
last = items.pop()
print(last, items)   # e ['b', 'd']

first = items.pop(0)
print(first, items)  # b ['d']

# clear() — remove ALL elements
items.clear()
print(items)   # []

8.6 List Comprehensions

List comprehensions provide a concise, Pythonic way to create lists.

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

# With condition (filter)
evens = [x for x in range(1, 21) if x % 2 == 0]
print(evens)     # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

# Transform strings
words = ["hello", "world", "python"]
upper = [w.upper() for w in words]
print(upper)     # ['HELLO', 'WORLD', 'PYTHON']

# Conditional expression in comprehension
labels = ["even" if x % 2 == 0 else "odd" for x in range(1, 6)]
print(labels)    # ['odd', 'even', 'odd', 'even', 'odd']

# Flatten a 2D list
matrix = [[1, 2], [3, 4], [5, 6]]
flat = [num for row in matrix for num in row]
print(flat)      # [1, 2, 3, 4, 5, 6]

8.7 Lists and For Loops

Python
scores = [85, 92, 78, 96, 88]

# Iterate directly
for score in scores:
    print(f"Score: {score}")

# With enumerate (index + value)
for i, score in enumerate(scores, 1):
    print(f"Student {i}: {score}")

# Calculate statistics
total = sum(scores)
avg = total / len(scores)
highest = max(scores)
lowest = min(scores)

print(f"Total: {total}, Avg: {avg:.1f}")
print(f"Highest: {highest}, Lowest: {lowest}")

8.8 Lists as Function Parameters

Lists are passed to functions by reference — changes inside the function affect the original list.

Python
def double_values(lst):
    """Double each value in the list IN PLACE."""
    for i in range(len(lst)):
        lst[i] *= 2

numbers = [1, 2, 3, 4, 5]
double_values(numbers)
print(numbers)    # [2, 4, 6, 8, 10] — original is modified!

# To avoid modifying original, pass a copy
original = [1, 2, 3]
double_values(original[:])    # pass a slice copy
print(original)               # [1, 2, 3] — unchanged!

# Or use .copy()
copy = original.copy()
double_values(copy)
print(original, copy)   # [1, 2, 3] [2, 4, 6]

8.9 Nested Lists (2D Arrays)

Python
# 2D list (matrix)
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Access element: matrix[row][col]
print(matrix[0][0])   # 1 (top-left)
print(matrix[1][2])   # 6 (row 1, col 2)
print(matrix[-1][-1]) # 9 (bottom-right)

# Print matrix nicely
for row in matrix:
    for val in row:
        print(f"{val:4}", end="")
    print()

# Create 3x3 matrix with comprehension
grid = [[0] * 3 for _ in range(3)]
print(grid)   # [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

# Transpose a matrix
transposed = [[matrix[j][i] for j in range(len(matrix))] for i in range(len(matrix[0]))]
print(transposed)  # [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

8.10 Common List Methods

Python
nums = [3, 1, 4, 1, 5, 9, 2, 6]

# sort() modifies in place
nums.sort()
print(nums)             # [1, 1, 2, 3, 4, 5, 6, 9]

# sort(reverse=True) for descending
nums.sort(reverse=True)
print(nums)             # [9, 6, 5, 4, 3, 2, 1, 1]

# sorted() returns NEW list
original = [5, 3, 8, 1]
sorted_list = sorted(original)
print(original)       # [5, 3, 8, 1] (unchanged)
print(sorted_list)    # [1, 3, 5, 8]

# Sort strings by length
words = ["banana", "pie", "apple", "kiwi"]
words.sort(key=len)
print(words)    # ['pie', 'kiwi', 'apple', 'banana']

Python
# Method 1: Using a loop
original = [1, 2, 3, 2, 4, 1, 5, 3]
unique = []
for item in original:
    if item not in unique:
        unique.append(item)
print(f"Original: {original}")
print(f"Unique:   {unique}")

# Method 2: Using set (doesn't preserve order in older Python)
unique2 = list(dict.fromkeys(original))
print(f"Unique2:  {unique2}")

Python
def rotate_list(lst, n):
    """Rotate list left by n positions."""
    n = n % len(lst)   # handle n > length
    return lst[n:] + lst[:n]

data = [1, 2, 3, 4, 5]
print(f"Original:   {data}")
print(f"Rotate by 2: {rotate_list(data, 2)}")
print(f"Rotate by 4: {rotate_list(data, 4)}")

Python
def matrix_add(A, B):
    """Add two matrices and return the result."""
    rows = len(A)
    cols = len(A[0])
    result = [[A[i][j] + B[i][j] for j in range(cols)] for i in range(rows)]
    return result

A = [[1, 2, 3], [4, 5, 6]]
B = [[7, 8, 9], [10, 11, 12]]

C = matrix_add(A, B)

print("Matrix A + B =")
for row in C:
    print([f"{v:3}" for v in row])

Python
from collections import Counter

# Purchase history (list of lists)
purchase_history = {
    "Alice":   ["Laptop", "Mouse", "Keyboard", "USB Hub", "Webcam"],
    "Bob":     ["Laptop", "Mouse", "Monitor", "Headphones"],
    "Charlie": ["Keyboard", "Mouse", "USB Hub", "Monitor"],
    "Diana":   ["Laptop", "Webcam", "Headphones", "Monitor"],
}

def find_common_items(user1, user2):
    """Find items purchased by both users."""
    return [item for item in user1 if item in user2]

def recommend_products(target_user, all_history):
    """Recommend products based on co-purchase patterns."""
    target_items = all_history[target_user]
    recommendations = []

    for user, items in all_history.items():
        if user == target_user:
            continue
        common = find_common_items(target_items, items)
        if len(common) >= 2:  # Similar user threshold
            new_items = [i for i in items if i not in target_items]
            recommendations.extend(new_items)

    # Rank by frequency
    freq = Counter(recommendations)
    return freq.most_common(3)

# Generate recommendations for Alice
target = "Alice"
recs = recommend_products(target, purchase_history)

print("═" * 45)
print(f"🛒 RECOMMENDATIONS FOR {target.upper()}")
print("═" * 45)
print(f"Purchased: {purchase_history[target]}")
print(f"\nTop Recommendations:")
for i, (product, score) in enumerate(recs, 1):
    print(f"  {i}. {product} (matched by {score} similar users)")
print("═" * 45)

Tuples & Dictionaries

9.1 Creating Tuples

A tuple is an ordered, immutable sequence. Once created, you cannot add, remove, or change elements. Tuples use parentheses () instead of square brackets.

Python
# Creating tuples
empty = ()                          # Empty tuple
single = (42,)                     # Single element — trailing comma required!
coords = (3, 4)                    # Two elements
colors = ("red", "green", "blue")  # Three strings
mixed = (1, "hello", 3.14, True)  # Mixed types

# Using tuple() constructor
from_list = tuple([1, 2, 3])      # From a list
from_str = tuple("hello")          # ('h','e','l','l','o')
from_range = tuple(range(5))       # (0,1,2,3,4)

# Without parentheses (tuple packing)
point = 10, 20, 30                # Also a tuple!
print(type(point))                  # <class 'tuple'>

9.2 Tuple Immutability

Unlike lists, tuples cannot be modified after creation. This makes them hashable, so they can be used as dictionary keys and set elements.

Python
t = (1, 2, 3)
# t[0] = 10     # ❌ TypeError: 'tuple' does not support item assignment
# t.append(4)   # ❌ AttributeError: no attribute 'append'

# Read-only access works fine
print(t[0])        # 1
print(t[-1])       # 3
print(t[1:3])      # (2, 3)

9.3 Tuple Packing & Unpacking

Packing assigns multiple values to a single tuple. Unpacking extracts values into individual variables.

Python
# Packing
person = "Alice", 25, "Engineer"

# Unpacking
name, age, job = person
print(name)   # Alice
print(age)    # 25

# Swap variables elegantly
a, b = 10, 20
a, b = b, a
print(a, b)   # 20 10

# Extended unpacking with *
first, *rest = (1, 2, 3, 4, 5)
print(first)  # 1
print(rest)   # [2, 3, 4, 5]

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

9.4 Tuples as Return Values

Python
def min_max(numbers):
    """Return both minimum and maximum."""
    return min(numbers), max(numbers)

lowest, highest = min_max([4, 1, 7, 2, 9])
print(f"Min: {lowest}, Max: {highest}")

def divide(a, b):
    """Return quotient and remainder."""
    return a // b, a % b

q, r = divide(17, 5)
print(f"17 ÷ 5 = {q} remainder {r}")

9.5 Named Tuples

Python
from collections import namedtuple

Student = namedtuple("Student", ["name", "age", "grade"])
s1 = Student("Alice", 20, "A")
print(s1.name)     # Alice
print(s1[1])       # 20
print(s1)          # Student(name='Alice', age=20, grade='A')

Point = namedtuple("Point", "x y")
p = Point(3, 4)
print(f"Distance: {(p.x**2 + p.y**2)**0.5:.2f}")

9.6 Creating Dictionaries

A dictionary maps keys to values. Keys must be immutable (strings, numbers, tuples).

Python
empty = {}
student = {"name": "Alice", "age": 20, "grade": "A"}
scores = dict(math=95, physics=88, chem=92)
from_pairs = dict([("a", 1), ("b", 2)])
from_zip = dict(zip(["x","y"], [10,20]))
print(student)

9.7 Dictionary Operations

Python
d = {"name": "Alice", "age": 20}

print(d["name"])                   # Alice
print(d.get("email", "N/A"))      # N/A (safe access)
d.setdefault("grade", "B")        # Sets "B" since missing
d["email"] = "alice@mail.com"     # Add new key
d["age"] = 21                     # Update existing
print("name" in d)                # True
print(len(d))                     # 4

9.8 Dictionary Methods

Python
d = {"a": 1, "b": 2, "c": 3}

print(d.keys())       # dict_keys(['a', 'b', 'c'])
print(d.values())     # dict_values([1, 2, 3])
print(d.items())      # dict_items([('a',1), ('b',2), ('c',3)])

for key, value in d.items():
    print(f"{key} → {value}")

d.update({"d": 4, "a": 100})  # Adds 'd', updates 'a'
val = d.pop("b")              # Returns 2, removes 'b'
d.clear()                     # Removes all items

9.9 Sparse Matrices with Dictionaries

Python
# Matrix: [[0,0,3], [0,5,0], [7,0,0]]
sparse = {(0,2): 3, (1,1): 5, (2,0): 7}

def get_element(matrix, row, col):
    return matrix.get((row, col), 0)

print(get_element(sparse, 0, 2))  # 3
print(get_element(sparse, 0, 0))  # 0 (not stored)

9.10 Aliasing vs Copying

Python
import copy

# Aliasing — same object
a = {"x": [1, 2], "y": 3}
b = a
b["y"] = 99
print(a["y"])  # 99 — a affected!

# Shallow copy — nested objects shared
a = {"x": [1, 2], "y": 3}
b = a.copy()
b["x"].append(3)
print(a["x"])  # [1, 2, 3] — shared!

# Deep copy — fully independent
a = {"x": [1, 2], "y": 3}
b = copy.deepcopy(a)
b["x"].append(3)
print(a["x"])  # [1, 2] — NOT affected

9.11 Dictionary Comprehensions

Python
squares = {x: x**2 for x in range(1, 6)}
print(squares)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Swap keys and values
original = {"a": 1, "b": 2}
swapped = {v: k for k, v in original.items()}

# Word frequency
text = "apple banana apple cherry banana apple"
words = text.split()
freq = {}
for w in words:
    freq[w] = freq.get(w, 0) + 1
print(freq)  # {'apple': 3, 'banana': 2, 'cherry': 1}

Python
def top_scorer(students):
    best_name, best_score = students[0]
    for name, score in students[1:]:
        if score > best_score:
            best_name, best_score = name, score
    return best_name

data = [("Alice", 85), ("Bob", 92), ("Charlie", 78)]
print(top_scorer(data))  # Bob

Python
def char_frequency(s):
    return {ch: s.count(ch) for ch in set(s)}
print(char_frequency("hello"))
# {'h': 1, 'e': 1, 'l': 2, 'o': 1}

Python
def invert_dict(d):
    inverted = {}
    for key, val in d.items():
        inverted.setdefault(val, []).append(key)
    return inverted

grades = {"Alice": "A", "Bob": "B", "Charlie": "A"}
print(invert_dict(grades))
# {'A': ['Alice', 'Charlie'], 'B': ['Bob']}

Python
import copy

def load_config(defaults, overrides):
    """Merge default config with environment overrides (deep merge)."""
    config = copy.deepcopy(defaults)
    for key, value in overrides.items():
        if isinstance(value, dict) and key in config:
            config[key] = load_config(config[key], value)
        else:
            config[key] = value
    return config

def validate_config(config, required_keys):
    """Validate that all required keys exist in config."""
    missing = [k for k in required_keys if k not in config]
    if missing:
        raise KeyError(f"Missing required keys: {missing}")
    return True

# Default configuration
defaults = {
    "app_name": "MyApp",
    "debug": False,
    "database": {
        "host": "localhost",
        "port": 5432,
        "name": "mydb",
    },
    "cache_ttl": 300,
    "max_connections": 100,
}

# Production overrides
prod_overrides = {
    "debug": False,
    "database": {
        "host": "db.prod.company.com",
        "port": 5432,
    },
    "max_connections": 500,
}

# Merge and validate
config = load_config(defaults, prod_overrides)
required = ("app_name", "database", "max_connections")  # tuple of required keys

print("═" * 45)
print("⚙️  APPLICATION CONFIGURATION")
print("═" * 45)
for key, value in config.items():
    if isinstance(value, dict):
        print(f"  {key}:")
        for k, v in value.items():
            print(f"    {k}: {v}")
    else:
        print(f"  {key}: {value}")
print("═" * 45)
print(f"✅ Config valid: {validate_config(config, required)}")

Classes & Objects

10.1 OOP Concepts

Object-Oriented Programming (OOP) organizes code around objects — data bundled with the functions that operate on it. A class is a blueprint; an object is an instance of that blueprint.

10.2 Creating a Class

Python
class Dog:
    """A simple Dog class."""

    def __init__(self, name, breed, age):
        # Instance attributes — unique to each object
        self.name = name
        self.breed = breed
        self.age = age

    def bark(self):
        return f"{self.name} says: Woof!"

    def info(self):
        return f"{self.name} is a {self.age}-year-old {self.breed}"

# Creating objects (instances)
dog1 = Dog("Buddy", "Golden Retriever", 3)
dog2 = Dog("Max", "German Shepherd", 5)

print(dog1.bark())
print(dog2.info())

10.3 Instance vs Class Attributes

Python
class Student:
    # Class attribute — shared by ALL instances
    school = "EduArtha University"
    count = 0

    def __init__(self, name, roll_no):
        # Instance attributes — unique to each object
        self.name = name
        self.roll_no = roll_no
        Student.count += 1

s1 = Student("Alice", 101)
s2 = Student("Bob", 102)

print(s1.school)       # EduArtha University (class attr)
print(s2.school)       # EduArtha University (same)
print(s1.name)         # Alice (instance attr)
print(Student.count)   # 2 (class attr)

10.4 The __str__ and __repr__ Methods

Python
class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade

    def __str__(self):
        """Human-readable string (for print/str)."""
        return f"{self.name} (Grade: {self.grade})"

    def __repr__(self):
        """Developer-readable string (for debugging)."""
        return f"Student('{self.name}', '{self.grade}')"

s = Student("Alice", "A")
print(s)        # Calls __str__: Alice (Grade: A)
print(repr(s))  # Calls __repr__: Student('Alice', 'A')

10.5 Complete Example: BankAccount Class

Python
class BankAccount:
    """A simple bank account with deposit and withdraw."""

    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance

    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            print(f"Deposited ₹{amount}. Balance: ₹{self.balance}")
        else:
            print("Amount must be positive!")

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

    def __str__(self):
        return f"Account({self.owner}, ₹{self.balance})"

acc = BankAccount("Alice", 1000)
acc.deposit(500)
acc.withdraw(200)
acc.withdraw(2000)
print(acc)

Python
class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

    def perimeter(self):
        return 2 * (self.length + self.width)

    def __str__(self):
        return f"Rectangle({self.length}x{self.width})"

r = Rectangle(5, 3)
print(f"Area: {r.area()}, Perimeter: {r.perimeter()}")
# Area: 15, Perimeter: 16

Python
class Student:
    def __init__(self, name):
        self.name = name
        self.grades = []

    def add_grade(self, grade):
        self.grades.append(grade)

    def gpa(self):
        if not self.grades:
            return 0
        return sum(self.grades) / len(self.grades)

    def __str__(self):
        return f"{self.name}: GPA={self.gpa():.2f}"

s = Student("Alice")
s.add_grade(90)
s.add_grade(85)
s.add_grade(92)
print(s)  # Alice: GPA=89.00

Python
class Counter:
    def __init__(self, start=0):
        self.value = start

    def increment(self):
        self.value += 1

    def decrement(self):
        self.value -= 1

    def reset(self):
        self.value = 0

    def __str__(self):
        return f"Counter({self.value})"

c = Counter()
c.increment()
c.increment()
c.increment()
c.decrement()
print(c)  # Counter(2)

Python
class Product:
    """E-commerce product with inventory tracking."""
    _id_counter = 0

    def __init__(self, name, price, stock, low_threshold=5):
        Product._id_counter += 1
        self.sku = f"SKU-{Product._id_counter:04d}"
        self.name = name
        self.price = price
        self.stock = stock
        self.low_threshold = low_threshold

    def sell(self, qty):
        if qty > self.stock:
            print(f"  ❌ Only {self.stock} units available!")
            return False
        self.stock -= qty
        print(f"  ✅ Sold {qty}x {self.name} (₹{qty * self.price:,.2f})")
        self._check_alert()
        return True

    def restock(self, qty):
        self.stock += qty
        print(f"  📦 Restocked {qty}x {self.name}. Stock: {self.stock}")

    def _check_alert(self):
        if self.stock <= self.low_threshold:
            print(f"  ⚠️  LOW STOCK ALERT: {self.name} only {self.stock} left!")

    def __str__(self):
        return f"[{self.sku}] {self.name} — ₹{self.price:,.2f} | Stock: {self.stock}"

    def __repr__(self):
        return f"Product('{self.name}', {self.price}, {self.stock})"

# Create inventory
inventory = [
    Product("Wireless Mouse", 599, 50),
    Product("Mechanical Keyboard", 2499, 8),
    Product("USB-C Hub", 1299, 3, low_threshold=5),
]

print("═" * 50)
print("🏪 PRODUCT INVENTORY DASHBOARD")
print("═" * 50)
for p in inventory:
    print(p)

print("\n📋 Processing Orders...")
inventory[0].sell(5)
inventory[1].sell(6)
inventory[2].sell(2)
inventory[2].restock(20)

Inheritance & Advanced OOP

11.1 Inheritance Basics

Inheritance lets a child class reuse code from a parent class. The child inherits all attributes and methods, and can add or override them.

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

    def speak(self):
        return f"{self.name} makes a sound"

class Dog(Animal):   # Dog inherits from Animal
    def __init__(self, name, breed):
        super().__init__(name, "Dog")  # Call parent __init__
        self.breed = breed

    def speak(self):   # Method overriding
        return f"{self.name} says: Woof!"

class Cat(Animal):
    def speak(self):
        return f"{self.name} says: Meow!"

dog = Dog("Buddy", "Labrador")
cat = Cat("Whiskers", "Cat")
print(dog.speak())
print(cat.speak())
print(isinstance(dog, Animal))  # True

11.2 super() and Method Overriding

Python
class Vehicle:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year

    def info(self):
        return f"{self.year} {self.make} {self.model}"

class ElectricCar(Vehicle):
    def __init__(self, make, model, year, battery_kwh):
        super().__init__(make, model, year)
        self.battery_kwh = battery_kwh

    def info(self):  # Override parent method
        base = super().info()  # Call parent method
        return f"{base} (Electric, {self.battery_kwh}kWh)"

car = ElectricCar("Tesla", "Model 3", 2024, 75)
print(car.info())

11.3 Multiple Inheritance & MRO

Python
class Flyable:
    def fly(self):
        return "I can fly!"

class Swimmable:
    def swim(self):
        return "I can swim!"

class Duck(Flyable, Swimmable):  # Multiple inheritance
    def quack(self):
        return "Quack!"

d = Duck()
print(d.fly())
print(d.swim())
print(d.quack())

# MRO — Method Resolution Order
print(Duck.mro())
# [Duck, Flyable, Swimmable, object]

11.4 Data Hiding & Encapsulation

Python
class Account:
    def __init__(self, balance):
        self.__balance = balance  # Name mangling: __balance → _Account__balance

    @property
    def balance(self):
        """Getter — controlled read access."""
        return self.__balance

    @balance.setter
    def balance(self, value):
        """Setter — with validation."""
        if value < 0:
            raise ValueError("Balance cannot be negative!")
        self.__balance = value

acc = Account(1000)
print(acc.balance)      # 1000 (uses getter)
acc.balance = 500       # Uses setter
# acc.balance = -100    # ❌ ValueError!
# acc.__balance         # ❌ AttributeError (name mangled)

11.5 Polymorphism

Python
class Shape:
    def area(self):
        raise NotImplementedError

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

class Rectangle(Shape):
    def __init__(self, w, h):
        self.w = w
        self.h = h
    def area(self):
        return self.w * self.h

# Polymorphism — same method name, different behavior
shapes = [Circle(5), Rectangle(4, 6), Circle(3)]
for s in shapes:
    print(f"{type(s).__name__}: area = {s.area():.2f}")

11.6 Abstract Classes

Python
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

    @abstractmethod
    def perimeter(self):
        pass

# shape = Shape()  # ❌ TypeError: Can't instantiate abstract class

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

11.7 @classmethod and @staticmethod

Python
class Employee:
    raise_pct = 1.05

    def __init__(self, name, salary):
        self.name = name
        self.salary = salary

    @classmethod
    def set_raise(cls, pct):
        """Modifies the class attribute."""
        cls.raise_pct = pct

    @staticmethod
    def is_workday(day):
        """Does not need self or cls."""
        return day.weekday() < 5

Employee.set_raise(1.10)
print(Employee.raise_pct)  # 1.10

Python
import math

class Shape:
    def area(self):
        raise NotImplementedError
    def __str__(self):
        return f"{type(self).__name__}: area={self.area():.2f}"

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

class Rectangle(Shape):
    def __init__(self, w, h):
        self.w, self.h = w, h
    def area(self):
        return self.w * self.h

print(Circle(5))       # Circle: area=78.54
print(Rectangle(4, 6)) # Rectangle: area=24.00

Python
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

class Student(Person):
    def __init__(self, name, age, roll_no):
        super().__init__(name, age)
        self.roll_no = roll_no

class GradStudent(Student):
    def __init__(self, name, age, roll_no, thesis):
        super().__init__(name, age, roll_no)
        self.thesis = thesis
    def __str__(self):
        return f"{self.name} (Roll:{self.roll_no}) - Thesis: {self.thesis}"

g = GradStudent("Alice", 24, 101, "ML in Healthcare")
print(g)

Python
class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius  # Uses setter

    @property
    def celsius(self):
        return self._celsius

    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("Below absolute zero!")
        self._celsius = value

    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32

t = Temperature(100)
print(f"{t.celsius}°C = {t.fahrenheit}°F")
# 100°C = 212.0°F

Python
from abc import ABC, abstractmethod
from datetime import datetime

class PaymentProcessor(ABC):
    """Abstract base class for all payment methods."""
    transaction_count = 0

    def __init__(self, amount, customer_id):
        self.amount = amount
        self.customer_id = customer_id
        self.timestamp = datetime.now()
        PaymentProcessor.transaction_count += 1
        self.txn_id = f"TXN{PaymentProcessor.transaction_count:05d}"

    @abstractmethod
    def process(self):
        pass

    def receipt(self):
        return f"[{self.txn_id}] ₹{self.amount} via {self.__class__.__name__}"

class CreditCardPayment(PaymentProcessor):
    def __init__(self, amount, customer_id, card_last4):
        super().__init__(amount, customer_id)
        self.card_last4 = card_last4

    def process(self):
        fee = self.amount * 0.02  # 2% processing fee
        print(f"💳 Credit Card ****{self.card_last4}")
        print(f"   Amount: ₹{self.amount} + Fee: ₹{fee:.2f}")
        print(f"   ✅ Payment processed! {self.receipt()}")

class UPIPayment(PaymentProcessor):
    def __init__(self, amount, customer_id, upi_id):
        super().__init__(amount, customer_id)
        self.upi_id = upi_id

    def process(self):
        print(f"📱 UPI Payment to {self.upi_id}")
        print(f"   Amount: ₹{self.amount} (No extra fee)")
        print(f"   ✅ Payment processed! {self.receipt()}")

class WalletPayment(PaymentProcessor):
    def __init__(self, amount, customer_id, wallet_name):
        super().__init__(amount, customer_id)
        self.wallet_name = wallet_name

    def process(self):
        cashback = self.amount * 0.05  # 5% cashback
        print(f"👛 {self.wallet_name} Wallet")
        print(f"   Amount: ₹{self.amount} | Cashback: ₹{cashback:.2f}")
        print(f"   ✅ Payment processed! {self.receipt()}")

# Polymorphic payment processing
payments = [
    CreditCardPayment(5000, "CUST001", "4242"),
    UPIPayment(1500, "CUST002", "user@paytm"),
    WalletPayment(800, "CUST003", "PhonePe"),
]

print("═" * 45)
print("💰 PAYMENT GATEWAY — TRANSACTIONS")
print("═" * 45)
for payment in payments:
    payment.process()
    print()

File Handling & Exceptions

12.1 Opening Files

Use open() to work with files. Always prefer the with statement — it automatically closes the file.

12.2 Reading Files

Python
# Always use 'with' — it auto-closes the file
with open("data.txt", "r") as f:
    content = f.read()          # Read entire file as string
    print(content)

with open("data.txt") as f:
    line = f.readline()         # Read one line
    print(line)

with open("data.txt") as f:
    lines = f.readlines()      # Read all lines → list
    print(lines)

# Best practice: iterate line by line (memory efficient)
with open("data.txt") as f:
    for line in f:
        print(line.strip())    # strip() removes \n

12.3 Writing Files

Python
# Write (creates new or overwrites)
with open("output.txt", "w") as f:
    f.write("Hello, World!\n")
    f.write("Second line\n")

# Append (adds to end)
with open("output.txt", "a") as f:
    f.write("Appended line\n")

# Write multiple lines
lines = ["Line 1\n", "Line 2\n", "Line 3\n"]
with open("output.txt", "w") as f:
    f.writelines(lines)

# Writing variables (must convert to string)
name = "Alice"
age = 25
with open("output.txt", "w") as f:
    f.write(f"Name: {name}\nAge: {age}\n")

12.4 Working with Directories

Python
import os

# List directory contents
print(os.listdir("."))            # List current directory

# Check if file/directory exists
print(os.path.exists("data.txt"))  # True/False
print(os.path.isfile("data.txt"))  # True if file
print(os.path.isdir("mydir"))      # True if directory

# Create directories
os.makedirs("path/to/dir", exist_ok=True)

# Join paths (cross-platform)
path = os.path.join("folder", "subfolder", "file.txt")
print(path)  # folder/subfolder/file.txt

12.5 Pickling (Binary Serialization)

Python
import pickle

# Save Python object to binary file
data = {"name": "Alice", "scores": [90, 85, 92]}
with open("data.pkl", "wb") as f:
    pickle.dump(data, f)

# Load Python object from binary file
with open("data.pkl", "rb") as f:
    loaded = pickle.load(f)
print(loaded)

12.6 Exception Handling

Python
# Basic try-except
try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ValueError:
    print("Not a valid number!")
except ZeroDivisionError:
    print("Cannot divide by zero!")
else:
    print(f"Result: {result}")       # Runs if NO exception
finally:
    print("This always runs.")      # Cleanup code

12.7 Common Exceptions

12.8 Custom Exceptions & raise

Python
class InsufficientFundsError(Exception):
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        super().__init__(
            f"Cannot withdraw ₹{amount}. Balance: ₹{balance}"
        )

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(balance, amount)
    return balance - amount

try:
    withdraw(100, 500)
except InsufficientFundsError as e:
    print(e)

Python
def count_words(filename):
    try:
        with open(filename) as f:
            content = f.read()
        words = content.split()
        print(f"Total words: {len(words)}")
    except FileNotFoundError:
        print(f"File '{filename}' not found!")

count_words("sample.txt")

Python
def copy_file(src, dst):
    try:
        with open(src, "r") as fin, open(dst, "w") as fout:
            fout.write(fin.read())
        print(f"Copied {src} → {dst}")
    except FileNotFoundError:
        print(f"Source file '{src}' not found!")
    except PermissionError:
        print("Permission denied!")

copy_file("input.txt", "backup.txt")

Python
import pickle

students = [
    {"name": "Alice", "roll": 101, "marks": 92},
    {"name": "Bob", "roll": 102, "marks": 85},
]

# Save
with open("students.pkl", "wb") as f:
    pickle.dump(students, f)

# Load
with open("students.pkl", "rb") as f:
Exercise 12.2: Write a safe division function that handles all errors
Python
def safe_divide():
    try:
        a = float(input("Enter numerator: "))
        b = float(input("Enter denominator: "))
        result = a / b
    except ValueError:
        print("Invalid input — enter numbers only!")
    except ZeroDivisionError:
        print("Cannot divide by zero!")
    else:
        print(f"Result: {a} / {b} = {result:.4f}")
    finally:
        print("Calculation attempted.")

safe_divide()

Exercise 12.3: Save and load a list of students using pickle
Python
import pickle

def save_students(students, filename):
    with open(filename, "wb") as f:
        pickle.dump(students, f)
    print(f"Saved {len(students)} students ✅")

def load_students(filename):
    try:
        with open(filename, "rb") as f:
            return pickle.load(f)
    except FileNotFoundError:
        print("No saved data found.")
        return []

data = [{"name": "Alice", "roll": 101}, {"name": "Bob", "roll": 102}]
save_students(data, "students.pkl")
loaded = load_students("students.pkl")
print(loaded)

Python
import csv
import os
from collections import defaultdict

def generate_sales_report(csv_file, output_file):
    """Read sales CSV, aggregate by product, generate report."""
    product_sales = defaultdict(lambda: {"qty": 0, "revenue": 0.0})

    try:
        with open(csv_file, "r") as f:
            reader = csv.DictReader(f)
            for row in reader:
                product = row["product"]
                qty = int(row["quantity"])
                price = float(row["price"])
                product_sales[product]["qty"] += qty
                product_sales[product]["revenue"] += qty * price

    except FileNotFoundError:
        print(f"❌ Error: File '{csv_file}' not found!")
        return
    except (ValueError, KeyError) as e:
        print(f"❌ Data error: {e}")
        return

    # Generate report
    total_revenue = sum(d["revenue"] for d in product_sales.values())
    report_lines = []
    report_lines.append("═" * 50)
    report_lines.append("📈 DAILY SALES SUMMARY REPORT")
    report_lines.append("═" * 50)
    report_lines.append(f"{' Product':20}{'Qty':>8}{'Revenue':>15}")
    report_lines.append("─" * 50)

    for product, data in sorted(product_sales.items()):
        report_lines.append(
            f" {product:20}{data['qty']:>8}  ₹{data['revenue']:>12,.2f}"
        )

    report_lines.append("─" * 50)
    report_lines.append(f" {'TOTAL':28}  ₹{total_revenue:>12,.2f}")
    report_lines.append("═" * 50)

    report = "\n".join(report_lines)
    print(report)

    # Save report to file
    with open(output_file, "w") as f:
        f.write(report)
    print(f"\n✅ Report saved to {output_file}")

# Demo with sample data
generate_sales_report("sales_data.csv", "daily_report.txt")