fixes and answers

Author: KaviHShah

materials/03_python_data_types_and_operators.md

@@ -46,6 +46,33 @@ What are the different primitive data types in expenses_calculator.py
 Why were they chosen?
 Are there any other data types you recognise?
 
+<!--
+::: {.callout-answer}
+1. 
+Strings (str)
+
+Examples: "food", "expenses.csv", "done".
+
+Why they were chosen: Strings are used for any textual data. In your script, they handle category names, filenames, and user input. Since Python treats strings as sequences of characters, they are perfect for labels and messages.
+
+Floats (float)
+
+Examples: 100.0, amount = float(parts[1]).
+
+Why they were chosen: Floats represent real numbers with decimal points. In a financial calculator, you need precision for cents (e.g., 10.50). If you used integers, you wouldn't be able to track partial currency units.
+
+Booleans (bool)
+
+Examples: True (in while True:), and the result of category == "done".
+
+Why they were chosen: Booleans represent truth values. They are the backbone of your script's logic, controlling the loop and the if/else validation checks.
+
+2. 
+
+Dictionaries (dict) and Lists (list)
+:::
+-->
+
 :::
 
 ## Python operators
@@ -237,6 +264,35 @@ Why are these data types used?
 
 Can you try using a set to identify expense type - what is the advantage/disadvantage?
 
+<!--
+::: {.callout-answer}
+1, 2. 
+Dictionaries (dict)
+
+Example: thresholds = {"food": 100.0, ...}
+
+Why it's used: Dictionaries allow for key-value mapping. In your script, the category name is the "key" and the budget limit is the "value." This is chosen because it allows for quick lookup. Instead of searching through a list to find the limit for "food," Python jumps straight to it.
+
+Lists (list)
+
+Example: expenses = [] and [category, amount]
+
+Why it's used: Lists are ordered and mutable. You use a list of lists (a nested structure) to keep a running history of transactions. Since you don't know how many expenses a user will enter, the list’s ability to grow dynamically is essential.
+
+2. Using a set to Identify Expense Types
+A set is an unordered collection of unique elements. The script could define valid categories using a set like this:
+
+valid_categories = {"food", "transport", "entertainment", "other"}
+
+Yes, you could use a set to identify the expense type.
+This is fast - faster than a list. You cannot store duplicate values in a set. This is not an issue and instead beneficial for category types.
+
+Unlike the dictionary used for thresholds, a set cannot hold an associated value. It can store the word "food," but it cannot link it to the numerical value 100.0.
+The Verdict:
+While the script could incorporate a set to validate category names, the Dictionary (thresholds) remains the most effective choice. It functions similarly to a set by allowing for fast membership checks of category names (the keys), but it provides the added necessity of storing the specific budget limits (the values) required for the script's calculations.
+:::
+-->
+
 :::
 
 ::: {.callout-exercise}
@@ -269,7 +325,7 @@ State the best data type to use in Python:
 
 12. You are working with text that may need to be split, joined, or manipulated.
 
-
+<!--
 ::: {.callout-answer}
 1. list — Ordered and mutable collection of names.
 2. set — For fast membership tests with unique elements, order is irrelevant.
@@ -287,6 +343,7 @@ State the best data type to use in Python:
 Which data type you use effects memory useage and speed of computations which may be important in larger programs.
 For further reading you can investigate why sets are generally faster to find unordered elements (membership tests) than lists or tuples
 :::
+-->
 :::
 
 

materials/04_python_functions.md

@@ -197,6 +197,89 @@ Functions can have default parameters, accept multiple arguments, and return mul
 Can you remove some of the code in the expense_calculator script into new functions that are used later in the script?
 Are there any other functions you might want to write and use in the script?
 
