Zhimalab

Zhimalab / Tutorials / Python in 21 Days

中文

🐍

Python in 21 Days

Starting the Python runtime…

Home Course overview

Python in 21 Days

Welcome to Python in 21 Days! This tutorial assumes you already have some programming background (e.g. you have seen C or Java), so we skip questions like "what is a variable" and focus on what makes Python unique.

21 days, from basic syntax to object-oriented programming, generators, and a capstone project. Each lesson has runnable code (powered by Pyodide — Python runs right in your browser) and hands-on exercises.

How to use: Pick a lesson from the sidebar on the left. Each lesson includes explanations, runnable code samples, and exercises. Click "Mark complete" when you finish to track your progress.

Intro Day 1 / 21 · Week 1 · Core syntax

Hello, Python

Python is famous for being concise. The classic first line of code only needs a single print(). Click the Run button on the code block below to try it:

hello.py

print("Hello, World!")
print("Hello, Python!")

print("Hello, World!")
print("Hello, Python!")

Python needs no main() function, no semicolons, no header files — just write and run. Variables don't need type declarations either; assignment creates them:

Variables & types

name = "Python"
age = 34
pi = 3.14159
is_awesome = True

print(name, type(name))
print(age, type(age))
print(pi, type(pi))
print(is_awesome, type(is_awesome))

name = "Python"
age = 34
pi = 3.14159
is_awesome = True

print(name, type(name))
print(age, type(age))
print(pi, type(pi))
print(is_awesome, type(is_awesome))

Key point: Python is dynamically typed — a variable's type is determined at runtime and may change at any time. Use type() to inspect any variable's type.

input() reads user input (returns a string), and the f-string (formatted string) is the recommended way to compose strings in Python 3.6+:

f-string intro

name = "Python"
print(f"Hello, {name}! Welcome to Python.")

# Expressions can be embedded directly in f-strings
print(f"Next year you will be {18 + 1} years old")

name = "Python"
print(f"Hello, {name}! Welcome to Python.")

# Expressions can be embedded directly in f-strings
print(f"Next year you will be {18 + 1} years old")

✎

Exercise

Create a variable city assigned to "Beijing" and a variable temp assigned to 26, then use an f-string to print: Beijing today's temperature is 26 degrees.

Your code
 city = "Beijing"
temp = 26
# Use an f-string to print the result
 city = "Beijing"
temp = 26
# Use an f-string to print the result
 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Basics Day 2 / 21 · Week 1

Numbers & strings

Python has three numeric types: int (integers, unbounded), float (floating point), and complex (complex numbers). The arithmetic operators are similar to C, but / always returns a float and // is integer division.

Arithmetic

