🐣 Never written code before? You're exactly who this guide is for.

Four habits make this course work without a teacher:

1️⃣ Click every "🎬 Try it" button. They're not decoration — watching a loop actually loop teaches more than reading about it ever will.

2️⃣ Read code out loud, top to bottom. Python runs one line at a time, like following a recipe. age = 21 reads as "put 21 into a box called age." If you can say a line in plain words, you understand it.

3️⃣ Take each section's quiz — a ✓ appears in the sidebar when you master it. Wrong answers show explanations; retry until it clicks. Nothing is graded, nobody is watching.

4️⃣ Type things in the ▶ Live Playground. It runs REAL Python in your browser. Break things on purpose — errors are free here, and reading error messages is a skill this course deliberately trains.

💡 Sections 1–10 are the heart of Python — go in order, one or two per sitting. Sections 11–19 are power-ups you can take slower. Nobody learns this in a day; everybody learns it by clicking around daily.

🎬 Try it — create the boxes

Click each button to "run" a line of Python and watch the variable box appear on the shelf.

name   = "Ravi"        # str  (text)
age    = 21            # int  (whole number)
gpa    = 8.7           # float (decimal)
passed = True          # bool (True / False)
marks  = [80, 92, 75]  # list (collection)

💡 Click a button again and its box just updates to the new value — reassigning a variable replaces whatever was there before (the old value is gone). Even marks counts as one value: the whole list lives in a single box.

The 5 core types you'll use every day

💡 Check any type with type(x) — e.g. type(21) → <class 'int'>

🎬 Try it — move the slider, watch the path light up

if marks >= 75:
    grade = "Distinction"
elif marks >= 50:
    grade = "Pass"
else:
    grade = "Fail"

marks = 65

💡 Python checks conditions top to bottom and runs only the first one that is True. Order matters!

Comparison operators

⚠️ Classic mistake: = assigns a value, == compares values.

🎬 Try it — step through the loop

marks = [80, 92, 75, 60, 88]
total = 0
for m in marks:      # m takes each value, one by one
    total = total + m
print(total)          # 395

💡 Data flow each iteration: m gets the next item → the loop body runs → repeat until the list is finished.

range() — loop a fixed number of times

for i in range(5):     # i = 0, 1, 2, 3, 4  (starts at 0, stops BEFORE 5)
    print("Hello", i)

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

💡 range(5) gives 0–4, not 1–5. "Start at 0, stop before the end" is everywhere in Python.

🎬 Try it — rocket countdown

count = 5
while count > 0:        # check condition first
    print(count)
    count = count - 1   # ⚠ must change, or loop runs forever!
print("Liftoff! 🚀")

⚠️ If you forget count = count - 1, the condition never becomes False → infinite loop. This is the #1 while-loop bug.

For vs While — which one?

💡 break exits any loop immediately; continue skips to the next iteration.

🎬 Try it — feed the machine

def add_marks(a, b):        # define: a, b are INPUTS (parameters)
    result = a + b
    return result           # OUTPUT goes back to the caller

total = add_marks(80, 92)   # call it → total becomes 172

a =   b =

💡 Define once, call many times. That's the whole point — no copy-pasting the same code.

The 4 pieces of a function

def greet(name):                 # 1️⃣ def + name + parameters
    message = "Hello, " + name    # 2️⃣ body (indented!)
    return message                # 3️⃣ return sends a value back

msg = greet("Priya")               # 4️⃣ call — "Priya" flows into name
print(msg)                        # Hello, Priya

⚠️ print() shows a value on screen; return hands it back to your code. They are NOT the same thing.

🎬 Try it — click an operation, watch the slots

fruits = ["apple", "banana", "mango", "grape"]

💡 Slicing rule: fruits[1:3] = start at index 1, stop before index 3 → 2 items.

List operations you'll use constantly

🎬 Try it — look up a key

student = {
    "name":  "Ravi",
    "age":   21,
    "grade": "A",
}
print(student["age"])   # 21

💡 Keys must be unique. Asking for a key that doesn't exist raises KeyError — use student.get("city", "N/A") for a safe default.

List vs Dictionary — when to use which?

🎬 Try it — slice the word

word = "PYTHON"

Everyday string tools

💡 f-strings are the modern way to build text: f"Total: {a + b}" even runs the math inside the braces.

🎬 Try it — safe number conversion

try:
    age = int(user_input)      # risky: what if it's not a number?
    print("Next year you'll be", age + 1)
except ValueError:
    print("That's not a number!")

user_input =

💡 Rule of thumb: wrap in try/except anything that depends on the outside world — user input, files, network, databases.

Common errors students meet first

🎬 Try it — the input() string trap

age = input("Your age: ")   # user types 5 → age is "5" (a STRING!)
print(age + 5)               # 💥 TypeError: str + int

age = int(input("Your age: "))  # ✅ convert first
print(age + 5)                  # 10

user types:

💡 Same idea for decimals: float(input()). Whatever comes from the keyboard, a file, or a network is text until YOU convert it.

print() tricks worth knowing

