🐍 Python Revision Tour II

Chapter 2 continues the Python revision with the four built-in collection types — strings, lists, tuples and dictionaries. It builds directly on Tour I.

2.1 Introduction

In Python Revision Tour I, we covered the basics — tokens, variables, data types, and flow control. Tour II goes deeper into Python's built-in data structures — the workhorses of real-world programming.

Which one should I use? Answer these questions from the top:

graph TD
    Q1{"Will you look items up\nby a NAME (key)?"}
    Q2{"Is it just text?"}
    Q3{"Will the items need\nto change later?"}
    D["🗂 Dictionary\n{'name': 'Arjun', 'age': 17}"]
    S["🔤 String\n'Hello'"]
    L["📋 List — mutable\n[10, 'two', 3.0]"]
    T["📦 Tuple — immutable\n(10, 20, 30)"]

    Q1 -->|"Yes"| D
    Q1 -->|"No, by position"| Q2
    Q2 -->|"Yes"| S
    Q2 -->|"No"| Q3
    Q3 -->|"Yes"| L
    Q3 -->|"No, fixed"| T

    style D fill:#FFE0B2,stroke:#FF9800
    style S fill:#C8E6C9,stroke:#4CAF50
    style L fill:#BBDEFB,stroke:#2196F3
    style T fill:#E1BEE7,stroke:#9C27B0

2.2 Strings in Python

A string is an ordered, immutable sequence of characters enclosed in single ' ', double " ", or triple ''' ''' quotes. Strings are one of Python's most-used data types.

# Creating strings
s1 = 'Hello'
s2 = "World"
s3 = '''This is a
multi-line string'''

print(type(s1))   # <class 'str'>
print(len(s1))    # 5

Indexing in Strings — Both Directions!

s = "Hello"
print(s[0])    # H  (first character)
print(s[4])    # o  (last character)
print(s[-1])   # o  (last character, negative index)
print(s[-5])   # H  (first character, negative index)

2.2.1 Item Assignment Not Supported

Strings are immutable — once created, individual characters cannot be changed. This is one of the most important properties of strings.

What really happens: Python never edits the old string. It builds a new string and moves the name s to it.

graph LR
    N(["name: s"])
    OLD["'Hello'\nold string — never changed"]
    NEW["'Jello'\nbrand-new string"]

    N -.->|"before"| OLD
    N -->|"after s = 'J' + s[1:]"| NEW

    style OLD fill:#ECEFF1,stroke:#90A4AE
    style NEW fill:#C8E6C9,stroke:#4CAF50

Code Example: string_immutable.py

# string_immutable.py
s = "Hello"

# Trying to change a character — WILL CRASH!
# s[0] = "J"    ← TypeError: 'str' object does not support item assignment

# ✅ CORRECT WAY — create a NEW string
s = "J" + s[1:]
print(s)   # Jello

# Another correct method
s = "Hello"
s = s.replace("H", "J")
print(s)   # Jello

2.2.2 Traversing a String

Traversal means visiting each character of a string one by one. Python gives you two clean ways to do this.

Code Example: string_traversal.py

# string_traversal.py

name = "Python"

# Method 1: for loop (PREFERRED — clean and Pythonic)
print("Method 1: for loop")
for ch in name:
    print(ch, end=" ")   # P y t h o n
print()

# Method 2: while loop with index
print("Method 2: while loop")
i = 0
while i < len(name):
    print(name[i], end=" ")   # P y t h o n
    i += 1
print()

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

Output:

Method 1: for loop
P y t h o n
Method 2: while loop
P y t h o n
Method 3: for with range
Index 0: P
Index 1: y
Index 2: t
Index 3: h
Index 4: o
Index 5: n

2.2.3 String Operators

Python supports several operators that work directly on strings.

Code Example: string_operators.py

# string_operators.py

s1 = "Hello"
s2 = " World"

# Concatenation
print(s1 + s2)        # Hello World