# Arithmetic
print(7 / 2)    # 3.5  — true division
print(7 // 2)   # 3    — floor division (rounds toward negative infinity)
print(7 % 2)    # 1    — modulo
print(2 ** 10)  # 1024 — exponentiation (not ^)
print(-7 // 2)  # -4   — note: floor division

# Python ints never overflow
print(2 ** 100)  # exact big integer

# Arithmetic
print(7 / 2)    # 3.5  — true division
print(7 // 2)   # 3    — floor division (rounds toward negative infinity)
print(7 % 2)    # 1    — modulo
print(2 ** 10)  # 1024 — exponentiation (not ^)
print(-7 // 2)  # -4   — note: floor division

# Python ints never overflow
print(2 ** 100)  # exact big integer

Strings

Strings can use single quotes, double quotes, or triple quotes. Triple quotes can span multiple lines. Strings support * repetition and + concatenation, but f-strings are more elegant.

String operations

s = "Hello, Python"

# Indexing (negative indices allowed)
print(s[0])     # H
print(s[-1])    # n

# Slicing [start:stop:step]
print(s[0:5])   # Hello
print(s[7:])    # Python
print(s[::-1])  # nohtyP, olleH — reverse

# Common operations
print(len(s))           # 13
print("Python" in s)    # True
print(s.upper())        # HELLO, PYTHON
print(s.replace("Python", "World"))

s = "Hello, Python"

# Indexing (negative indices allowed)
print(s[0])     # H
print(s[-1])    # n

# Slicing [start:stop:step]
print(s[0:5])   # Hello
print(s[7:])    # Python
print(s[::-1])  # nohtyP, olleH — reverse

# Common operations
print(len(s))           # 13
print("Python" in s)    # True
print(s.upper())        # HELLO, PYTHON
print(s.replace("Python", "World"))

Slicing is a core Python feature. s[start:stop:step] is half-open. s[::-1] reverses a string — the most classic Python trick.

✎

Exercise

Given the string s = "Hello, Python!", use slicing to extract "Python" and print it.

Your code
 s = "Hello, Python!"
# Use slicing to extract "Python" and print it
 s = "Hello, Python!"
# Use slicing to extract "Python" and print it
 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Basics Day 3 / 21 · Week 1

Booleans & operators

Python's booleans are True and False (capitalized). Comparison operators: == != < > <= >=. Logical operators are the English words and, or, not — not && || !.

Booleans & logic

print(3 > 2 and 2 > 1)   # True
print(3 > 5 or 2 > 1)    # True
print(not True)          # False

# Chained comparison — unique to Python
score = 85
print(60 <= score <= 100) # True

# Membership operators
print(3 in [1, 2, 3])     # True
print(5 not in [1, 2, 3]) # True

# Identity operator is
a = [1, 2]
b = a
c = [1, 2]
print(a is b)  # True — same object
print(a is c)  # False — same value but different objects
print(a == c)  # True — values are equal

print(3 > 2 and 2 > 1)   # True
print(3 > 5 or 2 > 1)    # True
print(not True)          # False

# Chained comparison — unique to Python
score = 85
print(60 <= score <= 100) # True

# Membership operators
print(3 in [1, 2, 3])     # True
print(5 not in [1, 2, 3]) # True

# Identity operator is
a = [1, 2]
b = a
c = [1, 2]
print(a is b)  # True — same object
print(a is c)  # False — same value but different objects
print(a == c)  # True — values are equal

Truthiness: the following values are all "false": 0, 0.0, "", [], {}, None. Everything else is "true".

Truthiness

# These are all False
print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False
print(bool(None))   # False

# These are all True
print(bool(42))     # True
print(bool("hi"))   # True
print(bool([0]))    # True (non-empty list)

# These are all False
print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False
print(bool(None))   # False

# These are all True
print(bool(42))     # True
print(bool("hi"))   # True
print(bool([0]))    # True (non-empty list)

is vs ==: is tests whether two references point to the same object (memory address); == tests whether values are equal. For value comparison, use ==.

✎

Exercise

Write a function is_leap_year(year) that decides whether a given year is a leap year. Rule: divisible by 4 but not by 100, or divisible by 400.

Your code
 def is_leap_year(year):
    # Write your code here
    pass

# Tests
print(is_leap_year(2024))  # True
print(is_leap_year(1900))  # False
print(is_leap_year(2000))  # True def is_leap_year(year):
    # Write your code here
    pass

# Tests
print(is_leap_year(2024))  # True
print(is_leap_year(1900))  # False
print(is_leap_year(2000))  # True 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Basics Day 4 / 21 · Week 1

Conditionals

Python uses if / elif / else for branching. There is no switch-case (3.10+ adds match-case). Important: Python uses indentation to mark code blocks; an indentation error is a syntax error.

if/elif/else

score = 78

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 = 78

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}")

Conditional expression (ternary): value1 if condition else value2, equivalent to C's condition ? value1 : value2.

Ternary & match

age = 20
status = "adult" if age >= 18 else "minor"
print(status)

# match-case (Python 3.10+)
command = "start"
match command:
    case "start":
        print("Starting")
    case "stop":
        print("Stopping")
    case _:
        print("Unknown command")

age = 20
status = "adult" if age >= 18 else "minor"
print(status)

# match-case (Python 3.10+)
command = "start"
match command:
    case "start":
        print("Starting")
    case "stop":
        print("Stopping")
    case _:
        print("Unknown command")

Indentation rule: use 4 spaces consistently (PEP 8 standard). pass is a no-op placeholder, used where the implementation is not yet written.

✎

Exercise

Write a function classify(num) that returns "positive", "negative", or "zero". Then test with 5, -3, 0.

Your code
 def classify(num):
    # Write your code here
    pass

# Tests
print(classify(5))   # positive
print(classify(-3))  # negative
print(classify(0))   # zero def classify(num):
    # Write your code here
    pass

# Tests
print(classify(5))   # positive
print(classify(-3))  # negative
print(classify(0))   # zero 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Basics Day 5 / 21 · Week 1

while loops

A while loop is similar to C, but Python has no do-while. break exits the loop, continue skips the current iteration. An else block can follow a loop — it runs when the loop ends normally (i.e. not via break).

while loop

# Classic: sum 1 to 100
total = 0
i = 1
while i <= 100:
    total += i
    i += 1
print(f"1+2+...+100 = {total}")  # 5050

# break: guess the number
attempts = 0
while True:
    attempts += 1
    if attempts >= 3:
        print(f"exceeded {attempts} attempts")
        break
    print(f"attempt #{attempts}")

# Classic: sum 1 to 100
total = 0
i = 1
while i <= 100:
    total += i
    i += 1
print(f"1+2+...+100 = {total}")  # 5050

# break: guess the number
attempts = 0
while True:
    attempts += 1
    if attempts >= 3:
        print(f"exceeded {attempts} attempts")
        break
    print(f"attempt #{attempts}")

while-else

# while-else: else runs only when the loop ends without break
n = 7
d = 2
while d < n:
    if n % d == 0:
        print(f"{n} is not prime")
        break
    d += 1
else:
    print(f"{n} is prime")  # no break occurred, so else runs

# while-else: else runs only when the loop ends without break
n = 7
d = 2
while d < n:
    if n % d == 0:
        print(f"{n} is not prime")
        break
    d += 1
else:
    print(f"{n} is prime")  # no break occurred, so else runs

while-else is a Python specialty: the else block runs when the loop completes without a break. Great for "search" scenarios — break when found, run else when not.

✎

Exercise

Use a while loop to compute 2^10 (without using the ** operator); store the result in a variable named result and print it.

Your code
 result = 1
n = 10
# Use a while loop to compute 2 ** 10
 result = 1
n = 10
# Use a while loop to compute 2 ** 10
 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Basics Day 6 / 21 · Week 1

for loops & range

Python's for is not C's for(init;cond;inc) — it is for-in iteration, walking each element of an iterable directly. range() generates integer sequences.

for loop

# range(start, stop, step) — half-open
for i in range(5):        # 0,1,2,3,4
    print(i, end=" ")
print()

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

# Iterate a string directly
for ch in "Python":
    print(ch, end=" ")
print()

# enumerate: index + value at the same time
fruits = ["apple", "banana", "orange"]
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

# range(start, stop, step) — half-open
for i in range(5):        # 0,1,2,3,4
    print(i, end=" ")
print()

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

# Iterate a string directly
for ch in "Python":
    print(ch, end=" ")
print()

# enumerate: index + value at the same time
fruits = ["apple", "banana", "orange"]
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

zip & nested loops

# zip: iterate multiple sequences in parallel
names = ["Alice", "Bob", "Carol"]
scores = [90, 85, 78]
for name, score in zip(names, scores):
    print(f"{name}: {score} pts")

# Nested loops: multiplication table
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}x{i}={i*j}", end="  ")
    print()

# zip: iterate multiple sequences in parallel
names = ["Alice", "Bob", "Carol"]
scores = [90, 85, 78]
for name, score in zip(names, scores):
    print(f"{name}: {score} pts")

# Nested loops: multiplication table
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}x{i}={i*j}", end="  ")
    print()

Python has no C-style for loop. Use range() when you need indices; enumerate() when you need index + value; zip() for parallel iteration.

✎

Exercise

Use a for loop with range() to print row 5 of a multiplication table: 1x5=5 2x5=10 3x5=15 4x5=20 5x5=25

Your code
 # Use a for loop to print row 5 of the multiplication table
 # Use a for loop to print row 5 of the multiplication table
 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Basics Day 7 / 21 · Week 1

Lists — basics

A list (list) is Python's most common data structure — mutable, ordered, holds any type. Think of it as a blend of C arrays and linked lists, but far more flexible.

List operations

# Creating lists
nums = [3, 1, 4, 1, 5, 9, 2, 6]
mixed = [1, "hello", True, 3.14]

# Indexing & slicing (same as strings)
print(nums[0])    # 3
print(nums[-1])   # 6
print(nums[2:5])  # [4, 1, 5]
print(nums[::-1]) # reversed

# Mutation
nums[0] = 99
nums.append(100)       # add to end
nums.insert(1, 50)     # insert at index
nums.remove(1)         # remove first occurrence of value 1
popped = nums.pop()    # pop from end
print(nums)

# Creating lists
nums = [3, 1, 4, 1, 5, 9, 2, 6]
mixed = [1, "hello", True, 3.14]

# Indexing & slicing (same as strings)
print(nums[0])    # 3
print(nums[-1])   # 6
print(nums[2:5])  # [4, 1, 5]
print(nums[::-1]) # reversed

# Mutation
nums[0] = 99
nums.append(100)       # add to end
nums.insert(1, 50)     # insert at index
nums.remove(1)         # remove first occurrence of value 1
popped = nums.pop()    # pop from end
print(nums)

List sorting

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

# sorted() returns a new list; original unchanged
print(sorted(nums))           # [1, 1, 2, 3, 4, 5, 6, 9]
print(sorted(nums, reverse=True))  # descending

# .sort() sorts in place and returns None
nums.sort()
print(nums)

# Custom sort key
words = ["banana", "apple", "cherry"]
words.sort(key=len)
print(words)  # ['apple', 'banana', 'cherry']

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

# sorted() returns a new list; original unchanged
print(sorted(nums))           # [1, 1, 2, 3, 4, 5, 6, 9]
print(sorted(nums, reverse=True))  # descending

# .sort() sorts in place and returns None
nums.sort()
print(nums)

# Custom sort key
words = ["banana", "apple", "cherry"]
words.sort(key=len)
print(words)  # ['apple', 'banana', 'cherry']

sorted() vs .sort(): sorted() returns a new list and leaves the original unchanged; .sort() sorts in place and returns None.

✎

Exercise

Given the list nums = [5, 3, 8, 1, 9, 2, 7], use sorted() to sort it in descending order; store the result in a variable named result and print it.

Your code
 nums = [5, 3, 8, 1, 9, 2, 7]
# Sort descending and store in result
 nums = [5, 3, 8, 1, 9, 2, 7]
# Sort descending and store in result
 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Intermediate Day 8 / 21 · Week 2 · Data structures & functions

List comprehensions

A list comprehension is one of Python's most elegant features — build a list in a single line. For someone with a C/Java background, this is the first lesson in "Pythonic" thinking.

List comprehension

# Traditional style
squares = []
for i in range(10):
    squares.append(i ** 2)

# List comprehension — one liner
squares = [i ** 2 for i in range(10)]
print(squares)

# With a filter
evens = [i for i in range(20) if i % 2 == 0]
print(evens)

# With a conditional expression
labels = ["even" if i % 2 == 0 else "odd" for i in range(5)]
print(labels)

# Traditional style
squares = []
for i in range(10):
    squares.append(i ** 2)

# List comprehension — one liner
squares = [i ** 2 for i in range(10)]
print(squares)

# With a filter
evens = [i for i in range(20) if i % 2 == 0]
print(evens)

# With a conditional expression
labels = ["even" if i % 2 == 0 else "odd" for i in range(5)]
print(labels)

Nested & dict comprehensions

# Nested comprehension
matrix = [[i * 3 + j for j in range(3)] for i in range(3)]
print(matrix)
# [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

# Dict / set comprehension
sq_dict = {i: i**2 for i in range(5)}
print(sq_dict)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Nested comprehension
matrix = [[i * 3 + j for j in range(3)] for i in range(3)]
print(matrix)
# [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

# Dict / set comprehension
sq_dict = {i: i**2 for i in range(5)}
print(sq_dict)  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Comprehension syntax: [expression for variable in iterable if condition]. If it spans more than two lines, use a regular loop instead.

✎

Exercise

Use a list comprehension to generate the squares of all even numbers from 1 to 20; the result should be [4, 16, 36, 64, 100, 144, 196, 256, 324, 400]. Store it in a variable named result.

Your code
 # Use a list comprehension to generate squares of evens in 1..20
 # Use a list comprehension to generate squares of evens in 1..20
 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Intermediate Day 9 / 21 · Week 2

Tuples & unpacking

A tuple (tuple) is an immutable list. Once created, it cannot be modified. Its uses: fixed data (e.g. coordinates), multiple function return values, and as dictionary keys (lists cannot be keys).

Tuples & unpacking

# Creating tuples
point = (3, 4)
single = (42,)    # a 1-tuple must have a trailing comma

# Immutable
# point[0] = 5  # TypeError!

# Unpacking
x, y = point
print(x, y)  # 3 4

# Swap variables — no temp needed
a, b = 1, 2
a, b = b, a
print(a, b)  # 2 1

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

# Creating tuples
point = (3, 4)
single = (42,)    # a 1-tuple must have a trailing comma

# Immutable
# point[0] = 5  # TypeError!

# Unpacking
x, y = point
print(x, y)  # 3 4

# Swap variables — no temp needed
a, b = 1, 2
a, b = b, a
print(a, b)  # 2 1

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

Multiple returns

# Functions can return multiple values (actually a tuple)
def min_max(nums):
    return min(nums), max(nums)

lo, hi = min_max([3, 1, 4, 1, 5, 9])
print(f"min: {lo}, max: {hi}")

# enumerate also yields tuples
for index, value in enumerate(["a", "b", "c"]):
    print(f"{index} -> {value}")

# Functions can return multiple values (actually a tuple)
def min_max(nums):
    return min(nums), max(nums)

lo, hi = min_max([3, 1, 4, 1, 5, 9])
print(f"min: {lo}, max: {hi}")

# enumerate also yields tuples
for index, value in enumerate(["a", "b", "c"]):
    print(f"{index} -> {value}")

Tuple vs list — when to use which? Use a tuple when the data won't change (safer, faster, hashable). Use a list when you need to add/remove/modify elements.

✎

Exercise

Use tuple unpacking to swap the values of a (currently 100) and b (currently 200) in one step, so that a=200 and b=100.

Your code
 a = 100
b = 200
# Use tuple unpacking to swap a and b
 a = 100
b = 200
# Use tuple unpacking to swap a and b
 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Intermediate Day 10 / 21 · Week 2

Dictionaries

A dictionary (dict) is Python's most powerful data structure — key-value mapping with O(1) lookup. Python 3.7+ guarantees insertion order. Keys must be immutable types (str, int, tuple); lists and dicts cannot be keys.

Dict operations

# Creation
student = {"name": "Alice", "age": 20, "major": "CS"}

# Access
print(student["name"])         # Alice
print(student.get("gpa", 0))   # 0 (returns default if key missing)

# Add / delete / modify
student["gpa"] = 3.8          # add/modify
del student["major"]          # delete
age = student.pop("age")      # pop
print(student)

# Iteration
scores = {"math": 90, "english": 85, "physics": 92}
for key, value in scores.items():
    print(f"{key} = {value}")

# Creation
student = {"name": "Alice", "age": 20, "major": "CS"}

# Access
print(student["name"])         # Alice
print(student.get("gpa", 0))   # 0 (returns default if key missing)

# Add / delete / modify
student["gpa"] = 3.8          # add/modify
del student["major"]          # delete
age = student.pop("age")      # pop
print(student)

# Iteration
scores = {"math": 90, "english": 85, "physics": 92}
for key, value in scores.items():
    print(f"{key} = {value}")

Dict comprehension & word count

# Dict comprehension
nums = [1, 2, 3, 4, 5]
sq = {n: n**2 for n in nums}
print(sq)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Word frequency
text = "the cat sat on the mat the cat"
words = text.split()
freq = {}
for word in words:
    freq[word] = freq.get(word, 0) + 1
print(freq)
# {'the': 3, 'cat': 2, 'sat': 1, 'on': 1, 'mat': 1}

# More elegant: collections.Counter
from collections import Counter
print(dict(Counter(words)))

# Dict comprehension
nums = [1, 2, 3, 4, 5]
sq = {n: n**2 for n in nums}
print(sq)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Word frequency
text = "the cat sat on the mat the cat"
words = text.split()
freq = {}
for word in words:
    freq[word] = freq.get(word, 0) + 1
print(freq)
# {'the': 3, 'cat': 2, 'sat': 1, 'on': 1, 'mat': 1}

# More elegant: collections.Counter
from collections import Counter
print(dict(Counter(words)))

dict.get(key, default) is the safe way to access a dictionary — when the key is absent it returns the default instead of raising an error.

✎

Exercise

Given the string text = "apple banana apple cherry banana apple", count occurrences of each word and store the result in a dictionary named freq. Expected: {'apple': 3, 'banana': 2, 'cherry': 1}

Your code
 text = "apple banana apple cherry banana apple"
freq = {}
# Count word frequency
 text = "apple banana apple cherry banana apple"
freq = {}
# Count word frequency
 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Intermediate Day 11 / 21 · Week 2

Sets

A set (set) is an unordered collection of unique elements. Core uses: deduplication and set operations (union, intersection, difference, symmetric difference). Lookup is O(1), as fast as a dict.

Set operations

# Creation
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}