+<!--
+::: {.callout-answer}
+```
+import os
+
+# Configuration
+THRESHOLDS = {
+    "food": 100.0,
+    "transport": 50.0,
+    "entertainment": 80.0,
+    "other": 70.0
+}
+FILENAME = "expenses.csv"
+
+def load_expenses(filename):
+    """Loads expenses from a CSV file into a list."""
+    expenses = []
+    if not os.path.exists(filename):
+        return expenses
+    
+    with open(filename, "r") as file:
+        for line in file:
+            parts = line.strip().split(",")
+            if len(parts) == 2:
+                expenses.append([parts[0].lower(), float(parts[1])])
+    return expenses
+
+def save_expenses(filename, expenses):
+    """Saves the current list of expenses to a CSV file."""
+    with open(filename, "w") as file:
+        for cat, amt in expenses:
+            file.write(f"{cat},{amt}\n")
+
+def get_category_total(expenses, category):
+    """Calculates the sum of expenses for a specific category."""
+    return sum(amt for cat, amt in expenses if cat == category)
+
+def check_budget(category, total_spent):
+    """Prints status messages based on the spending threshold."""
+    limit = THRESHOLDS.get(category, 0)
+    if total_spent > limit:
+        print(f"Warning: You have exceeded the {category} threshold!")
+        print(f"Total spent: {total_spent}")
+    else:
+        remaining = limit - total_spent
+        print(f"Total spent in {category}: {total_spent}")
+        print(f"Amount left for {category}: {remaining}")
+
+def main():
+    expenses = load_expenses(FILENAME)
+    
+    print("--- Expense Tracker ---")
+    print("Type 'done' as the category to finish.\n")
+
+    while True:
+        category = input("Category (food, transport, entertainment, other): ").lower()
+        if category == "done":
+            break
+        
+        if category not in THRESHOLDS:
+            print("Invalid category. Please try again.")
+            continue
+
+        try:
+            amount = float(input("Amount: "))
+            expenses.append([category, amount])
+            
+            current_total = get_category_total(expenses, category)
+            check_budget(category, current_total)
+            print()
+            
+        except ValueError:
+            print("Invalid amount. Please enter a number.\n")
+
+    save_expenses(FILENAME, expenses)
+    print("All expenses saved successfully.")
+
+if __name__ == "__main__":
+    main()
+```
+:::
+-->
+
 :::
 
 ::: {.callout-exercise}

materials/05_python_conditionals.md

@@ -145,6 +145,47 @@ What is the different indentation doing?
 Can you add an extra condition that you would like to your expense calculator?
 
 What are the limitations of conditional statements?
+
+<!--
+::: {.callout-answer}
+1. What do the conditional statements do?
+
+In the script, the if, elif (implied by the logic flow), and else blocks act as filters and triggers:
+
+Flow Control: The if category == "done": break statement monitors user input to decide exactly when to stop the loop and move to the saving phase.
+
+Validation: The line if category in thresholds and amount_str... ensures the program doesn't crash if someone types "pizza" as a category or "a lot" as an amount. It acts as a gatekeeper for clean data.
+
+Threshold Monitoring: The if current_total > thresholds[category]: block compares actual spending against set goals to trigger a specific warning message.
+
+2. What is the different indentation doing?
+
+In Python, indentation isn't just for neatness; it defines scope. It tells the computer which lines of code "belong" to a specific condition or loop.
+
+Level 1 (No indent): Code that runs globally (like setting the initial thresholds).
+
+Level 2 (One indent): Code that lives inside the while loop or the try block.
+
+Level 3 (Two indents): Code that only runs if a specific condition is met (like the code that processes an expense only if the input was validated).
+
+The "Nesting" Logic: You can only reach the "Total spent" calculation if you have already successfully passed through the "Is the input valid?" door. If that condition isn't met, the indented code is skipped entirely.
+
+3. Adding a "Savings Milestone" Condition
+
+A great addition would be an Overall Budget check. This warns the user if total spending across all categories exceeds a certain limit, even if individual categories are still under their specific thresholds.
+
+Add:
+
+```
+# Add this near the bottom of the while loop logic
+total_all_categories = sum(e[1] for e in expenses)
+overall_limit = 300.0
+
+if total_all_categories > overall_limit:
+    print(" CAUTION: You are over your budget!!!")
+```
+:::
+-->
 :::
 
 

materials/06_python_for_loops.md

@@ -117,11 +117,111 @@ Animal 3: elephant
 {{< level 2 >}}
 
 Using conditional statements, for loops and the functions we have seen, 
