When you work with architectural data, you often need to extract meaningful statistics from schedules and tables. Imagine you are given a schedule of rooms in a building, each with its name, area, and occupancy. Your goal is to write a function that processes this data and provides useful insights for design or analysis. You will use a hardcoded pandas DataFrame to represent the room schedule and create a function that returns the total building area, the average room area, and a list of rooms where the occupancy is greater than 4. The function should return these results as a dictionary with the keys `total_area`, `average_area`, and `high_occupancy_rooms`.

To approach this challenge, start by importing the **pandas** library and constructing a DataFrame with the specified columns. Then, define a function that calculates the required statistics using **pandas** methods.

import pandas as pd

# Hardcoded room schedule DataFrame
data = {
    'Room': ['Lobby', 'Conference', 'Office1', 'Office2', 'Storage', 'Lounge'],
    'Area': [120.5, 85.0, 42.0, 39.5, 30.0, 55.5],
    'Occupancy': [10, 8, 2, 2, 1, 5]
}
df = pd.DataFrame(data)

def calculate_room_statistics(room_df):
    total_area = room_df['Area'].sum()
    average_area = room_df['Area'].mean()
    high_occupancy_rooms = room_df.loc[room_df['Occupancy'] > 4, 'Room'].tolist()
    return {
        'total_area': total_area,
        'average_area': average_area,
        'high_occupancy_rooms': high_occupancy_rooms
    }

# Example usage
result = calculate_room_statistics(df)
print(result)

In this code, the DataFrame `df` contains the room schedule. The function `calculate_room_statistics` computes the **total area** using the `sum()` method, the **average area** using the `mean()` method, and filters rooms with occupancy greater than 4 using `.loc[]` and `.tolist()`. The result is a dictionary with the required statistics:

- **'total_area'**: the sum of all values in the `Area` column;
- **'average_area'**: the mean of all values in the `Area` column;
- **'high_occupancy_rooms'**: a list of room names from the `Room` column where the corresponding `Occupancy` value is greater than 4.

This approach makes it easy to extract key insights from architectural data using pandas.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import pandas as pd

class TestTask(unittest.TestCase):
    def test_correct_result_on_given_dataframe(self):
        import user_code
        importlib.reload(user_code)
        df = pd.DataFrame({
            'Room': ['Studio', 'Office', 'Meeting', 'Break'],
            'Area': [40.0, 30.0, 50.0, 20.0],
            'Occupancy': [3, 2, 7, 5]
        })
        func = getattr(user_code, 'calculate_room_statistics', None)
        _dynamic_test(
            self,
            callable(func),
            "Function calculate_room_statistics is defined.",
            "Function calculate_room_statistics is not defined.",
        )
        result = func(df) if callable(func) else None
        expected = {
            'total_area': 140.0,
            'average_area': 35.0,
            'high_occupancy_rooms': ['Meeting', 'Break']
        }
        _dynamic_test(
            self,
            isinstance(result, dict),
            "Function returns a dictionary.",
            f"Function should return a dictionary, got {type(result)}."
        )
        _dynamic_test(
            self,
            'total_area' in result and abs(result['total_area'] - expected['total_area']) < 1e-5,
            "Total area is correct.",
            f"Expected total_area {expected['total_area']}, got {result.get('total_area')}."
        )
        _dynamic_test(
            self,
            'average_area' in result and abs(result['average_area'] - expected['average_area']) < 1e-5,
            "Average area is correct.",
            f"Expected average_area {expected['average_area']}, got {result.get('average_area')}."
        )
        _dynamic_test(
            self,
            'high_occupancy_rooms' in result and result['high_occupancy_rooms'] == expected['high_occupancy_rooms'],
            "High occupancy rooms list is correct.",
            f"Expected {expected['high_occupancy_rooms']}, got {result.get('high_occupancy_rooms')}."
        )

    def test_empty_dataframe(self):
        import user_code
        importlib.reload(user_code)
        df = pd.DataFrame(columns=['Room', 'Area', 'Occupancy'])
        func = getattr(user_code, 'calculate_room_statistics', None)
        result = func(df) if callable(func) else None
        _dynamic_test(
            self,
            isinstance(result, dict),
            "Function returns a dictionary for empty input.",
            f"Function should return a dictionary, got {type(result)}."
        )
        _dynamic_test(
            self,
            'total_area' in result and result['total_area'] == 0,
            "Total area is 0 for empty DataFrame.",
            f"Expected total_area 0, got {result.get('total_area')}."
        )
        _dynamic_test(
            self,
            'average_area' in result and pd.isna(result['average_area']),
            "Average area is NaN for empty DataFrame.",
            f"Expected average_area NaN, got {result.get('average_area')}."
        )
        _dynamic_test(
            self,
            'high_occupancy_rooms' in result and result['high_occupancy_rooms'] == [],
            "High occupancy rooms is empty list for empty DataFrame.",
            f"Expected empty list, got {result.get('high_occupancy_rooms')}."
        )

    def test_all_rooms_low_occupancy(self):
        import user_code
        importlib.reload(user_code)
        df = pd.DataFrame({
            'Room': ['RoomA', 'RoomB'],
            'Area': [10.0, 20.0],
            'Occupancy': [1, 2]
        })
        func = getattr(user_code, 'calculate_room_statistics', None)
        result = func(df) if callable(func) else None
        _dynamic_test(
            self,
            result is not None and result.get('high_occupancy_rooms', None) == [],
            "Returns empty list if no room has occupancy > 4.",
            f"Expected empty list, got {result.get('high_occupancy_rooms') if result else result}."
        )

    def test_all_rooms_high_occupancy(self):
        import user_code
        importlib.reload(user_code)
        df = pd.DataFrame({
            'Room': ['A', 'B', 'C'],
            'Area': [1.0, 2.0, 3.0],
            'Occupancy': [5, 6, 10]
        })
        func = getattr(user_code, 'calculate_room_statistics', None)
        result = func(df) if callable(func) else None
        _dynamic_test(
            self,
            result is not None and result.get('high_occupancy_rooms', None) == ['A', 'B', 'C'],
            "Returns all rooms if all have occupancy > 4.",
            f"Expected ['A', 'B', 'C'], got {result.get('high_occupancy_rooms') if result else result}."
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

A hands-on course designed for architects to leverage Python for solving real-world architectural problems, including data analysis, geometry, visualization, and automation. This course blends architectural thinking with Python programming, focusing on practical applications relevant to the field.

Learn to analyze, manipulate, and summarize architectural data using Python and pandas. This section focuses on extracting insights from building data, room schedules, and material lists.

Apply Python to solve geometric and spatial problems relevant to architectural design, such as calculating areas, perimeters, and analyzing spatial relationships.

Harness Python's visualization libraries and automation capabilities to streamline architectural analysis and presentation.

Challenge: Calculate Room Statistics

Løsning