# Deduplication
nums = [1, 2, 2, 3, 3, 3, 4]
unique = list(set(nums))
print(unique)  # [1, 2, 3, 4]

# Set operations
print(s1 | s2)  # union {1,2,3,4,5,6}
print(s1 & s2)  # intersection {3,4}
print(s1 - s2)  # difference {1,2}
print(s1 ^ s2)  # symmetric difference {1,2,5,6}

# Membership test
print(3 in s1)  # True

# Creation
s1 = {1, 2, 3, 4}
s2 = {3, 4, 5, 6}

# Deduplication
nums = [1, 2, 2, 3, 3, 3, 4]
unique = list(set(nums))
print(unique)  # [1, 2, 3, 4]

# Set operations
print(s1 | s2)  # union {1,2,3,4,5,6}
print(s1 & s2)  # intersection {3,4}
print(s1 - s2)  # difference {1,2}
print(s1 ^ s2)  # symmetric difference {1,2,5,6}

# Membership test
print(3 in s1)  # True

Set applications

# Real-world example: find common elements of two lists
list_a = ["Python", "Java", "C++", "Go"]
list_b = ["Java", "Rust", "Python", "Swift"]

common = set(list_a) & set(list_b)
print(f"common: {common}")

only_a = set(list_a) - set(list_b)
print(f"only in A: {only_a}")