-Modify the expense calculator to also allow the input of a dictionary rather than a file.
+Modify the expense calculator to allow the input of a dictionary specified at the top of the script rather than a file.
+The dictionary should look like the following:
+```
+pre_existing_expenses = {
+    "food": [20.50, 15.00],
+    "transport": [10.00],
+    "entertainment": [90.00]
+}
+```
 Write code such that the calculator correctly loops through the dictionary to correctly load in pre-existing expenses and test your script.
 
 Look at eachothers code - how might it be improved?
 
+<!--
+::: {.callout-answer}
+```
+# --- Inputs ---
+# Thresholds
+thresholds = {
+    "food": 100.0,
+    "transport": 50.0,
+    "entertainment": 80.0,
+    "other": 70.0
+}
+
+# Example input dictionary simulating pre-existing data
+pre_existing_expenses = {
+    "food": [20.50, 15.00],
+    "transport": [10.00],
+    "entertainment": [90.00]
+}
+
+expenses = []
+
+# --- Functions ---
+
+def load_from_dict(data_dict):
+    """Loops through a dictionary to load pre-existing expenses."""
+    keys = list(data_dict.keys())
+    
+    # Using range and len to iterate through the dictionary keys
+    for i in range(len(keys)):
+        category = keys[i]
+        amounts = data_dict[category]
+        
+        # Using enumerate to process individual amounts
+        for index, amt in enumerate(amounts):
+            if category in thresholds:
+                expenses.append([category, float(amt)])
+            else:
+                print(f"Skipping unknown category: {category}")
+
+def get_total(category):
+    """Calculates total spent for a specific category."""
+    total = 0.0
+    for item in expenses:
+        if item[0] == category:
+            total += item[1]
+    return total
+
+def process_expense(category, amount):
+    """Handles the logic for adding an expense and checking thresholds."""
+    expenses.append([category, amount])
+    current_total = get_total(category)
+    limit = thresholds[category]
+    
+    print(f"\n--- Update for {category.upper()} ---")
+    if current_total > limit:
+        over_by = current_total - limit
+        print(f"ALERT: Threshold exceeded by {over_by}!")
+    else:
+        print(f"Added {amount}. Total: {current_total}")
+        print(f"Remaining budget: {limit - current_total}")
+
+# --- Execution part ---
+
+# 1. Load the initial data
+load_from_dict(pre_existing_expenses)
+print(f"Loaded {len(expenses)} existing records.\n")
+
+# 2. User Input Loop
+while True:
+    cat_input = input("Enter category (food, transport, entertainment, other) or 'done': ").lower()
+    
+    if cat_input == "done":
+        break
+        
+    if cat_input in thresholds:
+        amt_input = input(f"Enter amount for {cat_input}: ")
+        
+        # Simple validation
+        if amt_input.replace('.', '', 1).isdigit():
+            process_expense(cat_input, float(amt_input))
+        else:
+            print("Invalid numeric amount.")
+    else:
+        print("Invalid category. Please choose from the list.")
+
+print("\nFinal Expense List:", expenses)
+
+```
+:::
+
+-->
+
 :::
 
 ::: {.callout-exercise}

materials/07_python_while_conditional_loops.md

@@ -187,7 +187,7 @@ Improve the code, by adressing these limitations
 
 ::: {.callout-answer}
 
-Add code introducing a maximum number of iterations or a global valuse cap to force exit and stop an infinite loop
+Add code introducing a maximum number of iterations or a global value cap to force exit and stop an infinite loop
 You can also add an extra break statement to stop if a user has exceeded a limit
 :::
 
@@ -206,9 +206,9 @@ If it is not recognised from a set of your choice, then respond accordingly
 If they input "stop" or order more than 10 items, complete the order.
 Tell the customer the total cost.
 
-:::
-
 <!--
+::: {.callout-answer}
+```
 count = 0
 
 while True:
@@ -227,8 +227,14 @@ while True:
     continue
 
 print("Total drinks ordered:", count)
+```
+:::
 -->
 
+:::
+
+
+
 ## Summary
 
 ::: {.callout-tip}