The world's most popular beginner-friendly programming language

Python is a general-purpose programming language that prioritizes readability and simplicity. It uses indentation instead of curly braces, making code look clean and consistent.

What Do These Terms Mean?

x = 10        # x is an int
x = "hello"   # now x is a str ✅

if age >= 18:
    print("You can vote!")
else:
    print("Too young to vote")

if (age >= 18) {
    System.out.println("You can vote!");
} else {
    System.out.println("Too young to vote");
}

Notice: Python has no semicolons, no curly braces, no boilerplate — just clean logic.

Where is Python used?

Step 1 — Install Python

python3 --version
# Python 3.12.x

Step 2 — Choose an Editor

Step 3 — Your First Program 🎉

# hello.py — your very first Python program
print("Hello, World!")
print("Welcome to Python 🐍")

Hello, World!
Welcome to Python 🐍

🧪 What is Jupyter Notebook?

Jupyter Notebook is an interactive coding environment where you write and run Python in small chunks called cells — instead of writing an entire .py file. You see the output immediately below each cell, making it perfect for learning, experimentation, and data analysis.

How to Get Jupyter

pip install notebook
jupyter notebook

How It Works — Cell by Cell

In Jupyter, you write code in cells and press Shift + Enter to run each one. The output appears right below:

name = "Alice"
age = 25
print(f"Hi, I'm {name} and I'm {age} years old")

# Variables from Cell 1 are still available
birth_year = 2026 - age
print(f"{name} was born in {birth_year}")

Jupyter Cell Types

A variable is a named container that stores a value. In Python, you don't need to declare the type — Python figures it out automatically (dynamic typing).

# Creating variables — no type declaration needed!
name = "Alice"         # str  (text)
age = 25                # int  (whole number)
height = 5.6            # float (decimal number)
is_student = True       # bool (True/False)

print(name, age, height, is_student)
# Alice 25 5.6 True

Core Data Types

Type Checking & Conversion

# Check the type of a variable
x = 42
print(type(x))       # <class 'int'>

# Convert between types (type casting)
num_str = "100"
num_int = int(num_str)     # str → int
num_float = float(num_str) # str → float
back_to_str = str(42)     # int → str

print(num_int, num_float, back_to_str)
# 100 100.0 42

Variable Naming Rules

my_name = "Alice"
age2 = 25
_private = "secret"
MAX_SIZE = 100

# 2name = "Bob"    ← starts with number
# my-name = "Eve"  ← has hyphen
# class = "Math"   ← reserved keyword
# my name = "Pat"  ← has space

Convention: Use snake_case for variables and functions in Python (e.g., student_name, not studentName).

🔤 Strings — Working with Text

Strings (str) are sequences of characters. Python makes it easy to create, combine, and manipulate them.

# Creating strings
single = 'Hello'
double = "World"
multi = """This is a
multi-line string"""

# Concatenation (joining)
greeting = single + " " + double
print(greeting)    # Hello World

# Repetition
print("Ha" * 3)    # HaHaHa

# Length
print(len(greeting))  # 11

f-Strings (Formatted Strings) ⭐

The modern, recommended way to embed variables inside strings:

name = "Alice"
age = 25
city = "Hyderabad"

# f-string — put f before the quote, use {variable}
print(f"My name is {name}, I'm {age} years old")
# My name is Alice, I'm 25 years old

# You can even put expressions inside {}
print(f"Next year I'll be {age + 1}")
# Next year I'll be 26

Useful String Methods

text = "  Hello, Python World!  "

print(text.strip())       # "Hello, Python World!"  (remove spaces)
print(text.lower())       # "  hello, python world!  "
print(text.upper())       # "  HELLO, PYTHON WORLD!  "
print(text.replace("Python", "Java"))  # "  Hello, Java World!  "
print(text.split(","))     # ['  Hello', ' Python World!  ']
print("Python" in text)  # True

String Indexing & Slicing

Every character in a string has a position number (index). Slicing lets you extract a portion of the string using the syntax [start:stop:step].

📍 Indexing — Accessing One Character

word = "PYTHON"
#        P  Y  T  H  O  N
# Index: 0  1  2  3  4  5
# Neg:  -6 -5 -4 -3 -2 -1

print(word[0])      # P   (first character)
print(word[3])      # H   (4th character)
print(word[-1])     # N   (last character)
print(word[-2])     # O   (second from end)

✂️ Slicing — [start : stop : step]

Slicing extracts a substring. The syntax has 3 parts:

word = "PYTHON"

# [start:stop] — from start up to (but NOT including) stop
print(word[0:3])    # PYT   (index 0, 1, 2 — stop at 3)
print(word[2:5])    # THO   (index 2, 3, 4)

# Omit start → starts from beginning
print(word[:4])     # PYTH  (first 4 characters)

# Omit stop → goes to the end
print(word[2:])     # THON  (from index 2 to end)

# Both omitted → entire string
print(word[:])      # PYTHON (full copy)

🦘 Using Step

word = "PYTHON"

# [::step] — skip characters
print(word[::2])    # PTO   (every 2nd character: P_T_O_)
print(word[::3])    # PH    (every 3rd character: P__H__)

# Negative step → go BACKWARDS
print(word[::-1])   # NOHTYP  (reversed!)
print(word[::-2])   # NHY     (reversed, every 2nd)

# Combine start:stop:step
print(word[1:5:2])  # YH      (index 1 to 4, every 2nd)

📝 More Slicing Examples

msg = "Hello, World!"

print(msg[0:5])       # Hello
print(msg[7:])        # World!
print(msg[-6:])       # orld!
print(msg[-6:-1])     # orld