# Real-world example: find common elements of two lists
list_a = ["Python", "Java", "C++", "Go"]
list_b = ["Java", "Rust", "Python", "Swift"]

common = set(list_a) & set(list_b)
print(f"common: {common}")

only_a = set(list_a) - set(list_b)
print(f"only in A: {only_a}")

Set operators: | union, & intersection, - difference, ^ symmetric difference. More concise than calling methods.

✎

Exercise

Given two lists a = [1, 2, 3, 4, 5] and b = [4, 5, 6, 7, 8], use set operations to find their common elements; store the result in a variable named common.

Your code
 a = [1, 2, 3, 4, 5]
b = [4, 5, 6, 7, 8]
# Use set operations to find common elements
 a = [1, 2, 3, 4, 5]
b = [4, 5, 6, 7, 8]
# Use set operations to find common elements
 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Intermediate Day 12 / 21 · Week 2

Functions — basics

Python uses def to define a function. Unlike C/Java: parameters may have default values, can be passed by name, and can accept a variable number of arguments. Functions are first-class objects — they can be assigned to variables and passed as arguments.

Function definitions

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

print(greet("Alice"))          # Hello, Alice!
print(greet("Bob", "Hi"))      # Hi, Bob!
print(greet(name="Carol"))     # keyword argument

# Multiple return values
def divide(a, b):
    quotient = a // b
    remainder = a % b
    return quotient, remainder

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

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

print(greet("Alice"))          # Hello, Alice!
print(greet("Bob", "Hi"))      # Hi, Bob!
print(greet(name="Carol"))     # keyword argument

# Multiple return values
def divide(a, b):
    quotient = a // b
    remainder = a % b
    return quotient, remainder

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

Variadic arguments

# Variadic positional arguments
def sum_all(*args):
    """Accept any number of positional arguments."""
    return sum(args)

print(sum_all(1, 2, 3))       # 6
print(sum_all(1, 2, 3, 4, 5)) # 15

# Variadic keyword arguments
def make_profile(**kwargs):
    for key, value in kwargs.items():
        print(f"  {key}: {value}")

make_profile(name="Alice", age=25, city="Beijing")

# Mixing both
def func(a, b, *args, **kwargs):
    print(f"a={a}, b={b}, args={args}, kwargs={kwargs}")

func(1, 2, 3, 4, x=5, y=6)

# Variadic positional arguments
def sum_all(*args):
    """Accept any number of positional arguments."""
    return sum(args)

print(sum_all(1, 2, 3))       # 6
print(sum_all(1, 2, 3, 4, 5)) # 15

# Variadic keyword arguments
def make_profile(**kwargs):
    for key, value in kwargs.items():
        print(f"  {key}: {value}")

make_profile(name="Alice", age=25, city="Beijing")

# Mixing both
def func(a, b, *args, **kwargs):
    print(f"a={a}, b={b}, args={args}, kwargs={kwargs}")

func(1, 2, 3, 4, x=5, y=6)

*args collects extra positional arguments as a tuple; **kwargs collects extra keyword arguments as a dict. Parameter order: def f(required, default, *args, **kwargs).

✎

Exercise

Write a function power(base, exp=2) that computes base raised to exp. exp defaults to 2 (i.e. square).

Your code
 def power(base, exp=2):
    # Write your code here
    pass

# Tests
print(power(5))      # 25
print(power(2, 10))  # 1024
print(power(3, 3))   # 27 def power(base, exp=2):
    # Write your code here
    pass

