Bugs and Binary

Optional: Nested Loops and Advanced Patterns

Prajwal Kumar — Fri, 27 Mar 2026 17:54:29 +0530

Introduction

Sometimes you need to loop through lists inside other loops.

You have rooms organized by floor. You want to process every floor, and within each floor, every room.

Or you're comparing every sheet against every other sheet to find duplicates.

This is what nested loops do — loops inside loops.

But nested loops can make code slow and hard to read. This lesson shows you when they're necessary and when to avoid them.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Writing nested loops
When they're necessary
Performance implications
Keeping them readable
Alternatives when possible

Basic Nested Loop

A nested loop is a loop inside another loop.

floors = [
    ["Office 1", "Office 2"],
    ["Office 3", "Office 4"],
    ["Office 5", "Conference"]
]

for floor in floors:
    for room in floor:
        print(room)

Output:

Office 1
Office 2
Office 3
Office 4
Office 5
Conference

The outer loop processes each floor. The inner loop processes each room in that floor.

How Nested Loops Work

floors = [
    ["A", "B"],
    ["C", "D"]
]

for floor in floors:
    print(f"Floor: {floor}")
    for room in floor:
        print(f"  Room: {room}")

Output:

Floor: ['A', 'B']
  Room: A
  Room: B
Floor: ['C', 'D']
  Room: C
  Room: D

Step by step:

Outer loop: first floor ["A", "B"]
Inner loop: process "A", then "B"
Outer loop: second floor ["C", "D"]
Inner loop: process "C", then "D"

Architectural Example: Rooms by Floor

building = [
    ["Storage", "Mechanical"],
    ["Lobby", "Reception", "Office 1"],
    ["Office 2", "Office 3", "Conference"]
]

floor_names = ["Basement", "Ground", "First"]

for i, rooms in enumerate(building):
    print(f"{floor_names[i]}:")
    for room in rooms:
        print(f"  - {room}")
    print()

Output:

Basement:
  - Storage
  - Mechanical

Ground:
  - Lobby
  - Reception
  - Office 1

First:
  - Office 2
  - Office 3
  - Conference

The Performance Problem

Nested loops can get slow quickly.

# Outer loop: 100 items
# Inner loop: 100 items
# Total iterations: 100 × 100 = 10,000

for i in range(100):
    for j in range(100):
        # This runs 10,000 times
        pass

If each loop has 1,000 items, you get 1,000,000 iterations. This is called O(n²) complexity — it grows exponentially.

Rule of thumb: Avoid nested loops when dealing with large datasets unless absolutely necessary.

When Nested Loops Are Necessary

Use Case 1: Hierarchical Data

When your data has natural layers or levels.

# Sheets organized by discipline
disciplines = {
    "Architectural": ["A-101", "A-102", "A-201"],
    "Structural": ["S-101", "S-102"],
    "MEP": ["M-101", "E-101"]
}

for discipline, sheets in disciplines.items():
    print(f"{discipline}:")
    for sheet in sheets:
        print(f"  {sheet}")

Output:

Architectural:
  A-101
  A-102
  A-201
Structural:
  S-101
  S-102
MEP:
  M-101
  E-101

Use Case 2: Comparing Items

When you need to compare each item against every other item.

sheets = ["A-101", "A-102", "A-101", "A-201"]

print("Finding duplicates:")

for i in range(len(sheets)):
    for j in range(i + 1, len(sheets)):
        if sheets[i] == sheets[j]:
            print(f"Duplicate found: {sheets[i]}")

Output:

Finding duplicates:
Duplicate found: A-101

Use Case 3: Grid/Matrix Operations

When working with coordinates or 2D layouts.

# 3x3 grid of spaces
grid = [
    ["Office", "Office", "Meeting"],
    ["Office", "Open", "Office"],
    ["Storage", "Office", "Break"]
]

print("Grid Layout:")

for row_num, row in enumerate(grid):
    for col_num, space in enumerate(row):
        print(f"({row_num},{col_num}): {space}")

Keeping Nested Loops Readable

Use Descriptive Names

# Bad - unclear
for i in data:
    for j in i:
        print(j)

# Good - clear
for floor in building:
    for room in floor:
        print(room)

Limit Nesting Depth

Avoid more than 2-3 levels of nesting.

# Too deep (4 levels)
for building in campus:
    for floor in building:
        for wing in floor:
            for room in wing:
                # Hard to follow
                pass

# Better - flatten or extract to functions
for building in campus:
    for floor in building:
        process_floor(floor)  # Handle wings and rooms inside function

Add Comments for Complex Logic

floors = [["A", "B"], ["C", "D"]]

# Process each floor
for floor_num, rooms in enumerate(floors):
    print(f"Floor {floor_num}:")

    # Process each room on this floor
    for room in rooms:
        print(f"  Room: {room}")

Alternatives to Nested Loops

Alternative 1: Flatten the Data

Instead of nested loops, flatten your data structure.

# Nested structure
floors = [
    ["Office 1", "Office 2"],
    ["Office 3", "Office 4"]
]

# Nested loop
for floor in floors:
    for room in floor:
        print(room)

# Flattened structure
all_rooms = ["Office 1", "Office 2", "Office 3", "Office 4"]

# Single loop
for room in all_rooms:
    print(room)

If you don't need the floor grouping, flatten it.

Alternative 2: Use Dictionaries

When comparing or looking up values, dictionaries are faster than nested loops.

# Slow - nested loop
sheets = ["A-101", "A-102", "A-201"]
issued = ["A-101", "A-201"]

for sheet in sheets:
    for issued_sheet in issued:
        if sheet == issued_sheet:
            print(f"{sheet} is issued")

# Fast - dictionary lookup
issued_set = set(issued)

for sheet in sheets:
    if sheet in issued_set:
        print(f"{sheet} is issued")

The second version is much faster for large lists.

Alternative 3: Extract to Functions

Move inner loops to separate functions.

# Hard to read
for floor in building:
    for room in floor:
        if room["area"] >= 400:
            if room["height"] >= 2.7:
                print(f"{room['name']}: Compliant")

# Clearer
def is_compliant(room):
    return room["area"] >= 400 and room["height"] >= 2.7

for floor in building:
    for room in floor:
        if is_compliant(room):
            print(f"{room['name']}: Compliant")

You'll learn functions in Module 06.

Real Architectural Workflows

Example 1: Multi-Floor Room Report

building = [
    [{"name": "Storage", "area": 8.5}, {"name": "Mechanical", "area": 12.0}],
    [{"name": "Lobby", "area": 45.0}, {"name": "Office 1", "area": 12.5}],
    [{"name": "Office 2", "area": 15.3}, {"name": "Conference", "area": 32.0}]
]

floor_names = ["Basement", "Ground", "First"]

print("Building Room Report:")
print("=" * 60)

total_area = 0
total_rooms = 0

for floor_num, rooms in enumerate(building):
    floor_area = 0

    print(f"\\n{floor_names[floor_num]}:")
    print("-" * 60)

    for room in rooms:
        print(f"  {room['name']:20} {room['area']:6.1f}m²")
        floor_area += room["area"]
        total_rooms += 1

    print(f"  {'Floor Total:':20} {floor_area:6.1f}m²")
    total_area += floor_area

print("\\n" + "=" * 60)
print(f"Building Total: {total_area:.1f}m² ({total_rooms} rooms)")

Example 2: Sheet Cross-Reference

sheets = ["A-101", "A-102", "A-201"]
referenced_sheets = ["A-101", "S-101", "A-201", "M-101"]

print("Sheet Reference Check:")
print("-" * 50)

missing_refs = []

# Check each referenced sheet
for ref_sheet in referenced_sheets:
    found = False

    # See if it exists in our sheet set
    for sheet in sheets:
        if ref_sheet == sheet:
            found = True
            break

    if not found:
        missing_refs.append(ref_sheet)

if missing_refs:
    print("Missing sheets:")
    for sheet in missing_refs:
        print(f"  - {sheet}")
else:
    print("All referenced sheets exist")

# Output:
# Sheet Reference Check:
# --------------------------------------------------
# Missing sheets:
#   - S-101
#   - M-101

Note: This could be more efficient with a set:

sheet_set = set(sheets)

missing_refs = []
for ref_sheet in referenced_sheets:
    if ref_sheet not in sheet_set:
        missing_refs.append(ref_sheet)

Example 3: Room Pairing (Grid Layout)

# Simplified floor layout (3x3 grid)
layout = [
    ["Office", "Office", "Meeting"],
    ["Office", "Open", "Office"],
    ["Storage", "Office", "Break"]
]

print("Office Locations:")
print("-" * 40)

office_count = 0

for row_num, row in enumerate(layout):
    for col_num, space_type in enumerate(row):
        if space_type == "Office":
            office_count += 1
            print(f"Office {office_count}: Row {row_num}, Col {col_num}")

print(f"\\nTotal offices: {office_count}")

# Output:
# Office Locations:
# ----------------------------------------
# Office 1: Row 0, Col 0
# Office 2: Row 0, Col 1
# Office 3: Row 1, Col 0
# Office 4: Row 1, Col 2
# Office 5: Row 2, Col 1
#
# Total offices: 5

When NOT to Use Nested Loops

Don't Nest When You Can Filter

# Unnecessary nesting
floors = [["Office 1", "Storage"], ["Office 2", "Office 3"]]

for floor in floors:
    for room in floor:
        if "Office" in room:
            print(room)

# Better - flatten first
all_rooms = []
for floor in floors:
    all_rooms.extend(floor)

for room in all_rooms:
    if "Office" in room:
        print(room)

Don't Nest for Lookups

# Slow - O(n²)
sheets = ["A-101", "A-102", "A-201"]
issued = ["A-101", "A-201"]

for sheet in sheets:
    for issued_sheet in issued:
        if sheet == issued_sheet:
            print(f"{sheet} is issued")

# Fast - O(n)
issued_set = set(issued)

for sheet in sheets:
    if sheet in issued_set:
        print(f"{sheet} is issued")

Assignment

Create a new file called nested_loops.py
Basic nested loop:
- Create: floors = [["A", "B"], ["C", "D"], ["E", "F"]]
- Use nested loops to print each room
- Label each floor
Room report by floor:
- Floors: [["Office 1", "Office 2"], ["Office 3", "Conference"], ["Office 4", "Break Room"]]
- Floor names: ["Ground", "First", "Second"]
- Print formatted report with floor names
Finding duplicates:
- List: sheets = ["A-101", "A-102", "A-101", "A-201", "A-102"]
- Use nested loops to find duplicates
- Print each duplicate once
Grid processing:
- Create a 3x3 grid of room types
- Use nested loops with enumerate
- Print position and type for each
Total area calculation:
- Calculate total area across all floors
- Count total rooms
Compare efficiency:
- Create a list of 100 sheets
- Create a list of 50 "issued" sheets
- Find issued sheets using nested loop (time it mentally)
- Find issued sheets using set lookup
- See which is clearer
Real scenario - Multi-floor validation:
- Building with rooms per floor
- Each room has name and area
- Check if any room is below 12m²
- Report which floor and which room
- Count total violations

Floors with room data:

[  [{"name": "Office 1", "area": 12.5}, {"name": "Office 2", "area": 15.3}],  [{"name": "Conference", "area": 45.0}]]

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

What is a nested loop?
Why can nested loops be slow?
When are nested loops necessary?
How do you keep nested loops readable?
What are alternatives to nested loops?
When should you avoid nested loops?

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's nested loop guide provides additional examples and performance analysis
Big O notation explained covers algorithm complexity
When to use nested loops discusses real-world scenarios

Lesson 19: Common Loop Patterns

Prajwal Kumar — Fri, 27 Mar 2026 17:53:29 +0530

Introduction

You know how to write for loops. You know how to control them with break and continue.

Now you need to know the patterns — the common ways loops are actually used in real code.

Filtering lists. Counting items that meet criteria. Transforming data. Getting both index and item. Processing pairs of values.

These patterns come up repeatedly. Learn them once, use them everywhere.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Filtering (building new lists based on conditions)
Counting with conditions
Transforming data
Using enumerate() for index and item
Using zip() to process pairs
Finding min/max manually
Accumulating values

Pattern 1: Filtering

Build a new list containing only items that meet a condition.

room_areas = [450.5, 380.2, 520.8, 410.3, 395.7]

# Get only large rooms (>= 500)
large_rooms = []

for area in room_areas:
    if area >= 500:
        large_rooms.append(area)

print(large_rooms)
# Output: [520.8]

The pattern:

Create empty list
Loop through original list
Check condition
Append matching items

Architectural Example: Filter by Discipline

sheets = ["A-101", "A-102", "S-101", "A-201", "M-101", "S-102"]

# Get only architectural sheets
arch_sheets = []

for sheet in sheets:
    if sheet.startswith("A"):
        arch_sheets.append(sheet)

print(f"Architectural sheets: {arch_sheets}")
# Output: Architectural sheets: ['A-101', 'A-102', 'A-201']

Pattern 2: Counting with Conditions

Count how many items meet specific criteria.

room_areas = [450.5, 380.2, 520.8, 410.3, 395.7]

# Count compliant rooms
compliant_count = 0

for area in room_areas:
    if area >= 400:
        compliant_count += 1

print(f"Compliant rooms: {compliant_count} out of {len(room_areas)}")
# Output: Compliant rooms: 3 out of 5

The pattern:

Initialize counter to 0
Loop through list
Check condition
Increment counter if true

Architectural Example: Count by Status

sheets = ["A-101", "A-102", "A-201", "A-202", "S-101"]
issued = ["A-101", "A-201", "S-101"]

issued_count = 0
draft_count = 0

for sheet in sheets:
    if sheet in issued:
        issued_count += 1
    else:
        draft_count += 1

print(f"Issued: {issued_count}")
print(f"Draft: {draft_count}")
# Output:
# Issued: 3
# Draft: 2

Pattern 3: Transforming Data

Create a new list by transforming each item.

areas_sqm = [450.5, 380.2, 520.8]

# Convert to square feet
areas_sqft = []

for area in areas_sqm:
    area_sqft = area * 10.764
    areas_sqft.append(area_sqft)

print(areas_sqft)
# Output: [4849.122, 4092.4528, 5605.8752]

The pattern:

Create empty list
Loop through original
Transform each item
Append transformed value

Architectural Example: Generate File Names

sheet_numbers = ["A-101", "A-102", "A-201"]
project_code = "2024-001"

file_names = []

for sheet in sheet_numbers:
    file_name = f"{project_code}_{sheet}_Plan.pdf"
    file_names.append(file_name)

for name in file_names:
    print(name)

# Output:
# 2024-001_A-101_Plan.pdf
# 2024-001_A-102_Plan.pdf
# 2024-001_A-201_Plan.pdf

Pattern 4: Using enumerate()

Get both the index and the item in each iteration.

rooms = ["Office 1", "Office 2", "Conference"]

for index, room in enumerate(rooms):
    print(f"Room {index}: {room}")

# Output:
# Room 0: Office 1
# Room 1: Office 2
# Room 2: Conference

Start counting from 1:

for index, room in enumerate(rooms, start=1):
    print(f"Room {index}: {room}")

# Output:
# Room 1: Office 1
# Room 2: Office 2
# Room 3: Conference

Why enumerate() Is Useful

Without enumerate (awkward):

rooms = ["Office 1", "Office 2", "Conference"]

for i in range(len(rooms)):
    print(f"Room {i+1}: {rooms[i]}")

With enumerate (cleaner):

for i, room in enumerate(rooms, start=1):
    print(f"Room {i}: {room}")

Architectural Example: Numbered Room List

rooms = ["Office 1", "Office 2", "Conference", "Break Room"]

print("Room Schedule:")
print("-" * 40)

for number, room in enumerate(rooms, start=1):
    print(f"{number}. {room}")

# Output:
# Room Schedule:
# ----------------------------------------
# 1. Office 1
# 2. Office 2
# 3. Conference
# 4. Break Room

Pattern 5: Using zip()

Process two lists together, pairing up items at the same index.

room_names = ["Office 1", "Office 2", "Conference"]
room_areas = [12.5, 15.3, 45.8]

for name, area in zip(room_names, room_areas):
    print(f"{name}: {area}m²")

# Output:
# Office 1: 12.5m²
# Office 2: 15.3m²
# Conference: 45.8m²

zip() pairs up items: first with first, second with second, etc.

How zip() Works

names = ["A", "B", "C"]
numbers = [1, 2, 3]

for name, number in zip(names, numbers):
    print(f"{name} - {number}")

# Output:
# A - 1
# B - 2
# C - 3

If lists have different lengths, zip() stops at the shortest:

names = ["A", "B", "C"]
numbers = [1, 2]

for name, number in zip(names, numbers):
    print(f"{name} - {number}")

# Output:
# A - 1
# B - 2
# (C is not processed)

Architectural Example: Room Report

room_names = ["Office 1", "Office 2", "Conference", "Break Room"]
room_areas = [12.5, 15.3, 45.8, 18.2]
room_types = ["Private", "Private", "Meeting", "Common"]

print("Room Schedule:")
print("-" * 60)

for name, area, room_type in zip(room_names, room_areas, room_types):
    print(f"{name:15} {area:6.1f}m²  ({room_type})")

# Output:
# Room Schedule:
# ------------------------------------------------------------
# Office 1         12.5m²  (Private)
# Office 2         15.3m²  (Private)
# Conference       45.8m²  (Meeting)
# Break Room       18.2m²  (Common)

Pattern 6: Finding Min/Max Manually

Sometimes you need to find the smallest or largest item while tracking additional info.

room_areas = [450.5, 380.2, 520.8, 410.3]

smallest = room_areas[0]

for area in room_areas:
    if area < smallest:
        smallest = area

print(f"Smallest room: {smallest}m²")
# Output: Smallest room: 380.2m²

The pattern:

Start with first item
Compare each item
Update if condition is met

Architectural Example: Find Largest Non-Compliant Room

room_data = [
    {"name": "Office 1", "area": 420},
    {"name": "Office 2", "area": 380},
    {"name": "Office 3", "area": 395},
    {"name": "Office 4", "area": 450},
]

minimum_area = 400
largest_non_compliant = None

for room in room_data:
    if room["area"] < minimum_area:
        if largest_non_compliant is None or room["area"] > largest_non_compliant["area"]:
            largest_non_compliant = room

if largest_non_compliant:
    print(f"Largest non-compliant: {largest_non_compliant['name']} ({largest_non_compliant['area']}m²)")
else:
    print("All rooms compliant")

# Output: Largest non-compliant: Office 3 (395m²)

Pattern 7: Accumulating Values

Build up a total by adding each item.

room_areas = [450.5, 380.2, 520.8, 410.3]

total_area = 0

for area in room_areas:
    total_area += area

print(f"Total area: {total_area}m²")
# Output: Total area: 1761.8m²

You can also accumulate other things:

# Build a string
sheet_list = ["A-101", "A-102", "A-201"]
result = ""

for sheet in sheet_list:
    result += sheet + ", "

result = result.rstrip(", ")  # Remove trailing comma
print(result)
# Output: A-101, A-102, A-201

Combining Patterns

Real code often combines multiple patterns.

Filter and count:

room_areas = [450.5, 380.2, 520.8, 410.3, 395.7]

large_rooms = []
compliant_count = 0

for area in room_areas:
    # Filter
    if area >= 500:
        large_rooms.append(area)

    # Count
    if area >= 400:
        compliant_count += 1

print(f"Large rooms: {large_rooms}")
print(f"Compliant: {compliant_count}")

# Output:
# Large rooms: [520.8]
# Compliant: 3

Real Architectural Workflows

Example 1: Comprehensive Room Analysis

room_names = ["Office 1", "Office 2", "Conference", "Office 3", "Break Room"]
room_areas = [12.5, 15.3, 45.8, 11.2, 18.2]

# Multiple analyses in one loop
total_area = 0
office_count = 0
small_rooms = []

for name, area in zip(room_names, room_areas):
    # Accumulate total
    total_area += area

    # Count offices
    if "Office" in name:
        office_count += 1

    # Filter small rooms
    if area < 15:
        small_rooms.append(name)

print(f"Total area: {total_area}m²")
print(f"Offices: {office_count}")
print(f"Small rooms: {small_rooms}")

# Output:
# Total area: 103.0m²
# Offices: 3
# Small rooms: ['Office 1', 'Office 3']

Example 2: Sheet Processing Report

sheets = ["A-101", "A-102", "A-201", "S-101", "S-102"]
issued = ["A-101", "S-101"]

print("Sheet Processing Report:")
print("-" * 50)

processed = []
skipped = []

for i, sheet in enumerate(sheets, start=1):
    if sheet in issued:
        status = "Issued - Skipped"
        skipped.append(sheet)
    else:
        status = "Draft - Processed"
        processed.append(sheet)

    print(f"{i}. {sheet}: {status}")

print()
print(f"Processed: {len(processed)} sheets")
print(f"Skipped: {len(skipped)} sheets")

# Output:
# Sheet Processing Report:
# --------------------------------------------------
# 1. A-101: Issued - Skipped
# 2. A-102: Draft - Processed
# 3. A-201: Draft - Processed
# 4. S-101: Issued - Skipped
# 5. S-102: Draft - Processed
#
# Processed: 3 sheets
# Skipped: 2 sheets

Example 3: Building Code Compliance Check

rooms = ["Office 1", "Office 2", "Storage", "Office 3"]
areas = [12.5, 15.3, 8.2, 11.8]
heights = [2.8, 2.9, 2.5, 2.7]

minimum_area = 12.0
minimum_height = 2.7

compliant = []
violations = []

for name, area, height in zip(rooms, areas, heights):
    issues = []

    if area < minimum_area:
        issues.append(f"area {area}m² < {minimum_area}m²")
    if height < minimum_height:
        issues.append(f"height {height}m < {minimum_height}m")

    if issues:
        violations.append(f"{name}: {', '.join(issues)}")
    else:
        compliant.append(name)

print("Compliance Report:")
print("-" * 50)
print(f"Compliant: {len(compliant)}")
for room in compliant:
    print(f"  ✓ {room}")

print(f"\\nViolations: {len(violations)}")
for violation in violations:
    print(f"  ✗ {violation}")

# Output:
# Compliance Report:
# --------------------------------------------------
# Compliant: 2
#   ✓ Office 1
#   ✓ Office 2
#
# Violations: 2
#   ✗ Storage: area 8.2m² < 12.0m², height 2.5m < 2.7m
#   ✗ Office 3: height 2.7m < 2.7m

When to Use Each Pattern

Filtering: Need only items that meet criteria Counting: Need totals for different categories Transforming: Need modified version of each item enumerate(): Need position and item together zip(): Need to process multiple lists together Finding min/max: Need extremes with additional context Accumulating: Need running totals or combined values

Assignment