# Repetition
print("Ha" * 3)       # HaHaHa
print(3 * "-")        # ---  (order doesn't matter!)

# Membership
print("ell" in s1)    # True
print("xyz" in s1)    # False
print("xyz" not in s1)# True

# Comparison (lexicographic — based on ASCII values)
print("apple" < "banana")   # True  (a < b)
print("Apple" < "apple")    # True  (A=65 < a=97)
print("abc" == "abc")       # True

2.2.4 String Slices

Slicing extracts a portion (substring) of a string. It's one of the most useful string features in Python.

Syntax: string[start : stop : step]

• start — Index to begin (inclusive). Default: 0
• stop — Index to end (exclusive — NOT included). Default: len(s)
• step — Jump between characters. Default: 1

Picture it: s = "PYTHON" is a row of numbered boxes. s[1:4] starts at box 1 and stops before box 4, so it takes boxes 1, 2 and 3:

graph LR
    P["P\n0"] ~~~ Y["Y\n1"] ~~~ T["T\n2"] ~~~ H["H\n3"] ~~~ O["O\n4"] ~~~ N["N\n5"]

    style Y fill:#C8E6C9,stroke:#4CAF50
    style T fill:#C8E6C9,stroke:#4CAF50
    style H fill:#C8E6C9,stroke:#4CAF50
    style O fill:#FFCDD2,stroke:#F44336

🟩 taken by s[1:4] → "YTH" · 🟥 box 4 is the stop — not taken

Code Example: string_slicing.py

# string_slicing.py

s = "PYTHON"
#    0 1 2 3 4 5   (positive indices)
#   -6-5-4-3-2-1   (negative indices)

# Basic slices
print(s[1:4])      # YTH  (index 1,2,3 — stop=4 is excluded)
print(s[:3])       # PYT  (start defaults to 0)
print(s[3:])       # HON  (stop defaults to end)
print(s[:])        # PYTHON (full string)

# Step slicing
print(s[::2])      # PTO  (every 2nd character)
print(s[1::2])     # YHN  (start at 1, every 2nd)

# Negative step — REVERSAL!
print(s[::-1])     # NOHTYP  (reverse the string!)
print(s[4:1:-1])   # OHT  (from index 4 to 2, going backwards)

# Using negative indices
print(s[-3:])      # HON  (last 3 characters)
print(s[:-3])      # PYT  (everything except last 3)

2.2.5 String Functions

Python's str type comes loaded with built-in functions and methods. These are exam gold!

Case Functions:

Search & Replace:

Split & Join:

Strip Functions:

Check Functions (Return True/False):

Other Useful Functions:

Code Example: string_functions.py

# string_functions.py

s = "  Hello, World!  "

# Case operations
print(s.upper())        # "  HELLO, WORLD!  "
print(s.lower())        # "  hello, world!  "
print("hello world".title())   # "Hello World"

# Strip whitespace
print(s.strip())        # "Hello, World!"
clean = s.strip()

# Find and Count
print(clean.find("l"))  # 2
print(clean.count("l")) # 3
print(clean.find("xyz"))# -1 (not found — no crash!)

# Replace
print(clean.replace("World", "Python"))  # "Hello, Python!"

# Split and Join
sentence = "apple,banana,cherry"
fruits = sentence.split(",")
print(fruits)           # ['apple', 'banana', 'cherry']
print(" | ".join(fruits))  # apple | banana | cherry

# Check functions
print("Hello123".isalnum())   # True
print("Hello".isalpha())      # True
print("12345".isdigit())      # True
print("   ".isspace())        # True

# ord() and chr()
print(ord('A'))   # 65
print(ord('a'))   # 97
print(chr(65))    # A
print(chr(90))    # Z

2.3 Lists in Python

A list is an ordered, mutable (changeable) sequence that can hold items of different data types. Lists are the most versatile data structure in Python.