# Tests
print(power(5))      # 25
print(power(2, 10))  # 1024
print(power(3, 3))   # 27 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Intermediate Day 13 / 21 · Week 2

Lambda & higher-order functions

lambda is an anonymous function — defined in one line, ideal for short throwaway functions. map(), filter(), sorted() and other higher-order functions are often paired with lambda. That said, list comprehensions are usually more Pythonic than map/filter.

lambda expression

# Basic lambda syntax
square = lambda x: x ** 2
print(square(5))  # 25

# lambda is most often used as a sort key
students = [
    ("Alice", 85),
    ("Bob", 92),
    ("Carol", 78),
]

# Sort by score
by_score = sorted(students, key=lambda s: s[1], reverse=True)
print(by_score)
# [('Bob', 92), ('Alice', 85), ('Carol', 78)]

# Basic lambda syntax
square = lambda x: x ** 2
print(square(5))  # 25

# lambda is most often used as a sort key
students = [
    ("Alice", 85),
    ("Bob", 92),
    ("Carol", 78),
]

# Sort by score
by_score = sorted(students, key=lambda s: s[1], reverse=True)
print(by_score)
# [('Bob', 92), ('Alice', 85), ('Carol', 78)]

map / filter / reduce

# map: apply a function to every element
nums = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, nums))
print(squared)  # [1, 4, 9, 16, 25]

# filter: keep matching elements
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens)  # [2, 4]

# More Pythonic: list comprehensions
squared = [x**2 for x in nums]
evens = [x for x in nums if x % 2 == 0]

# reduce: accumulate
from functools import reduce
product = reduce(lambda a, b: a * b, nums)
print(product)  # 120 = 1*2*3*4*5

# map: apply a function to every element
nums = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x**2, nums))
print(squared)  # [1, 4, 9, 16, 25]

# filter: keep matching elements
evens = list(filter(lambda x: x % 2 == 0, nums))
print(evens)  # [2, 4]

# More Pythonic: list comprehensions
squared = [x**2 for x in nums]
evens = [x for x in nums if x % 2 == 0]

# reduce: accumulate
from functools import reduce
product = reduce(lambda a, b: a * b, nums)
print(product)  # 120 = 1*2*3*4*5

Pythonic advice: prefer list comprehensions over map/filter for simple operations — they read better. Reserve lambda for short one-line functions.

✎

Exercise

Given the list words = ["banana", "apple", "cherry", "date"], use sorted() with a lambda to sort by string length; store the result in a variable named result.

Your code
 words = ["banana", "apple", "cherry", "date"]
# Use sorted + lambda to sort by length
 words = ["banana", "apple", "cherry", "date"]
# Use sorted + lambda to sort by length
 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Intermediate Day 14 / 21 · Week 2

Strings — advanced

Python's string methods are very rich. Strings are immutable — every "modification" returns a new string.

String methods

text = "  Hello, World!  "

# Strip whitespace
print(text.strip())    # "Hello, World!"

# Split & join
csv = "Alice,25,CS,3.8"
parts = csv.split(",")
print(parts)  # ['Alice', '25', 'CS', '3.8']

joined = "-".join(parts)
print(joined)  # Alice-25-CS-3.8

# Find & replace
s = "Hello, Python!"
print(s.replace("Python", "World"))
print(s.find("Python"))  # 7 (index), -1 if not found
print(s.startswith("Hello"))  # True
print(s.count("l"))  # 3

text = "  Hello, World!  "

# Strip whitespace
print(text.strip())    # "Hello, World!"

# Split & join
csv = "Alice,25,CS,3.8"
parts = csv.split(",")
print(parts)  # ['Alice', '25', 'CS', '3.8']

joined = "-".join(parts)
print(joined)  # Alice-25-CS-3.8

# Find & replace
s = "Hello, Python!"
print(s.replace("Python", "World"))
print(s.find("Python"))  # 7 (index), -1 if not found
print(s.startswith("Hello"))  # True
print(s.count("l"))  # 3

String formatting

# String formatting
name = "Alice"
score = 95.678

# f-string (recommended)
print(f"Name: {name}")
print(f"Score: {score:.2f}")  # 2 decimal places: 95.68
print(f"{'center':^20}")     # centered padding

# Check methods
print("123".isdigit())     # True
print("abc".isalpha())     # True
print("Hello123".isalnum()) # True

# String formatting
name = "Alice"
score = 95.678

# f-string (recommended)
print(f"Name: {name}")
print(f"Score: {score:.2f}")  # 2 decimal places: 95.68
print(f"{'center':^20}")     # centered padding

# Check methods
print("123".isdigit())     # True
print("abc".isalpha())     # True
print("Hello123".isalnum()) # True

✎

Exercise

Given the string s = "hello world python", capitalize the first letter of each word so the result is "Hello World Python". Store it in a variable named result.

Your code
 s = "hello world python"
# Capitalize the first letter of each word
 s = "hello world python"
# Capitalize the first letter of each word
 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Advanced Day 15 / 21 · Week 3 · Advanced & practice

File I/O

File I/O uses the open() function. Always use the with statement — it closes the file automatically, even if an error occurs, preventing resource leaks. Modes: 'r' read, 'w' write (overwrite), 'a' append.

File read/write

# Write a file
with open("/tmp/test.txt", "w") as f:
    f.write("line 1\n")
    f.write("line 2\n")
    f.writelines(["line 3\n", "line 4\n"])

# Read the whole file at once
with open("/tmp/test.txt", "r") as f:
    content = f.read()
    print(content)

# Read line by line (recommended, memory-friendly)
with open("/tmp/test.txt", "r") as f:
    for line in f:
        print(f"line: {line.strip()}")

# Write a file
with open("/tmp/test.txt", "w") as f:
    f.write("line 1\n")
    f.write("line 2\n")
    f.writelines(["line 3\n", "line 4\n"])

# Read the whole file at once
with open("/tmp/test.txt", "r") as f:
    content = f.read()
    print(content)

# Read line by line (recommended, memory-friendly)
with open("/tmp/test.txt", "r") as f:
    for line in f:
        print(f"line: {line.strip()}")

The with statement is a context manager, equivalent to try-finally but cleaner. with open(...) as f: automatically calls f.close() when the block ends, even if an exception is raised.

JSON read/write

# JSON file I/O
import json

data = {
    "name": "Alice",
    "age": 20,
    "courses": ["math", "english", "physics"]
}

# Write JSON
with open("/tmp/data.json", "w") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

# Read JSON
with open("/tmp/data.json", "r") as f:
    loaded = json.load(f)
    print(loaded)
    print(loaded["courses"])

# JSON file I/O
import json

data = {
    "name": "Alice",
    "age": 20,
    "courses": ["math", "english", "physics"]
}