# Check if palindrome
word = "madam"
print(word == word[::-1])   # True ✅ (it's a palindrome!)

name = "Alice"

# ❌ This will CRASH — strings can't be changed in place
name[0] = "B"
# TypeError: 'str' object does not support item assignment

name = "Alice"

# ✅ Create a NEW string using concatenation
new_name = "B" + name[1:]
print(new_name)    # Blice

# ✅ Or use replace() — also creates a new string
new_name = name.replace("A", "B")
print(new_name)    # Blice

# The original is UNCHANGED
print(name)        # Alice  (still the same!)

So far we've seen simple values like int, str, bool. But real programs need to store collections of data. Python gives you four built-in data structures, each designed for different situations.

Key Terms

The Big Picture

📋 1. Lists — Ordered & Mutable

A list is like a shopping cart — you can add, remove, reorder, and change items anytime.

# Creating lists
fruits = ["apple", "banana", "cherry", "mango"]
numbers = [10, 20, 30, 40, 50]
mixed = ["Alice", 25, True, 3.14]  # different types OK!
empty = []                            # empty list

# Accessing by index (0-based)
print(fruits[0])      # apple   (first)
print(fruits[-1])     # mango   (last)
print(fruits[1:3])    # ['banana', 'cherry']  (slice)

# Check if item exists
print("banana" in fruits)   # True
print("grape" in fruits)    # False

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

# ➕ Adding items
fruits.append("mango")          # Add to end
fruits.insert(1, "kiwi")        # Add at index 1
fruits.extend(["grape", "fig"]) # Add multiple items
print(fruits)
# ['apple', 'kiwi', 'banana', 'cherry', 'mango', 'grape', 'fig']

# ➖ Removing items
fruits.remove("banana")        # Remove by value (first match)
popped = fruits.pop()          # Remove & return last item
fruits.pop(0)                   # Remove by index
print(f"Popped: {popped}")    # Popped: fig

# ✏️ Changing items
fruits[0] = "blueberry"       # Replace at index

# 📏 Length
print(len(fruits))             # number of items

numbers = [5, 2, 8, 1, 9, 3]

# Sorting
print(sorted(numbers))       # [1, 2, 3, 5, 8, 9]  (new list)
numbers.sort()                # sorts in-place (modifies original)
numbers.sort(reverse=True)   # descending: [9, 8, 5, 3, 2, 1]

# Reversing
numbers.reverse()             # reverses in-place

# Math on lists
print(sum(numbers))          # 28
print(min(numbers))          # 1
print(max(numbers))          # 9
print(numbers.count(5))     # 1  (how many times 5 appears)
print(numbers.index(8))     # position of first 8

# Joining lists
a = [1, 2]
b = [3, 4]
print(a + b)                 # [1, 2, 3, 4]
print(a * 3)                 # [1, 2, 1, 2, 1, 2]

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

# With filter: only even numbers
nums = [1, 2, 3, 4, 5, 6, 7, 8]
evens = [x for x in nums if x % 2 == 0]
print(evens)      # [2, 4, 6, 8]

# Transform: uppercase each fruit
fruits = ["apple", "banana", "cherry"]
upper = [f.upper() for f in fruits]
print(upper)      # ['APPLE', 'BANANA', 'CHERRY']

# Nested: flatten a 2D list
matrix = [[1, 2], [3, 4], [5, 6]]
flat = [n for row in matrix for n in row]
print(flat)       # [1, 2, 3, 4, 5, 6]

📌 2. Tuples — Ordered & Immutable

A tuple is like a sealed envelope — once created, you cannot change its contents. Use it for data that should stay fixed.

# Creating tuples
coordinates = (10, 20)
colors = ("red", "green", "blue")
singleton = (42,)         # ⚠️ single-element tuple needs a comma!
from_list = tuple([1, 2, 3])  # convert list → tuple

# Accessing (same as list)
print(colors[0])       # red
print(colors[-1])      # blue
print(colors[0:2])     # ('red', 'green')
print(len(colors))      # 3
print("red" in colors)  # True

# Unpacking — assign each element to a variable
point = (10, 20, 30)
x, y, z = point
print(f"x={x}, y={y}, z={z}")   # x=10, y=20, z=30

# Swap two variables (Python magic!)
a = 5
b = 10
a, b = b, a
print(a, b)    # 10 5

# Return multiple values from a function
def get_min_max(numbers):
    return min(numbers), max(numbers)

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

# Star unpacking — grab the rest
first, *middle, last = (1, 2, 3, 4, 5)
print(first, middle, last)  # 1 [2, 3, 4] 5

🎯 3. Sets — Unordered & Unique

A set is like a bag of unique items — no duplicates allowed, and there's no fixed order.

# Creating sets
unique_nums = {1, 2, 3, 4, 5}
vowels = {"a", "e", "i", "o", "u"}
empty_set = set()   # ⚠️ NOT {} — that creates an empty dict!

# 🔥 Killer feature: auto-remove duplicates
names = ["Alice", "Bob", "Alice", "Charlie", "Bob"]
unique_names = set(names)
print(unique_names)   # {'Alice', 'Bob', 'Charlie'}

# Convert back to list if needed
unique_list = list(unique_names)
print(unique_list)    # ['Alice', 'Bob', 'Charlie']

skills = {"Python", "SQL", "Excel"}

# ➕ Adding
skills.add("Tableau")          # add one item
skills.update(["R", "Java"])  # add multiple items

# ➖ Removing
skills.discard("Excel")       # remove (no error if missing)
skills.remove("SQL")          # remove (KeyError if missing!)

# 🔍 Membership test — SUPER FAST (O(1))
print("Python" in skills)    # True
print("C++" in skills)       # False