2.3.1 Creating Lists

Code Example: creating_lists.py

# creating_lists.py

# Empty list
empty = []
print(empty)        # []

# List of integers
numbers = [10, 20, 30, 40, 50]
print(numbers)      # [10, 20, 30, 40, 50]

# Mixed data types — Lists can hold anything!
mixed = [42, "Python", 3.14, True, None]
print(mixed)        # [42, 'Python', 3.14, True, None]

# Nested list (list of lists)
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrix[1][2]) # 6  (row 1, col 2)

# Using list() constructor
chars = list("CBSE")
print(chars)        # ['C', 'B', 'S', 'E']

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

Indexing in Lists — Same as Strings:

lst = [10, 20, 30, 40, 50]
print(lst[0])    # 10
print(lst[-1])   # 50
print(lst[2])    # 30

2.3.2 Lists vs. Strings

Both strings and lists are sequences, but they have key differences:

Code Example: list_vs_string.py

# list_vs_string.py

# String — IMMUTABLE
s = "Hello"
# s[0] = "J"   ← TypeError!

# List — MUTABLE
lst = ["H", "e", "l", "l", "o"]
lst[0] = "J"   # ✅ Allowed!
print(lst)     # ['J', 'e', 'l', 'l', 'o']

# Both support slicing
print(s[1:4])       # ell
print(lst[1:4])     # ['e', 'l', 'l']

# Both support membership
print("e" in s)     # True
print("e" in lst)   # True

2.3.3 List Operations

Code Example: list_operations.py

# list_operations.py

a = [1, 2, 3]
b = [4, 5, 6]

# Concatenation — creates a NEW list
c = a + b
print(c)           # [1, 2, 3, 4, 5, 6]

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

# Membership
print(2 in a)      # True
print(10 in a)     # False
print(10 not in a) # True

# Comparison
print([1,2,3] == [1,2,3])  # True
print([1,2,3] == [3,2,1])  # False (order matters!)

# Slicing a list — same syntax as strings
lst = [10, 20, 30, 40, 50]
print(lst[1:4])    # [20, 30, 40]
print(lst[::-1])   # [50, 40, 30, 20, 10]  (reversed!)
print(lst[::2])    # [10, 30, 50]

2.3.4 List Manipulation

Since lists are mutable, we can directly modify their elements — unlike strings!

Code Example: list_manipulation.py

# list_manipulation.py

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

# ① Updating an element
fruits[1] = "blueberry"
print(fruits)   # ['apple', 'blueberry', 'cherry', 'date', 'elderberry']

# ② Updating a slice (replace multiple elements at once)
fruits[2:4] = ["coconut", "durian"]
print(fruits)   # ['apple', 'blueberry', 'coconut', 'durian', 'elderberry']

# ③ Deleting an element by index
del fruits[0]
print(fruits)   # ['blueberry', 'coconut', 'durian', 'elderberry']

# ④ Deleting a slice
del fruits[1:3]
print(fruits)   # ['blueberry', 'elderberry']

# ⑤ Inserting in the middle via slice assignment
fruits[1:1] = ["fig", "grape"]
print(fruits)   # ['blueberry', 'fig', 'grape', 'elderberry']

2.3.5 Making True Copy of a List

This is one of the trickiest topics for students — and important for exams.

The Problem: Shallow (Alias) Copy

When you write b = a, Python does NOT create a new list. Both a and b point to the same list object. Changing one changes both!

graph LR
    subgraph CP["✅ copy1 = original[:]"]
        O2(["original"])
        C2(["copy1"])
        L2["[1, 2, 3, 4, 5]"]
        L3["[999, 2, 3, 4, 5]\na SEPARATE list"]
        O2 --> L2
        C2 --> L3
    end
    subgraph AL["❌ alias = original"]
        O1(["original"])
        A1(["alias"])
        L1["[999, 2, 3, 4, 5]\nONE list in memory"]
        O1 --> L1
        A1 --> L1
    end

    style L1 fill:#FFCDD2,stroke:#F44336
    style L2 fill:#C8E6C9,stroke:#4CAF50
    style L3 fill:#C8E6C9,stroke:#4CAF50