# Write JSON
with open("/tmp/data.json", "w") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

# Read JSON
with open("/tmp/data.json", "r") as f:
    loaded = json.load(f)
    print(loaded)
    print(loaded["courses"])

✎

Exercise

Write the string "Python is the best language" to the file /tmp/quote.txt, then read it back into a variable named content and print it.

Your code
 # Write to the file

# Read from the file

 # Write to the file

# Read from the file

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Advanced Day 16 / 21 · Week 3

Exceptions

Python uses try/except/else/finally to handle exceptions. except can specify an exception type. Do not use a bare except: — it hides bugs.

try/except/else/finally

# Basic structure
try:
    num = int("abc")
    result = 10 / num
except ValueError:
    print("not a valid number")
except ZeroDivisionError:
    print("cannot divide by zero")
except Exception as e:
    print(f"other error: {e}")
else:
    print(f"result: {result}")  # runs when no exception
finally:
    print("always runs")

# Basic structure
try:
    num = int("abc")
    result = 10 / num
except ValueError:
    print("not a valid number")
except ZeroDivisionError:
    print("cannot divide by zero")
except Exception as e:
    print(f"other error: {e}")
else:
    print(f"result: {result}")  # runs when no exception
finally:
    print("always runs")

raise & custom exceptions

# Raise an exception explicitly
def check_age(age):
    if age < 0:
        raise ValueError("age cannot be negative")
    return age

try:
    check_age(-5)
except ValueError as e:
    print(f"error: {e}")

# Custom exception
class InvalidScoreError(Exception):
    pass

def set_score(score):
    if not 0 <= score <= 100:
        raise InvalidScoreError("score must be between 0 and 100")
    return score

try:
    set_score(150)
except InvalidScoreError as e:
    print(f"error: {e}")

# Raise an exception explicitly
def check_age(age):
    if age < 0:
        raise ValueError("age cannot be negative")
    return age

try:
    check_age(-5)
except ValueError as e:
    print(f"error: {e}")

# Custom exception
class InvalidScoreError(Exception):
    pass

def set_score(score):
    if not 0 <= score <= 100:
        raise InvalidScoreError("score must be between 0 and 100")
    return score

try:
    set_score(150)
except InvalidScoreError as e:
    print(f"error: {e}")

Exception-handling principles: ① only catch exceptions you expect; ② handle them, don't just pass; ③ put the "normal path" in the else block; ④ use finally for resource cleanup.

✎

Exercise

Write a function safe_divide(a, b) that returns a / b. If b is 0, return the string "Error: division by zero" (do not raise).

Your code
 def safe_divide(a, b):
    # Write your code here
    pass

# Tests
print(safe_divide(10, 3))  # 3.333...
print(safe_divide(10, 0))  # Error: division by zero def safe_divide(a, b):
    # Write your code here
    pass

# Tests
print(safe_divide(10, 3))  # 3.333...
print(safe_divide(10, 0))  # Error: division by zero 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Advanced Day 17 / 21 · Week 3

Classes & objects

Python is object-oriented, but unlike Java it does not force everything into classes. class defines a class, __init__ is the constructor, self is Python's equivalent of Java's this. The first parameter of an instance method is always self.

Class definition

class Student:
    # Class variable (shared by all instances)
    school = "Tsinghua University"
    
    # Constructor
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score
    
    # Instance method
    def introduce(self):
        return f"I am {self.name} from {self.school}, {self.age} years old"
    
    # Magic methods
    def __str__(self):
        return f"Student({self.name})"
    
    def __repr__(self):
        return f"Student(name={self.name!r}, age={self.age}, score={self.score})"

s1 = Student("Alice", 20, 90)
print(s1.introduce())
print(s1)         # calls __str__
print(repr(s1))   # calls __repr__

class Student:
    # Class variable (shared by all instances)
    school = "Tsinghua University"
    
    # Constructor
    def __init__(self, name, age, score):
        self.name = name
        self.age = age
        self.score = score
    
    # Instance method
    def introduce(self):
        return f"I am {self.name} from {self.school}, {self.age} years old"
    
    # Magic methods
    def __str__(self):
        return f"Student({self.name})"
    
    def __repr__(self):
        return f"Student(name={self.name!r}, age={self.age}, score={self.score})"

s1 = Student("Alice", 20, 90)
print(s1.introduce())
print(s1)         # calls __str__
print(repr(s1))   # calls __repr__

__str__ vs __repr__: __str__ is user-facing (called by print); __repr__ is developer-facing (called in interactive sessions).

classmethod, staticmethod, property

# classmethod & staticmethod
class MathUtils:
    pi = 3.14159
    
    @staticmethod
    def is_even(n):
        return n % 2 == 0
    
    @classmethod
    def circle_area(cls, r):
        return cls.pi * r ** 2

print(MathUtils.is_even(4))       # True
print(MathUtils.circle_area(5))  # 78.54...

# Property decorator
class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius
    
    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32

t = Temperature(100)
print(t.fahrenheit)  # 212.0

# classmethod & staticmethod
class MathUtils:
    pi = 3.14159
    
    @staticmethod
    def is_even(n):
        return n % 2 == 0
    
    @classmethod
    def circle_area(cls, r):
        return cls.pi * r ** 2

print(MathUtils.is_even(4))       # True
print(MathUtils.circle_area(5))  # 78.54...

# Property decorator
class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius
    
    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32

t = Temperature(100)
print(t.fahrenheit)  # 212.0

✎

Exercise

Define a Circle class with a radius attribute. Method area() returns the area (πr²), method perimeter() returns the circumference (2πr). Use math.pi.

Your code
 import math

class Circle:
    def __init__(self, radius):
        # Write your code here
        pass
    
    def area(self):
        # Return the area
        pass
    
    def perimeter(self):
        # Return the perimeter
        pass

# Tests
c = Circle(5)
print(c.area())       # ~78.54
print(c.perimeter())  # ~31.42 import math

class Circle:
    def __init__(self, radius):
        # Write your code here
        pass
    
    def area(self):
        # Return the area
        pass
    
    def perimeter(self):
        # Return the perimeter
        pass

# Tests
c = Circle(5)
print(c.area())       # ~78.54
print(c.perimeter())  # ~31.42 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Advanced Day 18 / 21 · Week 3

Inheritance & magic methods

Python supports single and multiple inheritance. super() calls the parent class method. Magic methods (dunder methods) start and end with double underscores; they define object behavior — operator overloading, iteration, comparison, etc.

Inheritance & polymorphism

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return f"{self.name} makes a sound"

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
    def speak(self):  # method override
        return f"{self.name} ({self.breed}) says: Woof!"

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