frontend = {"HTML", "CSS", "JavaScript", "React"}
backend = {"Python", "JavaScript", "SQL", "Django"}

# Union — all skills from both (no duplicates)
all_skills = frontend | backend
print(all_skills)
# {'HTML', 'CSS', 'JavaScript', 'React', 'Python', 'SQL', 'Django'}

# Intersection — skills in BOTH
common = frontend & backend
print(common)          # {'JavaScript'}

# Difference — in frontend but NOT in backend
only_front = frontend - backend
print(only_front)      # {'HTML', 'CSS', 'React'}

# Symmetric difference — in one but NOT both
exclusive = frontend ^ backend
print(exclusive)
# {'HTML', 'CSS', 'React', 'Python', 'SQL', 'Django'}

# A frozenset is an immutable set — cannot add/remove items
constants = frozenset([3.14, 2.718, 1.618])
print(3.14 in constants)  # True

# Can be used as dictionary keys or inside other sets
pair = frozenset([1, 2])
my_dict = {pair: "a pair"}  # ✅ works!

📖 4. Dictionaries — Key-Value Pairs

A dictionary is like a phone book — you look up a name (key) to find a number (value). Every key must be unique.

# Creating a dictionary
student = {
    "name": "Alice",
    "age": 25,
    "city": "Hyderabad",
    "courses": ["Python", "Data Science"]
}

# Accessing values
print(student["name"])                 # Alice
print(student.get("age"))               # 25
print(student.get("phone", "N/A"))    # N/A  (default if missing)
print(student["courses"][0])           # Python  (nested access)

student = {"name": "Alice", "age": 25}

# ➕ Adding / Updating
student["email"] = "alice@email.com"   # add new key
student["age"] = 26                     # update existing
student.update({"city": "Mumbai", "gpa": 3.8})  # add multiple

# ➖ Removing
del student["email"]                   # delete key
removed = student.pop("gpa")           # remove & return value
print(f"Removed GPA: {removed}")       # 3.8

# 📏 Info
print(len(student))                    # number of keys
print("name" in student)              # True

scores = {"Math": 90, "Science": 85, "English": 78}

# Loop through keys
for subject in scores:
    print(subject)                # Math, Science, English

# Loop through values
for marks in scores.values():
    print(marks)                  # 90, 85, 78

# Loop through key-value pairs ⭐
for subject, marks in scores.items():
    print(f"{subject}: {marks}")

# Math: 90
# Science: 85
# English: 78

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

# Filter: only passing scores
scores = {"Math": 90, "Art": 45, "Science": 85, "PE": 30}
passed = {k: v for k, v in scores.items() if v >= 50}
print(passed)    # {'Math': 90, 'Science': 85}

# Swap keys and values
swapped = {v: k for k, v in scores.items()}
print(swapped)   # {90: 'Math', 45: 'Art', 85: 'Science', 30: 'PE'}

# A dictionary of dictionaries
classroom = {
    "Alice": {"age": 25, "grade": "A"},
    "Bob":   {"age": 22, "grade": "B"},
    "Charlie": {"age": 23, "grade": "A"}
}

# Access nested value
print(classroom["Alice"]["grade"])  # A

# Loop through nested dict
for name, info in classroom.items():
    print(f"{name}: age {info['age']}, grade {info['grade']}")

🔤 Bonus: Strings Are Sequences Too!

Strings behave like immutable lists of characters — you can index, slice, and loop through them.

word = "PYTHON"

print(word[0])      # P
print(word[-1])     # N
print(word[1:4])    # YTH
print(len(word))     # 6

for ch in word:
    print(ch, end=" ")
# P Y T H O N

🔢 Bonus: range() — Generate Number Sequences

range() produces a sequence of numbers on the fly — it doesn't store them all in memory, making it very efficient. You'll use it constantly with for loops.

# range(stop) — 0 to stop-1
print(list(range(5)))
# [0, 1, 2, 3, 4]

# range(start, stop) — start to stop-1
print(list(range(2, 8)))
# [2, 3, 4, 5, 6, 7]

# range(start, stop, step) — with custom step
print(list(range(0, 20, 3)))
# [0, 3, 6, 9, 12, 15, 18]

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

# Even numbers from 2 to 10
print(list(range(2, 11, 2)))
# [2, 4, 6, 8, 10]

Common Uses with Loops

# Repeat something 5 times
for i in range(5):
    print(f"Attempt {i + 1}")

# Loop with index over a list
fruits = ["apple", "banana", "cherry"]
for i in range(len(fruits)):
    print(f"{i}: {fruits[i]}")
# 0: apple
# 1: banana
# 2: cherry

# Quick sum: 1 + 2 + ... + 100
total = sum(range(1, 101))
print(total)   # 5050

🧭 When to Use What? — Decision Guide

Decision Flowchart

Converting Between Types

# List ↔ Tuple ↔ Set
my_list = [1, 2, 2, 3, 3, 3]

my_tuple = tuple(my_list)    # (1, 2, 2, 3, 3, 3)
my_set = set(my_list)        # {1, 2, 3}  — duplicates removed!
back_to_list = list(my_set)  # [1, 2, 3]

# Dict keys/values to list
d = {"a": 1, "b": 2}
print(list(d.keys()))     # ['a', 'b']
print(list(d.values()))   # [1, 2]
print(list(d.items()))    # [('a', 1), ('b', 2)]

Operators let you perform calculations, comparisons, and logical operations.

Arithmetic Operators

a = 15
b = 4

