🐍 Python Revision Tour I

Welcome to the Class 12 Python Revision Tour! This unit recaps the fundamentals of Python you learned in Class 11.

1.1 Introduction

Python is one of the most popular, beginner-friendly programming languages in the world. In Class 12, Chapter 1 is a revision tour — not new content, but a quick, structured recap of everything from Class 11 before you move into advanced topics like functions, files, and databases.

Python was created by Guido van Rossum and first released in 1991. It is an interpreted, high-level, general-purpose language known for its clean, readable syntax.

• 🔧 Type: Interpreted
• 🖥 Paradigm: Multi-paradigm (OOP + Procedural)
• 📦 Version: Python 3.x
• 🔤 Case-Sensitive: Yes

1.2 Tokens in Python

A token is the smallest individual unit of a Python program. Think of tokens as the "atoms" of your code — every single element you write belongs to one of five token categories.

1.2.1 Keywords

Python 3 has 35 reserved keywords. They have fixed meanings and cannot be used as identifiers.

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

1.2.2 Identifiers (Names)

An identifier is a name given to a variable, function, class, module, or any other object.

1.2.3 Literals / Values

1.2.4 Operators

Operators are special symbols that perform computations. Python has arithmetic (+ - * / // % **), relational (== != > < >= <=), logical (and or not), bitwise, membership, and identity operators.

1.2.5 Punctuators

Punctuators give structure to code. Key punctuators in Python: (), [], {}, :, ,, ., @, =, ;, # (comment), \ (continuation).

1.3 Barebones of a Python Program

Every Python program, no matter how complex, is made of the same basic building blocks.

Code Example: hello_world.py

# hello_world.py
# ① Comment — ignored by Python, explains what code does

# ② Import statement — loads extra tools (modules)
import math

# ③ Variable declaration — stores data
student_name = "Arjun"
marks = 95

# ④ Expression / Statement — performs an action
percentage = (marks / 100) * 100

# ⑤ Output — shows result to user
print(f"Hello, {student_name}! Your score: {marks}")

1.4 Variables and Assignments

A variable is a named location in memory that holds a value. In Python, you create a variable simply by assigning a value to a name using the = operator.

1.4.1 Dynamic Typing

Python is dynamically typed — a variable's type is determined at runtime, not at declaration time. The same variable can hold values of different types during its lifetime.

Code Example: dynamic_typing.py

# dynamic_typing.py
x = 10          # x is int
print(type(x))   # <class 'int'>

x = "Hello"    # Now x is str (same variable!)
print(type(x))   # <class 'str'>

x = 3.14        # Now x is float
print(type(x))   # <class 'float'>

1.4.2 Multiple Assignments

Code Example: assignments.py

# assignments.py
# ① Same value to multiple variables
a = b = c = 100
print(a, b, c)   # 100 100 100

# ② Different values in one line (tuple unpacking)
x, y, z = 10, 20, 30
print(x, y, z)   # 10 20 30

# ③ Swapping — NO temporary variable needed!
a, b = 5, 8
a, b = b, a     # Elegant Python swap!
print(a, b)   # 8 5

1.5 Simple Input and Output

• 📥 input() function:
  • input("prompt") — Returns a string ALWAYS.
  • Use int(input(...)) for numbers.
  • Use float(input(...)) for decimals.
• 📤 print() function:
  • sep=" " — separator between items.
  • end="\n" — what to print at end.
  • f-strings: f"Hello {name}".

Code Example: input_output.py

# input_output.py
# Taking input
name = input("Enter your name: ")
age  = int(input("Enter your age: "))

# Regular print
print("Hello,", name)              # Hello, Arjun

# f-string (formatted string — preferred!)
print(f"You are {age} years old.")

# Controlling separator and end
print("A", "B", "C", sep="-")     # A-B-C
print("Line 1", end=" ")
print("Line 2")                    # Line 1 Line 2 (same line)

1.6 Data Types

Python is dynamically typed but every value has a type. Python handles all of these automatically — no need to declare types like in C or Java.

1.7 Mutable and Immutable Types

This is one of the most important conceptual distinctions in Python — and a frequent exam question.

• 🔒 Immutable Types: Once created, the value cannot be changed in place. A new object is created on modification.
  • Examples: int - whole numbers, float - decimal numbers, str - text strings, tuple - fixed sequence, bool - True / False.
• 🔓 Mutable Types: Values can be changed in place after creation without creating a new object.
  • Examples: list - mutable sequence, dict - key-value pairs, set - unique collection.

Code Example: mutable_demo.py

# mutable_demo.py
# IMMUTABLE — string cannot be changed in place
s = "Hello"
# s[0] = "J"  ← TypeError: 'str' object does not support item assignment

# MUTABLE — list CAN be changed in place
my_list = [1, 2, 3]
my_list[0] = 100   # ✅ Allowed!
print(my_list)      # [100, 2, 3]

# IMMUTABLE — tuple CANNOT be changed
my_tuple = (1, 2, 3)
# my_tuple[0] = 100  ← TypeError!

1.8 Expressions

An expression is a combination of values, variables, and operators that Python evaluates to produce a result. Expressions always produce a value.

1.8.1 Evaluating Arithmetic Operations

1.8.2 Evaluating Relational Expressions

Relational (comparison) operators always return True or False.

Code Example: relational.py

# relational.py
x, y = 10, 20
print(x == y)  # False   — equal to
print(x != y)  # True    — not equal
print(x <  y)  # True    — less than
print(x >= y)  # False   — greater than or equal
print(5 < 10 < 15)  # True — Python allows chaining!

1.8.3 Evaluating Logical Expressions

Code Example: logical.py

# logical.py
age = 17
has_id = True

# Both conditions must be True
can_vote = (age >= 18) and has_id
print(can_vote)  # False

# At least one condition must be True
is_weekend = True
has_homework = False
can_play = is_weekend or has_homework
print(can_play)  # True

# Reverse the boolean value
print(not has_id)  # False

1.8.4 Type Casting

Converting one data type to another explicitly.

Code Example: type_casting.py

# String to Integer
age_str = "18"
age = int(age_str)
print(age)  # 18

# Float to Integer (truncates decimal)
pi = 3.14
pi_int = int(pi)
print(pi_int)  # 3

# Integer to String
marks = 95
marks_str = str(marks)
print(marks_str)  # "95"

1.8.5 Math Library

The math module provides mathematical functions.

Code Example: math_functions.py

import math

print(math.sqrt(16))      # 4.0
print(math.pow(2, 3))     # 8.0
print(math.ceil(3.2))     # 4
print(math.floor(3.8))    # 3
print(math.factorial(5))  # 120
print(math.pi)            # 3.14159...

1.9 Statement Flow Control

In Python, execution statements can flow in three structured paths:

1.10 Conditional Statements

if Statement

Executes code only if condition is True.

if-else Statement

Executes one block if condition is True, another if False.

if-elif-else Statement

Checks multiple conditions in sequence.

Code Example: conditionals.py

# Simple if
age = 18
if age >= 18:
    print("You can vote")

# if-else
marks = 65
if marks >= 40:
    print("Pass")
else:
    print("Fail")

# if-elif-else
marks = 85
if marks >= 90:
    grade = 'A+'
elif marks >= 80:
    grade = 'A'
elif marks >= 70:
    grade = 'B'
elif marks >= 60:
    grade = 'C'
else:
    grade = 'D'
print(f"Grade: {grade}")  # Grade: A

Nested if Statements

An if statement inside another if statement. Each level must be properly indented.

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

if num != 0:
    if num > 0:
        print("Positive number")
    else:
        print("Negative number")
else:
    print("Zero")

1.11 Looping Statements

Loops let you repeat a block of code multiple times without rewriting it. Python has two loop types.

for Loop

The for loop iterates over a sequence (list, tuple, string, range) and runs the block once for each item.

for <variable> in <sequence>:
    <body>

Code Example: for_loops.py

# for loop with range
for i in range(1, 6):
    print(i)  # Prints 1 to 5

# for loop with list
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

while Loop

The while loop repeats as long as a condition remains True. Use when you don't know in advance how many times to loop.

while <condition>:
    <body>

Code Example: while_loops.py

# while loop
count = 1
while count <= 5:
    print(count)
    count += 1

# while loop with user input
password = ""
while password != "python123":
    password = input("Enter password: ")
print("Access granted!")

1.12 Jump Statements

Jump statements alter the normal flow of a loop. Python has three: break, continue, and pass.

• 🛑 break
  • Immediately exits the loop
  • Control goes to next statement after loop
  • Works in both for and while
• ⏭ continue
  • Skips rest of current iteration
  • Control goes to next iteration
  • Works in both for and while

Code Example: jump_statements.py

# break - Find first multiple of 7
for i in range(1, 100):
    if i % 7 == 0:
        print(f"First multiple of 7: {i}")
        break  # Exit loop

# continue - Print only odd numbers
for i in range(1, 11):
    if i % 2 == 0:  # If even
        continue    # Skip this iteration
    print(i)  # Only prints odd numbers
# Output: 1 3 5 7 9

1.13 More on Loops

1.13.1 Nested Loops

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

Code Example: nested_loops.py

# Multiplication table
for i in range(1, 4):
    for j in range(1, 4):
        print(f"{i} x {j} = {i*j}")
    print()  # Blank line

# Pattern printing
for i in range(1, 6):
    for j in range(i):
        print("*", end=" ")
    print()  # New line

# Output:
# * 
# * * 
# * * * 
# * * * * 
# * * * * * 

1.13.2 Loop else Statement

Python allows an else clause on loops — a feature unique to Python! The else block executes only when the loop finishes normally (i.e., no break occurred).

Code Example: loop_else.py

# Check if number is prime
num = 17
for i in range(2, num):
    if num % i == 0:
        print(f"{num} is not prime")
        break
else:
    print(f"{num} is prime")  # Executes if no break occurred

for i in range(1, 10, 3):
    if i == 7:
        break
    print(i, end=" ")
else:
    print("done")

1 4

Practice Problems

Try these problems to solidify your understanding. These cover all topics in this chapter and are similar to CBSE board exam questions.

1. Variables & Input: Write a program to input the radius of a circle and display its area and circumference.
2. Conditionals: Write a program to input three numbers and print the largest of the three.
3. for Loop: Print the Fibonacci series up to n terms (input n from user).
4. while Loop: Find the factorial of a given number using a while loop.
5. break: Input numbers from user repeatedly until a negative number is entered. Print the sum of all positive numbers entered.
6. continue: Print all numbers from 1 to 50 that are NOT divisible by 3 or 5.
7. Loop else: Write a program to check if a number is prime using the loop-else construct.
8. Nested Loops: Print a right-angled triangle pattern of numbers (1 on row 1, 1 2 on row 2, etc.).
9. String Operations: Input a string. Count and display the number of vowels and consonants in it.
10. Type Casting: Input marks of 5 subjects (as strings). Convert, calculate percentage, and display with grade using if-elif.

Quick Reference

Input/Output:

• input() — Read input as string
• print() — Display output

Type Conversion:

• int(x) — to integer
• float(x)— to float
• str(x) — to string
• bool(x) — to boolean
• list(x) — to list
• tuple(x) — to tuple

Common Functions:

• type(x) — Get data type
• len(x) — Get length
• range(x) — Generate sequence of numbers
• abs(x) — Absolute val

Math Module:

• Import first: import math
• math.sqrt(), math.pow(), math.ceil(), math.floor(), math.factorial()

Loop Control:

• break — Exit loop
• continue — Skip to next iteration
• pass — Do nothing (placeholder)
• else — After loop

Operators:

• // — floor division
• % — modulus
• ** — exponent
• and, or, not
• == (equal), != (neq)