# Polymorphism
animals = [Dog("Rex", "Shiba Inu"), Cat("Mimi")]
for a in animals:
    print(a.speak())

print(isinstance(Dog("test", "test"), Animal))  # True

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return f"{self.name} makes a sound"

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
    def speak(self):  # method override
        return f"{self.name} ({self.breed}) says: Woof!"

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

# Polymorphism
animals = [Dog("Rex", "Shiba Inu"), Cat("Mimi")]
for a in animals:
    print(a.speak())

print(isinstance(Dog("test", "test"), Animal))  # True

Operator overloading

# Operator overloading
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    def __len__(self):
        return int((self.x**2 + self.y**2) ** 0.5)

v1 = Vector(3, 4)
v2 = Vector(1, 2)
print(v1 + v2)        # Vector(4, 6)
print(v1 * 3)         # Vector(9, 12)
print(v1 == Vector(3, 4))  # True
print(len(v1))        # 5

# Operator overloading
class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __repr__(self):
        return f"Vector({self.x}, {self.y})"
    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)
    def __mul__(self, scalar):
        return Vector(self.x * scalar, self.y * scalar)
    def __eq__(self, other):
        return self.x == other.x and self.y == other.y
    def __len__(self):
        return int((self.x**2 + self.y**2) ** 0.5)

v1 = Vector(3, 4)
v2 = Vector(1, 2)
print(v1 + v2)        # Vector(4, 6)
print(v1 * 3)         # Vector(9, 12)
print(v1 == Vector(3, 4))  # True
print(len(v1))        # 5

Common magic methods: __eq__(==), __add__(+), __len__(len()), __getitem__([]), __iter__(for loop).

✎

Exercise

Define a Book class with title and author attributes. Implement __str__ to return '"title" by author' (title wrapped in ASCII double quotes, then a space, the word "by", a space, and the author). Implement __eq__ to compare both title and author for equality.

Your code
 class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
    
    def __str__(self):
        # Return '"title" by author' (title wrapped in ASCII double quotes)
        pass
    
    def __eq__(self, other):
        # Compare both title and author
        pass

# Tests
b1 = Book("Python 101", "Guido")
b2 = Book("Python 101", "Guido")
b3 = Book("Java 101", "James")
print(str(b1))     # "Python 101" by Guido
print(b1 == b2)    # True
print(b1 == b3)    # False class Book:
    def __init__(self, title, author):
        self.title = title
        self.author = author
    
    def __str__(self):
        # Return '"title" by author' (title wrapped in ASCII double quotes)
        pass
    
    def __eq__(self, other):
        # Compare both title and author
        pass

# Tests
b1 = Book("Python 101", "Guido")
b2 = Book("Python 101", "Guido")
b3 = Book("Java 101", "James")
print(str(b1))     # "Python 101" by Guido
print(b1 == b2)    # True
print(b1 == b3)    # False 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Advanced Day 19 / 21 · Week 3

Modules & standard library

Python's standard library is extremely rich — "batteries included". import imports a module; from ... import ... imports specific objects. Every .py file is a module.

Standard library

# Common standard library modules
import random
import math
import datetime

# random — random numbers
print(random.randint(1, 100))    # random int in 1..100
print(random.choice(["red", "yellow", "blue"]))
print(random.sample(range(1, 50), 6))     # unique sampling

# math — math functions
print(math.sqrt(144))   # 12.0
print(math.ceil(3.1))   # 4 (round up)
print(math.floor(3.9))  # 3 (round down)
print(math.gcd(12, 18)) # 6 (greatest common divisor)

# datetime — date & time
now = datetime.datetime.now()
print(now.strftime("%Y-%m-%d %H:%M"))
today = datetime.date.today()
print(today)

# Common standard library modules
import random
import math
import datetime

# random — random numbers
print(random.randint(1, 100))    # random int in 1..100
print(random.choice(["red", "yellow", "blue"]))
print(random.sample(range(1, 50), 6))     # unique sampling

# math — math functions
print(math.sqrt(144))   # 12.0
print(math.ceil(3.1))   # 4 (round up)
print(math.floor(3.9))  # 3 (round down)
print(math.gcd(12, 18)) # 6 (greatest common divisor)

# datetime — date & time
now = datetime.datetime.now()
print(now.strftime("%Y-%m-%d %H:%M"))
today = datetime.date.today()
print(today)

collections & itertools

# collections — advanced containers
from collections import Counter, defaultdict, deque

# Counter — counting
text = "abracadabra"
c = Counter(text)
print(c.most_common(3))  # [('a', 5), ('b', 2), ('r', 2)]

# defaultdict — dict with a default value
dd = defaultdict(list)
dd["fruits"].append("apple")
dd["fruits"].append("banana")
print(dd["fruits"])  # ['apple', 'banana']

# itertools — iteration tools
from itertools import chain, product, combinations
print(list(chain([1, 2], [3, 4])))  # [1, 2, 3, 4]
print(list(combinations("ABC", 2)))  # [('A','B'),...]

# collections — advanced containers
from collections import Counter, defaultdict, deque

# Counter — counting
text = "abracadabra"
c = Counter(text)
print(c.most_common(3))  # [('a', 5), ('b', 2), ('r', 2)]

# defaultdict — dict with a default value
dd = defaultdict(list)
dd["fruits"].append("apple")
dd["fruits"].append("banana")
print(dd["fruits"])  # ['apple', 'banana']

# itertools — iteration tools
from itertools import chain, product, combinations
print(list(chain([1, 2], [3, 4])))  # [1, 2, 3, 4]
print(list(combinations("ABC", 2)))  # [('A','B'),...]

Import styles: import mod (call via mod.func()); from mod import func (call func() directly); import mod as m (alias).

✎

Exercise

Use the random module to generate 5 unique random integers between 1 and 100; store them in a list named numbers and print it. Use random.sample().

Your code
 import random
# Generate 5 unique random integers in 1..100
 import random
# Generate 5 unique random integers in 1..100
 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Advanced Day 20 / 21 · Week 3

Iterators & generators

Generators are a core Python feature — lazy evaluation: they don't produce all values at once, but yield them on demand. When processing large data streams, generators save huge amounts of memory.

Generators

# Generator function: yield instead of return
def countdown(n):
    while n > 0:
        yield n
        n -= 1

# A generator is an iterator
for i in countdown(5):
    print(i, end=" ")  # 5 4 3 2 1
print()

# Manual iteration
gen = countdown(3)
print(next(gen))  # 3
print(next(gen))  # 2
print(next(gen))  # 1

# Generator expression (like a list comprehension but with parens)
squares = (x**2 for x in range(1000000))
print(next(squares))  # 0 — no memory cost!
print(next(squares))  # 1