print(a + b)    # 19   Addition
print(a - b)    # 11   Subtraction
print(a * b)    # 60   Multiplication
print(a / b)    # 3.75 Division (always float)
print(a // b)   # 3    Floor division (integer)
print(a % b)    # 3    Modulus (remainder)
print(a ** b)   # 50625  Exponent (15^4)

Comparison Operators

These return True or False:

x = 10
y = 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?)
print(x <= y)   # True   (less or equal?)
print(x >= y)   # False  (greater or equal?)

Logical Operators

a = True
b = False

print(a and b)  # False  (both must be True)
print(a or b)   # True   (at least one True)
print(not a)     # False  (flip the value)

print() — Showing Output

# Basic print
print("Hello!")

# Multiple values
print("Age:", 25, "City:", "Mumbai")
# Age: 25 City: Mumbai

# Custom separator
print("A", "B", "C", sep="-")
# A-B-C

# Prevent new line at end
print("Loading", end="...")
print("Done!")
# Loading...Done!

input() — Getting User Input

# input() always returns a STRING
name = input("What's your name? ")
print(f"Hello, {name}!")

# For numbers, you must convert!
age = int(input("Enter your age: "))
year = 2026 - age
print(f"You were born around {year}")

Conditionals let your program choose different paths based on conditions.

age = 18

if age >= 18:
    print("You can vote! ✅")
elif age >= 16:
    print("Almost there! 🔜")
else:
    print("Too young to vote ❌")

Nested Conditions

score = 85

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:
    grade = "F"

print(f"Score: {score} → Grade: {grade}")
# Score: 85 → Grade: B

Combining Conditions

age = 25
has_license = True

if age >= 18 and has_license:
    print("You can drive! 🚗")

# Ternary (one-liner)
status = "adult" if age >= 18 else "minor"
print(status)  # adult

match-case — Python's Switch Statement (3.10+)

match-case is Python's version of a switch statement. It takes a value and checks it against multiple patterns — when a pattern matches, that block runs. Think of it as a cleaner alternative to writing long if-elif-elif-else chains when you're comparing one variable against many possible values.

command = "start"

match command:
    case "start":
        print("Starting the engine... 🚀")
    case "stop":
        print("Stopping the engine... 🛑")
    case "pause":
        print("Pausing... ⏸️")
    case _:
        print("Unknown command ❓")

# Starting the engine... 🚀

Matching with Patterns

# Match numbers
status_code = 404

match status_code:
    case 200:
        print("OK ✅")
    case 301 | 302:
        print("Redirect ↪️")
    case 404:
        print("Not Found 🔍")
    case 500:
        print("Server Error 💥")
    case _:
        print(f"Status: {status_code}")

# Not Found 🔍

for Loop — Iterate Over a Sequence

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

# I like apple
# I like banana
# I like cherry

range() — Generate Number Sequences

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

# Count by 2s
for i in range(0, 10, 2):
    print(i, end=" ")
# 0 2 4 6 8

while Loop — Repeat Until a Condition is False

count = 1
while count <= 5:
    print(f"Count: {count}")
    count += 1

# Count: 1
# Count: 2
# Count: 3
# Count: 4
# Count: 5

break & continue

for i in range(10):
    if i == 5:
        break
    print(i, end=" ")
# 0 1 2 3 4

for i in range(6):
    if i == 3:
        continue
    print(i, end=" ")
# 0 1 2 4 5

Functions let you write code once and use it many times. They take inputs (parameters), do something, and optionally return a result.

# Define a function
def greet(name):
    return f"Hello, {name}! 👋"

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

Parameters & Default Values

def introduce(name, age, city="Unknown"):
    print(f"{name} is {age} years old, from {city}")

introduce("Alice", 25, "Mumbai")
# Alice is 25 years old, from Mumbai

introduce("Bob", 30)
# Bob is 30 years old, from Unknown

Multiple Return Values

def calculate(a, b):
    return a + b, a - b, a * b

sum_val, diff, product = calculate(10, 3)
print(f"Sum: {sum_val}, Diff: {diff}, Product: {product}")
# Sum: 13, Diff: 7, Product: 30

x = 10  # Global variable

def my_func():
    x = 5  # Local variable (different from global x)
    print(f"Inside function: {x}")

my_func()
print(f"Outside function: {x}")
# Inside function: 5
# Outside function: 10

Python can read from and write to files on your computer. This is how you save data, load datasets, generate reports, and process logs.

Opening Files — The with Statement

Always use with to open files — it automatically closes the file when done, even if an error occurs.

Writing to a File

# Create and write to a file
with open("notes.txt", "w") as f:
    f.write("Hello from Python!\n")
    f.write("This is line 2.\n")
    f.write("This is line 3.\n")

# Append (add to end without erasing)
with open("notes.txt", "a") as f:
    f.write("This line was appended.\n")

Reading from a File

# Read entire file as one string
with open("notes.txt", "r") as f:
    content = f.read()
    print(content)

# Read line by line (memory efficient for big files)
with open("notes.txt", "r") as f:
    for line in f:
        print(line.strip())   # strip() removes \n

# Read all lines into a list
with open("notes.txt", "r") as f:
    lines = f.readlines()
    print(lines)
# ['Hello from Python!\n', 'This is line 2.\n', ...]

# Write student scores
with open("scores.csv", "w") as f:
    f.write("Name,Math,Science\n")
    f.write("Alice,90,85\n")
    f.write("Bob,78,92\n")
    f.write("Charlie,88,76\n")

# Read and process
with open("scores.csv", "r") as f:
    header = f.readline()  # skip header
    for line in f:
        parts = line.strip().split(",")
        name = parts[0]
        avg = (int(parts[1]) + int(parts[2])) / 2
        print(f"{name}: average = {avg}")