Code Example: list_copy.py

# list_copy.py

# ❌ ALIAS (NOT a copy!)
original = [1, 2, 3, 4, 5]
alias = original           # Both point to SAME list!
alias[0] = 999
print(original)   # [999, 2, 3, 4, 5] ← Original CHANGED!
print(alias)      # [999, 2, 3, 4, 5]

# ✅ TRUE COPY — Method 1: Slicing
original = [1, 2, 3, 4, 5]
copy1 = original[:]
copy1[0] = 999
print(original)   # [1, 2, 3, 4, 5] ← Original SAFE!
print(copy1)      # [999, 2, 3, 4, 5]

# ✅ TRUE COPY — Method 2: list() constructor
copy2 = list(original)
copy2[0] = 888
print(original)   # [1, 2, 3, 4, 5] ← Original SAFE!

# ✅ TRUE COPY — Method 3: .copy() method
copy3 = original.copy()
copy3[0] = 777
print(original)   # [1, 2, 3, 4, 5] ← Original SAFE!

a = [1, 2, 3]
b = a         # alias
c = a[:]      # true copy
print(id(a) == id(b))  # True  — same object!
print(id(a) == id(c))  # False — different objects!

2.3.6 List Functions

Python provides a rich set of list functions and methods. Know them all!

Methods that MODIFY the list (in-place):

Methods/Functions that return a value (do NOT modify):

Code Example: list_functions.py

# list_functions.py

lst = [30, 10, 50, 20, 40]
print("Original:", lst)     # [30, 10, 50, 20, 40]

# append — adds ONE element to end
lst.append(60)
print("After append(60):", lst)     # [30, 10, 50, 20, 40, 60]

# extend — adds MULTIPLE elements to end
lst.extend([70, 80])
print("After extend:", lst)         # [30, 10, 50, 20, 40, 60, 70, 80]

# insert — at specific position
lst.insert(1, 5)
print("After insert(1,5):", lst)    # [30, 5, 10, 50, 20, 40, 60, 70, 80]

# remove — first occurrence
lst.remove(5)
print("After remove(5):", lst)      # [30, 10, 50, 20, 40, 60, 70, 80]

# pop — removes and returns last element
popped = lst.pop()
print("Popped:", popped)            # 80
print("After pop():", lst)          # [30, 10, 50, 20, 40, 60, 70]

# pop(index) — removes and returns specific index
popped_at = lst.pop(2)
print("Popped at [2]:", popped_at)  # 50

# sort and reverse
lst.sort()
print("After sort():", lst)         # [10, 20, 30, 40, 60, 70]
lst.reverse()
print("After reverse():", lst)      # [70, 60, 40, 30, 20, 10]

# Statistics
print("min:", min(lst))   # 10
print("max:", max(lst))   # 70
print("sum:", sum(lst))   # 230
print("len:", len(lst))   # 6

graph LR
    A["lst = [1, 2, 3]"]
    B["[1, 2, 3, [4, 5]]\nlength 4 — the whole list\ngoes in as ONE item"]
    C["[1, 2, 3, 4, 5]\nlength 5 — each item\ngoes in separately"]

    A -->|"lst.append([4, 5])"| B
    A -->|"lst.extend([4, 5])"| C

    style B fill:#FFE0B2,stroke:#FF9800
    style C fill:#C8E6C9,stroke:#4CAF50

2.4 Tuples in Python

A tuple is an ordered, immutable sequence of elements. Think of a tuple as a "read-only list" — once created, it cannot be changed.

2.4.1 Creating Tuples

Code Example: creating_tuples.py

# creating_tuples.py

# Empty tuple
t0 = ()
print(t0)           # ()