# Generator function: yield instead of return
def countdown(n):
    while n > 0:
        yield n
        n -= 1

# A generator is an iterator
for i in countdown(5):
    print(i, end=" ")  # 5 4 3 2 1
print()

# Manual iteration
gen = countdown(3)
print(next(gen))  # 3
print(next(gen))  # 2
print(next(gen))  # 1

# Generator expression (like a list comprehension but with parens)
squares = (x**2 for x in range(1000000))
print(next(squares))  # 0 — no memory cost!
print(next(squares))  # 1

Generators — advanced

# Fibonacci generator
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# Take the first 10
from itertools import islice
fib10 = list(islice(fibonacci(), 10))
print(fib10)  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# yield from: delegate to a sub-generator
def flatten(nested):
    for item in nested:
        if isinstance(item, list):
            yield from flatten(item)
        else:
            yield item

print(list(flatten([1, [2, [3, 4]], 5])))
# [1, 2, 3, 4, 5]

# Fibonacci generator
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# Take the first 10
from itertools import islice
fib10 = list(islice(fibonacci(), 10))
print(fib10)  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

# yield from: delegate to a sub-generator
def flatten(nested):
    for item in nested:
        if isinstance(item, list):
            yield from flatten(item)
        else:
            yield item

print(list(flatten([1, [2, [3, 4]], 5])))
# [1, 2, 3, 4, 5]

yield vs return: return ends the function; yield "pauses" it — the next call to next() resumes from where it left off.

✎

Exercise

Write a generator function even_stream() that produces an infinite sequence of even numbers: 0, 2, 4, 6, 8, ... Use islice to take the first 5 and store them in a list named result.

Your code
 from itertools import islice

def even_stream():
    # Use yield to produce even numbers infinitely
    pass

# Take the first 5
 from itertools import islice

def even_stream():
    # Use yield to produce even numbers infinitely
    pass

# Take the first 5
 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

Capstone Day 21 / 21 · Week 3

Capstone: student manager

On the final day, tie everything together — classes, lists, dicts, file I/O, exception handling — and build a student grade manager. This is a typical small Python project.

Requirements: ① add a student (name, age, score); ② list all students; ③ sort by score; ④ compute average and max; ⑤ save to a JSON file.

Student manager

import json

class StudentManager:
    def __init__(self):
        self.students = []
    
    def add(self, name, age, score):
        """Add a student."""
        if not 0 <= score <= 100:
            raise ValueError("score must be between 0 and 100")
        self.students.append({
            "name": name, "age": age, "score": score
        })
    
    def list_all(self):
        """List all students."""
        for s in self.students:
            print(f"  {s['name']:<10} {s['age']}y  {s['score']}pts")
    
    def rank(self):
        """Sort by score, descending."""
        return sorted(self.students, key=lambda s: s["score"], reverse=True)
    
    def stats(self):
        """Compute summary statistics."""
        scores = [s["score"] for s in self.students]
        return {
            "count": len(scores),
            "avg": round(sum(scores) / len(scores), 1),
            "max": max(scores),
            "min": min(scores)
        }
    
    def save(self, path):
        with open(path, "w") as f:
            json.dump(self.students, f, ensure_ascii=False, indent=2)

# Usage
mgr = StudentManager()
mgr.add("Alice", 20, 90)
mgr.add("Bob", 21, 85)
mgr.add("Carol", 19, 95)
mgr.add("Dave", 22, 78)

print("=== All students ===")
mgr.list_all()

print("\n=== Score ranking ===")
for i, s in enumerate(mgr.rank(), 1):
    print(f"  #{i}: {s['name']} {s['score']}pts")

print("\n=== Statistics ===")
for k, v in mgr.stats().items():
    print(f"  {k}: {v}")

import json

class StudentManager:
    def __init__(self):
        self.students = []
    
    def add(self, name, age, score):
        """Add a student."""
        if not 0 <= score <= 100:
            raise ValueError("score must be between 0 and 100")
        self.students.append({
            "name": name, "age": age, "score": score
        })
    
    def list_all(self):
        """List all students."""
        for s in self.students:
            print(f"  {s['name']:<10} {s['age']}y  {s['score']}pts")
    
    def rank(self):
        """Sort by score, descending."""
        return sorted(self.students, key=lambda s: s["score"], reverse=True)
    
    def stats(self):
        """Compute summary statistics."""
        scores = [s["score"] for s in self.students]
        return {
            "count": len(scores),
            "avg": round(sum(scores) / len(scores), 1),
            "max": max(scores),
            "min": min(scores)
        }
    
    def save(self, path):
        with open(path, "w") as f:
            json.dump(self.students, f, ensure_ascii=False, indent=2)

# Usage
mgr = StudentManager()
mgr.add("Alice", 20, 90)
mgr.add("Bob", 21, 85)
mgr.add("Carol", 19, 95)
mgr.add("Dave", 22, 78)

print("=== All students ===")
mgr.list_all()

print("\n=== Score ranking ===")
for i, s in enumerate(mgr.rank(), 1):
    print(f"  #{i}: {s['name']} {s['score']}pts")

print("\n=== Statistics ===")
for k, v in mgr.stats().items():
    print(f"  {k}: {v}")

Congratulations on finishing the 21-day Python journey! You now have the core syntax, data structures, functions, OOP, file I/O, exceptions, and generators under your belt. Next you can explore: web development (Django/Flask), data analysis (Pandas/NumPy), automation scripts, machine learning, and more.

✎

Exercise

Using the StudentManager class above, create a manager, add 3 students (Alice 90, Bob 85, Carol 95), then call stats() and store the returned dict in a variable named info.

Your code
 import json

class StudentManager:
    def __init__(self):
        self.students = []
    def add(self, name, age, score):
        self.students.append({"name": name, "age": age, "score": score})
    def stats(self):
        scores = [s["score"] for s in self.students]
        return {"count": len(scores), "avg": round(sum(scores)/len(scores),1), "max": max(scores), "min": min(scores)}

# Create a manager, add students, get stats
 import json

class StudentManager:
    def __init__(self):
        self.students = []
    def add(self, name, age, score):
        self.students.append({"name": name, "age": age, "score": score})
    def stats(self):
        scores = [s["score"] for s in self.students]
        return {"count": len(scores), "avg": round(sum(scores)/len(scores),1), "max": max(scores), "min": min(scores)}

# Create a manager, add students, get stats
 

Read the explanation above carefully, then give it a try. If you are still stuck, try breaking the code into smaller steps.

🎉

Congratulations on finishing the course!

You have mastered the core of Python. Keep exploring the wider programming world!