# Alice: average = 87.5
# Bob: average = 85.0
# Charlie: average = 82.0

Errors (exceptions) happen — a file might not exist, a user might type "abc" instead of a number, or a network call might fail. Error handling lets your program recover gracefully instead of crashing.

Basic try / except

# Without error handling — CRASHES
# num = int("hello")  → ValueError!

# With error handling — recovers gracefully
try:
    num = int(input("Enter a number: "))
    print(f"You entered: {num}")
except ValueError:
    print("That's not a valid number! ❌")

How It Works

try:
    # risky code
except ErrorType:
    # handle that error
else:
    # runs if NO error
finally:
    # ALWAYS runs

Common Exception Types

Catching Multiple Exceptions

try:
    x = int(input("Enter a number: "))
    result = 100 / x
    print(f"Result: {result}")
except ValueError:
    print("Not a number!")
except ZeroDivisionError:
    print("Can't divide by zero!")
except Exception as e:
    print(f"Something went wrong: {e}")
else:
    print("Everything worked! ✅")
finally:
    print("This always runs (cleanup)")

def read_file_safe(filename):
    try:
        with open(filename, "r") as f:
            return f.read()
    except FileNotFoundError:
        print(f"❌ File '{filename}' not found")
        return None

content = read_file_safe("data.txt")
if content:
    print(content)
else:
    print("Using default data instead")

A module is a Python file containing functions, classes, and variables that you can import and reuse. Packages are folders of modules. Python comes with hundreds of built-in modules, and you can install thousands more.

Importing Modules

# Import entire module
import math
print(math.sqrt(144))     # 12.0
print(math.pi)              # 3.141592653589793

# Import specific function
from math import sqrt, pi
print(sqrt(64))             # 8.0
print(pi)                   # 3.14...

# Import with alias
import math as m
print(m.floor(3.7))         # 3
print(m.ceil(3.2))          # 4

Useful Built-in Modules

The random Module — Examples

import random

# Random integer between 1 and 10
print(random.randint(1, 10))

# Random float between 0 and 1
print(random.random())

# Pick a random item from a list
colors = ["red", "blue", "green"]
print(random.choice(colors))

# Shuffle a list in place
cards = [1, 2, 3, 4, 5]
random.shuffle(cards)
print(cards)  # e.g. [3, 1, 5, 2, 4]

Installing External Packages (pip)

# Install a package from PyPI (Python Package Index)
pip install requests
pip install pandas numpy matplotlib

# Then use in your code
import requests
response = requests.get("https://api.github.com")
print(response.json())

%%writefile myutils.py
# myutils.py — your custom module

def greet(name):
    return f"Hello, {name}! 👋"

def add(a, b):
    return a + b

PI = 3.14159

# Import and use your module
from myutils import greet, add, PI

print(greet("Alice"))   # Hello, Alice! 👋
print(add(10, 20))       # 30
print(PI)                # 3.14159

These two libraries are the foundation of Data Science in Python. NumPy handles numerical arrays, and Pandas handles tabular data (like Excel/CSV).

🔢 NumPy — Numerical Python

NumPy gives you arrays — like lists but much faster for math. All elements must be the same type.

import numpy as np

# Create arrays
a = np.array([1, 2, 3, 4, 5])
print(a)           # [1 2 3 4 5]
print(type(a))      # <class 'numpy.ndarray'>

# Math on entire array at once (vectorized — no loops needed!)
print(a * 2)        # [ 2  4  6  8 10]
print(a + 10)       # [11 12 13 14 15]
print(a ** 2)       # [ 1  4  9 16 25]

# Useful functions
print(np.mean(a))    # 3.0   (average)
print(np.sum(a))     # 15    (total)
print(np.std(a))     # 1.41  (standard deviation)
print(np.max(a))     # 5
print(np.min(a))     # 1

Creating Special Arrays

print(np.zeros(5))          # [0. 0. 0. 0. 0.]
print(np.ones(3))           # [1. 1. 1.]
print(np.arange(0, 10, 2))  # [0 2 4 6 8]
print(np.linspace(0, 1, 5)) # [0. 0.25 0.5 0.75 1.]
print(np.random.randint(1, 100, 5))  # 5 random ints

2D Arrays (Matrices)

matrix = np.array([
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
])

print(matrix.shape)       # (3, 3)  — 3 rows, 3 cols
print(matrix[0])          # [1 2 3]  — first row
print(matrix[1, 2])       # 6  — row 1, col 2
print(matrix.sum())       # 45  — sum of all
print(matrix.sum(axis=0))  # [12 15 18]  — column sums
print(matrix.sum(axis=1))  # [ 6 15 24]  — row sums

🐼 Pandas — DataFrames for Tabular Data

Pandas gives you DataFrames — like Excel spreadsheets in Python. Each column is a Series, and the whole table is a DataFrame.

import pandas as pd

# Create a DataFrame from a dictionary
data = {
    "Name": ["Alice", "Bob", "Charlie", "Diana"],
    "Age": [25, 30, 22, 28],
    "City": ["Mumbai", "Delhi", "Hyderabad", "Chennai"],
    "Score": [92, 78, 88, 95]
}

df = pd.DataFrame(data)
print(df)

      Name  Age       City  Score
0    Alice   25     Mumbai     92
1      Bob   30      Delhi     78
2  Charlie   22  Hyderabad     88
3    Diana   28    Chennai     95

Exploring Data

print(df.head())          # first 5 rows
print(df.tail(2))         # last 2 rows
print(df.shape)            # (4, 4) — 4 rows, 4 cols
print(df.columns)          # column names
print(df.describe())      # statistics (mean, std, min, max)
print(df.info())           # data types and null counts