# Tuple of integers
t1 = (10, 20, 30)
print(t1)           # (10, 20, 30)

# Mixed data types
t2 = (42, "Python", 3.14, True)
print(t2)

# ⚠️ CRITICAL: Single-element tuple — the comma is MANDATORY!
single_wrong = (42)      # This is just an int, NOT a tuple!
single_right = (42,)     # This IS a tuple — note the comma!
print(type(single_wrong))  # <class 'int'>
print(type(single_right))  # <class 'tuple'>

# Tuple without parentheses (tuple packing)
t3 = 1, 2, 3
print(t3)           # (1, 2, 3)
print(type(t3))     # <class 'tuple'>

# Using tuple() constructor
t4 = tuple([1, 2, 3])    # from list
t5 = tuple("CBSE")       # from string
print(t4)   # (1, 2, 3)
print(t5)   # ('C', 'B', 'S', 'E')

2.4.2 Tuples vs. Lists

Code Example: tuple_vs_list.py

# tuple_vs_list.py

t = (1, 2, 3)
lst = [1, 2, 3]

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

# ✅ List item assignment works
lst[0] = 99
print(lst)      # [99, 2, 3]

# Tuples can be dict keys, lists CANNOT
my_dict = {(1, 2): "point A", (3, 4): "point B"}
print(my_dict[(1, 2)])   # point A

# This would CRASH:
# bad_dict = {[1,2]: "point"}  ← TypeError: unhashable type: 'list'

2.4.3 Tuple Operations

Tuples support all read-only operations that lists do:

Code Example: tuple_operations.py

# tuple_operations.py

t1 = (10, 20, 30)
t2 = (40, 50, 60)

# Concatenation — creates NEW tuple
t3 = t1 + t2
print(t3)         # (10, 20, 30, 40, 50, 60)

# Repetition
t4 = (0,) * 4
print(t4)         # (0, 0, 0, 0)

# Membership
print(20 in t1)   # True
print(99 in t1)   # False

# Indexing
print(t1[0])      # 10
print(t1[-1])     # 30

# Slicing
print(t3[2:5])    # (30, 40, 50)
print(t3[::-1])   # (60, 50, 40, 30, 20, 10)

# Tuple unpacking — very Pythonic!
a, b, c = t1
print(a, b, c)    # 10 20 30

2.4.4 Tuple Functions and Methods

Tuples have only 2 methods (because they're immutable — can't add, remove, or sort):

Built-in functions that work on tuples:

Code Example: tuple_functions.py

# tuple_functions.py

marks = (85, 92, 78, 92, 88, 70)

print("Length:", len(marks))         # 6
print("Maximum:", max(marks))        # 92
print("Minimum:", min(marks))        # 70
print("Sum:", sum(marks))            # 505
print("Count of 92:", marks.count(92)) # 2 — count() is a tuple method
print("Index of 78:", marks.index(78)) # 2

# sorted() returns a LIST, not a tuple!
sorted_marks = sorted(marks)
print("Sorted:", sorted_marks)          # [70, 78, 85, 88, 92, 92]
print("Type:", type(sorted_marks))      # <class 'list'>

# If you need a sorted tuple:
sorted_tuple = tuple(sorted(marks))
print("Sorted tuple:", sorted_tuple)    # (70, 78, 85, 88, 92, 92)

2.5 Dictionaries in Python

A dictionary is a collection of key-value pairs. It's like a real dictionary — you look up a word (key) to find its definition (value). You find an item by its key, never by a position number. (Since Python 3.7, a dictionary also remembers the order in which you added the items.)

graph LR
    K1["🔑 'name'"] --> V1["'Arjun'"]
    K2["🔑 'age'"] --> V2["17"]
    K3["🔑 'marks'"] --> V3["95"]

    style K1 fill:#FFE0B2,stroke:#FF9800
    style K2 fill:#FFE0B2,stroke:#FF9800
    style K3 fill:#FFE0B2,stroke:#FF9800