🎬 Tuple — locked after creation

point = (10, 20)          # round brackets = tuple
x, y = point               # unpacking: x=10, y=20 ✨
point[0] = 99              # 💥 TypeError!

💡 Use a tuple for things that should never change: coordinates, RGB colors, (day, month, year). The lock is a feature, not a limitation.

🎬 Set — duplicates bounce off

visitors = set()
visitors.add("ravi")
visitors.add("ravi")     # ignored — already there!
print(len(visitors))     # 1

💡 Instant use case: unique_visitors = set(visitor_list) — de-duplicate any list in one line. Membership tests (x in my_set) are also lightning fast.

The 4 containers side by side

🎬 Try it — watch numbers go through the pipeline

numbers = [1, 2, 3, 4, 5, 6]

# the loop way (4 lines):
result = []
for x in numbers:
    if x % 2 == 0:
        result.append(x * x)

# the comprehension way (1 line — SAME thing):
result = [x * x for x in numbers if x % 2 == 0]
#         ⬆ transform   ⬆ source      ⬆ filter

💡 Read it aloud: "x squared, for each x in numbers, if x is even." If a comprehension gets hard to read aloud, use a normal loop instead.

Comprehension recipes

🎬 Try it — sort students by different keys

students = [("Ravi", 80), ("Priya", 92), ("Amit", 45)]

sorted(students, key=lambda s: s[1])                # by marks ↑
sorted(students, key=lambda s: s[1], reverse=True)  # by marks ↓ (toppers first)
sorted(students, key=lambda s: s[0])                # by name A→Z

💡 Read lambda s: s[1] as: "given a student s, sort using s[1] (the marks)". That's all a lambda is — a mini function without a name.

lambda + friends

💡 Honest advice: for map/filter, most Pythonistas prefer list comprehensions (section 12). But key=lambda in sorting is used everywhere — master that one.

🎬 Try it — who can see whom?

x = 10                 # GLOBAL — everyone can read it
def calc():
    y = 5              # LOCAL — exists only inside calc()
    print(x + y)       # works: local y + global x
calc()                 # 15
print(y)               # 💥 NameError — y died when calc() ended!

💡 Lookup order = LEGB: Local → Enclosing → Global → Built-in. Python searches the nearest room first, then widens.

Golden rules

1️⃣ Variables created inside a function are born when it's called and destroyed when it returns.

2️⃣ Reading a global from inside a function: fine. Changing one: needs global x — and if you find yourself doing that, usually the better design is to pass it in as a parameter and return the new value.

3️⃣ This is why functions are safe to reuse: whatever mess happens inside, stays inside. 🧹

🎬 Try it — a simulated notes.txt on disk

with open("notes.txt", "w") as f:   # "w" = write (⚠ erases existing!)
    f.write("Buy milk\n")

with open("notes.txt", "a") as f:   # "a" = append (adds to end)
    f.write("Pay fees\n")

with open("notes.txt", "r") as f:   # "r" = read
    for line in f:
        print(line.strip())

💡 with closes the file automatically, even if an error happens inside. Always use with — never bare open().

File modes

💡 Wrap file reads in try/except FileNotFoundError (section 9) — files are "outside world" and can always be missing.

🎬 Try it — call the standard library

💡 Three import styles: import math → math.sqrt(x)  ·  from math import sqrt → sqrt(x)  ·  avoid from math import * (pollutes your namespace).

Beyond built-ins: pip

# in the terminal (not in Python!):
pip install requests

💡 Your own files are modules too! If you have helpers.py, then import helpers works from any script in the same folder.

🎬 Try it — build students from the blueprint

class Student:
    def __init__(self, name, marks):   # runs automatically at creation
        self.name = name                # self = "THIS particular student"
        self.marks = marks
    def show(self):
        return f"{self.name} scored {self.marks}"

ravi  = Student("Ravi", 80)    # build object #1
priya = Student("Priya", 92)   # build object #2 — separate data!
print(ravi.show())            # Ravi scored 80

💡 self just means "this particular object". When you call ravi.show(), Python secretly passes ravi in as self.

Why bother with classes?

Without classes: parallel lists that can drift apart — names[3], marks[3], grades[3]… 😰

With classes: data + the functions that work on it, bundled together. A Student carries its own marks and knows how to display itself.

💡 You've been using objects all along! "hi".upper(), fruits.append() — strings and lists are objects with methods.

🎬 Try it — convert back and forth

import json
text = json.dumps(student)   # dict → text  (dump to string)
data = json.loads(text)      # text → dict  (load from string)

💡 Every web API you'll ever call returns JSON. requests.get(url).json() → instantly a Python dict → use everything from section 7!

The 4 json functions

💡 Memory hook: the s in dumps/loads = string. Without s = file.

Looping like a pro

# need the position too? → enumerate (NOT range(len(...)))
for i, name in enumerate(students, start=1):
    print(f"{i}. {name}")          # 1. Ravi  2. Priya  3. Amit

# two lists in parallel? → zip
for name, mark in zip(students, marks):
    print(f"{name}: {mark}")