Selecting Data

# Select a column (returns a Series)
print(df["Name"])

# Select multiple columns
print(df[["Name", "Score"]])

# Filter rows — students with score > 85
top_students = df[df["Score"] > 85]
print(top_students)
#       Name  Age       City  Score
# 0    Alice   25     Mumbai     92
# 2  Charlie   22  Hyderabad     88
# 3    Diana   28    Chennai     95

Adding & Modifying Columns

# Add a new column
df["Pass"] = df["Score"] >= 80

# Calculated column
df["Grade"] = df["Score"].apply(
    lambda x: "A" if x >= 90 else "B" if x >= 80 else "C"
)

print(df)

      Name  Age       City  Score   Pass Grade
0    Alice   25     Mumbai     92   True     A
1      Bob   30      Delhi     78  False     C
2  Charlie   22  Hyderabad     88   True     B
3    Diana   28    Chennai     95   True     A

%%writefile students.csv
Name,Age,City,Score,Subject
Alice,25,Mumbai,92,Math
Bob,30,Delhi,78,Science
Charlie,22,Hyderabad,88,Math
Diana,28,Chennai,95,Science
Eve,24,Mumbai,67,English
Frank,26,Delhi,91,Math
Grace,21,Hyderabad,83,English
Hiro,29,Chennai,74,Science
Ivy,23,Mumbai,96,Math
Jay,27,Delhi,59,English
Kavya,22,Hyderabad,88,Science
Leo,25,Chennai,72,Math
Meera,24,Mumbai,85,English
Nikhil,28,Delhi,93,Science
Olivia,21,Hyderabad,77,Math

import pandas as pd

# Read the CSV file into a DataFrame
df = pd.read_csv("students.csv")

# Quick look
print(df.head())          # first 5 rows
print(df.shape)            # (15, 5) — 15 rows, 5 columns
print(df.describe())      # statistics for numeric columns
print(df.info())           # data types and null check

# Filter — students who scored above 90
toppers = df[df["Score"] > 90]
print(toppers)

# Sort by score (highest first)
sorted_df = df.sort_values("Score", ascending=False)
print(sorted_df.head())

# Save filtered results to a new CSV
toppers.to_csv("toppers.csv", index=False)

print(df["Score"].mean())    # 88.25  (average)
print(df["Score"].median())  # 90.0   (middle value)
print(df["Score"].std())     # 7.27   (spread)
print(df["Score"].max())     # 95
print(df["Score"].min())     # 78

# Group by city and get average score
print(df.groupby("City")["Score"].mean())

# Value counts — how many from each city?
print(df["City"].value_counts())

Let's put everything together! You'll build a simple movie recommendation system using Python, Pandas, and everything you've learned. We'll create a movie dataset, explore it, filter it, and build a basic recommender.

📦 Step 1 — Create the Movie Dataset

Run this cell in Jupyter to create a CSV file with 20 movies:

%%writefile movies.csv
Title,Genre,Rating,Runtime,Year,Director
The Shawshank Redemption,Drama,9.3,142,1994,Frank Darabont
The Dark Knight,Action,9.0,152,2008,Christopher Nolan
Inception,Sci-Fi,8.8,148,2010,Christopher Nolan
Pulp Fiction,Crime,8.9,154,1994,Quentin Tarantino
Forrest Gump,Drama,8.8,142,1994,Robert Zemeckis
The Matrix,Sci-Fi,8.7,136,1999,Wachowski Sisters
Interstellar,Sci-Fi,8.6,169,2014,Christopher Nolan
The Godfather,Crime,9.2,175,1972,Francis Ford Coppola
Fight Club,Drama,8.8,139,1999,David Fincher
The Lion King,Animation,8.5,88,1994,Roger Allers
Toy Story,Animation,8.3,81,1995,John Lasseter
Avengers: Endgame,Action,8.4,181,2019,Russo Brothers
Joker,Drama,8.4,122,2019,Todd Phillips
Parasite,Thriller,8.5,132,2019,Bong Joon-ho
Spider-Man: No Way Home,Action,8.3,148,2021,Jon Watts
Dune,Sci-Fi,8.0,155,2021,Denis Villeneuve
Coco,Animation,8.4,105,2017,Lee Unkrich
The Prestige,Thriller,8.5,130,2006,Christopher Nolan
Whiplash,Drama,8.5,107,2014,Damien Chazelle
Up,Animation,8.3,96,2009,Pete Docter

This creates movies.csv with 20 movies, 6 columns. Now let's explore!

🔍 Step 2 — Load & Explore the Data

import pandas as pd

df = pd.read_csv("movies.csv")

# First look
print(df.head())
print(f"\nTotal movies: {len(df)}")
print(f"Columns: {list(df.columns)}")
print(f"\nData types:\n{df.dtypes}")
print(f"\nBasic stats:\n{df.describe()}")

❓ Step 3 — Answer Questions with Code

Now let's answer real questions about our movies. Try each one yourself before looking at the solution!

# Filter: runtime > 90 minutes
long_movies = df[df["Runtime"] > 90]
print(f"Movies longer than 90 min: {len(long_movies)} out of {len(df)}")
print(long_movies[["Title", "Runtime", "Genre"]])

Movies longer than 90 min: 17 out of 20

                         Title  Runtime    Genre
0   The Shawshank Redemption      142    Drama
1           The Dark Knight      152   Action
2                 Inception      148   Sci-Fi
...  (and 14 more)

# Top-rated movies (rating > 8.5)
top_rated = df[df["Rating"] > 8.5].sort_values("Rating", ascending=False)
print(top_rated[["Title", "Rating", "Year"]])

                       Title  Rating  Year