student["age"] follows the arrow from the key 'age' and gives 17.

2.5.1 Creating a Dictionary

Code Example: creating_dict.py

# creating_dict.py

# Empty dictionary
d0 = {}
print(d0)            # {}
print(type(d0))      # <class 'dict'>

# Dictionary with initial values
student = {
    "name": "Arjun",
    "age": 17,
    "marks": 95,
    "passed": True
}
print(student)

# Mixed key types (keys must be immutable)
mixed = {
    1: "one",
    "two": 2,
    (3, 4): "tuple key"
}
print(mixed[1])        # one
print(mixed["two"])    # 2
print(mixed[(3, 4)])   # tuple key

# Using dict() constructor
d2 = dict(name="Priya", age=16, city="Delhi")
print(d2)              # {'name': 'Priya', 'age': 16, 'city': 'Delhi'}

# Creating from list of tuples
d3 = dict([("a", 1), ("b", 2), ("c", 3)])
print(d3)              # {'a': 1, 'b': 2, 'c': 3}

2.5.2 Accessing Elements of a Dictionary

Code Example: accessing_dict.py

# accessing_dict.py

student = {"name": "Arjun", "age": 17, "marks": 95}

# Method 1: Direct key access — FAST
print(student["name"])   # Arjun
print(student["marks"])  # 95

# ❌ Key error if key doesn't exist
# print(student["grade"])  ← KeyError: 'grade'

# ✅ Method 2: get() — SAFE (returns None or default if key not found)
print(student.get("grade"))          # None  (no crash!)
print(student.get("grade", "N/A"))   # N/A   (custom default value)

# Checking if key exists
if "age" in student:
    print("Age found:", student["age"])   # Age found: 17

2.5.3 Characteristics of a Dictionary

Code Example: dict_characteristics.py

# dict_characteristics.py

# Duplicate keys — LAST VALUE WINS
d = {"a": 1, "b": 2, "a": 99}
print(d)    # {'a': 99, 'b': 2}  — first "a":1 is overwritten!

# Values can be any type — even lists, dicts!
complex_dict = {
    "name": "Arjun",
    "scores": [85, 90, 88],
    "address": {"city": "Delhi", "pin": 110001}
}
print(complex_dict["scores"])          # [85, 90, 88]
print(complex_dict["address"]["city"]) # Delhi

# Lists CANNOT be keys (unhashable!)
# bad = {[1,2]: "value"}  ← TypeError: unhashable type: 'list'

# Tuples CAN be keys
good = {(1, 2): "coordinates"}
print(good[(1, 2)])   # coordinates

2.5.4 Dictionary Operations

Code Example: dict_operations.py

# dict_operations.py

student = {"name": "Arjun", "age": 17}

# ① Adding a new key-value pair
student["marks"] = 95
print(student)   # {'name': 'Arjun', 'age': 17, 'marks': 95}

# ② Updating an existing value
student["age"] = 18
print(student)   # {'name': 'Arjun', 'age': 18, 'marks': 95}

# ③ Deleting a key-value pair using del
del student["age"]
print(student)   # {'name': 'Arjun', 'marks': 95}

# ④ Deleting using pop() — also returns the value
removed = student.pop("marks")
print("Removed value:", removed)  # 95
print(student)                    # {'name': 'Arjun'}

# ⑤ Checking membership (checks KEYS only!)
student = {"name": "Arjun", "age": 17, "marks": 95}
print("name" in student)     # True
print("Arjun" in student)    # False  — "Arjun" is a VALUE, not a KEY!
print(17 in student)         # False  — 17 is a VALUE!

# ⑥ Traversal
for key in student:
    print(key, ":", student[key])

2.5.5 Dictionary Functions and Methods

Code Example: dict_methods.py

# dict_methods.py

student = {"name": "Arjun", "age": 17, "marks": 95, "grade": "A"}