# loop a dictionary? → .items()
for key, value in student.items():
    print(key, "→", value)

Everyday one-liners

The script skeleton every .py file should have

"""What this script does — one line."""
import json                          # 1. imports at the top

def main():                          # 2. real work inside functions
    ...

if __name__ == "__main__":           # 3. the "main guard"
    main()

💡 The main guard means: "run main() only when this file is executed directly — not when it's imported by another script." Every professional Python file has it.

🟢 Warm-up

Ask for the user's name and birth year, then print "Hi Ravi, you turn 25 in 2026!"

name = input("Name: ")
year = int(input("Birth year: "))
print(f"Hi {name}, you turn {2026 - year} in 2026!")

Read a number and print whether it's even or odd.

n = int(input("Number: "))
if n % 2 == 0:
    print("Even")
else:
    print("Odd")

Use a loop to add up 1+2+…+100. (Answer: 5050)

total = 0
for i in range(1, 101):
    total += i          # shorthand for total = total + i
print(total)            # 5050 — or cheat: sum(range(1, 101))

🟡 Building strength

Write get_grade(marks) → "Distinction" (≥75), "Pass" (≥50), else "Fail". Test with 3 values.

def get_grade(marks):
    if marks >= 75: return "Distinction"
    if marks >= 50: return "Pass"
    return "Fail"

for m in [90, 60, 30]:
    print(m, "→", get_grade(m))

Count the vowels in "programming is beautiful". (Answer: 9)

text = "programming is beautiful"
count = 0
for ch in text:
    if ch in "aeiou":
        count += 1
print(count)   # 9 — one-liner: sum(1 for c in text if c in "aeiou")

Find the largest number in [34, 78, 12, 91, 45] without using max().

nums = [34, 78, 12, 91, 45]
biggest = nums[0]           # start with the first
for n in nums:
    if n > biggest:
        biggest = n
print(biggest)             # 91

Pick a random 1–10, let the user guess until correct, say "higher"/"lower" each time.

import random
secret = random.randint(1, 10)
while True:
    guess = int(input("Guess: "))
    if guess == secret:
        print("Correct! 🎉")
        break
    print("Higher!" if guess < secret else "Lower!")

🔴 Level up

Given {"Ravi": 80, "Priya": 92, "Amit": 45}, print each student's grade (reuse exercise 4!) and the class average.

marks = {"Ravi": 80, "Priya": 92, "Amit": 45}
for name, m in marks.items():
    print(f"{name}: {m} → {get_grade(m)}")
avg = sum(marks.values()) / len(marks)
print(f"Class average: {avg:.1f}")   # 72.3

Read two numbers and divide them. Handle BOTH bad input ("abc") and division by zero — the program must never crash.

try:
    a = float(input("a: "))
    b = float(input("b: "))
    print(f"{a} / {b} = {a / b}")
except ValueError:
    print("Please enter numbers only!")
except ZeroDivisionError:
    print("Cannot divide by zero!")

Count how often each word appears in "the cat and the dog and the bird".

text = "the cat and the dog and the bird"
counts = {}
for word in text.split():
    counts[word] = counts.get(word, 0) + 1
print(counts)   # {'the': 3, 'cat': 1, 'and': 2, 'dog': 1, 'bird': 1}

A script that appends whatever the user types to todo.txt, then prints all saved tasks numbered.

task = input("New task: ")
with open("todo.txt", "a") as f:
    f.write(task + "\n")

with open("todo.txt") as f:          # "r" is the default mode
    for i, line in enumerate(f, 1):
        print(f"{i}. {line.strip()}")

Build a Student class with name + a list of marks, an average() method, and a grade() method that uses the average. Create two students and print their report cards.

class Student:
    def __init__(self, name, marks):
        self.name = name
        self.marks = marks
    def average(self):
        return sum(self.marks) / len(self.marks)
    def grade(self):
        avg = self.average()
        if avg >= 75: return "Distinction"
        if avg >= 50: return "Pass"
        return "Fail"

for s in [Student("Ravi", [80, 75, 88]), Student("Amit", [40, 55, 35])]:
    print(f"{s.name}: avg {s.average():.1f} → {s.grade()}")

# 1. STORE data in variables
students = ["Ravi", "Priya", "Amit"]        # list
marks    = {"Ravi": 80, "Priya": 92, "Amit": 45}   # dict

# 2. WRAP logic in a function (define once…)
def get_grade(score):
    if score >= 75:          # 3. DECIDE with if/elif/else
        return "Distinction"
    elif score >= 50:
        return "Pass"
    return "Fail"

# 4. REPEAT with a loop (…call many times)
for name in students:
    score = marks[name]                       # dict lookup
    print(f"{name}: {score} → {get_grade(score)}")  # f-string

# Output:
# Ravi: 80 → Distinction
# Priya: 92 → Distinction
# Amit: 45 → Fail

Every Python program is just these moves combined: store data → make decisions → repeat work → wrap it in functions → handle failures. Master these 5 and everything else (files, APIs, classes) is built on top.