The Shawshank Redemption      9.3  1994
The Godfather                 9.2  1972
The Dark Knight               9.0  2008
Pulp Fiction                  8.9  1994
Inception                     8.8  2010
Forrest Gump                  8.8  1994
Fight Club                    8.8  1999
The Matrix                    8.7  1999
Interstellar                  8.6  2014

# Count movies by genre
genre_counts = df["Genre"].value_counts()
print(genre_counts)

Drama        5
Sci-Fi       4
Animation    4
Action       3
Crime        2
Thriller     2

# Filter by director
nolan = df[df["Director"] == "Christopher Nolan"]
print(f"Nolan has {len(nolan)} movies in our dataset:\n")
print(nolan[["Title", "Genre", "Rating", "Year"]])

Nolan has 4 movies in our dataset:

              Title    Genre  Rating  Year
The Dark Knight      Action    9.0  2008
Inception            Sci-Fi    8.8  2010
Interstellar         Sci-Fi    8.6  2014
The Prestige       Thriller    8.5  2006

# Filter by year range
movies_90s = df[(df["Year"] >= 1990) & (df["Year"] <= 1999)]
movies_90s = movies_90s.sort_values("Rating", ascending=False)
print(f"90s movies ({len(movies_90s)} found):\n")
print(movies_90s[["Title", "Rating", "Year"]])

90s movies (6 found):

                       Title  Rating  Year
The Shawshank Redemption      9.3  1994
Pulp Fiction                  8.9  1994
Forrest Gump                  8.8  1994
Fight Club                    8.8  1999
The Matrix                    8.7  1999
Toy Story                     8.3  1995

# Group by genre, calculate average rating
avg_by_genre = df.groupby("Genre")["Rating"].mean().sort_values(ascending=False)
print("Average rating by genre:\n")
for genre, avg in avg_by_genre.items():
    print(f"  {genre:12s} → {avg:.2f}")

Average rating by genre:

  Crime        → 9.05
  Drama        → 8.76
  Action       → 8.57
  Sci-Fi       → 8.53
  Thriller     → 8.50
  Animation    → 8.38

# Find extremes
longest = df.loc[df["Runtime"].idxmax()]
shortest = df.loc[df["Runtime"].idxmin()]

print(f"🏆 Longest:  {longest['Title']} ({longest['Runtime']} min)")
print(f"⚡ Shortest: {shortest['Title']} ({shortest['Runtime']} min)")
print(f"\n📏 Average runtime: {df['Runtime'].mean():.0f} min")

🏆 Longest:  Avengers: Endgame (181 min)
⚡ Shortest: Toy Story (81 min)

📏 Average runtime: 133 min

# Categorize movies by rating
def categorize(rating):
    if rating >= 9.0:
        return "🏆 Masterpiece"
    elif rating >= 8.5:
        return "⭐ Excellent"
    elif rating >= 8.0:
        return "👍 Great"
    else:
        return "👌 Good"

df["Category"] = df["Rating"].apply(categorize)
print(df[["Title", "Rating", "Category"]].head(10))

                       Title  Rating        Category
The Shawshank Redemption      9.3  🏆 Masterpiece
The Dark Knight               9.0  🏆 Masterpiece
Inception                     8.8  ⭐ Excellent
Pulp Fiction                  8.9  ⭐ Excellent
Forrest Gump                  8.8  ⭐ Excellent
The Matrix                    8.7  ⭐ Excellent
Interstellar                  8.6  ⭐ Excellent
The Godfather                 9.2  🏆 Masterpiece
Fight Club                    8.8  ⭐ Excellent
The Lion King                 8.5  ⭐ Excellent

🤖 Step 4 — Build a Simple Recommender

Now let's build a function that recommends movies based on what the user likes!

# Read the dataset first
df = pd.read_csv("movies.csv")

def recommend_movies(df, genre=None, min_rating=8.0, max_runtime=999, top_n=5):
    """Recommend movies based on filters."""
    result = df.copy()

    # Apply filters
    if genre:
        result = result[result["Genre"].str.lower() == genre.lower()]
    result = result[result["Rating"] >= min_rating]
    result = result[result["Runtime"] <= max_runtime]

    # Sort by rating and return top N
    result = result.sort_values("Rating", ascending=False).head(top_n)

    if len(result) == 0:
        print("No movies found matching your criteria 😞")
        return

    print(f"\n🎬 Recommended Movies ({len(result)} found):\n")
    for i, (_, movie) in enumerate(result.iterrows(), 1):
        print(f"  {i}. {movie['Title']}")
        print(f"     ⭐ {movie['Rating']} | ⏱️ {movie['Runtime']} min | 🎨 {movie['Genre']} | 📅 {movie['Year']}")
        print()

Try It Out!

# 🌟 Show me the best Sci-Fi movies
recommend_movies(df, genre="Sci-Fi")

🎬 Recommended Movies (4 found):

  1. Inception
     ⭐ 8.8 | ⏱️ 148 min | 🎨 Sci-Fi | 📅 2010

  2. The Matrix
     ⭐ 8.7 | ⏱️ 136 min | 🎨 Sci-Fi | 📅 1999

  3. Interstellar
     ⭐ 8.6 | ⏱️ 169 min | 🎨 Sci-Fi | 📅 2014

  4. Dune
     ⭐ 8.0 | ⏱️ 155 min | 🎨 Sci-Fi | 📅 2021

# 🎥 Short movies (under 2 hours) with great ratings
recommend_movies(df, min_rating=8.3, max_runtime=120)