# keys(), values(), items()
print(student.keys())    # dict_keys(['name', 'age', 'marks', 'grade'])
print(student.values())  # dict_values(['Arjun', 17, 95, 'A'])
print(student.items())   # dict_items([('name', 'Arjun'), ...])

# Convert to lists if needed
key_list = list(student.keys())
print(key_list)          # ['name', 'age', 'marks', 'grade']

# update() — adds/modifies multiple items at once
student.update({"city": "Delhi", "age": 18})
print(student)   # age updated to 18, city added

# Traversal using items()
print("\nStudent Report:")
for key, value in student.items():
    print(f"  {key:10}: {value}")

# fromkeys() — create dict with fixed value
subjects = ["Physics", "Chemistry", "Maths", "CS"]
marks_template = dict.fromkeys(subjects, 0)
print(marks_template)
# {'Physics': 0, 'Chemistry': 0, 'Maths': 0, 'CS': 0}

# popitem() — removes last inserted item
last = student.popitem()
print("Removed:", last)  # ('city', 'Delhi') — the last INSERTED key (updating 'age' did not move it)

# Nested dict traversal
school = {
    "class12": {"strength": 40, "subjects": 5},
    "class11": {"strength": 35, "subjects": 5}
}
for cls, info in school.items():
    print(f"{cls}: {info['strength']} students")

⚠️ Common Errors and Misconceptions

a = [1, 2, 3]
b = a
c = a[:]
a.append(4)
print(b, c)
d = {"x": 1, "y": 2}
d["x"] = 10
print(len(d), d.get("z", 0), "y" in d)

[1, 2, 3, 4] [1, 2, 3]
2 0 True

Practice Problems

Test your mastery of Tour II topics with these board-style problems:

Strings:

1. Write a program to count the number of vowels and consonants in a string
2. Write a program to check if a string is a palindrome (without using slicing)
3. Write a program to reverse words in a sentence: "Hello World" → "World Hello"
4. Write a program to count occurrences of each character in a string using a dictionary
5. Write a program using ord() to encode a message (shift each letter by 3 — Caesar cipher)

Lists & Tuples:

6. Write a program to find the second-largest element in a list (without sorting)
7. Write a program to remove duplicate elements from a list while preserving order
8. Write a program to find the frequency of each element in a list using a dictionary
9. Demonstrate the difference between alias copy and true copy of a list
10. Write a program to flatten a list of lists: [[1,2],[3,4],[5,6]] → [1,2,3,4,5,6]

Dictionaries:

11. Write a program to merge two dictionaries
12. Write a program to create a frequency dictionary from a list of words
13. Write a program to find the key with the maximum value in a dictionary
14. Write a program to invert a dictionary (swap keys and values)

Quick Reference

Strings — Key Facts:

• Immutable — s[0] = 'X' raises TypeError
• Slicing: s[start:stop:step], reverse: s[::-1]
• find() → -1 if not found | index() → ValueError if not found
• split() → string to list | join() → list to string
• ord() → ASCII value | chr() → character from ASCII

Lists — Key Facts:

• Mutable — lst[0] = 99 is allowed
• True copy: lst[:] or lst.copy() or list(lst) — NOT b = a
• append(x) → adds 1 item | extend([x,y]) → adds multiple
• sort() → modifies original | sorted() → returns new list
• pop() → removes last | pop(i) → removes at index i

Tuples — Key Facts:

• Immutable — cannot change after creation
• Single-element: (42,) — comma is mandatory!
• Only 2 methods: count() and index()
• sorted(t) returns a list, not a tuple
• Can be used as dictionary keys (lists cannot)

Dictionaries — Key Facts:

• Key-value pairs: {key: value}
• Keys must be unique and immutable
• d[key] → KeyError if missing | d.get(key) → None if missing
• in checks keys, NOT values
• keys(), values(), items() → view objects