Create a new file called loop_patterns.py
Filtering:
- List: areas = [450.5, 380.2, 520.8, 410.3, 395.7]
- Create new list with only areas >= 400
- Print the filtered list
Counting:
- Same list
- Count how many are: small (< 400), standard (400-600), large (> 600)
- Print counts for each category
Transforming:
- List: areas_sqm = [450, 380, 520]
- Convert to square feet (multiply by 10.764)
- Store in new list
- Print both lists
Using enumerate:
- List: rooms = ["Office 1", "Office 2", "Conference", "Break Room"]
- Print numbered list starting from 1
Using zip:
- Names: ["Office 1", "Office 2", "Conference"]
- Areas: [12.5, 15.3, 45.8]
- Print each: "Name: Area"
Finding max:
- List: areas = [450.5, 380.2, 520.8, 410.3]
- Find largest area manually (don't use max())
- Print result
Accumulating:
- Same list
- Calculate total area
- Calculate average (total / count)
- Print both
Combining patterns:
- Names: ["Office 1", "Office 2", "Office 3", "Storage"]
- Areas: [12.5, 15.3, 11.2, 8.5]
- Use zip to process both
- Filter offices only (name contains "Office")
- Calculate total office area
- Count offices
- Print summary
Real scenario - Compliance analysis:
- Rooms: ["Office 1", "Office 2", "Storage", "Office 3"]
- Areas: [12.5, 15.3, 8.2, 11.8]
- Minimum: 12.0
- Use enumerate and zip
- Create compliant list and non-compliant list
- Print numbered report showing each room's status

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

How do you build a filtered list?
How do you count items that meet a condition?
How do you create a transformed version of a list?
What does enumerate() give you?
What does zip() do with two lists?
How do you calculate a running total?

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's enumerate() documentation covers additional parameters and use cases
Python's zip() documentation explains how to handle unequal length lists
Real Python's guide to Python enumerate() provides comprehensive examples

Lesson 18: Loop Control (break and continue)

Prajwal Kumar — Fri, 27 Mar 2026 17:51:42 +0530

Introduction

You know how to loop through lists with for loops. You know how to repeat until a condition changes with while loops.

But sometimes you need more control. You need to exit a loop early when you find what you're looking for. Or skip certain items without processing them.

This is what break and continue do.

break exits the loop immediately. continue skips to the next iteration.

They give you fine-grained control over loop execution.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Using break to exit loops early
Using continue to skip iterations
When to use each
Combining with conditionals
Common patterns

The break Statement

break exits the loop immediately, skipping any remaining iterations.

sheets = ["A-101", "A-102", "S-101", "S-102", "M-101"]

# Find first structural sheet
for sheet in sheets:
    if sheet.startswith("S"):
        print(f"Found structural sheet: {sheet}")
        break  # Stop searching

Output:

Found structural sheet: S-101

The loop stops as soon as it finds "S-101". It never checks "S-102" or "M-101".

How break Works

When Python hits break, it exits the loop immediately and continues with the code after the loop.

for i in range(1, 11):
    if i == 5:
        print("Stopping at 5")
        break
    print(i)

print("Loop finished")

Output:

1
2
3
4
Stopping at 5
Loop finished

The loop processes 1, 2, 3, 4, then hits the break at 5 and exits.

Architectural Example: Finding a Specific Sheet

sheets = ["A-101", "A-102", "A-201", "A-202", "S-101"]
target = "A-201"
found = False

print(f"Searching for {target}...")

for sheet in sheets:
    print(f"  Checking {sheet}")
    if sheet == target:
        print(f"  Found it!")
        found = True
        break

if not found:
    print(f"{target} not found")

Output:

Searching for A-201...
  Checking A-101
  Checking A-102
  Checking A-201
  Found it!

It stops checking once it finds the target. No need to check the remaining sheets.

break with while Loops

break works with while loops too.

revision = 0

while True:  # Infinite loop
    revision += 1
    print(f"Revision {revision}")

    if revision >= 5:
        print("Approved")
        break  # Exit the loop

print("Done")

Output:

Revision 1
Revision 2
Revision 3
Revision 4
Revision 5
Approved
Done

while True creates an infinite loop, but break exits it when the condition is met.

The continue Statement

continue skips the rest of the current iteration and moves to the next one.

room_areas = [450.5, 380.2, 520.8, 410.3, 395.7]

# Process only compliant rooms
for area in room_areas:
    if area < 400:
        continue  # Skip non-compliant rooms

    print(f"Processing room: {area}m²")

Output:

Processing room: 450.5m²
Processing room: 520.8m²
Processing room: 410.3m²

The rooms with areas below 400 are skipped. The code after continue doesn't run for those items.

How continue Works

When Python hits continue, it skips the rest of the loop body and goes to the next iteration.

for i in range(1, 11):
    if i % 2 == 0:  # Skip even numbers
        continue
    print(i)

Output:

Even numbers (2, 4, 6, 8, 10) are skipped.

Architectural Example: Processing Issued Sheets Only

sheets = ["A-101", "A-102", "A-201", "A-202"]
issued = ["A-101", "A-201"]

print("Processing issued sheets:")

for sheet in sheets:
    if sheet not in issued:
        continue  # Skip draft sheets

    print(f"  Exporting {sheet}")
    print(f"  Sending to contractor")

Output:

Processing issued sheets:
  Exporting A-101
  Sending to contractor
  Exporting A-201
  Sending to contractor

Draft sheets (A-102, A-202) are skipped entirely.

break vs continue

break:

Exits the entire loop
Use when you found what you're looking for
Use when a condition means you should stop entirely

continue:

Skips to the next iteration
Use when you want to skip certain items
Use when some items don't need processing

# break - stop at first failure
for area in room_areas:
    if area < 400:
        print("Found non-compliant room, stopping check")
        break
    print(f"{area}m²: OK")

# continue - skip failures, check everything
for area in room_areas:
    if area < 400:
        continue  # Skip this one
    print(f"{area}m²: OK")

Common Patterns

Pattern 1: Early Exit on Error

sheets = ["A-101", "A-102", "INVALID", "A-201"]

print("Validating sheets:")

for sheet in sheets:
    if len(sheet) < 5:
        print(f"Error: Invalid sheet number '{sheet}'")
        break
    print(f"  {sheet}: Valid")

print("Validation stopped")

Output:

Validating sheets:
  A-101: Valid
  A-102: Valid
Error: Invalid sheet number 'INVALID'
Validation stopped

Pattern 2: Skip Invalid Data

room_areas = [450.5, -1, 520.8, 0, 410.3]

print("Valid room areas:")

for area in room_areas:
    if area <= 0:
        continue  # Skip invalid data
    print(f"  {area}m²")

Output:

Valid room areas:
  450.5m²
  520.8m²
  410.3m²

Pattern 3: Find First Match

floor_names = ["Basement", "Ground", "First", "Second"]
target = "First"

for i, floor in enumerate(floor_names):
    if floor == target:
        print(f"'{target}' is at index {i}")
        break
else:
    print(f"'{target}' not found")

Output:

'First' is at index 2

Pattern 4: Process Subset

sheets = ["A-101", "A-102", "S-101", "A-201", "M-101"]

print("Architectural sheets only:")

for sheet in sheets:
    if not sheet.startswith("A"):
        continue  # Skip non-architectural

    print(f"  {sheet}")

Output:

Architectural sheets only:
  A-101
  A-102
  A-201

Real Architectural Workflows

Example 1: Finding Non-Compliant Rooms

room_data = [
    {"name": "Office 1", "area": 420},
    {"name": "Office 2", "area": 380},
    {"name": "Office 3", "area": 450},
    {"name": "Office 4", "area": 395},
]

minimum_area = 400

print("Checking for first non-compliant room:")

for room in room_data:
    if room["area"] >= minimum_area:
        continue  # Skip compliant rooms

    # First non-compliant room found
    print(f"Found: {room['name']} ({room['area']}m²)")
    break

print("Check complete")

Output:

Checking for first non-compliant room:
Found: Office 2 (380m²)
Check complete

Example 2: Export Only Changed Sheets

sheets = ["A-101", "A-102", "A-201", "A-202"]
unchanged = ["A-102", "A-202"]

print("Exporting modified sheets:")

for sheet in sheets:
    if sheet in unchanged:
        print(f"  {sheet}: Skipped (unchanged)")
        continue

    print(f"  {sheet}: Exported")

Output:

Exporting modified sheets:
  A-101: Exported
  A-102: Skipped (unchanged)
  A-201: Exported
  A-202: Skipped (unchanged)

Example 3: Stop at Budget Limit

items = [
    {"name": "Windows", "cost": 50000},
    {"name": "Doors", "cost": 30000},
    {"name": "Flooring", "cost": 40000},
    {"name": "Lighting", "cost": 25000},
]

budget = 100000
spent = 0

print("Adding items to project:")

for item in items:
    if spent + item["cost"] > budget:
        print(f"\\nBudget limit reached at {spent}")
        print(f"Cannot add: {item['name']}")
        break

    spent += item["cost"]
    print(f"  {item['name']}: ${item['cost']} (Total: ${spent})")

print(f"\\nFinal total: ${spent}")

Output:

Adding items to project:
  Windows: $50000 (Total: $50000)
  Doors: $30000 (Total: $80000)

Budget limit reached at 80000
Cannot add: Flooring

Final total: $80000

The else Clause with Loops

Loops can have an else block that runs if the loop completes without hitting break.

sheets = ["A-101", "A-102", "A-201"]
target = "S-101"

for sheet in sheets:
    if sheet == target:
        print(f"Found {target}")
        break
else:
    print(f"{target} not found")

Output:

S-101 not found

If break is hit, the else doesn't run. If the loop completes normally, else runs.

This is useful for search patterns:

# Find first non-compliant room
for area in room_areas:
    if area < 400:
        print(f"Non-compliant: {area}m²")
        break
else:
    print("All rooms compliant")

Common Mistakes

Using continue when you mean break

# Wrong - continues checking all rooms
for area in room_areas:
    if area < 400:
        print("Found non-compliant room")
        continue  # Keeps looping!

If you want to stop at the first non-compliant room, use break, not continue.

break/continue in wrong place

# Wrong - break is outside the if
for area in room_areas:
    if area < 400:
        print("Non-compliant")
    break  # This always breaks on first iteration!

break needs to be inside the condition if you want conditional exit.

Forgetting what continue does

for area in room_areas:
    if area < 400:
        continue
    # This code runs for compliant rooms only
    print(f"{area}m²: Processing")

After continue, the code below it doesn't run for that iteration.

When NOT to Use break/continue

Don't use continue when filtering:

# Awkward
compliant = []
for area in room_areas:
    if area < 400:
        continue
    compliant.append(area)

# Clearer
compliant = []
for area in room_areas:
    if area >= 400:
        compliant.append(area)

The second version is more straightforward.

Don't use break when you can use a condition:

# Awkward
count = 0
for i in range(100):
    if count >= 10:
        break
    count += 1

# Clearer
for i in range(10):
    # Just loop 10 times

Use the right tool. If you know the count, use range.

Assignment

Create a new file called loop_control.py
Find first match with break:
- List: sheets = ["A-101", "A-102", "S-101", "S-102", "M-101"]
- Find and print the first sheet starting with "S"
- Use break to stop searching
Skip invalid data with continue:
- List: areas = [450.5, -1, 520.8, 0, 410.3, -5]
- Print only positive areas
- Use continue to skip invalid values
Search with else:
- List: sheets = ["A-101", "A-102", "A-201"]
- Search for "A-150"
- Use break if found
- Use else to print "not found"
Stop at threshold:
- List: costs = [5000, 3000, 4000, 2500, 6000]
- Budget: 10000
- Add costs until budget exceeded
- Use break when limit reached
- Print total spent
Process subset:
- List: sheets = ["A-101", "A-102", "S-101", "A-201", "M-101"]
- Process only sheets starting with "A"
- Use continue to skip others
- Print processed sheets
Early exit on error:
- List: areas = [450, 420, -50, 380]
- Check each area
- If any negative, print error and break
- Otherwise print "All valid"
Real scenario - Compliance check:
- Rooms: [{"name": "Office 1", "area": 420}, {"name": "Office 2", "area": 380}, {"name": "Office 3", "area": 450}]
- Find first non-compliant room (< 400)
- Print its name and area
- Stop checking after first failure

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

What does break do?
What does continue do?
When should you use break vs continue?
What does the else clause do with loops?
What happens if break is outside the if block?

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's break and continue documentation covers loop control in detail
Real Python's guide to loop control provides additional examples and use cases

Lesson 17: while Loops (Repeating Until Done)

Prajwal Kumar — Fri, 27 Mar 2026 17:50:47 +0530

Introduction

In the last lesson, you learned for loops — they process every item in a list.

But sometimes you don't have a list. Sometimes you need to repeat something until a condition changes.

Keep processing revisions until the design is approved. Count down floors until you reach ground level. Ask for input until the user provides valid data.

This is what while loops do. They repeat as long as a condition is true.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Writing while loops
Loop conditions
Updating variables inside loops
Avoiding infinite loops
When to use while vs for
Common while loop patterns

Basic while Loop

A while loop repeats as long as its condition is true.

count = 1

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

print("Done")

Output:

Count: 1
Count: 2
Count: 3
Count: 4
Count: 5
Done

The loop checks the condition before each iteration. When it becomes false, the loop stops.

The Syntax

while condition:
    # code block (indented)
    # this repeats while condition is True

Key parts:

while — keyword that starts the loop
condition — must be True for loop to continue
: — colon required
Indented block — code that repeats

How It Works

Python checks the condition before each iteration.

floor = 3

while floor > 0:
    print(f"Floor {floor}")
    floor -= 1

print("Ground level")

Step 1: Is floor > 0? Yes (3 > 0). Print "Floor 3", floor becomes 2 Step 2: Is floor > 0? Yes (2 > 0). Print "Floor 2", floor becomes 1 Step 3: Is floor > 0? Yes (1 > 0). Print "Floor 1", floor becomes 0 Step 4: Is floor > 0? No (0 is not > 0). Exit loop Continue: Print "Ground level"

Output:

Floor 3
Floor 2
Floor 1
Ground level

Updating the Condition

The loop must eventually make the condition false. Otherwise, it runs forever.

This works (condition changes):

revision = 0

while revision < 5:
    revision += 1
    print(f"Revision {revision}")

The condition eventually becomes false when revision reaches 5.

This doesn't work (infinite loop):

revision = 0

while revision < 5:
    print(f"Revision {revision}")
    # revision never changes - infinite loop!

Without updating revision, the condition stays true forever. The loop never ends.

Infinite Loops

An infinite loop runs forever because its condition never becomes false.

# Infinite loop - don't run this!
count = 1

while count > 0:
    print(count)
    count += 1  # count keeps growing, always > 0

To stop an infinite loop: Press Ctrl+C in the terminal.

Always make sure your loop has a way to exit.

Architectural Example: Processing Revisions

revision = 0
status = "Draft"

while status != "Approved" and revision < 10:
    revision += 1
    print(f"Creating revision {revision}...")

    # Simulate approval after 5 revisions
    if revision >= 5:
        status = "Approved"

print(f"Final status: {status} after {revision} revisions")

Output:

Creating revision 1...
Creating revision 2...
Creating revision 3...
Creating revision 4...
Creating revision 5...
Final status: Approved after 5 revisions

The loop continues until the status is approved OR we hit 10 revisions (safety limit).

while vs for

Use for loops when:

You have a list to process
You know how many iterations you need
You're iterating through a collection

rooms = ["Office 1", "Office 2", "Office 3"]

for room in rooms:
    print(room)

Use while loops when:

You repeat until a condition changes
You don't know how many iterations you'll need
The loop depends on external factors

floor = 10

while floor > 0:
    print(f"Floor {floor}")
    floor -= 1

In practice: You'll use for loops 90% of the time. while loops are for specific situations.

Common Patterns

Pattern 1: Countdown

floor = 5

while floor >= 0:
    if floor == 0:
        print("Ground floor")
    else:
        print(f"Floor {floor}")
    floor -= 1

Pattern 2: Processing Until Valid

# Simulate checking if data is valid
attempts = 0
max_attempts = 3
valid = False

while not valid and attempts < max_attempts:
    attempts += 1
    print(f"Attempt {attempts}")

    # Simulate validation
    if attempts == 2:
        valid = True
        print("Data validated")

if not valid:
    print("Validation failed after maximum attempts")

Pattern 3: Building Up to a Target

current_area = 0
target_area = 1000

room_size = 150

while current_area < target_area:
    current_area += room_size
    print(f"Current total: {current_area}m²")

print(f"Target of {target_area}m² reached")

Output:

Current total: 150m²
Current total: 300m²
Current total: 450m²
Current total: 600m²
Current total: 750m²
Current total: 900m²
Current total: 1050m²
Target of 1000m² reached

Real Architectural Workflows

Example 1: Sheet Revision Counter

sheet_number = "A-101"
revision = 0
max_revisions = 5

print(f"Processing {sheet_number}")

while revision < max_revisions:
    revision += 1
    print(f"  Revision {revision}: In progress")

print(f"  Final: Revision {revision} issued")

Output:

Processing A-101
  Revision 1: In progress
  Revision 2: In progress
  Revision 3: In progress
  Revision 4: In progress
  Revision 5: In progress
  Final: Revision 5 issued

Example 2: Floor-by-Floor Processing

current_floor = 10
target_floor = 0

print("Descending floors:")

while current_floor > target_floor:
    print(f"  Processing floor {current_floor}")
    current_floor -= 1

print(f"Reached floor {target_floor}")

Output:

Descending floors:
  Processing floor 10
  Processing floor 9
  Processing floor 8
  Processing floor 7
  Processing floor 6
  Processing floor 5
  Processing floor 4
  Processing floor 3
  Processing floor 2
  Processing floor 1
Reached floor 0

Example 3: Accumulating Until Threshold

total_area = 0
target_area = 2000
room_count = 0

# Average room size
room_size = 420

print(f"Adding rooms until {target_area}m² is reached:")

while total_area < target_area:
    room_count += 1
    total_area += room_size
    print(f"  Room {room_count}: {total_area}m² total")

print(f"\\nNeeded {room_count} rooms to reach {target_area}m²")

Output:

Adding rooms until 2000m² is reached:
  Room 1: 420m² total
  Room 2: 840m² total
  Room 3: 1260m² total
  Room 4: 1680m² total
  Room 5: 2100m² total

Needed 5 rooms to reach 2000m²

Combining while with Lists

You can use while loops with lists, though for loops are usually clearer.

sheets = ["A-101", "A-102", "A-201", "A-202"]
index = 0

while index < len(sheets):
    print(sheets[index])
    index += 1

This works, but a for loop is simpler:

sheets = ["A-101", "A-102", "A-201", "A-202"]

for sheet in sheets:
    print(sheet)

Use the right tool for the job. If you have a list, use a for loop.

Common Mistakes

Forgetting to update the condition variable

# Infinite loop!
count = 0

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

Always update the variable that affects the condition.

Wrong comparison operator

floor = 5

# This never runs (condition is immediately false)
while floor < 0:
    print(floor)
    floor -= 1

If floor starts at 5, it's never less than 0. The loop never executes. You probably meant floor > 0.

No exit condition

# Infinite loop!
approved = False

while not approved:
    print("Waiting for approval...")
    # approved never changes to True

Make sure there's a way for the condition to become false.

Add a safety limit:

approved = False
checks = 0
max_checks = 10

while not approved and checks < max_checks:
    checks += 1
    print(f"Check {checks}: Waiting for approval...")

    # Simulate approval
    if checks == 5:
        approved = True

Off-by-one errors

count = 1

# Runs 4 times, not 5
while count < 5:
    print(count)
    count += 1

# Output: 1, 2, 3, 4 (missing 5)

If you want to include 5, use <=:

count = 1

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

# Output: 1, 2, 3, 4, 5

When NOT to Use while Loops

Don't use while when for is clearer:

# Awkward
rooms = ["Office 1", "Office 2", "Office 3"]
i = 0

while i < len(rooms):
    print(rooms[i])
    i += 1

# Better
for room in rooms:
    print(room)

Don't use while for fixed iterations:

# Awkward
count = 0

while count < 10:
    print(f"Floor {count + 1}")
    count += 1

# Better
for floor in range(1, 11):
    print(f"Floor {floor}")

Use while only when the number of iterations depends on a changing condition.

Assignment

Create a new file called while_loops.py
Basic countdown:
- Start at 5
- Loop while count > 0
- Print each number
- Decrement count
Count up to target:
- Start at 0
- Target: 10
- Loop while count < target
- Print each number
- Increment count
Floor descent:
- Start at floor 8
- Count down to ground (0)
- Print each floor number
Accumulate until threshold:
- Start with total = 0
- Target = 1000
- Add 150 each iteration
- Print running total
- Stop when target is reached or exceeded
Revision counter:
- Start at revision 0
- Max revisions = 5
- Loop while revision < max
- Print revision number
- Increment revision
Conditional exit:
- Start with status = "Draft"
- Counter = 0
- Loop while status != "Approved" and counter < 10
- Increment counter each time
- Set status = "Approved" when counter reaches 5
- Print final status and counter
Compare with for loop:
- Write a while loop that counts 1-10
- Write a for loop with range() that does the same
- See which is clearer
Intentional mistakes:
- Write a while loop that would run infinitely (but comment it out!)
- Write a while loop with wrong comparison (condition never true)
- See what happens with off-by-one errors

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

What does a while loop do?
When does a while loop stop running?
Why must you update the condition variable?
What causes an infinite loop?
When should you use while instead of for?
When is a for loop better than while?

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's while loop documentation covers the technical details
Real Python's while loop guide provides additional examples and patterns

Lesson 16: for Loops (Iterating Through Lists)

Prajwal Kumar — Fri, 27 Mar 2026 17:49:43 +0530

Introduction

You've learned how to store multiple items in lists. You've learned how to make decisions with if statements.

But so far, to work with every item in a list, you'd need to write code for each one individually:

rooms = ["Office 1", "Office 2", "Office 3", "Office 4", "Office 5"]

print(rooms[0])
print(rooms[1])
print(rooms[2])
print(rooms[3])
print(rooms[4])

This is manageable for 5 rooms. It's absurd for 500.

for loops solve this. They let you write code once and apply it to every item in a list automatically.

This is the lesson where Python stops being a learning exercise and starts being genuinely useful.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Writing basic for loops
Loop variables and iteration
Processing each item
Building new lists while looping
Counting and accumulating values
Combining loops with conditionals

Basic for Loop

A for loop processes each item in a list, one at a time.

rooms = ["Office 1", "Office 2", "Office 3"]

for room in rooms:
    print(room)

Output:

Office 1
Office 2
Office 3

The code inside the loop (the indented part) runs once for each item in the list.

The Syntax

for item in list:
    # code block (indented)
    # this runs once for each item

Key parts:

for — keyword that starts the loop
item — temporary variable that holds the current item
in — keyword connecting the variable to the list
list — the list you're looping through
: — colon required
Indented block — code that runs for each item

How It Works

Python processes the loop step by step:

sheets = ["A-101", "A-102", "A-201"]

for sheet in sheets:
    print(f"Processing {sheet}")

Step 1: sheet = "A-101", print "Processing A-101" Step 2: sheet = "A-102", print "Processing A-102" Step 3: sheet = "A-201", print "Processing A-201" Done: Loop exits, code continues

The loop variable (sheet) automatically updates with each iteration.

Naming Loop Variables

The loop variable name is up to you. Choose something descriptive.

# Good - descriptive
for room in rooms:
    print(room)

for sheet_number in sheet_numbers:
    print(sheet_number)

for area in room_areas:
    print(area)

# Bad - vague
for x in rooms:
    print(x)

for item in room_areas:
    print(item)

The name should make the code readable. Someone should be able to understand what's being processed.

Processing Each Item

You can do anything with the current item inside the loop.

Check conditions:

room_areas = [450.5, 380.2, 520.8, 410.3]

for area in room_areas:
    if area < 400:
        print(f"Warning: Room area {area}m² is below minimum")

Output:

Warning: Room area 380.2m² is below minimum

Perform calculations:

room_areas = [450.5, 380.2, 520.8, 410.3]

for area in room_areas:
    area_sqft = area * 10.764
    print(f"{area}m² = {area_sqft:.1f} sq ft")

Architectural Example: Validating Rooms

room_areas = [450.5, 380.2, 520.8, 410.3, 395.7]
minimum_area = 400

print("Room Compliance Check:")
print("-" * 30)

for area in room_areas:
    if area >= minimum_area:
        status = "✓ Compliant"
    else:
        status = "✗ Non-compliant"

    print(f"{area}m²: {status}")

Output:

Room Compliance Check:
------------------------------
450.5m²: ✓ Compliant
380.2m²: ✗ Non-compliant
520.8m²: ✓ Compliant
410.3m²: ✓ Compliant
395.7m²: ✗ Non-compliant

You wrote the logic once. It checked all 5 rooms. It would work the same for 500 rooms.

Building New Lists

You can create a new list by appending items during the loop.

Filter large rooms:

room_areas = [450.5, 380.2, 520.8, 410.3, 395.7]

large_rooms = []

for area in room_areas:
    if area >= 500:
        large_rooms.append(area)

print(large_rooms)
# Output: [520.8]

Transform data:

areas_sqm = [450.5, 380.2, 520.8]
areas_sqft = []

for area in areas_sqm:
    area_sqft = area * 10.764
    areas_sqft.append(area_sqft)

print(areas_sqft)
# Output: [4849.122, 4092.4528, 5605.8752]

Counting and Accumulating

Use loops to count items or calculate totals.

Count compliant rooms:

room_areas = [450.5, 380.2, 520.8, 410.3, 395.7]

compliant_count = 0

for area in room_areas:
    if area >= 400:
        compliant_count += 1

print(f"Compliant rooms: {compliant_count} out of {len(room_areas)}")
# Output: Compliant rooms: 3 out of 5

Calculate total area:

room_areas = [450.5, 380.2, 520.8, 410.3, 395.7]

total_area = 0

for area in room_areas:
    total_area += area

average_area = total_area / len(room_areas)

print(f"Total area: {total_area}m²")
print(f"Average area: {average_area:.1f}m²")
# Output:
# Total area: 2157.5m²
# Average area: 431.5m²

Looping Through Different Types

Numbers:

floor_numbers = [1, 2, 3, 4, 5]

for floor in floor_numbers:
    print(f"Processing floor {floor}")

Strings:

sheet_numbers = ["A-101", "A-102", "A-201"]

for sheet in sheet_numbers:
    print(f"Sheet: {sheet}")

Mixed (but keep lists homogeneous when possible):

# Works, but not recommended
mixed = ["A-101", 12, True]

for item in mixed:
    print(item)

Real Architectural Workflows

Example 1: Sheet Status Report

sheets = ["A-101", "A-102", "A-201", "A-202", "S-101"]
issued = ["A-101", "A-201", "S-101"]

print("Sheet Status Report:")
print("-" * 40)

for sheet in sheets:
    if sheet in issued:
        status = "Issued"
    else:
        status = "Draft"

    print(f"{sheet}: {status}")

Output:

Sheet Status Report:
----------------------------------------
A-101: Issued
A-102: Draft
A-201: Issued
A-202: Draft
S-101: Issued

Example 2: Room Categorization

room_areas = [450.5, 380.2, 520.8, 410.3, 395.7, 680.4]

small = []
standard = []
large = []

for area in room_areas:
    if area < 400:
        small.append(area)
    elif area < 600:
        standard.append(area)
    else:
        large.append(area)

print(f"Small rooms: {len(small)}")
print(f"Standard rooms: {len(standard)}")
print(f"Large rooms: {len(large)}")

# Output:
# Small rooms: 2
# Standard rooms: 3
# Large rooms: 1

Example 3: Building File Names

sheet_numbers = ["A-101", "A-102", "A-201"]
project_code = "2024-001"

file_names = []

for sheet in sheet_numbers:
    file_name = f"{project_code}_{sheet}_Floor_Plan.pdf"
    file_names.append(file_name)

for file_name in file_names:
    print(file_name)

# Output:
# 2024-001_A-101_Floor_Plan.pdf
# 2024-001_A-102_Floor_Plan.pdf
# 2024-001_A-201_Floor_Plan.pdf

The range() Function

Sometimes you need to loop a specific number of times, not through a list.

for i in range(5):
    print(i)

Output:

range(5) creates a sequence from 0 to 4 (5 numbers total).

Architectural example:

for floor in range(1, 11):
    print(f"Processing floor {floor}")

# Output:
# Processing floor 1
# Processing floor 2
# ...
# Processing floor 10

range(1, 11) creates numbers from 1 to 10 (11 is exclusive).

Looping with Indexes

If you need both the item and its position, use enumerate().

rooms = ["Office 1", "Office 2", "Conference"]

for index, room in enumerate(rooms):
    print(f"Room {index}: {room}")

Output:

Room 0: Office 1
Room 1: Office 2
Room 2: Conference

If you want to start counting from 1:

for index, room in enumerate(rooms, start=1):
    print(f"Room {index}: {room}")

Output:

Room 1: Office 1
Room 2: Office 2
Room 3: Conference

Common Mistakes

Modifying the list while looping

# Don't do this
rooms = ["Office 1", "Office 2", "Office 3"]

for room in rooms:
    if room == "Office 2":
        rooms.remove(room)  # Modifying while iterating causes issues

This can skip items or cause errors. Instead, build a new list:

# Do this
rooms = ["Office 1", "Office 2", "Office 3"]
filtered_rooms = []

for room in rooms:
    if room != "Office 2":
        filtered_rooms.append(room)

rooms = filtered_rooms

Wrong indentation

rooms = ["Office 1", "Office 2"]

for room in rooms:
print(room)  # Not indented - error!

The code block must be indented.

Forgetting to create accumulator variables

# Wrong - compliant_count doesn't exist
for area in room_areas:
    if area >= 400:
        compliant_count += 1  # Error!

Initialize before the loop:

# Correct
compliant_count = 0
for area in room_areas:
    if area >= 400:
        compliant_count += 1

Using the loop variable after the loop

sheets = ["A-101", "A-102", "A-201"]

for sheet in sheets:
    print(sheet)

print(f"Last sheet processed: {sheet}")  # This works but is confusing

After the loop, sheet holds the last value ("A-201"). This works but can be confusing. If you need the last item, be explicit:

last_sheet = sheets[-1]
print(f"Last sheet: {last_sheet}")

Assignment

Create a new file called for_loops.py
Basic loop:
- Create a list: rooms = ["Office 1", "Office 2", "Conference", "Break Room"]
- Loop through and print each room
Conditional processing:
- List: room_areas = [450.5, 380.2, 520.8, 410.3, 395.7]
- Loop through and print warnings for rooms below 400m²
Counting:
- Same list as above
- Count how many rooms are compliant (>= 400m²)
- Print the count
Building a filtered list:
- Same list
- Create a new list with only large rooms (>= 500m²)
- Print the new list
Calculating totals:
- Loop through the areas
- Calculate total area
- Calculate average area
- Print both
Categorization:
- Create three empty lists: small, standard, large
- Loop through room_areas
- Categorize each: < 400 = small, 400-600 = standard, > 600 = large
- Print how many in each category
Sheet naming:
- List: sheets = ["101", "102", "201", "202"]
- Loop through and create file names: "A-{number}_Plan.pdf"
- Store in a new list
- Print all file names
Using range():
- Loop from 1 to 10 (floors)
- Print "Floor {number}"
Real scenario - Compliance report:
- Areas: [450.5, 380.2, 520.8, 410.3, 395.7]
- Minimum: 400m²
- Loop through and print each area with status (Compliant/Non-compliant)
- Count total compliant and non-compliant
- Print summary

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

What does a for loop do?
What are the required parts of a for loop?
How does Python process a for loop?
How do you create a filtered list using a loop?
How do you count items that meet a condition?
What does range(5) produce?
How do you get both the index and the item in a loop?
Why shouldn't you modify a list while looping through it?

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's official for loop documentation covers additional details and examples
Real Python's guide to for loops provides comprehensive coverage with architectural patterns
Python Tutor lets you visualize how loops execute step by step

Optional: Writing Clean Conditionals

Prajwal Kumar — Fri, 27 Mar 2026 16:16:13 +0530

Introduction

You know how to write if statements. You know how to combine conditions. You can check requirements and validate data.

But conditionals can get messy fast.

Nested if statements inside other if statements. Long chains of conditions that are hard to follow. Logic that works but takes mental effort to parse.

This lesson is about writing conditionals that are not just correct, but readable. Code that you (or someone else) can understand six months from now without having to trace through every branch.

These aren't essential skills for basic automation, but they'll make your code easier to maintain as your scripts grow more complex.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

When nesting is necessary vs unnecessary
How to flatten nested conditions
Keeping conditions readable
Common refactoring patterns
Avoiding common pitfalls

Nesting: When It Makes Sense

Sometimes you need to nest conditions because the logic requires it.

Example: Check if something exists before checking its properties

sheet_number = "A-101"
submitted_sheets = ["A-101", "A-102", "A-201"]
sheet_status = {"A-101": "Issued", "A-102": "Draft"}

# Check if sheet is submitted first
if sheet_number in submitted_sheets:
    # Only check status if it exists
    if sheet_number in sheet_status:
        if sheet_status[sheet_number] == "Issued":
            print("Sheet is issued")
        else:
            print("Sheet is not issued")
    else:
        print("Status unknown")
else:
    print("Sheet not submitted")

This nesting makes sense because each check depends on the previous one. You can't check the status if the sheet doesn't exist.

Unnecessary Nesting

Often, conditions that look like they need nesting can be flattened.

Example: Checking multiple independent conditions

# Nested (harder to read)
room_area = 420

if room_area >= 400:
    if room_area < 600:
        category = "Standard"

Flattened (clearer):

room_area = 420

if room_area >= 400 and room_area < 600:
    category = "Standard"

Or even better, use a range check:

if 400 <= room_area < 600:
    category = "Standard"

Flattening with elif

Nested conditions can often be replaced with elif.

Nested version:

sheet_discipline = "A"
sheet_number = 250

if sheet_discipline == "A":
    if sheet_number > 200:
        category = "Elevations/Sections"
    else:
        category = "Plans"
else:
    category = "Other discipline"

Flattened version:

sheet_discipline = "A"
sheet_number = 250

if sheet_discipline == "A" and sheet_number > 200:
    category = "Elevations/Sections"
elif sheet_discipline == "A":
    category = "Plans"
else:
    category = "Other discipline"

The flattened version is easier to scan. Each possibility is at the same indentation level.

Early Returns (In Functions)

When you learn functions (Module 06), you'll use early returns to avoid nesting.

Preview:

# Nested (harder to follow)
def check_room(area, height):
    if area >= 400:
        if height >= 2.7:
            return "Compliant"
        else:
            return "Height insufficient"
    else:
        return "Area insufficient"

# Early returns (clearer)
def check_room(area, height):
    if area < 400:
        return "Area insufficient"

    if height < 2.7:
        return "Height insufficient"

    return "Compliant"

The second version checks failure conditions first and exits early. If the code reaches the end, you know everything passed.

We'll cover this more in Module 06. For now, just know this pattern exists.

Breaking Up Complex Conditions

Long conditions are hard to read. Break them into named variables.

Hard to read:

if room_area >= 400 and ceiling_height >= 2.7 and has_windows and not is_basement and has_egress and fire_rating >= 1:
    print("Habitable")

Easier to read:

area_ok = room_area >= 400
height_ok = ceiling_height >= 2.7
light_ok = has_windows and not is_basement
safety_ok = has_egress and fire_rating >= 1

if area_ok and height_ok and light_ok and safety_ok:
    print("Habitable")

The second version is self-documenting. You can see what each part checks without parsing the entire condition.

Architectural Example: Complex Validation

Before (one long condition):

if room_area >= minimum_area and ceiling_height >= minimum_height and has_windows and not is_basement and has_fire_exit and fire_rating >= required_rating and ventilation_adequate:
    status = "Approved"
else:
    status = "Rejected"

After (broken down):

# Size requirements
meets_size = room_area >= minimum_area and ceiling_height >= minimum_height

# Light and location
meets_location = has_windows and not is_basement

# Safety requirements
meets_safety = has_fire_exit and fire_rating >= required_rating and ventilation_adequate

# Overall check
if meets_size and meets_location and meets_safety:
    status = "Approved"
else:
    status = "Rejected"

This also makes debugging easier. If something fails, you can check each variable individually.

Avoid Deep Nesting

As a rule of thumb, try to avoid more than 2-3 levels of nesting.

Too deep (4 levels):

if discipline == "A":
    if floor > 0:
        if area > 400:
            if has_windows:
                print("Habitable residential space")

Better (flattened):

is_residential = (
    discipline == "A" and
    floor > 0 and
    area > 400 and
    has_windows
)

if is_residential:
    print("Habitable residential space")

When Nesting Is Actually Better

Sometimes nesting is clearer because it shows dependency.

Example: Progressive checks

# Clear dependency: only check status if sheet exists
if sheet_number in submitted_sheets:
    status = sheet_status.get(sheet_number)

    if status == "Issued":
        print("Send to contractor")
    elif status == "Draft":
        print("Continue work")
    else:
        print("Status unknown")
else:
    print("Sheet not submitted")

This nesting makes sense. The status checks only matter if the sheet was submitted.

Flattening this would be awkward:

# Less clear
if sheet_number in submitted_sheets and sheet_status.get(sheet_number) == "Issued":
    print("Send to contractor")
elif sheet_number in submitted_sheets and sheet_status.get(sheet_number) == "Draft":
    print("Continue work")
elif sheet_number in submitted_sheets:
    print("Status unknown")
else:
    print("Sheet not submitted")

The flattened version repeats the existence check. The nested version is actually clearer here.

Positive vs Negative Conditions

Write conditions positively when possible.

Negative (harder to parse):

if not is_not_approved:
    print("Approved")

Positive (clearer):

if is_approved:
    print("Approved")

Another example:

# Negative
if not (area < minimum_area):
    print("Compliant")

# Positive (clearer)
if area >= minimum_area:
    print("Compliant")

Comments for Complex Logic

When conditions are genuinely complex, add comments explaining the business logic.

# Fire safety: Building is compliant if it has EITHER:
# 1. Fire doors on every floor, OR
# 2. Full sprinkler system AND fire alarm
compliant = (
    has_fire_doors_all_floors or
    (has_full_sprinklers and has_fire_alarm)
)

if compliant:
    print("Fire safety requirements met")

The comment explains why the condition exists, not just what it does.

Real Examples: Before and After

Example 1: Room Categorization

Before:

room_area = 450

if room_area >= 400:
    if room_area < 600:
        category = "Standard"
    else:
        if room_area < 800:
            category = "Large"
        else:
            category = "Oversized"
else:
    category = "Too Small"

After:

room_area = 450

if room_area < 400:
    category = "Too Small"
elif room_area < 600:
    category = "Standard"
elif room_area < 800:
    category = "Large"
else:
    category = "Oversized"

Example 2: Sheet Processing

Before:

if sheet_number in submitted_sheets:
    if sheet_discipline == "A":
        if sheet_type == "Plan":
            if sheet_status == "Issued":
                print("Process architectural plan")

After:

is_arch_plan = (
    sheet_number in submitted_sheets and
    sheet_discipline == "A" and
    sheet_type == "Plan" and
    sheet_status == "Issued"
)

if is_arch_plan:
    print("Process architectural plan")

Example 3: Validation with Detailed Feedback

Before:

if area >= 400:
    if height >= 2.7:
        if has_windows:
            print("Compliant")
        else:
            print("Non-compliant: No windows")
    else:
        print("Non-compliant: Insufficient height")
else:
    print("Non-compliant: Insufficient area")

After:

# Check each requirement
issues = []

if area < 400:
    issues.append("Insufficient area")
if height < 2.7:
    issues.append("Insufficient height")
if not has_windows:
    issues.append("No windows")

# Report
if issues:
    print("Non-compliant:")
    for issue in issues:
        print(f"  - {issue}")
else:
    print("Compliant")

The second version reports all issues at once, not just the first one encountered.

Common Pitfalls

Over-nesting

# Too deep
if a:
    if b:
        if c:
            if d:
                print("All true")

Flatten when possible:

if a and b and c and d:
    print("All true")

Repeating Conditions

# Repeated checks
if status == "Issued" and discipline == "A":
    print("Architectural issued")
elif status == "Draft" and discipline == "A":
    print("Architectural draft")
elif status == "Review" and discipline == "A":
    print("Architectural in review")

Better:

if discipline == "A":
    if status == "Issued":
        print("Architectural issued")
    elif status == "Draft":
        print("Architectural draft")
    elif status == "Review":
        print("Architectural in review")

Or extract the check:

is_architectural = discipline == "A"

if is_architectural:
    if status == "Issued":
        print("Architectural issued")
    elif status == "Draft":
        print("Architectural draft")
    elif status == "Review":
        print("Architectural in review")

Assignment

Create a new file called clean_conditionals.py
Refactor this nested condition:

room_area = 450

if room_area >= 400:
    if room_area < 600:
        print("Standard")

Flatten it using and

Refactor this nested condition:

if discipline == "A":
    if number > 200:
        category = "Elevations"
    else:
        category = "Plans"

Use elif instead

Break up this complex condition:

if area >= 400 and height >= 2.7 and windows and not basement:
    print("Compliant")

Create named boolean variables for each check
Combine them clearly

Find and fix the over-nesting:

if submitted:
    if reviewed:
        if approved:
            print("Ready")

Flatten appropriately

Improve readability:

if not (area < 400):
    print("Compliant")

Rewrite positively

Real scenario - Validation with feedback:
- Check: area >= 400, height >= 2.7, has_windows = True
- List ALL issues, not just the first
- Print them clearly

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

How can you flatten nested if statements?
When should you use elif instead of nested if?
Why break complex conditions into named variables?
What's a good rule of thumb for nesting depth?
When is nesting actually clearer than flattening?
Why write positive conditions instead of negative ones?

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's style guide (PEP 8) includes recommendations for writing clear conditionals
Real Python's guide to code quality covers refactoring techniques and best practices

Lesson 15: Combining Conditions (and, or, not)

Prajwal Kumar — Fri, 27 Mar 2026 16:13:48 +0530

Introduction

In the last lesson, you learned to check single conditions. But real-world validation rarely involves just one check.

A room isn't just compliant because it meets the area requirement. It also needs adequate ceiling height, proper ventilation, and fire safety measures.

A sheet isn't ready for issue just because it's marked "Approved." It also needs to be reviewed, have no outstanding comments, and match the current design intent.

This is where logical operators come in. They let you combine multiple conditions into one check.

Python provides three logical operators: and, or, and not.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Using and to require all conditions
Using or to require at least one condition
Using not to reverse a condition
Combining operators with parentheses
Common validation patterns

The and Operator

Use and when ALL conditions must be true.

room_area = 420
ceiling_height = 2.8

if room_area >= 400 and ceiling_height >= 2.7:
    print("Room is compliant")

Both conditions must be true for the code to run:

room_area >= 400 must be True
ceiling_height >= 2.7 must be True

If either is false, the entire condition is false.

Truth Table for and

True  and True  = True
True  and False = False
False and True  = False
False and False = False

All conditions must be true. One false condition makes the whole thing false.

Architectural Example: Room Compliance

room_area = 420
ceiling_height = 2.8
has_windows = True

minimum_area = 400
minimum_height = 2.7

if room_area >= minimum_area and ceiling_height >= minimum_height and has_windows:
    print("Room meets all habitability requirements")
else:
    print("Room does not meet requirements")

All three conditions must be true:

Area >= 400
Height >= 2.7
Has windows

If any one fails, the room is non-compliant.

The or Operator

Use or when AT LEAST ONE condition must be true.

has_fire_door = False
has_sprinklers = True
has_fire_alarm = True

if has_fire_door or has_sprinklers or has_fire_alarm:
    print("Fire safety requirement met")

At least one condition must be true. If any one is true, the entire condition is true.

Truth Table for or

True  or True  = True
True  or False = True
False or True  = True
False or False = False

Only one condition needs to be true. All must be false for the result to be false.

Architectural Example: Fire Safety

has_fire_door = False
has_sprinklers = True
has_fire_alarm = False

if has_fire_door or has_sprinklers or has_fire_alarm:
    print("Fire safety: Compliant")
else:
    print("Fire safety: Non-compliant - needs at least one safety measure")

# Output: Fire safety: Compliant (sprinklers = True)

The building needs at least one fire safety measure. It has sprinklers, so it's compliant.

The not Operator

Use not to reverse a boolean value.

is_basement = False

if not is_basement:
    print("Floor is above ground")

not flips the value:

not True becomes False
not False becomes True

Truth Table for not

not True  = False
not False = True

Architectural Example: Floor Eligibility

is_basement = False
is_mechanical = False

if not is_basement and not is_mechanical:
    print("Floor is habitable")
else:
    print("Floor is not habitable")

# Output: Floor is habitable

The floor is habitable if it's NOT a basement AND NOT a mechanical floor.

Combining Multiple Operators

You can combine and, or, and not in the same condition.

room_area = 420
ceiling_height = 2.8
is_basement = False
has_windows = True

if room_area >= 400 and ceiling_height >= 2.7 and not is_basement and has_windows:
    print("Room is habitable")

All of these must be true:

Area >= 400
Height >= 2.7
NOT basement
Has windows

Operator Precedence

When combining operators, Python evaluates them in this order:

not (highest priority)
and
or (lowest priority)

result = True or False and False
print(result)  # Output: True

This evaluates as: True or (False and False) → True or False → True

Best practice: Use parentheses to make your intent clear, even if they're not strictly necessary.

result = True or (False and False)  # Explicit

Using Parentheses for Clarity

Parentheses let you control the order of evaluation and make complex conditions more readable.

room_area = 420
is_corner_unit = True
has_windows = False

# Without parentheses (confusing)
if room_area >= 400 and is_corner_unit or has_windows:
    print("Acceptable")

# With parentheses (clear)
if (room_area >= 400 and is_corner_unit) or has_windows:
    print("Acceptable")

The first version is ambiguous. The second version is explicit: area AND corner unit, OR has windows.

Common Patterns

Pattern 1: Range Checking (Between Min and Max)

room_area = 450
min_area = 400
max_area = 600

if room_area >= min_area and room_area <= max_area:
    print("Area is within acceptable range")

You can also use chained comparisons (from Module 02):

if min_area <= room_area <= max_area:
    print("Area is within acceptable range")

Both work. The chained version is more concise.

Pattern 2: Exclusion (Not This and Not That)

floor_type = "Residential"

if floor_type != "Basement" and floor_type != "Mechanical":
    print("Floor is habitable")

Or using not in with a list:

excluded_types = ["Basement", "Mechanical", "Parking"]

if floor_type not in excluded_types:
    print("Floor is habitable")

The second approach scales better if you have many exclusions.

Pattern 3: At Least One Required Feature

has_elevator = True
has_ramp = False
has_ground_access = False

if has_elevator or has_ramp or has_ground_access:
    print("Building is accessible")
else:
    print("Building requires accessibility improvements")

Pattern 4: All Requirements Must Be Met

has_permits = True
design_approved = True
budget_approved = True
site_ready = False

if has_permits and design_approved and budget_approved and site_ready:
    print("Ready to begin construction")
else:
    print("Not ready - check requirements")

# Output: Not ready - check requirements (site_ready is False)

Real Architectural Workflows

Example 1: Complex Room Validation

room_area = 420
ceiling_height = 2.8
has_windows = True
is_basement = False
has_egress = True

minimum_area = 400
minimum_height = 2.7

# All conditions must be met
is_habitable = (
    room_area >= minimum_area and
    ceiling_height >= minimum_height and
    has_windows and
    not is_basement and
    has_egress
)

if is_habitable:
    print("Room is habitable")
    print("Approved for occupancy")
else:
    print("Room does not meet habitability requirements")

    # Detailed feedback
    if room_area < minimum_area:
        print(f"  - Area too small: {room_area}m² (minimum: {minimum_area}m²)")
    if ceiling_height < minimum_height:
        print(f"  - Height too low: {ceiling_height}m (minimum: {minimum_height}m)")
    if not has_windows:
        print("  - No windows")
    if is_basement:
        print("  - Basement location not allowed")
    if not has_egress:
        print("  - No emergency egress")

Example 2: Sheet Readiness Check

design_complete = True
reviewed = True
no_open_comments = False
matches_specs = True

ready_for_issue = (
    design_complete and
    reviewed and
    no_open_comments and
    matches_specs
)

if ready_for_issue:
    print("Sheet is ready for issue")
else:
    print("Sheet is not ready for issue:")

    if not design_complete:
        print("  - Design incomplete")
    if not reviewed:
        print("  - Not reviewed")
    if not no_open_comments:
        print("  - Has open comments")
    if not matches_specs:
        print("  - Does not match specifications")

# Output:
# Sheet is not ready for issue:
#   - Has open comments

Example 3: Priority Assignment

severity = "High"
affects_construction = True
deadline_passed = False

# Critical if severity is high AND affects construction OR deadline passed
is_critical = (severity == "High" and affects_construction) or deadline_passed

if is_critical:
    priority = 1
    response_time = "24 hours"
else:
    priority = 2
    response_time = "3 days"

print(f"Priority: {priority}, Response time: {response_time}")
# Output: Priority: 1, Response time: 24 hours

Common Mistakes

Using and when you mean or

# Wrong - this is never true
if room_type == "Office" and room_type == "Meeting":
    print("Conference space")

A room can't be both "Office" AND "Meeting" at the same time. You probably meant or:

if room_type == "Office" or room_type == "Meeting":
    print("Workspace")

Forgetting parentheses in complex conditions

# Ambiguous
if area >= 400 and height >= 2.7 or has_windows:
    print("Compliant")

# Clear
if (area >= 400 and height >= 2.7) or has_windows:
    print("Compliant")

The second version makes it obvious: (area AND height) OR windows.

Double negatives

# Confusing
if not not is_approved:
    print("Approved")

# Clear
if is_approved:
    print("Approved")

Avoid double negatives. They make code hard to read.

Checking the same thing multiple times

# Redundant
if area >= 400 and area > 300:
    print("Large room")

If area >= 400 is true, then area > 300 is automatically true. The second check is redundant.

Assignment

Create a new file called combining_conditions.py
Room habitability checker:
- Variables: area = 420, height = 2.8, windows = True
- Minimums: min_area = 400, min_height = 2.7
- Check if ALL requirements are met
- Print "Habitable" or "Not habitable"
Fire safety validator:
- Variables: fire_door = False, sprinklers = True, alarm = False
- At least ONE must be true
- Print "Compliant" or "Non-compliant"
Floor eligibility:
- Variables: floor_number = 3, is_mechanical = False
- Floor is habitable if: floor >= 0 AND NOT mechanical
- Print result
Range validation:
- Variable: room_area = 520
- Valid range: 400 to 600
- Use AND to check both min and max
- Print "Within range" or "Out of range"
Complex project readiness:
- Variables: permits = True, design_done = True, budget_ok = False, site_ready = True
- Project can start if ALL are true
- Print "Ready to start" or "Not ready"
- If not ready, print which conditions failed
Priority assignment:
- Variables: severity = "High", urgent = True
- Critical if: severity == "High" AND urgent
- Print priority level
Exclusion check:
- Variable: floor_type = "Residential"
- Excluded types: "Basement", "Mechanical", "Parking"
- Check if floor_type is NOT in excluded list
- Print "Allowed" or "Not allowed"
Experiment:
- Write a condition with and where both are true
- Write a condition with and where one is false (see result)
- Write a condition with or where both are false
- Use parentheses to change the order of evaluation

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

When does an and condition return True?
When does an or condition return True?
What does not do to a boolean value?
Which operator has the highest priority: and, or, or not?
Why should you use parentheses in complex conditions?
How do you check if a value is within a range using and?

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's boolean operations documentation covers logical operators in detail
Real Python's guide to operators provides additional examples and use cases

Lesson 14: Making Decisions (if, elif, else)

Prajwal Kumar — Fri, 27 Mar 2026 16:12:23 +0530

Introduction

You've learned how to store data in variables and lists. You've learned how to perform calculations and manipulate strings. But so far, your programs do the same thing every time they run.

Real workflows aren't like that. You need to check conditions and respond accordingly.

Is this room compliant with code? If yes, approve it. If no, flag it for review.

Is this sheet issued? If yes, skip it. If no, process it.

This is what control flow does — it lets your code make decisions based on conditions. The primary tool for this is the if statement.

This lesson covers all forms of conditional logic: if, else, and elif. We'll build from simple checks to complex decision trees.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Writing basic if statements
Adding else blocks for two outcomes
Using elif for multiple conditions
Understanding code blocks and indentation
Common patterns in architectural validation

Basic if Statements

An if statement checks a condition. If the condition is True, the indented code block runs. If False, it's skipped.

room_area = 420

if room_area >= 400:
    print("Room meets minimum area requirement")

If room_area is 420, the condition room_area >= 400 is True, so the print statement executes.

If room_area is 350, the condition is False, so nothing prints.

The Syntax

if condition:
    # code block (indented)
    # this runs if condition is True

Key points:

The condition must evaluate to True or False
The colon : is required
The code block must be indented (4 spaces or 1 tab)
If the condition is False, the block is skipped entirely

Indentation Matters

Python uses indentation to define code blocks. This is different from many other languages that use curly braces {}.

room_area = 420

if room_area >= 400:
    print("Room is compliant")
    print("Approved for construction")

print("Check complete")

The first two print statements are inside the if block (indented). They only run if the condition is true.

The last print statement is outside the block (not indented). It runs regardless.

Output (when room_area = 420):

Room is compliant
Approved for construction
Check complete

Output (when room_area = 350):

Check complete

Architectural Example: Room Compliance

room_area = 380
minimum_area = 400

if room_area < minimum_area:
    print(f"Warning: Room area {room_area}m² is below minimum {minimum_area}m²")

Output:

Warning: Room area 380m² is below minimum 400m²

If the room meets the requirement, nothing prints. Sometimes that's what you want — only flag problems.

Adding else: Two Outcomes

Often you need to handle both cases: what happens if the condition is true, AND what happens if it's false.

room_area = 420

if room_area >= 400:
    print("Room is compliant")
else:
    print("Room is too small")

Now there are two possible paths:

If room_area >= 400 is True: "Room is compliant"
If room_area >= 400 is False: "Room is too small"

One or the other always executes. Never both.

The Syntax

if condition:
    # runs if condition is True
else:
    # runs if condition is False

The else block is optional. Use it when you need to handle both outcomes.

Architectural Example: Sheet Status

sheet_status = "Draft"

if sheet_status == "Issued":
    print("Sheet is approved for construction")
else:
    print("Sheet needs review before issue")

Output:

Sheet needs review before issue

This explicitly handles both cases: issued sheets and everything else.

Multiple Conditions: elif

What if you have more than two possibilities?

You could write multiple if statements:

room_area = 450

if room_area < 400:
    category = "Too Small"

if room_area >= 400 and room_area < 500:
    category = "Standard"

if room_area >= 500 and room_area < 700:
    category = "Large"

if room_area >= 700:
    category = "Oversized"

This works, but it's inefficient. Every if is checked even after you've found the answer.

Better: use elif (else if).

room_area = 450

if room_area < 400:
    category = "Too Small"
elif room_area < 500:
    category = "Standard"
elif room_area < 700:
    category = "Large"
else:
    category = "Oversized"

print(category)  # Output: Standard

How elif Works

elif means "else if" — if the previous conditions were false, check this one.

Python checks conditions in order:

Is room_area < 400? No (450 is not < 400)
Is room_area < 500? Yes (450 < 500)
Execute that block, skip the rest

Once one condition is true, the rest are ignored. This is efficient and prevents overlap.

The Syntax

if condition_1:
    # runs if condition_1 is True
elif condition_2:
    # runs if condition_1 is False and condition_2 is True
elif condition_3:
    # runs if previous conditions are False and condition_3 is True
else:
    # runs if all conditions are False

You can have as many elif blocks as needed. The else at the end is optional but common — it catches everything that didn't match.

Order Matters

The order of conditions matters because Python stops at the first True condition.

room_area = 450

# Correct order
if room_area < 400:
    category = "Too Small"
elif room_area < 500:
    category = "Standard"
elif room_area < 700:
    category = "Large"
else:
    category = "Oversized"

print(category)  # Output: Standard

If you reverse the order:

# Wrong order
if room_area < 700:
    category = "Large"  # This catches 450!
elif room_area < 500:
    category = "Standard"  # Never reached

Here, 450 < 700, so it's categorized as "Large" and the Standard check never runs.

Rule: Order conditions from most specific to least specific, or from smallest to largest ranges.

Architectural Example: Floor Classification

floor_number = 0

if floor_number < 0:
    floor_type = "Basement"
elif floor_number == 0:
    floor_type = "Ground Floor"
elif floor_number <= 3:
    floor_type = "Lower Floors"
elif floor_number <= 10:
    floor_type = "Mid Floors"
else:
    floor_type = "Upper Floors"

print(f"Floor {floor_number}: {floor_type}")
# Output: Floor 0: Ground Floor

When to Use Each Form

Just if: Use when you only care about one case (usually flagging problems).

if area < minimum:
    print("Warning: Area too small")

if-else: Use when you have exactly two outcomes.

if status == "Issued":
    print("Approved")
else:
    print("Not approved")

if-elif-else: Use when you have multiple distinct possibilities.

if area < 400:
    category = "Small"
elif area < 600:
    category = "Medium"
else:
    category = "Large"

Real Architectural Workflows

Example 1: Room Validation

room_area = 380
room_height = 2.6

minimum_area = 400
minimum_height = 2.7

# Check area
if room_area < minimum_area:
    print(f"Area violation: {room_area}m² (minimum: {minimum_area}m²)")

# Check height
if room_height < minimum_height:
    print(f"Height violation: {room_height}m (minimum: {minimum_height}m)")

# Output:
# Area violation: 380m² (minimum: 400m²)
# Height violation: 2.6m (minimum: 2.7m)

Example 2: Sheet Status Categorization

sheet_status = "Draft"

if sheet_status == "Issued":
    action = "Send to contractor"
elif sheet_status == "Approved":
    action = "Prepare for issue"
elif sheet_status == "In Review":
    action = "Wait for approval"
elif sheet_status == "Draft":
    action = "Continue design work"
else:
    action = "Unknown status - check manually"

print(f"Action: {action}")
# Output: Action: Continue design work

Example 3: Priority Assignment

issue_severity = "Critical"

if issue_severity == "Critical":
    priority = 1
    deadline = "24 hours"
elif issue_severity == "High":
    priority = 2
    deadline = "3 days"
elif issue_severity == "Medium":
    priority = 3
    deadline = "1 week"
else:
    priority = 4
    deadline = "2 weeks"

print(f"Priority: {priority}, Deadline: {deadline}")
# Output: Priority: 1, Deadline: 24 hours

Common Mistakes

Forgetting the colon

if room_area >= 400  # Missing colon
    print("Compliant")
# SyntaxError: invalid syntax

The colon is required. It signals the start of the code block.

Wrong indentation

if room_area >= 400:
print("Compliant")  # Not indented
# IndentationError: expected an indented block

The code block must be indented. Use 4 spaces (or 1 tab, but be consistent).

Using = instead of ==

if room_area = 400:  # Wrong - this is assignment
    print("Compliant")
# SyntaxError: invalid syntax

Use == for comparison, not = (which is assignment).

Overlapping elif conditions

room_area = 450

if room_area < 500:
    category = "Small"
elif room_area < 600:  # Never reached if area is 450
    category = "Medium"

If 450 < 500, the first condition is true, so the second is never checked. Order your conditions carefully.

Missing else when you need it

status = "Unknown"

if status == "Issued":
    action = "Send to contractor"
elif status == "Draft":
    action = "Continue work"

print(action)
# Error: UnboundLocalError (if status is neither)

If status is something else, action is never defined. Add an else to catch unexpected values:

if status == "Issued":
    action = "Send to contractor"
elif status == "Draft":
    action = "Continue work"
else:
    action = "Check status manually"

Assignment

Create a new file called conditionals.py
Room area validator:
- Create variables: room_area = 380, minimum_area = 400
- Write an if statement that prints a warning if the room is too small
Add an else block:
- Print "Room is compliant" if it meets the requirement
Sheet status checker:
- Variable: sheet_status = "Draft"
- Use if-elif-else to print an action for each status:
  - "Issued" → "Send to contractor"
  - "Approved" → "Prepare for issue"
  - "Draft" → "Continue work"
  - Anything else → "Unknown status"
Room categorization:
- Variable: room_area = 520
- Use if-elif-else to categorize:
  - < 400: "Too Small"
  - < 500: "Standard"
  - < 700: "Large"
  - = 700: "Oversized"
- Print the category
Floor classification:
- Variable: floor_number = 5
- Categorize:
  - < 0: "Basement"
  - == 0: "Ground"
  - 1-3: "Lower"
  - 4-10: "Mid"
  - 10: "Upper"
Real scenario - Compliance checker:
- Variables: area = 420, height = 2.6
- Minimums: min_area = 400, min_height = 2.7
- Check both conditions
- If both pass: "Compliant"
- If either fails: print which one(s) failed
Experiment:
- Try an if statement without a colon (see the error)
- Try a code block without indentation (see the error)
- Use = instead of == in a condition (see the error)
- Write elif conditions in wrong order and see what happens

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

What does an if statement do?
Why does indentation matter in Python?
What does an else block do?
What is elif short for?
What happens when one elif condition is True?
Why does the order of conditions matter?
When would you use just if vs if-else vs if-elif-else?

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's official documentation on if statements provides additional details
Real Python's guide to conditionals covers edge cases and best practices

Optional: Intermediate List Techniques

Prajwal Kumar — Tue, 10 Mar 2026 16:29:47 +0530

Introduction

Everything you've learned in the previous three lessons is enough to start building real automation scripts. You can create lists, modify them, and use methods to organize and analyze data.

This lesson is optional. It covers techniques that aren't essential for basic workflows but become useful as your scripts get more complex.

Come back to this lesson when you need these techniques. You'll know when that is — either because you hit a problem that these solve, or because you see them in someone else's code and want to understand what's happening.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Lists containing lists (nested lists)
Advanced slicing techniques
Introduction to tuples (immutable lists)
When you might need these techniques

Lists of Lists

A list can contain other lists. This is called a nested list or a list of lists.

Basic Example

# Rooms organized by floor
floor_1_rooms = ["Office 1", "Office 2"]
floor_2_rooms = ["Office 3", "Office 4"]

# Store both floors in one list
all_floors = [floor_1_rooms, floor_2_rooms]

print(all_floors)
# Output: [["Office 1", "Office 2"], ["Office 3", "Office 4"]]

Now all_floors is a list containing two lists.

Accessing Items

To access items in a nested list, use multiple indexes.

all_floors = [["Office 1", "Office 2"], ["Office 3", "Office 4"]]

# Get the first floor
first_floor = all_floors[0]
print(first_floor)
# Output: ["Office 1", "Office 2"]

# Get a specific room
room = all_floors[0][1]
print(room)
# Output: Office 2

The syntax all_floors[0][1] means:

all_floors[0] → Get the first floor list
[1] → Get the second item in that list

Architectural Example: Organizing Rooms by Floor

basement_rooms = ["Storage", "Mechanical"]
ground_rooms = ["Lobby", "Reception", "Office 1"]
first_rooms = ["Office 2", "Office 3", "Conference"]

building = [basement_rooms, ground_rooms, first_rooms]

# How many floors?
floor_count = len(building)
print(f"Floors: {floor_count}")
# Output: Floors: 3

# How many rooms on ground floor?
ground_floor_room_count = len(building[1])
print(f"Ground floor rooms: {ground_floor_room_count}")
# Output: Ground floor rooms: 3

# Print all floors and their rooms
for i, floor_rooms in enumerate(building):
    print(f"Floor {i}: {floor_rooms}")

# Output:
# Floor 0: ["Storage", "Mechanical"]
# Floor 1: ["Lobby", "Reception", "Office 1"]
# Floor 2: ["Office 2", "Office 3", "Conference"]

(The enumerate() function gives you both the index and the item. You'll see this more in Module 05.)

When to Use Lists of Lists

Lists of lists are useful when your data has natural layers or groups:

Rooms organized by floor
Sheets organized by discipline
Coordinates (list of [x, y, z] points)
Schedule data (list of rows, each row is a list of values)

Example: Sheet organization

arch_sheets = ["A-101", "A-102", "A-201"]
struct_sheets = ["S-101", "S-102"]
mep_sheets = ["M-101", "E-101"]

all_sheets = [arch_sheets, struct_sheets, mep_sheets]

# Total sheets across all disciplines
total = sum(len(discipline) for discipline in all_sheets)
print(f"Total sheets: {total}")
# Output: Total sheets: 7

Advanced Slicing

You've already seen basic slicing: my_list[start:end]. There's more you can do.

Step Values

You can specify a step value: my_list[start:end:step]

sheets = ["A-101", "A-102", "A-201", "A-202", "S-101", "S-102"]

# Every other item
every_other = sheets[::2]
print(every_other)
# Output: ["A-101", "A-201", "S-101"]

# Every third item
every_third = sheets[::3]
print(every_third)
# Output: ["A-101", "A-202"]

The syntax is [start:end:step]. If you omit start and end, it means "entire list."

Reversing with Slicing

A negative step reverses the list.

sheets = ["A-101", "A-102", "A-201", "A-202"]

reversed_sheets = sheets[::-1]

print(reversed_sheets)
# Output: ["A-202", "A-201", "A-102", "A-101"]

This creates a new reversed list without modifying the original.

Compare to .reverse():

sheets.reverse()  # Modifies original

reversed_sheets = sheets[::-1]  # Creates new list, original unchanged

Copying a List

You can copy a list using slicing.

original = ["A-101", "A-102", "A-201"]

# Copy the list
copy = original[:]

# Modify the copy
copy.append("A-202")

print(original)  # Output: ["A-101", "A-102", "A-201"] (unchanged)
print(copy)      # Output: ["A-101", "A-102", "A-201", "A-202"]

Why does this matter? Because assigning lists doesn't create a copy:

original = ["A-101", "A-102"]
reference = original  # This does NOT create a copy

reference.append("A-201")

print(original)   # Output: ["A-101", "A-102", "A-201"] (changed!)
print(reference)  # Output: ["A-101", "A-102", "A-201"]

Both variables point to the same list. Changes to one affect the other.

To create a true copy:

copy = original[:]
# or
copy = original.copy()
# or
copy = list(original)

All three methods create an independent copy.

Architectural Example: Extracting Ranges

sheets = ["A-101", "A-102", "A-201", "A-202", "S-101", "S-102", "M-101"]

# First 4 sheets
first_four = sheets[:4]
print(first_four)
# Output: ["A-101", "A-102", "A-201", "A-202"]

# Last 3 sheets
last_three = sheets[-3:]
print(last_three)
# Output: ["S-102", "M-101"]

# Middle section
middle = sheets[2:5]
print(middle)
# Output: ["A-201", "A-202", "S-101"]

Tuples (Immutable Lists)

A tuple is like a list, but it can't be changed after creation. It's immutable.

Creating Tuples

Tuples use parentheses instead of square brackets.

# List (mutable)
room_list = ["Office 1", "Office 2"]

# Tuple (immutable)
room_tuple = ("Office 1", "Office 2")

You can access items the same way:

project_info = ("2024-001", "Community Center", "In Progress")

project_code = project_info[0]
print(project_code)  # Output: 2024-001

But you can't modify them:

project_info[0] = "2024-002"
# Error: TypeError: 'tuple' object does not support item assignment

You also can't add or remove items:

project_info.append("Approved")
# Error: AttributeError: 'tuple' object has no attribute 'append'

Why Use Tuples?

Tuples are for data that shouldn't change.

Use tuples when:

The data is fixed (coordinates, project metadata)
You want to prevent accidental modification
You're returning multiple values from a function (Module 06)

Examples:

# Project metadata (shouldn't change)
project = ("2024-001", "Community Center", "Smith Architects")

# A point in 3D space
point = (125.3, 78.9, 45.2)

# RGB color values
color = (255, 128, 0)

Unpacking Tuples

You can assign tuple values to multiple variables at once.

project_info = ("2024-001", "Community Center", "In Progress")

# Unpack into three variables
project_code, project_name, status = project_info

print(project_code)  # Output: 2024-001
print(project_name)  # Output: Community Center
print(status)        # Output: In Progress

This works with lists too, but it's most common with tuples.

Architectural Example:

# Point coordinates
point = (125.3, 78.9, 45.2)

x, y, z = point

print(f"X: {x}, Y: {y}, Z: {z}")
# Output: X: 125.3, Y: 78.9, Z: 45.2

Tuples vs Lists: When to Use Each

Use lists when:

Data might change (add, remove, modify items)
You're building a collection dynamically
You need list methods like .sort() or .append()

Use tuples when:

Data is fixed and shouldn't change
You want to ensure immutability
You're working with coordinates or structured records

In practice: You'll use lists 90% of the time. Tuples are for special cases.

Real Examples

Lists of Lists: Room Schedule

# Each room: [name, area, type]
rooms = [
    ["Office 1", 12.5, "Private"],
    ["Office 2", 15.3, "Private"],
    ["Conference", 45.8, "Meeting"],
    ["Break Room", 18.2, "Common"]
]

# Total area
total_area = sum(room[1] for room in rooms)
print(f"Total area: {total_area}m²")
# Output: Total area: 91.8m²

# Print each room
for room in rooms:
    name = room[0]
    area = room[1]
    room_type = room[2]
    print(f"{name}: {area}m² ({room_type})")

# Output:
# Office 1: 12.5m² (Private)
# Office 2: 15.3m² (Private)
# Conference: 45.8m² (Meeting)
# Break Room: 18.2m² (Common)

Tuples: Fixed Project Data

# Project metadata (shouldn't change)
project = ("2024-001", "Community Center", "Smith Architects", "In Progress")

# Unpack
code, name, architect, status = project

print(f"Project: {name}")
print(f"Code: {code}")
print(f"Architect: {architect}")
print(f"Status: {status}")

# Output:
# Project: Community Center
# Code: 2024-001
# Architect: Smith Architects
# Status: In Progress

Copying Lists Safely

original_sheets = ["A-101", "A-102", "A-201"]

# Wrong - creates reference, not copy
wrong_copy = original_sheets
wrong_copy.append("A-202")
print(original_sheets)
# Output: ["A-101", "A-102", "A-201", "A-202"] (modified!)

# Correct - creates independent copy
original_sheets = ["A-101", "A-102", "A-201"]
correct_copy = original_sheets[:]
correct_copy.append("A-202")
print(original_sheets)
# Output: ["A-101", "A-102", "A-201"] (unchanged)

When You'll Need These Techniques

Lists of lists:

When you start working with schedule data from Revit
When organizing elements by category or level
When processing CSV files (rows of data)

Advanced slicing:

When you need to copy lists
When extracting specific ranges
When reversing without mutation

Tuples:

When working with coordinates
When functions return multiple values (Module 06)
When you want to prevent accidental changes

You don't need to master these now. Just know they exist. When you encounter a situation where they'd help, you'll remember this lesson and come back.

Assignment

Create a new file called intermediate_lists.py
Create a list of lists for three floors:
- Basement: ["Storage", "Mechanical"]
- Ground: ["Lobby", "Office 1", "Office 2"]
- First: ["Office 3", "Conference"]
Store all three in a building list
Access and print:
- The second floor (Ground)
- The first room on the ground floor ("Lobby")
- The total number of floors
- The total number of rooms (sum across all floors)
Create a list: sheets = ["A-101", "A-102", "A-201", "A-202", "S-101", "S-102"]
Use slicing to:
- Get every other sheet
- Reverse the list (without modifying the original)
- Create a copy of the list
Create a tuple for project info: ("2024-001", "Community Center", "Active")
Unpack the tuple into three variables and print each
Try to modify the tuple (append or change an item) — see the error
Experiment:
- Create a list and assign it to another variable
- Modify the second variable
- See that both variables changed (they reference the same list)
- Now create a proper copy using [:] and verify it's independent

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's data structures tutorial covers lists, tuples, and more
Real Python's guide to nested lists has additional examples
Understanding slicing provides detailed explanation of slice syntax

Lesson 13: List Methods That Matter

Prajwal Kumar — Tue, 10 Mar 2026 16:25:18 +0530

Introduction

You know how to create lists, access items, and modify them. That's the foundation.

But Python provides built-in methods that handle common operations architects do constantly — sorting sheet numbers, finding the largest room area, counting how many of a certain type exist, checking if an item is in your list.

These methods save you from writing your own logic for tasks that come up repeatedly. They're fast, reliable, and used in virtually every script you'll write.

This lesson covers the list methods you'll actually use in real workflows.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Sorting lists with .sort() and sorted()
Reversing lists with .reverse()
Counting occurrences with .count()
Finding items with .index()
Checking membership with in and not in
Finding min, max, and sum for numeric lists
Combining lists with +

Sorting Lists

.sort() — Sort in Place

The .sort() method sorts a list in place (modifies the original list).

sheets = ["A-201", "A-101", "A-102"]

sheets.sort()

print(sheets)
# Output: ["A-101", "A-102", "A-201"]

By default, it sorts in ascending order (smallest to largest, A to Z).

For numbers:

areas = [450.5, 380.2, 520.8, 410.3]

areas.sort()

print(areas)
# Output: [380.2, 410.3, 450.5, 520.8]

Reverse order:

areas.sort(reverse=True)

print(areas)
# Output: [520.8, 450.5, 410.3, 380.2]

sorted() — Return a New Sorted List

If you want to keep the original list unchanged, use sorted() instead.

sheets = ["A-201", "A-101", "A-102"]

sorted_sheets = sorted(sheets)

print(sheets)         # Output: ["A-201", "A-101", "A-102"] (unchanged)
print(sorted_sheets)  # Output: ["A-101", "A-102", "A-201"]

The difference:

.sort() modifies the list, returns None
sorted() returns a new sorted list, leaves original unchanged

For most architectural workflows, .sort() is fine. You're usually okay modifying the original list.

Architectural Example: Organizing Sheet Numbers

sheets = ["A-201", "S-101", "A-102", "A-101", "S-102"]

sheets.sort()

print(sheets)
# Output: ["A-101", "A-102", "A-201", "S-101", "S-102"]

Sheet numbers sort alphabetically, which groups them by discipline and orders them numerically within each discipline.

Reversing Lists

.reverse() — Reverse in Place

The .reverse() method reverses the order of items in a list.

floors = ["Basement", "Ground", "First", "Second"]

floors.reverse()

print(floors)
# Output: ["Second", "First", "Ground", "Basement"]

This modifies the original list.

Architectural Example: Top-Down Floor List

floors = ["Ground", "First", "Second", "Third"]

# Reverse to show from top down
floors.reverse()

print(floors)
# Output: ["Third", "Second", "First", "Ground"]

You can also reverse while sorting:

areas = [450.5, 380.2, 520.8, 410.3]

areas.sort(reverse=True)

print(areas)
# Output: [520.8, 450.5, 410.3, 380.2]

Counting Occurrences

.count() — Count How Many Times a Value Appears

Use .count() to find how many times a specific value appears in a list.

room_types = ["Office", "Meeting", "Office", "Office", "Storage"]

office_count = room_types.count("Office")

print(office_count)
# Output: 3

Architectural Example: Counting Room Types

room_types = ["Office", "Meeting", "Office", "Break Room", "Office", "Meeting"]

offices = room_types.count("Office")
meetings = room_types.count("Meeting")

print(f"Offices: {offices}")
# Output: Offices: 3

print(f"Meeting rooms: {meetings}")
# Output: Meeting rooms: 2

This is useful for quick counts without writing loops (though in Module 05, you'll learn more flexible ways to filter and count).

Finding Items

.index() — Find the Position of a Value

Use .index() to find the first position (index) where a value appears.

sheets = ["A-101", "A-102", "A-201", "A-202"]

position = sheets.index("A-201")

print(position)
# Output: 2

If the value doesn't exist, you get an error:

sheets.index("A-999")
# Error: ValueError: 'A-999' is not in list

You can check first using in:

if "A-201" in sheets:
    position = sheets.index("A-201")
    print(f"Found at index {position}")

Honestly, you won't use .index() as often as other methods. It's more common to just check if something exists (using in) rather than caring about its exact position.

Checking Membership

in and not in — Check if a Value Exists

The in operator checks if a value exists in a list. It returns True or False.

sheets = ["A-101", "A-102", "A-201"]

# Check if exists
if "A-101" in sheets:
    print("Sheet found")
# Output: Sheet found

# Check if doesn't exist
if "S-101" not in sheets:
    print("Structural sheet not in list")
# Output: Structural sheet not in list

This is one of the most useful operations. You'll use it constantly.

Architectural Example: Validating Required Sheets

required_sheets = ["A-101", "A-201", "S-101"]
submitted_sheets = ["A-101", "A-102", "A-201"]

# Check if all required sheets are submitted
for sheet in required_sheets:
    if sheet in submitted_sheets:
        print(f"{sheet}: ✓")
    else:
        print(f"{sheet}: Missing")

# Output:
# A-101: ✓
# A-201: ✓
# S-101: Missing

(This uses a loop, which you'll learn properly in Module 05. For now, just see how in works.)

Finding Min, Max, and Sum

For lists containing numbers, Python provides built-in functions.

min() — Find Smallest Value

areas = [450.5, 380.2, 520.8, 410.3]

smallest = min(areas)

print(smallest)
# Output: 380.2

max() — Find Largest Value

largest = max(areas)

print(largest)
# Output: 520.8

sum() — Add All Values

total = sum(areas)

print(total)
# Output: 1761.8

Architectural Example: Room Area Analysis

room_areas = [450.5, 380.2, 520.8, 410.3, 395.7]

smallest_room = min(room_areas)
largest_room = max(room_areas)
total_area = sum(room_areas)
average_area = total_area / len(room_areas)

print(f"Smallest room: {smallest_room}m²")
print(f"Largest room: {largest_room}m²")
print(f"Total area: {total_area}m²")
print(f"Average area: {average_area:.1f}m²")

# Output:
# Smallest room: 380.2m²
# Largest room: 520.8m²
# Total area: 2157.5m²
# Average area: 431.5m²

These functions only work on lists containing numbers. If you try them on strings, you'll get unexpected results (or errors).

Combining Lists

Using + to Combine Lists

You can combine two lists using the + operator.

arch_sheets = ["A-101", "A-102"]
struct_sheets = ["S-101", "S-102"]

all_sheets = arch_sheets + struct_sheets

print(all_sheets)
# Output: ["A-101", "A-102", "S-101", "S-102"]

This creates a new list. The original lists are unchanged.

print(arch_sheets)
# Output: ["A-101", "A-102"] (unchanged)

If you want to add to an existing list (instead of creating a new one), use .extend() from the previous lesson:

arch_sheets.extend(struct_sheets)

print(arch_sheets)
# Output: ["A-101", "A-102", "S-101", "S-102"]

Real Architectural Workflows

Sorting and Analyzing Room Areas

room_areas = [450.5, 380.2, 520.8, 410.3, 395.7, 478.2]

# Sort to see distribution
room_areas.sort()
print("Sorted areas:", room_areas)
# Output: Sorted areas: [380.2, 395.7, 410.3, 450.5, 478.2, 520.8]

# Find range
smallest = min(room_areas)
largest = max(room_areas)
print(f"Range: {smallest}m² to {largest}m²")
# Output: Range: 380.2m² to 520.8m²

# Calculate total
total = sum(room_areas)
print(f"Total area: {total}m²")
# Output: Total area: 2635.7m²

Organizing Mixed Sheet List

sheets = ["A-201", "S-101", "A-102", "M-101", "A-101", "S-102"]

# Sort alphabetically
sheets.sort()
print(sheets)
# Output: ["A-101", "A-102", "A-201", "M-101", "S-101", "S-102"]

# Count by discipline
arch_count = sum(1 for s in sheets if s.startswith("A"))
struct_count = sum(1 for s in sheets if s.startswith("S"))
mep_count = sum(1 for s in sheets if s.startswith("M"))

print(f"Architectural: {arch_count}")
print(f"Structural: {struct_count}")
print(f"MEP: {mep_count}")

# Output:
# Architectural: 3
# Structural: 2
# MEP: 1

(The counting uses list comprehensions, which we'll cover in the optional Lesson 04. For now, just see the pattern.)

Checking Required vs Submitted Sheets

required = ["A-101", "A-102", "A-201", "S-101"]
submitted = ["A-101", "A-102", "A-201"]

# Check each required sheet
missing = []
for sheet in required:
    if sheet not in submitted:
        missing.append(sheet)

if missing:
    print("Missing sheets:", missing)
else:
    print("All required sheets submitted")

# Output: Missing sheets: ['S-101']

Common Mistakes

Trying to sort mixed types

mixed = ["A-101", 101, "A-102"]

mixed.sort()
# Error: TypeError: '<' not supported between instances of 'int' and 'str'

Lists with mixed types (strings and numbers) can't be sorted. Keep your lists homogeneous.

Expecting .sort() to return the sorted list

sheets = ["A-201", "A-101", "A-102"]

sorted_sheets = sheets.sort()

print(sorted_sheets)
# Output: None

.sort() modifies the list in place and returns None. If you need the sorted result, use sorted():

sorted_sheets = sorted(sheets)

Or just use the modified original:

sheets.sort()
print(sheets)
# Output: ["A-101", "A-102", "A-201"]

Using min/max/sum on non-numeric lists

sheets = ["A-101", "A-102", "A-201"]

total = sum(sheets)
# Error: TypeError: unsupported operand type(s) for +: 'int' and 'str'

min(), max(), and sum() only work on numbers (or things that can be added/compared numerically).

For strings, min() and max() return alphabetically first/last:

sheets = ["A-201", "A-101", "A-102"]

print(min(sheets))  # Output: A-101
print(max(sheets))  # Output: A-201

This can be useful, but be aware of what it's actually doing.

Assignment

Create a new file called list_methods.py
Create this list: room_areas = [450.5, 380.2, 520.8, 410.3, 395.7]
Sort the list and print it
Find and print:
- Smallest area
- Largest area
- Total area
- Average area (total / count)
Create this list: sheets = ["A-201", "S-101", "A-102", "A-101", "S-102", "A-201"]
Sort the list and print it
Count how many times "A-201" appears
Check if "M-101" exists in the list
Create two lists:
- floor_1_rooms = ["Office 1", "Office 2", "Conference"]
- floor_2_rooms = ["Office 3", "Break Room"]
Combine them into all_rooms using +
Print the total number of rooms
Real scenario:
- You have room types: ["Office", "Meeting", "Office", "Office", "Storage", "Meeting"]
- Count offices and meeting rooms
- Check if "Break Room" exists
- Sort the list alphabetically
- Print results
Experiment:
- Try to sort a list with both strings and numbers (see the error)
- Try sorted_list = my_list.sort() and print sorted_list (see that it's None)

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's sorting documentation covers advanced sorting techniques
Built-in functions documentation lists all functions like min, max, sum with examples

Lesson 12: Accessing and Modifying Lists

Prajwal Kumar — Tue, 10 Mar 2026 16:01:10 +0530

Introduction

In the last lesson, you learned how to create lists and access items by index. But lists would be pretty limited if you could only read from them.

The real power of lists comes from being able to change them. Add new items. Remove outdated ones. Update values as your project evolves.

This is what makes lists useful for real workflows. Your room schedule changes? Update the list. Project adds three floors? Add them to the list. Client removes a building wing? Remove those items.

Lists are mutable — they can be modified after creation. This lesson shows you how.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Changing individual items in a list
Adding items to a list (.append(), .insert())
Removing items from a list (.remove(), .pop(), del)
When to use each method
Common mistakes when modifying lists

Changing Items

You can change any item in a list by assigning a new value to its index.

rooms = ["Office 1", "Office 2", "Conference Room"]

# Change the first room
rooms[0] = "Manager Office"

print(rooms)
# Output: ["Manager Office", "Office 2", "Conference Room"]

The syntax is the same as variable assignment, just with an index.

Architectural Example: Updating Sheet Names

sheets = ["A-101 Draft", "A-102 Draft", "A-201 Draft"]

# First sheet is now issued
sheets[0] = "A-101 Issued"

print(sheets)
# Output: ["A-101 Issued", "A-102 Draft", "A-201 Draft"]

You can change multiple items:

sheets[1] = "A-102 Issued"
sheets[2] = "A-201 Issued"

print(sheets)
# Output: ["A-101 Issued", "A-102 Issued", "A-201 Issued"]

Adding Items

There are several ways to add items to a list.

.append() — Add to the End

The most common way to add an item is with .append(). This adds the item to the end of the list.

rooms = ["Office 1", "Office 2"]

rooms.append("Conference Room")

print(rooms)
# Output: ["Office 1", "Office 2", "Conference Room"]

Architectural Example: Building a Sheet List

sheets = []

# Add sheets one by one
sheets.append("A-101")
sheets.append("A-102")
sheets.append("A-201")

print(sheets)
# Output: ["A-101", "A-102", "A-201"]

This is particularly useful when you're building a list dynamically — you start with an empty list and add items as you process data.

.insert() — Add at a Specific Position

If you need to add an item at a specific position (not the end), use .insert().

rooms = ["Office 1", "Office 2", "Office 3"]

# Insert at index 1 (second position)
rooms.insert(1, "Conference Room")

print(rooms)
# Output: ["Office 1", "Conference Room", "Office 2", "Office 3"]

The syntax is .insert(index, item). The new item goes at that index, and everything after it shifts to the right.

Architectural Example: Adding a Floor

floors = ["Ground", "First", "Second"]

# Add basement at the beginning
floors.insert(0, "Basement")

print(floors)
# Output: ["Basement", "Ground", "First", "Second"]

.extend() — Add Multiple Items

If you want to add multiple items at once, use .extend() with another list.

arch_sheets = ["A-101", "A-102"]
struct_sheets = ["S-101", "S-102"]

arch_sheets.extend(struct_sheets)

print(arch_sheets)
# Output: ["A-101", "A-102", "S-101", "S-102"]

This adds all items from the second list to the first list.

Note: This is different from .append():

# Using append (adds the list as a single item)
list_1 = ["A-101", "A-102"]
list_2 = ["S-101", "S-102"]
list_1.append(list_2)

print(list_1)
# Output: ["A-101", "A-102", ["S-101", "S-102"]]

# Using extend (adds each item from the list)
list_1 = ["A-101", "A-102"]
list_2 = ["S-101", "S-102"]
list_1.extend(list_2)

print(list_1)
# Output: ["A-101", "A-102", "S-101", "S-102"]

For combining lists, .extend() is usually what you want.

Removing Items

There are several ways to remove items from a list.

.remove() — Remove by Value

Use .remove() to delete the first occurrence of a specific value.

rooms = ["Office 1", "Office 2", "Conference Room", "Office 3"]

rooms.remove("Conference Room")

print(rooms)
# Output: ["Office 1", "Office 2", "Office 3"]

If the value doesn't exist, you get an error:

rooms.remove("Nonexistent Room")
# Error: ValueError: list.remove(x): x not in list

You can check first using in:

if "Conference Room" in rooms:
    rooms.remove("Conference Room")

.pop() — Remove by Index

Use .pop() to remove an item at a specific index. It removes the item AND returns it.

sheets = ["A-101", "A-102", "A-201", "A-202"]

# Remove and get the last item
last_sheet = sheets.pop()

print(last_sheet)  # Output: A-202
print(sheets)      # Output: ["A-101", "A-102", "A-201"]

You can specify an index:

sheets = ["A-101", "A-102", "A-201", "A-202"]

# Remove second item (index 1)
removed = sheets.pop(1)

print(removed)  # Output: A-102
print(sheets)   # Output: ["A-101", "A-201", "A-202"]

If you don't specify an index, .pop() removes the last item.

del — Delete by Index

The del keyword removes an item at a specific index, but doesn't return it.

rooms = ["Office 1", "Office 2", "Conference Room"]

del rooms[1]

print(rooms)
# Output: ["Office 1", "Conference Room"]

You can also delete entire ranges:

sheets = ["A-101", "A-102", "A-201", "A-202", "S-101"]

# Delete items at index 2 and 3
del sheets[2:4]

print(sheets)
# Output: ["A-101", "A-102", "S-101"]

.clear() — Remove Everything

Use .clear() to remove all items from a list, leaving it empty.

rooms = ["Office 1", "Office 2", "Office 3"]

rooms.clear()

print(rooms)
# Output: []

When to Use Each Method

Adding items:

Use .append() when adding to the end (most common)
Use .insert() when you need a specific position
Use .extend() when adding multiple items from another list

Removing items:

Use .remove() when you know the value but not the position
Use .pop() when you know the position and want the value back
Use del when you know the position and don't need the value
Use .clear() when you want to empty the entire list

Real Architectural Examples

Building a Drawing Set Dynamically

sheets = []

# Add architectural sheets
sheets.append("A-101")
sheets.append("A-102")
sheets.append("A-201")

# Add structural sheets
struct_sheets = ["S-101", "S-102"]
sheets.extend(struct_sheets)

print(sheets)
# Output: ["A-101", "A-102", "A-201", "S-101", "S-102"]

# Client removes second floor
sheets.remove("A-201")

print(sheets)
# Output: ["A-101", "A-102", "S-101", "S-102"]

Managing Room Schedules

rooms = ["Office 1", "Office 2", "Conference Room"]

# Scope change: add break room
rooms.append("Break Room")

# Rename first office
rooms[0] = "Manager Office"

# Remove conference room (not needed)
rooms.remove("Conference Room")

print(rooms)
# Output: ["Manager Office", "Office 2", "Break Room"]

Processing Floor Lists

floors = ["Basement", "Ground", "First", "Second"]

# Add penthouse
floors.append("Penthouse")

# Remove basement (value engineering)
floors.remove("Basement")

print(floors)
# Output: ["Ground", "First", "Second", "Penthouse"]

# Get floor count
print(f"Building has {len(floors)} floors")
# Output: Building has 4 floors

Common Mistakes

Trying to append multiple items incorrectly

sheets = ["A-101"]

# Wrong - this creates a nested list
sheets.append(["A-102", "A-201"])
print(sheets)
# Output: ["A-101", ["A-102", "A-201"]]

# Correct - use extend
sheets = ["A-101"]
sheets.extend(["A-102", "A-201"])
print(sheets)
# Output: ["A-101", "A-102", "A-201"]

Removing items that don't exist

rooms = ["Office 1", "Office 2"]

rooms.remove("Conference Room")
# Error: ValueError: list.remove(x): x not in list

# Check first
if "Conference Room" in rooms:
    rooms.remove("Conference Room")
else:
    print("Room not found")

Modifying while iterating (preview — you'll see this more in Module 05)

# Don't do this
rooms = ["Office 1", "Office 2", "Office 3"]
for room in rooms:
    if room == "Office 2":
        rooms.remove(room)  # Modifying while looping causes issues

# We'll cover the correct way to do this in Module 05

For now, just know: modifying a list while looping through it can cause unexpected behavior. We'll address this properly when we cover loops.

Using .pop() without storing the value

sheets = ["A-101", "A-102", "A-201"]

# If you don't need the removed value
sheets.pop()  # Works, but wasteful

# Better - use del if you don't need the value
del sheets[-1]

Though honestly, .pop() is fine even if you don't use the return value. This is a minor point.

Assignment

Create a new file called modifying_lists.py
Start with an empty list called sheets
Add these sheets one by one using .append():
- "A-101"
- "A-102"
- "A-201"
- Print the list after adding all three
Insert "A-150" between "A-102" and "A-201"
- Hint: Find the right index first
- Print the list
Change "A-201" to "A-202"
- Print the list
Remove "A-150" using .remove()
- Print the list
Create a second list with structural sheets: ["S-101", "S-102"]
- Add these to your sheets list using .extend()
- Print the combined list
Remove the last sheet using .pop() and print what was removed
- Print the final list
Experiment:
- Try to remove a sheet that doesn't exist (see the error)
- Try to use .pop() on an empty list (see the error)
Real scenario:
- Start with: rooms = ["Office 1", "Office 2", "Conference", "Office 3"]
- Remove "Conference"
- Insert "Reception" at the beginning
- Change "Office 3" to "Manager Office"
- Add "Break Room" at the end
- Print the final list

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's list methods documentation covers all list methods in detail
Real Python's list tutorial includes additional examples and edge cases

Lesson 11: What Are Lists?

Prajwal Kumar — Tue, 10 Mar 2026 15:57:39 +0530

Introduction

You're managing a project with 50 rooms. You need to store their names in your script.

You could create 50 separate variables:

room_1 = "Office 1"
room_2 = "Office 2"
room_3 = "Office 3"
# ... 47 more lines of this

Or you could use a list:

rooms = ["Office 1", "Office 2", "Office 3", ...]

The difference is night and day. The first approach doesn't scale. The second does.

Lists store multiple items in one container. If you've used selection sets in Revit or worked with layer lists in CAD, you already understand the concept. Python lists work the same way — they're organised collections you can reference and manipulate as a group.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

What lists are and how to create them
Accessing items by position (index)
Why Python starts counting at 0
Using negative indexes to count from the end
Finding list length with len()
When to use lists vs individual variables

Creating a List

Lists are created using square brackets, with items separated by commas.

floors = ["Basement", "Ground", "First", "Second"]
sheets = ["A-101", "A-102", "A-201", "A-202"]
areas = [450.5, 380.2, 520.8, 410.3]

Each of these is a single variable holding multiple values. Instead of managing floor_1, floor_2, floor_3 separately, you have one floors list with everything organised inside.

You can also create an empty list and fill it later:

rooms = []

We'll cover adding items in the next lesson.

Accessing Items by Index

Each item in a list has a position called an index. This is where things get a bit unusual if you're new to programming.

Python starts counting at 0, not 1.

sheets = ["A-101", "A-102", "A-201", "A-202"]

To access items:

sheets[0] gives you "A-101" (first item)
sheets[1] gives you "A-102" (second item)
sheets[2] gives you "A-201" (third item)
sheets[3] gives you "A-202" (fourth item)

This zero-based indexing feels strange at first, but it's standard across virtually all programming languages. It's rooted in how computer memory works. You'll adjust to it quickly through practice.

Negative Indexing

Python also lets you count backwards from the end using negative numbers.

sheets = ["A-101", "A-102", "A-201", "A-202"]

last_sheet = sheets[-1]      # "A-202"
second_last = sheets[-2]     # "A-201"

This is particularly useful when you need the last item in a list but don't know (or don't want to calculate) how long the list is.

Finding List Length

Use len() to find how many items are in a list.

rooms = ["Office 1", "Office 2", "Conference", "Break Room"]
room_count = len(rooms)
print(room_count)  # Output: 4

This works for any list, regardless of what's inside.

arch_sheets = ["A-101", "A-102", "A-201"]
struct_sheets = ["S-101", "S-102"]
mep_sheets = ["M-101", "E-101"]

total_sheets = len(arch_sheets) + len(struct_sheets) + len(mep_sheets)
print(f"Total sheets: {total_sheets}")  # Output: Total sheets: 7

Why Lists Matter

Compare these two approaches:

Without lists:

room_1 = "Office 1"
room_2 = "Office 2"
room_3 = "Office 3"
# ... and so on

What happens when you need to add a room? You create another variable. What if you need to rename all of them? You update each one manually. What if you have 500 rooms? This approach breaks down completely.

With lists:

rooms = ["Office 1", "Office 2", "Office 3"]

Adding a room becomes a single operation (next lesson). Processing all rooms becomes possible (Module 05 on loops). The logic doesn't change whether you have 3 rooms or 300.

Lists scale. Individual variables don't.

Real Examples

Floor Names

floors = ["Basement", "Ground", "First", "Second", "Third"]

# Access first floor
first_floor = floors[0]
print(first_floor)  # Output: Basement

# Access top floor
top_floor = floors[-1]
print(top_floor)  # Output: Third

# Count floors
floor_count = len(floors)
print(f"Building has {floor_count} floors")  # Output: Building has 5 floors

Sheet Numbers

sheets = ["A-101", "A-102", "A-201", "A-202", "S-101", "S-102"]

# First sheet
print(sheets[0])  # Output: A-101

# Last sheet
print(sheets[-1])  # Output: S-102

# Total count
print(len(sheets))  # Output: 6

Room Areas

areas = [450.5, 380.2, 520.8, 410.3, 395.7]

# First room
print(areas[0])  # Output: 450.5

# Last room
print(areas[-1])  # Output: 395.7

# Count
print(len(areas))  # Output: 5

Common Mistakes

Forgetting Python starts at 0

This trips up everyone initially.

sheets = ["A-101", "A-102", "A-201"]

first_sheet = sheets[1]
print(first_sheet)  # Output: A-102 (not what you wanted!)

# Correct
first_sheet = sheets[0]
print(first_sheet)  # Output: A-101

The first item is always at index 0. You'll internalize this with practice.

Index out of range

rooms = ["Office 1", "Office 2", "Office 3"]

# This list has 3 items: indexes 0, 1, 2
# There is no index 3

print(rooms[3])
# Error: IndexError: list index out of range

If a list has 3 items, the valid indexes are 0, 1, and 2. The last index is always len(list) - 1.

Alternatively, use negative indexing to avoid this:

last_room = rooms[-1]  # Always gets the last item, regardless of length

Using the wrong brackets

# Wrong - these create different data types
sheets = ("A-101", "A-102")  # Parentheses create a tuple
sheets = {"A-101", "A-102"}  # Curly braces create a set

# Correct - square brackets create a list
sheets = ["A-101", "A-102"]

Lists always use square brackets [].

When to Use Lists

Use lists when you have:

Multiple items of the same type
Data that might grow or shrink
Items you need to process as a group

Examples:

Room names, areas, or types
Sheet numbers
Floor names
Element IDs
View names

Don't use lists for:

Unrelated values that don't naturally group together

# Avoid this
project_info = ["Community Center", 12, True, 450000]

# Better
project_name = "Community Center"
floor_count = 12
is_approved = True
budget = 450000

Later in the course, you'll learn about dictionaries (Module 07), which handle mixed-type data more elegantly.

Assignment

Create a new file called lists_practice.py
Create three lists:
- Floor names: ["Basement", "Ground", "First", "Second", "Third"]
- Sheet numbers: ["A-101", "A-102", "A-201", "A-202"]
- Room areas: [450.5, 380.2, 520.8, 410.3]
For each list, print:
- The first item (index 0)
- The last item (using negative indexing)
- The total number of items (using len())
Access the third item in the floors list. Remember: the third item is at index 2.
Experiment with errors:
- Try accessing sheets[10] on your 4-item list
- Read the error message
- Try accessing sheets[-10]
- Understanding these errors now will help you debug later
Create an empty list called rooms and print its length. Verify it returns 0.
Real scenario practice:
- Given this list: ["A-101", "A-102", "A-201", "A-202", "S-101"]
- Print the total number of sheets
- Print the last architectural sheet (at index 3)
- Print the first structural sheet (at index 4)

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's official list documentation provides additional examples and details
Python Tutor offers a visual step-by-step execution to see how list indexing works in practice

Lesson 10: Expressions and Operators

Prajwal Kumar — Sat, 07 Feb 2026 21:23:38 +0530

Introduction

You've spent the last five lessons learning the building blocks: variables, numbers, strings, booleans, and type conversion.

You've already been writing expressions without realising it.

Every time you wrote floor_count * floor_height or room_name + " " + str(room_number), you were writing an expression, a combination of values, variables, and operators that produces a result.

This lesson ties everything together. We'll review what you've learned, introduce a few operators you haven't seen yet, and show you how to build complex expressions that solve real architectural problems.

Think of this as your checkpoint before moving forward.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Review all operators you've learned so far
Understand operator precedence (order of operations)
Learn compound assignment operators (+=, -=, *=, /=)
Use the walrus operator (:=) for inline assignment
Master chaining comparisons
Build complex architectural calculations
Recognise when expressions become too complex

What Is an Expression?

An expression is any valid combination of values, variables, and operators that produces a result.

Simple expressions:

5 + 3                    # Result: 8
floor_count              # Result: value of floor_count
"A" + "-" + "101"       # Result: "A-101"

Complex expressions:

ground_floor_height + (floor_count - 1) * typical_floor_height

Key point: Every expression evaluates to a single value.

Operators You've Already Learned

Let's review what you already know.

Arithmetic Operators

a + b    # Addition
a - b    # Subtraction
a * b    # Multiplication
a / b    # Division (always returns float)
a // b   # Floor division (returns integer)
a % b    # Modulo (remainder)
a ** b   # Exponentiation (a to the power of b)

You've used these for building height calculations, area computations, and budget math.

Comparison Operators

a > b     # Greater than
a < b     # Less than
a >= b    # Greater than or equal
a <= b    # Less than or equal
a == b    # Equal to
a != b    # Not equal to

You've used these for compliance checks and validation.

Logical Operators

a and b   # Both must be True
a or b    # At least one must be True
not a     # Reverses the boolean

You've used these for multi-condition checks.

String Operators

a + b     # Concatenation
a * n     # Repetition

You've used these for building sheet names and file paths.

Operator Precedence (The Rules)

When you write complex expressions, Python needs to know what order to evaluate them.

Full precedence order (highest to lowest):

* (Exponentiation)
+x, x, not x (Unary plus, minus, not)
, /, //, % (Multiplication, division, floor division, modulo)
+, (Addition, subtraction)
<, <=, >, >=, ==, != (Comparisons)
and (Logical AND)
or (Logical OR)

Example: Order Matters

# Without parentheses
result = 10 + 5 * 2
print(result)  # Output: 20 (not 30)
# Evaluates as: 10 + (5 * 2)

# With parentheses
result = (10 + 5) * 2
print(result)  # Output: 30

Architectural Example: Building Height

ground_floor_height = 4.5
typical_floor_height = 3.2
floor_count = 12

# Wrong (without parentheses)
total_height = ground_floor_height + floor_count * typical_floor_height
print(total_height)  # Output: 42.9
# This calculates: 4.5 + (12 * 3.2) = 4.5 + 38.4

# Correct (with parentheses)
typical_floors = floor_count - 1
total_height = ground_floor_height + typical_floors * typical_floor_height
print(total_height)  # Output: 39.7
# This calculates: 4.5 + (11 * 3.2) = 4.5 + 35.2

Best Practice: When in doubt, use parentheses. They make your intent clear and prevent bugs.

New Operators: Compound Assignment

You've been writing code like this:

floor_count = 8
floor_count = floor_count + 1
print(floor_count)  # Output: 9

There's a shorter way:

floor_count = 8
floor_count += 1
print(floor_count)  # Output: 9

+= is a compound assignment operator. It adds to the variable and reassigns in one step.

All Compound Assignment Operators

x += 5    # Same as: x = x + 5
x -= 3    # Same as: x = x - 3
x *= 2    # Same as: x = x * 2
x /= 4    # Same as: x = x / 4
x //= 2   # Same as: x = x // 2
x %= 3    # Same as: x = x % 3
x **= 2   # Same as: x = x ** 2

Architectural Example: Running Totals

# Calculating total area across multiple floors
total_area = 0

# Floor 1
total_area += 450.5

# Floor 2
total_area += 480.2

# Floor 3
total_area += 465.8

print(total_area)  # Output: 1396.5

This is especially useful when accumulating values in loops (which you'll learn in the next module).

String Concatenation with +=

sheet_name = "A-101"
sheet_name += " Ground Floor Plan"
print(sheet_name)  # Output: A-101 Ground Floor Plan

# Same as:
sheet_name = sheet_name + " Ground Floor Plan"

Chaining Comparisons

Python lets you chain comparison operators in a way that reads naturally.

Standard Way (Verbose)

room_area = 420

# Check if area is between 400 and 500
is_valid = room_area >= 400 and room_area <= 500
print(is_valid)  # Output: True

Chained Way (Cleaner)

room_area = 420

# Check if area is between 400 and 500
is_valid = 400 <= room_area <= 500
print(is_valid)  # Output: True

This reads like math notation: "400 is less than or equal to room_area, which is less than or equal to 500."

Architectural Example: Code Compliance Range

ceiling_height = 2.8

# Habitable rooms must be between 2.4m and 3.0m
is_compliant = 2.4 <= ceiling_height <= 3.0
print(is_compliant)  # Output: True

# Multiple rooms
rooms = [
    {"name": "Office 1", "height": 2.8},
    {"name": "Office 2", "height": 2.3},
    {"name": "Office 3", "height": 3.1}
]

for room in rooms:
    height = room["height"]
    is_valid = 2.4 <= height <= 3.0

    if is_valid:
        print(f"{room['name']}: PASS")
    else:
        print(f"{room['name']}: FAIL - height {height}m")

# Output:
# Office 1: PASS
# Office 2: FAIL - height 2.3m
# Office 3: FAIL - height 3.1m

The Walrus Operator (:=) — Assignment in Expressions

Note: This is a newer Python feature (3.8+). It's optional but useful.

Sometimes you want to assign a value and use it in the same expression.

Without Walrus Operator

building_height = 35.7
floor_height = 3.2

floor_count = building_height / floor_height

if floor_count > 10:
    print(f"Building has {floor_count} floors")

With Walrus Operator

building_height = 35.7
floor_height = 3.2

if (floor_count := building_height / floor_height) > 10:
    print(f"Building has {floor_count} floors")

The walrus operator := assigns the result to floor_count AND uses it in the comparison.

When to use it: When you need a value for both a check and later use.

When not to use it: When it makes code less readable. Clarity > brevity.

The `in` Operator (Membership)

Check if a value exists in a string or collection.

In Strings

sheet_name = "A-101 Ground Floor Plan"

if "Floor" in sheet_name:
    print("This is a floor plan")

if "Ceiling" not in sheet_name:
    print("This is not a ceiling plan")

Architectural Example: Filtering Sheets

sheet_names = [
    "A-101 Floor Plan",
    "A-102 Floor Plan",
    "A-201 Ceiling Plan",
    "S-101 Foundation Plan"
]

# Find all floor plans
floor_plans = []
for sheet in sheet_names:
    if "Floor" in sheet:
        floor_plans.append(sheet)

print(floor_plans)
# Output: ['A-101 Floor Plan', 'A-102 Floor Plan', 'S-101 Foundation Plan']

You'll use in extensively when working with lists (next module).

The `is` Operator (Identity)

is checks if two variables point to the exact same object in memory.

For most architectural work, you'll use == (equality) not is (identity).

# Checking for None (special value)
room_name = None

if room_name is None:
    print("Room has no name")

# Don't use 'is' for numbers or strings
floor_count = 12
if floor_count is 12:  # This works but is bad practice
    print("Twelve floors")

# Use == instead
if floor_count == 12:  # Correct
    print("Twelve floors")

Rule of thumb: Use is only for checking None. Use == for everything else.

Building Complex Expressions

Now let's combine everything into real architectural calculations.

Example 1: Floor Area Ratio with Validation

site_area = 2000.0
gross_floor_area = 8500.0
max_far = 5.0

# Calculate FAR and check if compliant
far = gross_floor_area / site_area
is_compliant = far <= max_far

print(f"FAR: {far}")
print(f"Max FAR: {max_far}")
print(f"Compliant: {is_compliant}")

# Output:
# FAR: 4.25
# Max FAR: 5.0
# Compliant: True

Example 2: Budget Breakdown with Percentages

total_budget = 5000000
design_percentage = 15
construction_percentage = 75
contingency_percentage = 10

# Calculate allocations
design_budget = total_budget * (design_percentage / 100)
construction_budget = total_budget * (construction_percentage / 100)
contingency_budget = total_budget * (contingency_percentage / 100)

# Verify totals
total_allocated = design_budget + construction_budget + contingency_budget

print(f"Design: ${design_budget:,.0f}")
print(f"Construction: ${construction_budget:,.0f}")
print(f"Contingency: ${contingency_budget:,.0f}")
print(f"Total: ${total_allocated:,.0f}")

# Output:
# Design: $750,000
# Construction: $3,750,000
# Contingency: $500,000
# Total: $5,000,000

Example 3: Multi-Condition Room Validation

# Room requirements
room_area = 420
ceiling_height = 2.8
has_windows = True
is_basement = False

# Minimum requirements
min_area = 400
min_height = 2.7

# Complex validation
area_ok = room_area >= min_area
height_ok = ceiling_height >= min_height
natural_light_ok = has_windows or not is_basement

is_habitable = area_ok and height_ok and natural_light_ok

print(f"Area OK: {area_ok}")
print(f"Height OK: {height_ok}")
print(f"Natural Light OK: {natural_light_ok}")
print(f"Habitable: {is_habitable}")

# Output:
# Area OK: True
# Height OK: True
# Natural Light OK: True
# Habitable: True

When Expressions Become Too Complex

Complex expressions are powerful, but they can become unreadable.

Too Complex (Hard to Read)

result = (site_area * 0.6 + parking_area * 0.4) / (total_floors - basement_floors + penthouse_floors * 1.5) if total_floors > 5 and has_parking else site_area / total_floors

Better (Broken Down)

if total_floors > 5 and has_parking:
    weighted_area = site_area * 0.6 + parking_area * 0.4
    adjusted_floors = total_floors - basement_floors + penthouse_floors * 1.5
    result = weighted_area / adjusted_floors
else:
    result = site_area / total_floors

Best Practice: If an expression spans more than one line or requires mental effort to parse, break it down into smaller steps with descriptive variable names.

The Pain vs The Python Fix

The Pain: Manually calculating building metrics. Every dimension change means recalculating everything by hand or in multiple spreadsheet cells.

The Python Fix: Write the expression once. Change one input, everything updates.

# Define once
ground_floor_height = 4.5
typical_floor_height = 3.2
floor_count = 12
floor_area = 450.0

# Calculate automatically
typical_floors = floor_count - 1
total_height = ground_floor_height + (typical_floors * typical_floor_height)
total_area = floor_count * floor_area
average_height = total_height / floor_count

print(f"Total height: {total_height}m")
print(f"Total area: {total_area}m²")
print(f"Average floor height: {average_height}m")

# Change floor count
floor_count = 18

# Recalculate
typical_floors = floor_count - 1
total_height = ground_floor_height + (typical_floors * typical_floor_height)
total_area = floor_count * floor_area
average_height = total_height / floor_count

print(f"\\nWith {floor_count} floors:")
print(f"Total height: {total_height}m")
print(f"Total area: {total_area}m²")
print(f"Average floor height: {average_height}m")

Assignment

Create a new file called expressions_practice.py
Complex building calculation:
- Variables: ground_floor = 4.5, typical_floor = 3.2, penthouse = 5.0, floor_count = 15
- 1 ground floor, 13 typical floors, 1 penthouse
- Calculate total building height
- Use proper operator precedence (parentheses where needed)
Budget calculator with compound operators:
- Start with: total_budget = 0
- Add: design = 750000
- Add: construction = 3500000
- Add: contingency = 500000
- Use += for each addition
- Print final total
Range validation with chained comparisons:
- Variables: ceiling_height = 2.8, min_height = 2.4, max_height = 3.0
- Check if height is within range using chained comparison
- Test with values: 2.3, 2.8, 3.1
FAR calculation with validation:
- Variables: site_area = 2000, gross_floor_area = 8500, max_far = 5.0
- Calculate FAR
- Check if compliant (FAR <= max_far)
- Print results clearly
Sheet name filtering:
- List: ["A-101 Floor Plan", "A-201 Ceiling Plan", "S-101 Floor Plan"]
- Use in operator to find sheets containing "Floor"
- Print matching sheets
Multi-condition validation:
- Room: area = 420, height = 2.6, windows = True, basement = False
- Requirements: area >= 400, height >= 2.7, windows or not basement
- Create boolean for each condition
- Combine with and
- Print which conditions pass/fail
Experiment:
- Write a complex expression on one line
- Break it down into multiple lines with named variables
- Compare readability

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

Module 02 Complete!

You've learned:

Variables (naming and storing information)
Numbers (integers and floats)
Strings (text manipulation)
Booleans (True/False logic)
Type conversion (changing between types)
Expressions (combining it all together)

What's next: Module 03 covers control flow — making decisions with if statements and repeating work with loops. You now have all the building blocks you need.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's operator precedence table — complete reference
PEP 572 — The Walrus Operator — official documentation on :=
Real Python's guide to operators — comprehensive coverage with examples

Lesson 09: Type Conversion (Changing Data Types)

Prajwal Kumar — Sat, 07 Feb 2026 21:08:32 +0530

Introduction

You've already run into this problem.

You want to print "Level 3" but you have the number 3 stored in a variable. You try to combine them and Python throws an error.

Or you read area values from an Excel export. They look like numbers, but Python treats them as text. Your calculations fail.

This happens because Python is strict about data types. A number is not text. Text is not a number. You can't mix them without being explicit.

Type conversion is how you change data from one type to another. It's a practical necessity, not a theoretical concept.

This lesson shows you when you need type conversion and how to do it correctly.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Understand why type conversion is necessary
Convert numbers to strings (and back)
Convert between integers and floats
Convert to booleans
Handle conversion errors
Apply type conversion to real architectural workflows

Why Type Conversion Matters

Python won't let you mix types without permission.

floor = 3
message = "Level " + floor
# Error: TypeError: can only concatenate str (not "int") to str

You need to explicitly convert the number to a string:

floor = 3
message = "Level " + str(floor)
print(message)  # Output: Level 3

This explicitness prevents bugs. Python forces you to be clear about your intentions.

Checking a Variable's Type

Use type() to see what type a variable is.

floor_count = 12
floor_height = 3.2
project_name = "Community Center"
is_issued = True

print(type(floor_count))    # Output: 
print(type(floor_height))   # Output: 
print(type(project_name))   # Output: 
print(type(is_issued))      # Output:

Converting to String: str()

Convert any type to a string using str().

Number to String

floor = 3
floor_str = str(floor)

print(floor)           # Output: 3 (integer)
print(floor_str)       # Output: 3 (string)
print(type(floor_str)) # Output:

Why This Matters: File Naming

project_code = "2024-001"
revision = 3

# Wrong (can't concatenate string and int)
file_name = project_code + "_R" + revision + ".pdf"
# Error: TypeError

# Correct
file_name = project_code + "_R" + str(revision) + ".pdf"
print(file_name)  # Output: 2024-001_R3.pdf

Float to String

area = 450.75
area_str = str(area)

print(area_str)  # Output: 450.75
print(type(area_str))  # Output:

Boolean to String

is_issued = True
status_str = str(is_issued)

print(status_str)  # Output: True
print(type(status_str))  # Output:

Converting to Integer: int()

Convert strings or floats to integers using int().

String to Integer

floor_str = "12"
floor_int = int(floor_str)

print(floor_int)  # Output: 12
print(type(floor_int))  # Output: 

# Now you can do math
total = floor_int + 3
print(total)  # Output: 15

Float to Integer (Truncates Decimal)

area = 450.89
area_int = int(area)

print(area_int)  # Output: 450 (decimal is cut off, not rounded)

Important: int() truncates (cuts off) the decimal. It doesn't round.

height = 3.9
height_int = int(height)
print(height_int)  # Output: 3 (not 4)

Architectural Example: Counting Full Floors

building_height = 32.7
floor_height = 3.2

# How many full floors fit?
full_floors = int(building_height / floor_height)
print(full_floors)  # Output: 10

# More precise
full_floors = int(building_height // floor_height)
print(full_floors)  # Output: 10

Converting to Float: float()

Convert strings or integers to floats using float().

String to Float

area_str = "450.75"
area_float = float(area_str)

print(area_float)  # Output: 450.75
print(type(area_float))  # Output: 

# Now you can calculate
total_area = area_float * 2
print(total_area)  # Output: 901.5

Integer to Float

floor_count = 12
floor_count_float = float(floor_count)

print(floor_count_float)  # Output: 12.0
print(type(floor_count_float))  # Output:

Why This Matters: Data from External Sources

# Data imported from Excel or CSV comes as strings
areas_from_excel = ["450.5", "380.2", "520.8"]

# Convert to floats for calculations
areas = []
for area_str in areas_from_excel:
    area = float(area_str)
    areas.append(area)

total_area = sum(areas)
print(total_area)  # Output: 1351.5

Converting to Boolean: bool()

Convert other types to boolean using bool().

How It Works

Python converts values to True or False based on whether they're "truthy" or "falsy".

Falsy values (become False):

0 (zero)
0.0 (zero float)
"" (empty string)
None

Truthy values (become True):

Any non-zero number
Any non-empty string

print(bool(1))       # Output: True
print(bool(0))       # Output: False
print(bool(42))      # Output: True
print(bool(-5))      # Output: True

print(bool("text"))  # Output: True
print(bool(""))      # Output: False

print(bool(3.14))    # Output: True
print(bool(0.0))     # Output: False

Architectural Example: Checking for Empty Values

room_name = ""
area = 0
status = "Draft"

has_name = bool(room_name)
has_area = bool(area)
has_status = bool(status)

print(has_name)    # Output: False (empty string)
print(has_area)    # Output: False (zero)
print(has_status)  # Output: True (non-empty string)

Conversion Errors

Not all conversions are possible. Python will raise an error if you try to convert something that doesn't make sense.

Invalid String to Integer

text = "hello"
number = int(text)
# Error: ValueError: invalid literal for int() with base 10: 'hello'

You can only convert strings that look like numbers.

# These work
int("123")      # Output: 123
int("0")        # Output: 0
int("-45")      # Output: -45

# These don't
int("12.5")     # Error: ValueError (use float() first)
int("hello")    # Error: ValueError
int("12a")      # Error: ValueError

Invalid String to Float

text = "Room 101"
area = float(text)
# Error: ValueError: could not convert string to float: 'Room 101'

# These work
float("12.5")    # Output: 12.5
float("0.0")     # Output: 0.0
float("123")     # Output: 123.0

# These don't
float("hello")   # Error: ValueError
float("12.5m")   # Error: ValueError (can't have letters)

The Pain vs The Python Fix

The Pain: Reading room areas from an Excel export. They're stored as text. Your area calculations fail. You manually convert 200 values.

The Python Fix: Convert once, calculate reliably.

# Areas imported from Excel (as strings)
area_data = ["450.5", "380.2", "520.8", "410.3", "395.7"]

# Convert all to floats
areas = []
for area_str in area_data:
    area = float(area_str)
    areas.append(area)

# Now calculate
total_area = sum(areas)
average_area = total_area / len(areas)

print(f"Total area: {total_area} m²")
print(f"Average area: {average_area} m²")

# Output:
# Total area: 2157.5 m²
# Average area: 431.5 m²

Real Architectural Workflows

Example 1: Building File Names with Number

project_code = "2024-001"
discipline = "Architecture"
sheet_number = 101
revision = 3

# Convert numbers to strings for file name
file_name = f"{project_code}_{discipline}_Sheet_{sheet_number}_R{str(revision).zfill(2)}.pdf"

print(file_name)
# Output: 2024-001_Architecture_Sheet_101_R03.pdf

Note: .zfill(2) pads with zeros (we'll learn string methods in depth later).

Example 2: Processing User Input

# User enters floor count as text
floor_input = "12"

# Convert to integer for calculations
floor_count = int(floor_input)

floor_height = 3.2
total_height = floor_count * floor_height

print(f"Total height: {total_height}m")
# Output: Total height: 38.4m

Example 3: Rounding Areas for Display

# Precise area from calculation
room_area = 450.7893

# Convert to int to round down
area_rounded = int(room_area)

print(f"Area: {area_rounded} m²")
# Output: Area: 450 m²

If you want proper rounding (not truncating), use round():

room_area = 450.7893
area_rounded = round(room_area)

print(area_rounded)  # Output: 451

f-strings: An Alternative to Conversion

Earlier, we converted numbers to strings for concatenation:

floor = 3
message = "Level " + str(floor)

With f-strings, Python handles conversion automatically:

floor = 3
message = f"Level {floor}"
print(message)  # Output: Level 3

This is cleaner and more readable.

Architectural Example

project = "Community Center"
floor_count = 12
area = 3500.5
is_approved = True

report = f"Project: {project}, Floors: {floor_count}, Area: {area}m², Approved: {is_approved}"

print(report)
# Output: Project: Community Center, Floors: 12, Area: 3500.5m², Approved: True

Type Conversion Chain

Sometimes you need to convert through multiple types.

# String that looks like a float, but you want an integer
area_str = "450.75"

# Can't go directly string → int
area_int = int(area_str)
# Error: ValueError: invalid literal for int() with base 10: '450.75'

# Convert string → float → int
area_float = float(area_str)
area_int = int(area_float)

print(area_int)  # Output: 450

# Or in one line
area_int = int(float(area_str))
print(area_int)  # Output: 450

Common Mistakes

Mistake 1: Converting strings with units

area = "450 m²"
area_float = float(area)
# Error: ValueError (can't convert because of " m²")

Fix: Remove the unit first.

area = "450 m²"
area_clean = area.replace(" m²", "")
area_float = float(area_clean)
print(area_float)  # Output: 450.0

Mistake 2: Expecting int() to round

height = 3.9
height_int = int(height)
print(height_int)  # Output: 3 (not 4!)

Use round() if you want rounding:

height = 3.9
height_rounded = round(height)
print(height_rounded)  # Output: 4

Mistake 3: Not checking if conversion is possible

user_input = "abc"
number = int(user_input)
# Error: ValueError

You'll learn error handling in a later module, but for now, be aware conversions can fail.

Mistake 4: Converting empty strings

area_str = ""
area_float = float(area_str)
# Error: ValueError: could not convert string to float: ''

Check for empty values first:

area_str = ""

if area_str:
    area_float = float(area_str)
else:
    area_float = 0.0

print(area_float)  # Output: 0.0

Assignme

Create a new file called type_conversion_practice.py
File name builder:
- Variables: project = "2024-001", sheet = 101, revision = 3
- Build: "2024-001_Sheet_101_R03.pdf"
- Convert numbers to strings
- Print the file name
Area calculations from string data:
- Start with: areas = ["450.5", "380.2", "520.8"]
- Convert each to float
- Calculate total area
- Calculate average area
- Print results
Floor count calculator:
- Variables: building_height = 35.7, floor_height = 3.2
- Calculate how many full floors fit (use int())
- Calculate leftover height
- Print both values
Room status checker:
- Variables: room_name = "", area = 0, status = "Draft"
- Use bool() to check which values are "truthy"
- Print results for each
String to number with error:
- Try: area_str = "450 m²"
- Try to convert directly to float (see the error)
- Clean the string first (remove " m²")
- Then convert to float
- Print result
Experiment:
- Try converting "hello" to int (see the error)
- Try converting 3.9 to int (does it round?)
- Try converting an empty string to float (see the error)
- Use f-strings to avoid manual conversion for "Level 5"

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's official documentation on type conversion covers built-in conversion functions
Real Python's guide to type conversion explains conversion with detailed examples
Python's round() function for proper rounding instead of truncating

Lesson 08: Booleans (True or False)

Prajwal Kumar — Sat, 07 Feb 2026 20:41:51 +0530

Introduction

Every decision in architecture involves yes or no questions.

Is the room compliant with code? Is the drawing issued? Does the area meet the minimum requirement?

In Python, these yes/no states are called booleans. They're named after George Boole, a mathematician who formalised logic.

Booleans are simple — they can only be True or False. But they're the foundation of every automated decision your scripts will make.

This lesson shows you how booleans work and how to use them to check conditions in architectural workflows.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Understand what booleans are (True/False values)
Learn comparison operators (>, <, ==, !=, >=, <=)
Use logical operators (and, or, not)
Store boolean results in variables
Apply booleans to architectural decision-making

What Is a Boolean?

A boolean is a data type with only two possible values:

True
False

That's it. Nothing else.

Notice: True and False are capitalised in Python. This matters.

is_issued = True      # Correct
is_approved = False   # Correct

is_issued = true      # Wrong (lowercase 't')
# Error: NameError: name 'true' is not defined

Where Booleans Come From

You can create booleans directly:

is_issued = True
is_approved = False
requires_review = True

Or you get them as the result of comparisons:

floor_area = 450
minimum_area = 400

meets_requirement = floor_area > minimum_area
print(meets_requirement)  # Output: True

Comparison Operators

Comparison operators compare two values and return True or False.

Greater Than (>)

floor_area = 450
minimum_area = 400

result = floor_area > minimum_area
print(result)  # Output: True

Less Than (<)

ceiling_height = 2.4
minimum_height = 2.7

result = ceiling_height < minimum_height
print(result)  # Output: True

Equal To (==)

room_count = 12
expected_count = 12

result = room_count == expected_count
print(result)  # Output: True

Important: Use == (double equals) for comparison, not = (single equals for assignment).

x = 5       # Assignment (creates/updates variable)
x == 5      # Comparison (checks if equal)

Not Equal To (!=)

status = "Draft"
required_status = "Issued"

result = status != required_status
print(result)  # Output: True (they are different)

Greater Than or Equal To (>=)

room_area = 400
minimum_area = 400

result = room_area >= minimum_area
print(result)  # Output: True (equal counts)

Less Than or Equal To (<=)

floor_count = 8
maximum_floors = 10

result = floor_count <= maximum_floors
print(result)  # Output: True

Architectural Examples: Comparisons

Checking Code Compliance

room_height = 2.4
minimum_height = 2.7

is_compliant = room_height >= minimum_height
print(is_compliant)  # Output: False

if is_compliant:
    print("Room meets code requirement")
else:
    print("Room height too low")

Checking Floor Area

room_area = 450
minimum_area = 400

meets_requirement = room_area > minimum_area
print(meets_requirement)  # Output: True

Validating Sheet Status

sheet_status = "Issued"
required_status = "Issued"

is_ready = sheet_status == required_status
print(is_ready)  # Output: True

Comparing Strings

You can compare strings using the same operators.

Equality

room_type_1 = "Conference Room"
room_type_2 = "Conference Room"

result = room_type_1 == room_type_2
print(result)  # Output: True

Warning: String comparisons are case-sensitive.

status_1 = "Issued"
status_2 = "issued"

result = status_1 == status_2
print(result)  # Output: False (different case)

# Fix: standardize case first
result = status_1.lower() == status_2.lower()
print(result)  # Output: True

Logical Operators

Logical operators combine multiple boolean values.

AND (and)

Both conditions must be True for the result to be True.

floor_area = 450
ceiling_height = 2.8

minimum_area = 400
minimum_height = 2.7

area_ok = floor_area >= minimum_area
height_ok = ceiling_height >= minimum_height

is_compliant = area_ok and height_ok
print(is_compliant)  # Output: True (both are True)

Truth Table for AND:

True  and True  = True
True  and False = False
False and True  = False
False and False = False

OR (or)

At least one condition must be True for the result to be True.

is_fire_rated = False
has_sprinklers = True

is_protected = is_fire_rated or has_sprinklers
print(is_protected)  # Output: True (one is True)

Truth Table for OR:

True  or True  = True
True  or False = True
False or True  = True
False or False = False

NOT (not)

Reverses a boolean value.

is_issued = False
needs_review = not is_issued
print(needs_review)  # Output: True

Truth Table for NOT:

not True  = False
not False = True

Architectural Examples: Logical Operators

Room Validation (Multiple Conditions)

room_area = 450
ceiling_height = 2.8
has_windows = True

# All conditions must be met
minimum_area = 400
minimum_height = 2.7

area_ok = room_area >= minimum_area
height_ok = ceiling_height >= minimum_height

is_valid = area_ok and height_ok and has_windows
print(is_valid)  # Output: True

Fire Safety Check (At Least One Must Be True)

has_fire_door = False
has_sprinklers = True
has_fire_alarm = True

is_safe = has_fire_door or has_sprinklers or has_fire_alarm
print(is_safe)  # Output: True (at least one is True)

Excluding Certain Conditions

is_basement = False
is_mechanical = False

is_habitable = not is_basement and not is_mechanical
print(is_habitable)  # Output: True

Combining Comparisons and Logic

You can write complex conditions in one line.

room_area = 450
ceiling_height = 2.8
is_basement = False

minimum_area = 400
minimum_height = 2.7

# Room is valid if it meets size requirements AND is not a basement
is_valid = (room_area >= minimum_area and
            ceiling_height >= minimum_height and
            not is_basement)

print(is_valid)  # Output: True

Order of Operations (Logical)

Python evaluates logical operators in this order:

not (highest priority)
and
or (lowest priority)

result = True or False and False
print(result)  # Output: True
# Evaluates as: True or (False and False)
# Which is: True or False = True

Best Practice: Use parentheses to make your intent clear.

result = (True or False) and False
print(result)  # Output: False
# Now the or happens first

Boolean Values from Other Types

Some values are considered "truthy" or "falsy" in boolean contexts.

Falsy values (evaluate to False):

False
None
0 (zero)
"" (empty string)
[] (empty list)
{} (empty dictionary)

Truthy values (evaluate to True):

Everything else

room_name = ""
has_name = bool(room_name)
print(has_name)  # Output: False (empty string)

room_name = "Conference Room"
has_name = bool(room_name)
print(has_name)  # Output: True (non-empty string)

This becomes useful later when checking if variables have values.

The Pain vs The Python Fix

The Pain: Manually checking if 500 rooms meet code requirements. One by one. In a spreadsheet.

The Python Fix: Define the rule once, check all rooms automatically.

# Room data (simplified)
rooms = [
    {"name": "Conference A", "area": 450, "height": 2.8},
    {"name": "Conference B", "area": 380, "height": 2.9},
    {"name": "Office 1", "area": 420, "height": 2.6},
    {"name": "Office 2", "area": 410, "height": 2.8}
]

# Requirements
minimum_area = 400
minimum_height = 2.7

# Check each room
for room in rooms:
    area_ok = room["area"] >= minimum_area
    height_ok = room["height"] >= minimum_height
    is_compliant = area_ok and height_ok

    if is_compliant:
        print(f"{room['name']}: PASS")
    else:
        print(f"{room['name']}: FAIL")

# Output:
# Conference A: PASS
# Conference B: FAIL (area too small)
# Office 1: FAIL (height too low)
# Office 2: PASS

Common Mistakes

Mistake 1: Using = instead of ==

floor_count = 10

# Wrong (assignment, not comparison)
if floor_count = 10:
    print("Ten floors")
# Error: SyntaxError: invalid syntax

# Correct (comparison)
if floor_count == 10:
    print("Ten floors")

Mistake 2: Comparing booleans explicitly

You don't need to compare booleans to True or False.

is_issued = True

# Redundant
if is_issued == True:
    print("Issued")

# Better
if is_issued:
    print("Issued")

Mistake 3: Confusing and/or logic

# You want: area > 400 OR height > 2.7
area = 380
height = 2.8

# Wrong (both conditions must be true)
is_ok = area > 400 and height > 2.7
print(is_ok)  # Output: False

# Correct (at least one must be true)
is_ok = area > 400 or height > 2.7
print(is_ok)  # Output: True

Mistake 4: Forgetting operator precedence

x = True
y = False
z = True

# Without parentheses (not happens first)
result = not x and y or z
print(result)  # Output: True

# With parentheses (clear intent)
result = (not x) and (y or z)
print(result)  # Output: False

When in doubt, use parentheses.

Assignment

Create a new file called boolean_practice.py
Room compliance checker:
- Create variables: room_area = 420, ceiling_height = 2.6
- Set requirements: minimum_area = 400, minimum_height = 2.7
- Check if room meets both requirements using and
- Print "Compliant" or "Not Compliant"
Project status validator:
- Variables: design_complete = True, permits_approved = False, budget_approved = True
- Project can proceed if ALL three are True
- Check and print result
Floor eligibility checker:
- Variables: floor_number = 0, is_mechanical = False
- A floor is habitable if it's NOT floor 0 AND NOT mechanical
- Use not operator
- Print result
Multiple room checks:
- Create a list of room areas: [380, 420, 450, 390]
- Minimum area: 400
- For each area, check if it meets minimum and print result
String comparison practice:
- Variables: status_1 = "Issued", status_2 = "issued"
- Compare directly (case-sensitive)
- Compare after converting to lowercase
- Observe the different results
Experiment:
- Try using = instead of == in a comparison (see the error)
- Try: True and False or True — what's the result?
- Try: (True and False) or True — is it different?
- Check if an empty string is truthy or falsy using bool("")

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's official documentation on booleans covers boolean operations in detail
Real Python's guide to boolean logic explains truth tables and logical operators
Python's operator precedence table shows the complete order of operations

Lesson 07: Strings (Text and Labels)

Prajwal Kumar — Sat, 07 Feb 2026 20:27:10 +0530

Introduction

Architects work with text constantly. Room names, sheet numbers, view names, file paths, drawing titles.

If you've ever renamed 200 sheets by hand, or spent an hour fixing inconsistent room names, you know the pain.

In Python, text is called a string. Strings are how you handle names, labels, and any text-based information.

This lesson is critical. Most BIM automation involves manipulating strings — reading them, combining them, extracting parts, and reformatting them.

By the end of this lesson, you'll see why strings are the most useful data type for architectural workflows.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Understand what strings are and how to create them
Learn to combine strings (concatenation)
Extract parts of strings (slicing)
Change string case (upper, lower, title)
Find and replace text in strings
Use string methods for real BIM tasks
Avoid common string errors

What Is a String?

A string is text enclosed in quotes.

room_name = "Conference Room"
sheet_number = "A-101"
file_path = "C:/Projects/2024-001/Floor Plans.pdf"

You can use single quotes or double quotes. Python treats them the same.

room_name = "Conference Room"   # Double quotes
room_name = 'Conference Room'   # Single quotes (same result)

Why Both Quote Types Exist

Sometimes your text contains quotes. Having both types makes this easier.

# Text with an apostrophe
note = "Client's requirements changed"  # Double quotes work

# Or
note = 'Client\\'s requirements changed'  # Escape the apostrophe with \\

# Text with double quotes inside
message = 'The room is called "Main Conference"'

Use whichever makes your string clearer.

Creating Strings

# Simple strings
project_name = "Community Center"
architect = "Smith & Associates"
status = "In Progress"

# Empty string
description = ""

# Multi-line strings (use triple quotes)
notes = """
This is a multi-line string.
It can span several lines.
Useful for long descriptions.
"""

Combining Strings (Concatenation)

Use the + operator to join strings.

discipline = "A"
sheet_number = "101"
full_number = discipline + "-" + sheet_number

print(full_number)  # Output: A-101

Architectural Example: Sheet Naming

discipline = "A"
sheet_type = "Floor Plan"
level = "Level 02"
revision = "R03"

# Build the full sheet name
sheet_name = discipline + " - " + sheet_type + " - " + level + " - " + revision

print(sheet_name)
# Output: A - Floor Plan - Level 02 - R03

Common Mistake: Concatenating Strings and Numbers

You can't directly concatenate strings and numbers.

floor_number = 2
floor_name = "Level " + floor_number
# Error: TypeError: can only concatenate str (not "int") to str

Convert the number to a string first using str().

floor_number = 2
floor_name = "Level " + str(floor_number)

print(floor_name)  # Output: Level 2

Architectural Example: Room Numbering

room_type = "Conference Room"
room_number = 201

# Convert number to string before concatenating
full_name = room_type + " " + str(room_number)

print(full_name)  # Output: Conference Room 201

String Length

Find how many characters are in a string using len().

sheet_name = "A-101"
name_length = len(sheet_name)

print(name_length)  # Output: 5

Why This Matters

# Check if sheet number is the correct format
sheet_number = "A-101"

if len(sheet_number) == 5:
    print("Sheet number format is correct")
else:
    print("Sheet number format is wrong")

String Indexing (Accessing Individual Characters)

Each character in a string has a position (index). Python starts counting at 0.

sheet_number = "A-101"
#               0 1 2 3 4  (index positions)

first_char = sheet_number[0]
print(first_char)  # Output: A

last_char = sheet_number[4]
print(last_char)  # Output: 1

Negative Indexing

You can count from the end using negative numbers.

sheet_number = "A-101"

last_char = sheet_number[-1]
print(last_char)  # Output: 1

second_last = sheet_number[-2]
print(second_last)  # Output: 0

String Slicing (Extracting Parts)

Extract a portion of a string using [start:end].

sheet_number = "A-101"

# Get discipline (first character)
discipline = sheet_number[0]
print(discipline)  # Output: A

# Get number part (characters 2 to end)
number = sheet_number[2:]
print(number)  # Output: 101

# Get first three characters
prefix = sheet_number[0:3]
print(prefix)  # Output: A-1

Slicing Rules

[start:end] — from start up to (but not including) end
[start:] — from start to the end
[:end] — from beginning up to (but not including) end
[:] — entire string (useful for copying)

Architectural Example: Extracting Discipline from Sheet Number

sheet_numbers = ["A-101", "S-201", "M-301", "E-401"]

for sheet in sheet_numbers: # We'll learn about for loops in the coming lessons.
    discipline = sheet[0]
    print("Discipline:", discipline)

# Output:
# Discipline: A
# Discipline: S
# Discipline: M
# Discipline: E

String Methods

Strings come with built-in methods (functions) that perform common operations.

Changing Case

project_name = "community center"

# Make all uppercase
upper_name = project_name.upper()
print(upper_name)  # Output: COMMUNITY CENTER

# Make all lowercase
lower_name = project_name.lower()
print(lower_name)  # Output: community center

# Title case (first letter of each word capitalized)
title_name = project_name.title()
print(title_name)  # Output: Community Center

Architectural Use Case: Standardising Room Names

# Room names from different sources have inconsistent capitalization
rooms = ["conference room", "MEETING ROOM", "break Room"]

# Standardize to title case
standardized_rooms = []
for room in rooms:
    standardized = room.title()
    standardized_rooms.append(standardized)

print(standardized_rooms)
# Output: ['Conference Room', 'Meeting Room', 'Break Room']

Removing Whitespace

Whitespace (spaces, tabs, newlines) at the beginning or end of strings can cause problems.

room_name = "  Conference Room  "

# Remove whitespace from both ends
clean_name = room_name.strip()
print(clean_name)  # Output: "Conference Room"

# Remove from left side only
clean_left = room_name.lstrip()
print(clean_left)  # Output: "Conference Room  "

# Remove from right side only
clean_right = room_name.rstrip()
print(clean_right)  # Output: "  Conference Room"

Why This Matters

# Data imported from Excel might have extra spaces
room_1 = "Conference Room"
room_2 = "Conference Room "  # Extra space at end

# These are NOT equal
print(room_1 == room_2)  # Output: False

# Clean the data first
room_1_clean = room_1.strip()
room_2_clean = room_2.strip()

print(room_1_clean == room_2_clean)  # Output: True

Finding Text in Strings

Check if a string contains certain text.

sheet_name = "A-101 Ground Floor Plan"

# Check if it contains "Floor"
if "Floor" in sheet_name:
    print("This is a floor plan")

# Check if it doesn't contain something
if "Ceiling" not in sheet_name:
    print("This is not a ceiling plan")

Find Position of Text

sheet_name = "A-101 Ground Floor Plan"

# Find where "Floor" starts
position = sheet_name.find("Floor")
print(position)  # Output: 14

# Find returns -1 if text is not found
position = sheet_name.find("Ceiling")
print(position)  # Output: -1

Replacing Text

Replace all occurrences of one string with another.

sheet_name = "A-101 Ground Floor Plan"

# Replace "Ground" with "First"
new_name = sheet_name.replace("Ground", "First")
print(new_name)  # Output: A-101 First Floor Plan

Architectural Use Case: Batch Renaming

# Update all sheet names from "Draft" to "Issued"
sheet_names = [
    "A-101 Draft Floor Plan",
    "A-102 Draft Floor Plan",
    "A-201 Draft Elevation"
]

issued_names = []
for sheet in sheet_names:
    new_name = sheet.replace("Draft", "Issued")
    issued_names.append(new_name)

print(issued_names)
# Output:
# ['A-101 Issued Floor Plan', 'A-102 Issued Floor Plan', 'A-201 Issued Elevation']

Splitting Strings

Break a string into a list of parts.

sheet_number = "A-101"

# Split at the hyphen
parts = sheet_number.split("-")
print(parts)  # Output: ['A', '101']

# Access individual parts
discipline = parts[0]
number = parts[1]

print("Discipline:", discipline)  # Output: Discipline: A
print("Number:", number)          # Output: Number: 101

Architectural Example: Parsing Sheet Numbers

sheet_numbers = ["A-101", "S-201", "M-301", "E-401"]

for sheet in sheet_numbers:
    parts = sheet.split("-")
    discipline = parts[0]
    number = parts[1]

    print(f"Sheet {sheet}: Discipline = {discipline}, Number = {number}")

# Output:
# Sheet A-101: Discipline = A, Number = 101
# Sheet S-201: Discipline = S, Number = 201
# Sheet M-301: Discipline = M, Number = 301
# Sheet E-401: Discipline = E, Number = 401

Joining Strings

Combine a list of strings into one string.

parts = ["A", "101"]

# Join with a hyphen
sheet_number = "-".join(parts)
print(sheet_number)  # Output: A-101

# Join with an underscore
file_name = "_".join(parts)
print(file_name)  # Output: A_101

Architectural Example: Building File Names

project_code = "2024-001"
discipline = "Architecture"
drawing_type = "Floor Plans"
revision = "R02"

# Join parts with underscores
parts = [project_code, discipline, drawing_type, revision]
file_name = "_".join(parts) + ".pdf"

print(file_name)
# Output: 2024-001_Architecture_Floor Plans_R02.pdf

String Formatting (f-strings)

A cleaner way to build strings with variables.

Instead of concatenating:

project = "Community Center"
year = 2024
message = "Project: " + project + ", Year: " + str(year)
print(message)

Use f-strings (formatted string literals):

project = "Community Center"
year = 2024
message = f"Project: {project}, Year: {year}"
print(message)

Both output: Project: Community Center, Year: 2024

Why f-strings Are Better

No need to convert numbers to strings
More readable
Easier to maintain

Architectural Examples

# Building report
floor_count = 12
floor_height = 3.2
total_height = floor_count * floor_height

report = f"Building has {floor_count} floors at {floor_height}m each = {total_height}m total"
print(report)
# Output: Building has 12 floors at 3.2m each = 38.4m total

# Sheet naming
discipline = "A"
number = 101
sheet_name = f"{discipline}-{number}"
print(sheet_name)
# Output: A-101

# Room naming
room_type = "Conference"
room_number = 201
full_name = f"{room_type} Room {room_number}"
print(full_name)
# Output: Conference Room 201

The Pain vs The Python Fix

The Pain: Renaming 200 sheets manually to follow a new naming standard.

The Python Fix: Define the pattern once, apply it to all sheets.

# Old naming: "A-101 - GROUND FLOOR PLAN"
# New naming: "A-101_Ground_Floor_Plan"

old_names = [
    "A-101 - GROUND FLOOR PLAN",
    "A-102 - FIRST FLOOR PLAN",
    "A-201 - NORTH ELEVATION"
]

new_names = []
for old_name in old_names:
    # Convert to title case
    name = old_name.title()
    # Replace " - " with "_"
    name = name.replace(" - ", "_")
    # Replace spaces with underscores
    name = name.replace(" ", "_")

    new_names.append(name)

for i, new_name in enumerate(new_names):
    print(f"{old_names[i]} → {new_name}")

# Output:
# A-101 - GROUND FLOOR PLAN → A-101_Ground_Floor_Plan
# A-102 - FIRST FLOOR PLAN → A-102_First_Floor_Plan
# A-201 - NORTH ELEVATION → A-201_North_Elevation

Common Mistakes

Mistake 1: Trying to change a string directly

Strings are immutable (cannot be changed after creation).

sheet_name = "A-101"
sheet_name[0] = "S"
# Error: TypeError: 'str' object does not support item assignment

Instead, create a new string:

sheet_name = "A-101"
new_name = "S" + sheet_name[1:]
print(new_name)  # Output: S-101

Mistake 2: Forgetting to convert numbers to strings

floor = 2
name = "Level " + floor
# Error: TypeError: can only concatenate str (not "int") to str

Fix:

floor = 2
name = "Level " + str(floor)
print(name)  # Output: Level 2

# Or use f-strings
name = f"Level {floor}"
print(name)  # Output: Level 2

Mistake 3: Off-by-one errors in slicing

sheet = "A-101"
number = sheet[2:4]  # Trying to get "101"
print(number)  # Output: 10 (not 101!)

# Correct
number = sheet[2:]
print(number)  # Output: 101

Mistake 4: Case-sensitive comparisons

room_1 = "Conference Room"
room_2 = "conference room"

print(room_1 == room_2)  # Output: False (different case)

# Fix: standardize case before comparing
print(room_1.lower() == room_2.lower())  # Output: True

Assignment

Create a new file called string_practice.py
Sheet naming exercise:
- Create variables: discipline = "A", sheet_type = "Floor Plan", level = "02"
- Combine them into: "A-Floor Plan-02"
- Convert to: "A_FLOOR_PLAN_02" (uppercase, underscores)
Room naming standardization:
- Start with: rooms = ["conference room", "MEETING ROOM", "Break Room "]
- Standardize to title case
- Remove extra whitespace
- Print the cleaned list
Sheet number parsing:
- Start with: sheet = "A-101-Ground-Floor-Plan"
- Extract: discipline ("A")
- Extract: number ("101")
- Extract: description ("Ground-Floor-Plan")
- Print each part separately
File name builder:
- Variables: project = "2024-001", drawing = "Floor Plans", revision = 3
- Build: "2024-001_Floor_Plans_R03.pdf"
- Use f-strings
Batch renaming simulation:
- Start with: ["A-101 Draft", "A-102 Draft", "A-201 Draft"]
- Replace "Draft" with "Issued"
- Print before and after
Experiment:
- Try to change a character in a string directly (see the error)
- Slice your name to get just the first 3 letters
- Check if "Floor" is in "Ground Floor Plan"

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's official string documentation lists all string methods
Real Python's guide to f-strings covers string formatting in depth
Python string methods cheat sheet for quick reference

Lesson 06 - Numbers (Integers and Float)

Prajwal Kumar — Sat, 07 Feb 2026 20:08:47 +0530

Introduction

Architects work with numbers constantly. Floor counts, room areas, building heights, budget calculations.

Python handles numbers in two ways: integers (whole numbers) and floats (decimal numbers).

Understanding the difference matters. It affects how your calculations work and what results you get.

This lesson shows you how Python treats numbers and how to use them in real architectural calculations.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Understand the difference between integers and floats
Learn when to use each type
Perform basic math operations (+, -, *, /)
Understand why division behaves differently than you expect
See how number types affect real calculations

Two Types of Numbers

Python treats whole numbers and decimal numbers as different types.

Integers (int) — Whole numbers, no decimal point

floor_count = 12
window_count = 48
door_count = 24

Floats (float) — Numbers with decimal points

floor_height = 3.2
room_area = 42.5
wall_thickness = 0.2

When to Use Each Type

Use Integers When Counting Things

Things you count are always whole numbers. You can't have 12.5 floors or 3.7 doors.

# Counting
floor_count = 8
room_count = 45
column_count = 16

# IDs and numbers
sheet_number = 101
revision_number = 3

Use Floats When Measuring Things

Measurements are rarely exact whole numbers.

# Distances and heights
floor_height = 3.2
ceiling_height = 2.7
wall_length = 12.5

# Areas and volumes
room_area = 42.5
floor_area = 850.75

# Coordinates
x_coordinate = 125.3
y_coordinate = 78.9

Basic Math Operations

Python uses the operators you already know.

Addition (+)

ground_floor_height = 4.5
typical_floor_height = 3.2
total_height = ground_floor_height + typical_floor_height

print(total_height)  # Output: 7.7

Subtraction (-)

total_area = 450.0
circulation_area = 75.5
usable_area = total_area - circulation_area

print(usable_area)  # Output: 374.5

Multiplication (*)

floor_count = 8
floor_height = 3.2
total_height = floor_count * floor_height

print(total_height)  # Output: 25.6

Division (/)

total_area = 450.0
floor_count = 3
area_per_floor = total_area / floor_count

print(area_per_floor)  # Output: 150.0

The Division Surprise

Division in Python always returns a float, even when dividing whole numbers.

total_floors = 12
half_floors = total_floors / 2

print(half_floors)    # Output: 6.0 (not 6)
print(type(half_floors))  # Output:

Notice: 6.0 not 6. The result is a float.

This is intentional. Python assumes you want precision.

Integer Division (//)

If you want to divide and get an integer back, use // (floor division).

total_floors = 13
floors_per_section = total_floors // 3

print(floors_per_section)  # Output: 4 (not 4.333...)

Floor division divides and rounds down to the nearest whole number.

When This Matters

# You have 100 seats and tables that fit 8 people
seats = 100
seats_per_table = 8

tables_needed = seats // seats_per_table
print(tables_needed)  # Output: 12

# Regular division would give you 12.5 tables
# But you can't have half a table

Modulo (%) — The Remainder

The modulo operator % gives you the remainder after division.

seats = 100
seats_per_table = 8

tables_needed = seats // seats_per_table
leftover_seats = seats % seats_per_table

print(tables_needed)    # Output: 12
print(leftover_seats)   # Output: 4

You need 12 tables. 4 seats will be left over.

Architectural Use Case

# You're ordering tiles. Tiles come in boxes of 25.
tiles_needed = 378
tiles_per_box = 25

boxes_needed = tiles_needed // tiles_per_box
extra_tiles = tiles_needed % tiles_per_box

print(boxes_needed)  # Output: 15 boxes
print(extra_tiles)   # Output: 3 tiles short

# You need 16 boxes to have enough

Exponentiation (**)

Raise a number to a power using **.

# Area of a square
side_length = 5
area = side_length ** 2

print(area)  # Output: 25

# Volume of a cube
side_length = 3
volume = side_length ** 3

print(volume)  # Output: 27

Mixing Integers and Floats

When you mix integers and floats, Python converts the result to a float.

floor_count = 8        # Integer
floor_height = 3.2     # Float

total_height = floor_count * floor_height
print(total_height)    # Output: 25.6 (float)

This is called type promotion. Python promotes the integer to a float to avoid losing precision.

Order of Operations (PEMDAS)

Python follows standard math rules.

Parentheses

Exponents

Multiplication and Division (left to right)

Addition and Subtraction (left to right)

# Without parentheses
result = 10 + 5 * 2
print(result)  # Output: 20 (multiplication first)

# With parentheses
result = (10 + 5) * 2
print(result)  # Output: 30 (parentheses first)

Architectural Example

# Calculate total building height
ground_floor_height = 4.5
typical_floor_height = 3.2
floor_count = 8

# Wrong (without parentheses)
total_height = ground_floor_height + floor_count * typical_floor_height
print(total_height)  # Output: 30.1
# This calculates: 4.5 + (8 * 3.2) = 4.5 + 25.6

# Correct (with parentheses)
typical_floors = floor_count - 1
total_height = ground_floor_height + (typical_floors * typical_floor_height)
print(total_height)  # Output: 27.9
# This calculates: 4.5 + (7 * 3.2) = 4.5 + 22.4

When in doubt, use parentheses. They make your intent clear.

Real Architectural Calculations

Example 1: Building Height

ground_floor_height = 4.5
typical_floor_height = 3.2
floor_count = 12

# Ground floor + typical floors
typical_floors = floor_count - 1
total_height = ground_floor_height + (typical_floors * typical_floor_height)

print("Building height:", total_height, "meters")
# Output: Building height: 39.7 meters

Example 2: Floor Area Ratio (FAR)

site_area = 2000.0
gross_floor_area = 8500.0

far = gross_floor_area / site_area

print("Floor Area Ratio:", far)
# Output: Floor Area Ratio: 4.25

Example 3: Budget Per Square Meter

total_budget = 5000000
total_area = 3500.0

cost_per_sqm = total_budget / total_area

print("Cost per sqm:", cost_per_sqm)
# Output: Cost per sqm: 1428.5714285714287

Notice: The result has many decimal places. We'll learn to format numbers properly in a later lesson.

The Pain vs The Python Fix

The Pain: Calculating building metrics by hand. Every time a dimension changes, you recalculate everything.

The Python Fix: Define the variables once. Change one value, everything updates.

# Define once
floor_count = 12
floor_height = 3.2
ground_floor_height = 4.5

# Calculate automatically
typical_floors_height = (floor_count - 1) * floor_height
total_height = ground_floor_height + typical_floors_height
average_height = total_height / floor_count

print("Total height:", total_height)
print("Average height:", average_height)

# Change floor count
floor_count = 15

# Recalculate automatically
typical_floors_height = (floor_count - 1) * floor_height
total_height = ground_floor_height + typical_floors_height
average_height = total_height / floor_count

print("New total height:", total_height)
print("New average height:", average_height)

Common Mistakes

Mistake 1: Expecting integer division to give an integer

total_floors = 12
result = total_floors / 2

print(result)  # Output: 6.0 (float, not 6)

Use // if you want an integer.

total_floors = 12
result = total_floors // 2

print(result)  # Output: 6 (integer)

Mistake 2: Dividing by zero

area = 450.0
floor_count = 0

area_per_floor = area / floor_count
# Error: ZeroDivisionError: division by zero

Python can't divide by zero. Check your values before dividing.

Mistake 3: Forgetting order of operations

# You want: 4.5 + (7 * 3.2)
# You write:
total = 4.5 + 7 * 3.2
print(total)  # Output: 26.9 (correct, but unclear)

# Better (explicit):
total = 4.5 + (7 * 3.2)
print(total)  # Output: 26.9 (clear intent)

Mistake 4: Confusing `*` (exponent) with `^` (not exponent in Python)

# Wrong (^ is not exponent in Python)
area = 5 ^ 2  # This does something else entirely

# Correct
area = 5 ** 2
print(area)  # Output: 25

Assignment

Create a new file called building_calculations.py
Define these variables:
- Ground floor height (4.5 meters)
- Typical floor height (3.2 meters)
- Number of floors (10)
- Site area (1500 square meters)
- Floor area per level (450 square meters)
Calculate and print:
- Total building height
- Total gross floor area
- Floor Area Ratio (FAR)
- Average floor height
Change the number of floors to 15 and run the script again. Verify all calculations update.
Experiment:
- Try dividing by zero. Read the error.
- Calculate the number of full floors in 32 meters with 3.2m floor height (use //)
- Find how many meters are left over (use %)
- Calculate the area of a square room with 4.5m sides (use *)
Create a budget calculation:
- Total budget: 4,000,000
- Total area: 2,800 square meters
- Calculate cost per square meter
- Calculate 15% contingency on the budget

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's official documentation on numeric types covers integers and floats in detail
Real Python's guide to operators explains all Python operators with examples
Python's math module provides additional mathematical functions (we'll cover this later)

Lesson 05 - What are Variables?

Prajwal Kumar — Sat, 07 Feb 2026 19:47:49 +0530

Introduction

You've worked with parameters in Revit. You've used named cells in Excel. You've connected inputs in Grasshopper.

All of these are the same concept: giving a name to a piece of information so you can reference it later.

In Python, we call these variables.

This lesson shows you how to create and use variables in Python. By the end, you'll see that variables aren't some programming concept, they're just a way to name and store information, something you already do every day.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Understand what variables are and why they exist
Create variables using assignment
Learn Python's variable naming rules
Recognise why good naming matters
See how variables relate to BIM parameters and spreadsheet cells

What Is a Variable?

A variable is a named container for information.

Instead of writing 3.2 every time you need floor height, you write floor_height once and use that name everywhere.

floor_height = 3.2

This does two things:

Creates a variable called floor_height
Stores the value 3.2 inside it

Now, whenever you write floor_height in your code, Python knows you mean 3.2.

The Architectural Parallel

You already work with variables. You just call them different things.

In Revit:

Parameters store values (Room Number, Area, Level)
You name them once, reference them everywhere

In Excel:

Named cells or ranges store values
Formulas reference those names

In Grasshopper:

Number sliders have names
Components connect to those names, not the values directly

In Python:

Variables store values
Your code references those variable names

Same concept. Different tools.

Creating Variables (Assignment)

You create a variable using the equals sign =. This is called assignment.

project_name = "Community Center"
floor_count = 5
ceiling_height = 3.0
is_approved = True

The pattern is always:

variable_name = value

Left side: the name you're creating

Right side: the value you're storing

Why Variables Matter

Without Variables

print(12 * 3.2)
print(12 * 3.2 + 4.5)
print((12 * 3.2 + 4.5) / 12)

What happens when floor count changes from 12 to 15?

You have to find and change every 12 manually. And hope you didn't miss any.

With Variables

floor_count = 12
floor_height = 3.2
ground_floor_height = 4.5

total_height = floor_count * floor_height
building_height = total_height + ground_floor_height
average_height = building_height / floor_count

print(total_height)
print(building_height)
print(average_height)

What happens when floor count changes to 15?

You change one line: floor_count = 15

Everything else updates automatically.

This is the point of variables.

Variable Naming Rules

Python has strict rules about variable names.

Must Follow:

1. Start with a letter or underscore

floor_height = 3.2  # ✓ Valid
_temp = 5           # ✓ Valid
2nd_floor = 2       # ✗ Invalid (starts with number)

2. Only letters, numbers, and underscores

room_area = 42.5       # ✓ Valid
floor_2_area = 42.5    # ✓ Valid
room-area = 42.5       # ✗ Invalid (hyphen not allowed)
room.area = 42.5       # ✗ Invalid (dot not allowed)

3. Case sensitive

floor_height = 3.2
Floor_Height = 3.5
FLOOR_HEIGHT = 4.0

These are three different variables.

4. Cannot use reserved words

Python reserves certain words for its own use (guess what - we’ll be learning about these reserved words in the coming lessons :))

if = 5      # ✗ Invalid ('if' is reserved)
for = 10    # ✗ Invalid ('for' is reserved)
class = 3   # ✗ Invalid ('class' is reserved)

Variable Naming Conventions

Python doesn't enforce these, but the community follows them.

Use snake_case for variable names

Words separated by underscores, all lowercase.

# Good
floor_height = 3.2
room_name = "Conference Room"
is_fire_rated = True

# Bad (but technically valid)
FloorHeight = 3.2      # Looks like a class name
floorHeight = 3.2      # JavaScript style
FLOOR_HEIGHT = 3.2     # Looks like a constant

Use descriptive names

# Bad
h = 3.2
n = "Project"
x = True

# Good
floor_height = 3.2
project_name = "Project"
is_approved = True

You write code once. You read it hundreds of times.

Clear names save time.

Variables Are References, Not Boxes

This is important to understand.

When you create a variable, you're not creating a container. You're creating a label that points to a value.

floor_height = 3.2

Think of it like this:

The value 3.2 exists in memory
The name floor_height points to it

You can have multiple names pointing to the same value:

standard_height = 3.2
floor_height = standard_height

Now both standard_height and floor_height point to 3.2.

If you change one:

floor_height = 3.5

Only floor_height changes. standard_height still points to 3.2.

Updating Variables

You can change what a variable points to at any time.

floor_count = 5
print(floor_count)  # Output: 5

floor_count = 8
print(floor_count)  # Output: 8

The old value (5) is forgotten. The variable now points to 8.

You can even use the current value to calculate the new value:

floor_count = 5
floor_count = floor_count + 1
print(floor_count)  # Output: 6

This reads as:

Get the current value of floor_count (5)
Add 1 to it (6)
Store the result back in floor_count

Variables in Action: A Real Example

Let's say you're calculating the total height of a building.

The manual way:

print("Ground floor: 4.5m")
print("Typical floors: " + str(8 * 3.2) + "m")
print("Total: " + str(4.5 + (8 * 3.2)) + "m")

Output:

Ground floor: 4.5m
Typical floors: 25.6m
Total: 30.1m

The variable way:

ground_floor_height = 4.5
typical_floor_height = 3.2
floor_count = 8

typical_floors_height = floor_count * typical_floor_height
total_height = ground_floor_height + typical_floors_height

print("Ground floor: " + str(ground_floor_height) + "m")
print("Typical floors: " + str(typical_floors_height) + "m")
print("Total: " + str(total_height) + "m")

Output:

Ground floor: 4.5m
Typical floors: 25.6m
Total: 30.1m

Same result. But now:

The logic is clear
The calculation is reusable
Changing floor count updates everything

Common Mistakes

Mistake 1: Using a variable before creating it

print(floor_height)
floor_height = 3.2

Error: NameError: name 'floor_height' is not defined

Fix: Define the variable first.

floor_height = 3.2
print(floor_height)

Mistake 2: Confusing assignment with comparison

floor_height = 3.2  # Assignment (creating/updating)
floor_height == 3.2  # Comparison (checking if equal)

The single = assigns a value.

The double == checks if two values are equal.

We'll cover == in a later lesson.

Mistake 3: Using spaces in variable names

floor height = 3.2  # ✗ Invalid

Error: SyntaxError: invalid syntax

Fix: Use underscores.

floor_height = 3.2  # ✓ Valid

Assignment

Create a new file called project_variables.py
Create variables for a building project:
- Project name (string)
- Client name (string)
- Floor count (integer)
- Typical floor height (float)
- Ground floor height (float)
- Project status (string like "In Progress" or "Complete")
Use these variables to calculate:
- Total building height
- Average floor height
Print the results using clear messages
Change the floor count and run the script again. Verify the calculations update automatically.
Experiment:
- Try creating a variable with a space in the name. Read the error.
- Try using a variable before defining it. Read the error.
- Create two variables with similar names that differ only in capitalisation. Confirm they're different.

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python's official documentation on variables covers the basics with additional examples
PEP 8 Style Guide explains Python's naming conventions in detail
Real Python's guide to variables offers a deeper dive with more examples

Lesson 04 - Hello World

Prajwal Kumar — Sat, 24 Jan 2026 15:38:17 +0530

Introduction

At some point in your career, you drew your first line in CAD. It wasn't remarkable, and it certainly wasn't architecture yet. But it confirmed something important: the machine responded exactly to what you told it to do.

This lesson is that same moment, just in a different medium.

You're not learning "programming" yet. You're learning how to give a clear instruction and observe the result.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Understand how Python executes code (top to bottom, left to right)
Learn what syntax means
Write your first Python program using print()
Run a Python file in VS Code
Understand what's happening when you run code
Build trust in the language

Why Python Feels Manageable

Python works for architects because it's readable. What you type looks like what you mean.

Minimal ceremony. Minimal noise. Often, you write a thought. The computer follows it.

This is intentional. Python was designed for humans first.

How Python Executes Code

Before writing anything, understand how Python behaves.

Python reads your code in a very predictable way. It goes from top to bottom and from left to right. No guessing. No hidden behavior.

Whatever you write is executed in the exact order you write it. This predictability is one of Python's biggest strengths, especially as your scripts grow.

A Quick Note on Syntax

You'll hear the word syntax often. It simply means the grammar rules of a programming language.

Just like drawings have line weights, layers, and naming conventions, Python has its own grammar.

The good news? Python's syntax is minimal by design.

We'll only introduce new rules when they become necessary.

Writing Your First Line of Python

For this lesson, we'll run Python outside Revit or Grasshopper. Think of this as a neutral learning sandbox where nothing can break.

Step 1: Open VS Code

Open Visual Studio Code.

Step 2: Create a New Python File

Create a new file and save it as:

hello_world.py

The .py extension tells your computer that this file contains Python code.

Step 3: Write the Code

Type the following exactly:

print("Hello World")

No setup, no configuration, nothing else required.

Step 4: Run the File

Click the Run ▶ button in the top-right corner of VS Code.

You should see the following output:

Hello World

You just wrote and executed your first Python program.

What Just Happened?

Let's break down the line you wrote.

print("Hello World")

The word print is a built-in Python instruction that means "show this to me."

The text inside the quotes is the message you want displayed.

When you pressed Run, Python read your instruction, translated it, and displayed the result. You did not explain how to display the text. You only stated what you wanted.

That separation is important.

An Important Mental Model

Python is not clever or intuitive. It is precise and obedient.

If something doesn't work later, it's usually because the instruction was unclear or written in the wrong order. It's almost never because you're "bad at coding."

Practice

Replace your code with the following:

print("This is my first lesson in Python")
print("I am an Architect")
print("And I am learning Python for Architects")

Run the file again and observe what happens.

Each line prints separately. Python executes the file from top to bottom. The order you write is the order you see.

Change the text. Add your name. Nothing breaks. This is a safe space to experiment.

Assignment

Create a new file called introduction.py
Use the print() function to display the following:
- Your name
- Your current role (e.g., "Architectural Designer")
- One reason you're learning Python (e.g., "To automate sheet creation")
Run the file and verify the output
Experiment: change the text, add more lines, see what happens

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Python Official Tutorial — comprehensive but dense. Useful later when you want to dive deep
If you want to experiment without installing anything, try Python Tutor to visualise how code executes line by line

Optional: Configuring pyRevit

Prajwal Kumar — Tue, 13 Jan 2026 20:54:56 +0530

Introduction

This lesson is optional for learners using the Revit route.

We'll configure pyRevit to give you a stable testing environment for the course.

If you're using Rhino or standalone Python, skip this lesson.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Install pyRevit (if you haven't already)
Download the Python for Architects starter kit
Understand pyRevit's folder structure
Add the extension to pyRevit manually
Verify the extension appears in Revit

Install pyRevit

If you haven't already, follow the previous lesson to install pyRevit.

Once installed, return here.

Download the Startup Kit

Extension Download

Download and unzip PythonForArchitects.zip

Do not rename the folder. pyRevit relies on the .extension suffix to recognize extensions.

Once unzipped, the extension is ready to use.

Extension Structure (For Awareness)

You don't need to memorize this, but understanding it helps when customizing tools later.

PythonForArchitects.extension
└── PythonForArchitects.tab
    ├── Sandbox.panel
    │   ├── Lesson 0.pushbutton
    │   │   └── script.py
    │   ├── Lesson 1.pushbutton
    │   │   └── script.py
    │   └── ...
    ├── Links.panel
    │   └── ...
    └── ...

pyRevit reads this folder structure and automatically generates the UI.

No compiling. No installers.

Add the Extension to pyRevit

Open pyRevit Settings in Revit
Locate Custom Extension Directories
Add the parent directory that contains PythonForArchitects.extension

Example path:

C:\\Users\\YourName\\Desktop\\PythonForArchitects

(Not the .extension folder itself — the folder that contains it)

Restart Revit

You should now see a new Ribbon tab called: PythonForArchitects

If the tab appears, the extension is installed correctly ✅

Assignment

Download and unzip the PythonForArchitects starter kit
Open pyRevit Settings in Revit
Add the parent directory to Custom Extension Directories
Restart Revit
Verify the PythonForArchitects tab appears in the Ribbon

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

pyRevit documentation has detailed guides for advanced customization
If your extension isn't showing up, check the pyRevit troubleshooting guide

Lesson 03 - Setting Up Your Coding Workspace

Prajwal Kumar — Sun, 11 Jan 2026 17:45:57 +0530

Introduction

Before writing any code, you need a stable environment. One place to learn Python logic. Another place to automate Revit or Rhino.

This lesson walks you through installing the core tools and connecting them to your design software.

By the end, you'll have everything ready to write your first Python script.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Install Python 3.x on your system
Install Visual Studio Code as your code editor
Add the Python extension to VS Code
Connect Python to Revit via pyRevit
Connect Python to Rhino via GhPython
Verify your setup is working

Part A: The Core Tools

These are the industry-standard tools required to write and test Python code independently of any BIM software.

Install Python 3.x (The Interpreter)

Python is the "engine" that translates your text commands into machine instructions.

Download: Python.org

Select the latest stable 3.x version.

Critical: During installation, check the box labelled "Add Python to PATH"

(This lets VS Code find Python automatically. Without it, you'll troubleshoot for 30 minutes.)

Install Visual Studio Code (Recommended)

Visual Studio Code (VS Code) is a lightweight but powerful code editor. Unlike a basic text editor, it provides syntax highlighting, error detection, and debugging tools.

Download: code.visualstudio.com

Why VS Code?

It's the professional standard. Syntax highlighting. Error detection. Debugging tools. Manages folders and version control.

You'll outgrow Notepad in a week. Start here.

Install the Python Extension for VS Code

VS Code needs a specific plugin to "understand" Python logic and provide intelligent suggestions.

Open VS Code
Navigate to the Extensions view (icon with four squares on the left sidebar)
Search for "Python" (published by Microsoft)
Click Install

Part B: Integrating with AEC Software

Once the core engine is ready, connect it to your primary design tools.

Route 1: Revit (pyRevit)

Revit does not support "raw" Python scripts out of the box in a user-friendly way. pyRevit acts as the bridge.

Installation: Download pyRevit

Function: It allows you to create custom ribbon buttons that execute Python scripts. It bypasses the need for the Revit SDK or complex C# compilation.

Route 2: Rhino (GhPython)

Rhino has deep, native integration with Python through Grasshopper.

Access: Open Grasshopper and locate the Python Script component.

Function: This component allows you to use Python to generate geometry, move points, or analyse surfaces using the RhinoCommon library.

Assignment

Install Python 3.x on your computer (make sure you check "Add Python to PATH")
Install Visual Studio Code
Install the Microsoft Python Extension in VS Code
If you use Revit: Install pyRevit
If you use Rhino: Open Grasshopper and locate the Python Script component
Verify your setup:
- Open VS Code
- Create a new file called test.py
- Type: print("Setup complete")
- Click the Run button (▶) in the top-right corner
- You should see: Setup complete in the terminal

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

If you're having trouble with Python installation, check the official Python installation guide
For VS Code setup tips, see Getting Started with Python in VS Code
If pyRevit isn't showing up in Revit, check the pyRevit troubleshooting guide

Lesson 02 - Python in the AEC Ecosystem

Prajwal Kumar — Sun, 11 Jan 2026 14:25:46 +0530

Introduction

We moved from drafting (lines) to CAD (digital lines) to BIM (databases).

The modern architect manages data. Costs. Materials. Schedules. Quantities. Coordination rules.

The problem? Our software creates data well. Manipulating it the way you need? Not so much.

Revit, Archicad, Navisworks store enormous amounts of information. But when you want custom logic, batch rules, or project-specific checks, you hit friction.

That's where Python enters the picture.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Understand why Python instead of C#
Learn where Python lives in AEC software
See Python working inside tools (Revit, Rhino, Blender)
See Python working between tools (Excel ↔ Revit, Web ↔ Design)
Understand the difference between Python grammar (logic) and vocabulary (APIs)

Why Python and Not C#?

Most professional software (Revit, AutoCAD) is written in C#.

If C# is the industry standard, why aren't we learning that?

Think of C# like Construction Documents. Incredibly precise, structured, and "safe" — but it takes time to set up. You have to define every single detail before you can even start. It's designed for software engineers building heavy-duty applications.

Python is like a napkin sketch. It's designed for speed and readability. You have an idea, type it out, see the result immediately.

The Trade-off

C# is faster for the computer to read (microseconds)
Python is faster for you to write (minutes vs. hours)

As architects, we aren't building the next Revit from scratch. We just want to automate a boring task before lunch.

Python is the tool that lets you "sketch" that solution quickly.

Where Does Python Live?

Python is unique because it's platform-agnostic. It lives everywhere.

Inside the Tools (Embedded)

These are scripts that run inside your design software to handle tasks the standard buttons can't.

Revit (via Dynamo or pyRevit)

The Pain: You need to create 50 sheets for a new project and name them based on a client's Excel standard. Doing this manually takes an hour.

The Python Fix: Script reads Excel. Creates all 50 sheets. 4 seconds.

Rhino (via Grasshopper/GhPython)

The Pain: You want to create a facade pattern that changes randomly, but standard Grasshopper "spaghetti" is getting messy and slow.

The Python Fix: Simple loop generates thousands of unique panels efficiently. Canvas stays clean.

Blender (Native)

The Pain: You need to render 20 different camera angles for a client presentation overnight.

The Python Fix: Script moves camera, renders, saves, moves to next spot. While you sleep.

Between the Tools (Interoperability)

Python acts as the "Universal Translator." Software A doesn't speak to Software B, but they both speak Python.

Excel ↔ Revit (The Data Bridge)

Scenario: Your Room Data Sheets (finish requirements, occupancy loads) live in Excel.

The Python Fix: Script pulls data from Excel and pushes it into Revit Room Parameters automatically. No manual typing.

Web ↔ Design (The Context Fetcher)

Scenario: You need site data (weather stats, topography, nearby buildings) for a new site.

The Python Fix: Script connects to Google Maps or OpenStreetMap APIs to download 3D site context directly into Rhino.

Civil 3D ↔ Structural Analysis (The Calculator)

Scenario: Site terrain changed in Civil 3D. You need to re-check column foundation depths.

The Python Fix: Script reads new terrain mesh and updates column heights in analysis software immediately.

The Core Concept: Grammar vs. Vocabulary

This is the most important concept to grasp before we write code.

What Stays the Same (The Grammar)

Whether you're in Dynamo, Grasshopper, or a standalone script, the Python logic is identical:

Variables: Storing data (e.g., wall_height = 3000)
Loops: Repeating actions (e.g., "For every sheet in this list...")
Conditionals: Making decisions (e.g., "If the room area is < 10 m²...")

What Changes (The Vocabulary)

The inputs and outputs depend on the software you're using.

In Revit: You speak the "Revit API" (walls, windows, sheets)
In Rhino: You speak "RhinoCommon" (NURBS, meshes, points)

We'll cover these later.

The key takeaway: learn the grammar once. Apply it everywhere.

Assignment

List the three main software tools you use most often (e.g., Revit, Rhino, Excel, Navisworks)
For each tool, write down one repetitive task you wish you could automate
Think about whether that task happens inside one tool or between multiple tools

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

Browse the pyRevit extensions gallery to see real tools built by architects
Check out McNeel's Python Guide for Rhino examples
Explore Dynamo's Python documentation if you're coming from visual programming

Lesson 01 - Why Python Matters for Architects

Prajwal Kumar — Sat, 10 Jan 2026 18:48:37 +0530

Introduction

Despite decades of software progress — from manual drafting to CAD to BIM — the day-to-day workflow still burns time on things that don't require design intelligence.

Renaming hundreds of sheets.

Fixing parameters one element at a time.

Exporting schedules, cleaning them in Excel, repeating it next week.

None of this requires creativity. But it consumes an unreasonable amount of time.

If you've used Grasshopper, Revit formulas, or Excel functions — you already think in logic. Python is the same idea, just less clicking. This lesson explains why Python matters for architects and where it fits in your workflow.

Lesson Overview

This section contains a general overview of topics you will learn in this lesson.

Understand where architects already use logic-based systems
Recognise the limitations of GUI-based software
Learn what APIs are and how Python accesses them
See real examples of Python automating architectural tasks
Understand Python as a workflow amplifier, not a career switch

You Already Use Logic

You don't need to be a programmer to use Python.

If you're an architect, you already use logic-based systems every day, just not in text form.

Grasshopper
Visual scripting is programming, just without typing code.

Revit
Constraints and calculated parameters are rule-based logic.

Excel
If you've written an IF, VLOOKUP, or COUNTIF, you already think algorithmically.

Navisworks
Search Sets are structured queries over model data.

This isn't a leap into something foreign. It's an extension of what you already do — expressed more directly.

The GUI Ceiling

Most AEC software is built around Graphical User Interfaces (GUIs), buttons, dialogs, checkboxes.

GUIs are useful, but they come with a hard limit.

Software teams can only fit so many buttons on a screen. If the exact button for your problem doesn't exist, you're forced into manual work.

The result:

Too many clicks
Too much repetition
Too little control

The interface becomes the bottleneck — not your ability to think or design.

Python: Access Beneath the Interface

The buttons you see in Revit, Rhino, or Navisworks are only the surface.

Underneath them is something far more powerful: the API (Application Programming Interface).

The buttons you click in Revit? They call functions underneath.

Python lets you call those functions directly. No clicking. No waiting. Just logic.

Python acts as glue between tools. It lets you combine actions that would normally require dozens — or hundreds — of manual steps.

How Python Actually Works (At a High Level)

At its core, using Python in AEC workflows looks like this:

You gain access to a software's API
You identify the functions you need (rename, read, update, check)
You glue those functions together into a logical sequence
You define the cases where they should apply
You loop over all relevant elements until every task is processed

Instead of doing work element by element, you define the rules once and let the computer do the repetition.

The real win? You can package that logic into a reusable tool — and run it on another project, another model, or another deadline.

That's how you buy back time for design.

What This Looks Like in Practice

When you use Python, your role shifts.

You stop acting like a manual operator and start behaving like a rule designer or batch operator.

Renaming 300 Drawings

Manual way: Rename. Enter. Repeat. 300 times.

Python way: Read a spreadsheet and rename everything in seconds.

Validating Model Health

Manual way: Scan schedules and hope nothing is missed.

Python way: Define rules once and let the script flag violations automatically.

Schedule Extraction

Manual way: Export → Excel → clean → format → repeat.

Python way: Pull model data directly into a pre-formatted report.

Same intent. Radically different effort.

Assignment

Think about the most repetitive task you do in your current workflow. Write it down.
Break that task into steps. For example:
- Open schedule
- Read each row
- Check if the room name follows the naming standard
- If not, flag it
Identify which step takes the most time. That's likely where Python can help.

Knowledge Check

The following questions are an opportunity to reflect on key topics in this lesson. If you can't answer a question, click on it to review the material, but keep in mind you are not expected to memorise or master this knowledge.

Additional Resources

This section contains helpful links to related content. It isn't required, so consider it supplemental.

If you want to see Python in action before writing code yourself, check out this pyRevit example showing sheet renaming automation
The Revit API documentation is where you'll eventually look up functions. Don't worry about understanding it yet — we'll cover that later

Python for Architects: Foundation

Prajwal Kumar — Sat, 10 Jan 2026 16:48:28 +0530

Overview

Python for Architects is a free, open course created to help architects understand and work with computation in a way that actually fits architectural practice.

There is no shortage of material online for learning how to code. What's missing is context.

Most Python courses teach you to build web apps or process text files. Useful — if you're building web apps. Not useful if you're managing BIM data at 3am before a deadline.

This course exists for that gap.

What This Course Is (and Isn't)

Python is taught here through real architectural workflows, rather than generic programming examples.

Every example, exercise, and explanation is rooted in things architects already deal with:

BIM data
Geometry
Repetitive workflows
Naming, checking, organizing, and automating work

You won't see shopping carts, guessing games, or abstract programming puzzles here.

Every concept answers a simple question:

Where does this show up in an actual office?

How This Course Works

Architects already think in steps, rules, and systems.

Design standards, building codes, office templates, and personal workflows are all structured ways of thinking. This course starts there and shows how that same logic can be written down in a form computers understand.

Python is one such language. It allows you to take architectural logic and:

Make it explicit
Repeat it reliably
Apply it at scale

We start with how you already think. Syntax comes later.

What You'll Learn

This course intentionally covers a broad foundation before getting technical.

You'll start by learning how to:

Break architectural tasks into clear steps
Understand how data and geometry are structured
Recognize patterns that can be automated
Read simple Python scripts without fear

From there, you'll gradually apply the same ideas to:

BIM-related tasks
Geometry and coordinates
File and data workflows
Repetitive office processes

By the end of the course, you should understand what Python is doing, why it's useful, and where it fits in architectural practice — even if you don't consider yourself "technical."

A Note About Tools

This course doesn't start with tools.

Tools change. Concepts last.

Once you understand data, logic, and structure — documentation makes sense. New scripts feel readable.

That's the goal.

A Note on Language

This course is written and maintained in English. Python itself, along with most documentation and community resources, also operates primarily in English.

If English is not your first language, this isn't meant to discourage you — only to set expectations. You may occasionally need extra time with unfamiliar terms, and that's completely normal.

We encourage you to:

Pause on concepts that feel unclear
Look up terms as you encounter them
Use translation tools or resources in your native language when helpful

Learning to work with technical material often involves reading, searching, and cross-referencing information. These are skills that develop naturally as you progress through the course.

Take your time. Understanding grows with exposure and use.

One Last Thing

This course is cumulative.

Each part builds on what came before it. Skipping sections will create gaps that show up later.

Take it slow. Stay curious. Don't skip the foundations

💡pyNavis

Prajwal Kumar — Wed, 07 Jan 2026 02:59:26 +0530

1:00 AM (Dubai time).

I went down a small rabbit hole tonight thinking about a simple question:
Why can’t we run Python in Navisworks the way we do with pyRevit?

A bit of searching later, I found a few past attempts at this idea. Interesting experiments, good intentions — but all of them seem to be abandoned now. No maintained tools, no real ecosystem, no “default” way of doing it.

And that’s… curious.

Navisworks is still everywhere in coordination workflows, yet Python-based automation never really took hold there. Maybe the barrier was technical. Maybe the audience was smaller. Or maybe it just never had its pyRevit moment.

Either way, this feels like an opportunity worth exploring.

Not a full-blown framework. Not a big promise. Just a small MVP:

run Python scripts from inside Navisworks
prove the concept
put it out in the open
see if anyone else cares

If the reaction is there, great. If not, it’s still a useful experiment and a better understanding of Navisworks’ limits.

For now, I’m just capturing the thought while it’s fresh — and leaving a few links below to some of the older attempts I came across.

GitHub - pyrevitlabs/NavisPythonWrapper: Python Wrapper for Navisworks API (Work in progress)

Python Wrapper for Navisworks API (Work in progress) - pyrevitlabs/NavisPythonWrapper

GitHubpyrevitlabs

GitHub - dimven/NavisPythonShell: An IronPython console for Navisworks

An IronPython console for Navisworks. Contribute to dimven/NavisPythonShell development by creating an account on GitHub.

GitHubdimven

Let’s see where this goes.

Pokeit

Prajwal Kumar — Sun, 14 Sep 2025 13:46:24 +0530

PokeIt is a lighthearted tool built on pyRevit, inspired by the classic Facebook Poke.
It allows Revit users to send quick nudges or emoji messages directly inside Revit, making team communication a little more fun (and sometimes more effective).

Instead of writing long chats or emails, you can:
👉 Remind someone to check a detail.
👉 Give a friendly nudge to review the model.
👉 Or just say “hello” in a fun way.

How It Works

Simple Registration: Create a username, no accounts required.
Send a Poke: Choose any registered user and send them an emoji nudge.
Get Notified: Background listener instantly pops up pokes inside Revit.

Key Features

👋 Emoji-based poke messages
📡 Real-time notifications inside Revit
🛠 Lightweight setup (only pyRevit required)
🔒 Privacy-friendly (usernames only, no personal data)

Tech Stack

pyRevit (IronPython) → Revit integration
Firebase Realtime Database → instant syncing
Win32 popups → in-app notifications

Why I Built It

PokeIt began as a weekend experiment: “What if Revit had pokes, like Facebook?”
What started as a joke turned into a quirky yet useful tool — bringing a bit of fun and immediacy into the daily AEC workflow.

SpotiVit

Prajwal Kumar — Sun, 14 Sep 2025 13:45:29 +0530

SpotiVit is a playful proof-of-concept that brings Spotify controls directly into Revit.
Designed as a weekend experiment, it demonstrates how even “closed” AEC environments can connect seamlessly with modern APIs.

Instead of switching between apps, users can play, pause, and change tracks right from the Revit ribbon.

How It Works

Built with pyRevit as the add-in framework
Powered by Spotipy, the Python client for Spotify’s Web API
Secure OAuth authentication for Spotify accounts
Custom Revit UI buttons to:
- Detect active playback devices
- Play/pause music
- Switch playlists (e.g. AEC Flow by Bugs&Binary)

Why It Matters

SpotiVit isn’t just about music.
It’s a demonstration of integration—showing that AEC tools like Revit don’t have to stay siloed.

Key lessons:

APIs unlock new workflows, even in traditional design software
Authentication and web integrations are approachable for tool-builders
Small hacks can spark big ideas in AEC tech

Status

SpotiVit is not a production-ready tool.
It’s a weekend hack that showcases what’s possible when curiosity meets code.

But it stands as an example of how Bugs & Binary experiments turn into real insights for AEC teams.

FreeFroots

Prajwal Kumar — Sun, 14 Sep 2025 13:44:00 +0530

Revit can be powerful—but also painfully repetitive.
FreeFroots helps AEC professionals cut the clicks, clean the data, and speed up design with a collection of free, open-source automation tools.

What You Get 🍎

⚡ Faster Workflows – automate repetitive tasks in Revit.
🎯 Essential Tools Only – no clutter, just what you need.
🌍 Open & Free – community-driven, forever open-source.
🚀 Grows With You – from small fixes to large-scale projects.

How It Works 🌳

Built on pyRevit + Python
Runs inside Revit as a simple, lightweight tab
Always improving with community contributions

Our Story ✨

When popular tools like DiRoots went paid, many AEC professionals were left searching for an alternative.
FreeFroots was born to bring back free, open automation tools—and create a space for both pros and beginners to contribute, learn, and grow together.

Try It in 3 Steps ⚙️

Download FreeFroots from GitHub
Install pyRevit (your bridge between Python & Revit)
Start Automating directly inside Revit

Quick Links 🔗

GitHub - Bugs-and-Binary/FreeFroots: FreeFroots is an open-source, free toolset that roots your AEC workflows in Revit, offering seamless integration and fruitfully simple solutions.

FreeFroots is an open-source, free toolset that roots your AEC workflows in Revit, offering seamless integration and fruitfully simple solutions. - Bugs-and-Binary/FreeFroots

GitHubBugs-and-Binary

Releases · pyrevitlabs/pyRevit

Rapid Application Development (RAD) Environment for Autodesk Revit® - pyrevitlabs/pyRevit

GitHubpyrevitlabs

The Electricity That’s Powering AEC...

Prajwal Kumar — Fri, 12 Sep 2025 12:25:36 +0530

Every era has its spark.
Electricity powered the 20th century.
Computational Design is doing the same for AEC, quietly, but radically.

On a podcast with Joe Rogan, Naval Ravikant made an interesting observation: electricity was the defining technology of the 20th century.

And with every game-changing technology comes a shift. A disruption. A complete rewrite of how we work.

From Buckets to Machines

Before electricity, water bearers hauled buckets. Then pumps took over.
Factories ran on human muscle—until machines did it better.

Jobs didn’t just disappear. They evolved. New skills, new roles, new industries.

That’s exactly where we are with computational design in AEC.

A Brief Evolution of AEC Workflows

Architects once drafted by hand.
Then came CAD—faster, cleaner, more precise.
Then BIM—smarter, data-driven, interconnected.
Now computational design is flipping the script again.

What Computational Design Changes

Repetitive tasks → Automated
Manual modeling → Optimized
Days of work → Reduced to minutes

But here’s the kicker: just like electricity didn’t put people out of work, computational design isn’t replacing architects, engineers, or designers.

Instead, it’s amplifying their capabilities:

The tedious becomes effortless.
The impossible becomes feasible.
The role shifts from repetitive execution → to higher-level decision-making, boundary-pushing, and designing like never before.

We’re Only Scratching the Surface

I’m writing this on a machine running billions of calculations per second—optimizing, simulating, and solving problems faster than any human ever could.

And yet, we’re only scratching the surface.

The real revolution isn’t just in speed.
It’s in how we harness this power to:

Rethink design
Automate the mundane
Unlock creativity at scale

Here’s to what’s next. 🚀

The Effort-Reward Equation: What Rats Can Teach Us About Tech Adoption

Prajwal Kumar — Fri, 12 Sep 2025 12:24:14 +0530

At Columbia University, researchers conducted a simple but brilliant experiment. They wanted to see how much effort a rat would endure if the reward (a piece of cheese) was tempting enough.

The setup?
A contraption we’ll call the Columbia Obstruction Device: an electrified cage, a rat, and a variable-sized piece of cheese.

The rat had two choices:

Stay put and avoid the shock
Brave the pain and claim the prize

What Happened

Same shock, same cheese → The rat stays put.
More shock, same cheese → Not a chance.
More shock, bigger cheese → Okay, now we’re talking. The rat pushes through.
Less shock, same cheese → The rat takes the win.

Increase the difficulty too much, and the rat gives up. Increase the reward enough, and the rat finds a way.

You get the idea.

The Human Parallel

Now, let’s swap out the rat for a human and the cheese for the conveniences of technology. The principle stays the same.

This is exactly what we deal with in design technology. The automation we build promises efficiency, but users won’t adopt it just because we say it’s great. Their willingness to use it depends on the effort required to get the reward.

And let’s be real: there’s never going to be enough cheese.
There will always be some manual input and some learning curve. People won’t magically switch just because the tool is available. If the perceived effort is too high compared to the payoff, they’ll stick to their old ways—no matter how inefficient.

The Balance of Effort and Reward

The key? Make your application compelling or reduce the effort required to use it.

Respect the balance. Users aren’t lazy—they just need the right incentive.

So before launching your next automation tool, ask yourself:

If you were the user, would you bother jumping the fence?