🎬 Recommended Movies (4 found):

  1. The Lion King
     ⭐ 8.5 | ⏱️ 88 min | 🎨 Animation | 📅 1994

  2. Whiplash
     ⭐ 8.5 | ⏱️ 107 min | 🎨 Drama | 📅 2014

  3. Coco
     ⭐ 8.4 | ⏱️ 105 min | 🎨 Animation | 📅 2017

  4. Up
     ⭐ 8.3 | ⏱️ 96 min | 🎨 Animation | 📅 2009

# 🤠 Best Action movies
recommend_movies(df, genre="Action", top_n=3)

🎬 Recommended Movies (3 found):

  1. The Dark Knight
     ⭐ 9.0 | ⏱️ 152 min | 🎨 Action | 📅 2008

  2. Avengers: Endgame
     ⭐ 8.4 | ⏱️ 181 min | 🎨 Action | 📅 2019

  3. Spider-Man: No Way Home
     ⭐ 8.3 | ⏱️ 148 min | 🎨 Action | 📅 2021

🎯 Step 5 — Challenges (Try Yourself!)

These are open-ended — try solving them before peeking at the hints.

the_movies = df[df["Title"].str.contains("The")]
print(f"Movies with 'The' in title: {len(the_movies)}\n")
print(the_movies["Title"].tolist())

director_avg = df.groupby("Director")["Rating"].mean().sort_values(ascending=False)
print("Directors by average rating:\n")
print(director_avg.head(10))

df["Decade"] = (df["Year"] // 10) * 10
df["Decade"] = df["Decade"].apply(lambda d: f"{d}s")
print(df[["Title", "Year", "Decade"]])

# Movies per decade
print("\nMovies per decade:")
print(df["Decade"].value_counts().sort_index())

# Interactive version
print("\n🎬 Movie Recommender \n")
print("Available genres:", sorted(df["Genre"].unique()))

genre = input("\nEnter genre (or press Enter for all): ").strip()
min_r = input("Minimum rating (default 8.0): ").strip()
max_t = input("Max runtime in minutes (default any): ").strip()

recommend_movies(df,
    genre=genre if genre else None,
    min_rating=float(min_r) if min_r else 8.0,
    max_runtime=int(max_t) if max_t else 999
)

with open("movie_report.txt", "w") as f:
    f.write("=== MOVIE ANALYSIS REPORT ===\n\n")
    f.write(f"Total movies: {len(df)}\n")
    f.write(f"Average rating: {df['Rating'].mean():.2f}\n")
    f.write(f"Average runtime: {df['Runtime'].mean():.0f} min\n\n")

    f.write("Top 5 Movies:\n")
    top5 = df.sort_values("Rating", ascending=False).head(5)
    for _, m in top5.iterrows():
        f.write(f"  - {m['Title']} ({m['Rating']})\n")

print("✅ Report saved to movie_report.txt")

OOP lets you create your own data types by bundling data (attributes) and behavior (methods) together into a class. Think of a class as a blueprint, and objects as the actual things built from that blueprint.

Your First Class

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

    def introduce(self):
        return f"Hi, I'm {self.name}, age {self.age}, grade {self.grade}"

    def is_passing(self):
        return self.grade >= 50

s1 = Student("Alice", 25, 92)
s2 = Student("Bob", 22, 45)

print(s1.introduce())    # Hi, I'm Alice, age 25, grade 92
print(s2.is_passing())   # False
print(s1.name)            # Alice

Key Concepts

Inheritance

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

    def speak(self):
        return f"{self.name} says {self.sound}!"

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name, "Woof")
        self.breed = breed

    def fetch(self):
        return f"{self.name} fetches the ball! 🎾"

dog = Dog("Buddy", "Golden Retriever")
print(dog.speak())    # Buddy says Woof!
print(dog.fetch())    # Buddy fetches the ball! 🎾

class BankAccount:
    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}")

    def withdraw(self, amount):
        if amount > self.balance:
            print("❌ Insufficient funds!")
        else:
            self.balance -= amount
            print(f"✅ Withdrew ₹{amount}. Balance: ₹{self.balance}")

acc = BankAccount("Alice", 1000)
acc.deposit(500)     # ✅ Deposited ₹500. Balance: ₹1500
acc.withdraw(200)    # ✅ Withdrew ₹200. Balance: ₹1300
acc.withdraw(5000)   # ❌ Insufficient funds!

Try these exercises to test your understanding. Click each to reveal the solution.

def celsius_to_fahrenheit(celsius):
    return (celsius * 9/5) + 32

temp_c = float(input("Enter temperature in Celsius: "))
print(f"{temp_c}°C = {celsius_to_fahrenheit(temp_c)}°F")

num = int(input("Enter a number: "))
print(f"{num} is {'Even ✅' if num % 2 == 0 else 'Odd'}")

for i in range(1, 21):
    if i % 15 == 0: print("FizzBuzz")
    elif i % 3 == 0: print("Fizz")
    elif i % 5 == 0: print("Buzz")
    else: print(i)

numbers = [12, 5, 8, 23, 3, 17, 9]
total = 0
minimum = maximum = numbers[0]
for num in numbers:
    total += num
    if num < minimum: minimum = num
    if num > maximum: maximum = num
print(f"Sum:{total} Avg:{total/len(numbers)} Min:{minimum} Max:{maximum}")

students = {"Alice": 92, "Bob": 78, "Charlie": 95}
topper = max(students, key=students.get)
print(f"🏆 Topper: {topper} with {students[topper]} marks")

sentence = "the cat sat on the mat the cat smiled"
word_count = {}
for word in sentence.split():
    word_count[word] = word_count.get(word, 0) + 1
for w, c in word_count.items():
    print(f"{w}: {c}")

Quick Cheat Sheet