previous changes splitting expense calculator

Author: KaviHShah

.DS_Store

@@ -0,0 +1,3 @@
+def get_category_total(expenses, category):
+    """Simple math logic to filter and sum expenses."""
+    return sum(amount for cat, amount in expenses if cat == category)

course_files/scripts/basics.py

@@ -0,0 +1,12 @@
+def load_expenses(filename):
+    """Uses try-except and a for loop to load data."""
+    data = []
+    try:
+        with open(filename, "r") as file:
+            for line in file:
+                parts = line.strip().split(",")
+                if len(parts) == 2:
+                    data.append([parts[0].lower(), float(parts[1])])
+    except FileNotFoundError:
+        print("No existing records found. Starting fresh.")
+    return data

course_files/scripts/file_reader.py

@@ -0,0 +1,6 @@
+def save_expenses(filename, expenses):
+    """Uses the 'with' keyword to safely write to a file."""
+    with open(filename, "w") as file:
+        for cat, amount in expenses:
+            file.write(f"{cat},{amount}\n")
+    print("All expenses saved successfully.")

course_files/scripts/file_writer.py

@@ -0,0 +1,21 @@
+def collect_expenses(thresholds, expenses, get_total_func, check_logic_func):
+    """Uses a while loop to interact with the user."""
+    print("Enter your expenses. Type 'done' to finish.\n")
+    
+    while True:
+        category = input("Category (food, transport, entertainment, other): ").lower()
+        if category == "done":
+            break
+        
+        amount_str = input("Amount: ")
+        
+        # Validation
+        if category in thresholds and amount_str.replace('.', '', 1).isdigit():
+            amount = float(amount_str)
+            expenses.append([category, amount])
+            
+            # Use the passed-in logic functions
+            current_total = get_total_func(expenses, category)
+            check_logic_func(category, current_total, thresholds)
+        else:
+            print("Invalid input. Try again.\n")

course_files/scripts/input_handler.py

@@ -0,0 +1,11 @@
+def check_threshold(category, current_total, thresholds):
+    """Handles the conditional logic for budget warnings."""
+    limit = thresholds.get(category, 0)
+    if current_total > limit:
+        print(f"Warning: You have exceeded the {category} threshold!")
+        print(f"Total spent in {category}: {current_total}")
+    else:
+        remaining = limit - current_total
+        print(f"Added to {category}.")
+        print(f"Total spent in {category}: {current_total}")
+        print(f"Amount left for {category}: {remaining}\n")

course_files/scripts/logic.py

@@ -0,0 +1,33 @@
+import file_reader
+import file_writer
+import basics
+import logic
+import input_handler
+import summary
+
+# 1. Variable Assignments
+FILE_NAME = "expenses.csv"
+THRESHOLDS = {
+    "food": 100.0,
+    "transport": 50.0,
+    "entertainment": 80.0,
+    "other": 70.0
+}
+
+# 2. Function Calls
+# Load data from the CSV (Uses Try/Except)
+current_expenses = file_reader.load_expenses(FILE_NAME)
+
+# Run the input loop (Uses While Loop)
+input_handler.collect_expenses(
+    THRESHOLDS, 
+    current_expenses, 
+    basics.get_category_total, 
+    logic.check_threshold
+)
+
+# Display the final list (Uses For Loop)
+summary.display_summary(current_expenses)
+
+# Save data back to the file (Uses 'With' statement)
+file_writer.save_expenses(FILE_NAME, current_expenses)

course_files/scripts/main.py

@@ -0,0 +1,8 @@
+def display_summary(expenses):
+    """Uses a for loop to iterate through the data and print a report."""
+    print("\n--- Expense Summary ---")
+    for item in expenses:
+        category = item[0]
+        amount = item[1]
+        print(f"Category: {category.capitalize()} | Amount: ${amount:.2f}")
+    print("-----------------------\n")

course_files/scripts/summary.py

@@ -5,12 +5,12 @@ title: Data Types and Operators
 ::: {.callout-tip}
 #### Learning Objectives
 
-- Learn about python data types and operators
+- Learn about python data types
 - Learn when to use different data types
 
 :::
 
-## Python Data types
+## Introducing python Data types
 
 In programming, **data types** define the kind of data a variable can hold, such as numbers, text, or more complex structures, and they determine what operations can be performed on that data. 
 
@@ -21,44 +21,87 @@ Using data types in Python is straightforward: you assign a value to a variable,
 For example, `x = 10` creates an integer, whereas `x = 10.3` creates a float.
 A float in a decimal placed number and is stored in python in a 64 bit format.
 
-For an overview of data types use the cheat sheet.
+For an overview of data types use the **cheat sheet**.
 
-### Primitive Data Types
+::: {.callout-note}
 
-Primitive data types contain single values e.g. numbers and words
+To check the data type of a python object use the ```type()``` function.
 
-The main thing to remember is that sequences of letters like words are called strings and require quotation marks around them:
+```{python}
+
+x = 10
+print(type(x))
+
+```
+:::
+
+
+## Primitive Data Types
+
+Primitive data types contain single values e.g. numbers and words.
+
+### Numerical data types
+
+Python has three numerical data types:
+- integers: whole numbers `int`
+- floats: decimal placed numbers which are also known as floating point numbers `float`
+- complex numbers: python has direct support for complex numbers (*a + bi*). These are not used often by most python users and will not be discussed further in this course.
+
+### Words and text
+
+Sequences of letters like words are called strings and require quotation marks around them:
 
 ```name = "Alice"``` creates a string. 
 
+Strings can be single words or paragraphs.
+
+### Boolean: true or false
+
 The boolean data types use the key words ```True``` and ```False```
 
+### The placeholder
+
 ```None``` can also be used as a placeholder for a variable has no meaningful value yet.
 
-Understanding data types is essential for writing correct programs, performing calculations, and managing data efficiently.
-Data types behave slightly differently in different languages for example the way numbers a rounded.
+## The importance of data types
 
-## Python operators
+Python makes working with data types easier than many other programming languages. When you create a variable, Python automatically decides what type of data it is based on the value you give it. In most cases, the correct data type is a straightforward choice. For example, when indexing a table or referring to whole number counts integers are used, whereas measurements often require decimal places and so floats are used.
 
-**operators** are symbols or keywords used to perform operations on data and variables, like calculations or comparisons. 
-This of mathematical singles like ```+``` 0r ```<```.
+That said, Python’s data types each have their own rules and behaviors. As you’ll see in the following exercises, understanding these differences is important for writing correct programs, doing calculations, and working with data effectively. It’s also helpful to know that data types can behave differently in other languages—for example, in how numbers are rounded.
 
-Most of the operators in python make sense. Use the cheat sheet table to look them up if you need.
+## Immutable versus mutable data types
 
-::: {.callout-exercise}
-#### Using operators
+In Python, data types can be either **mutable** or **immutable**, which refers to whether their values can be changed after they are created.
+
+Most python primitive data types, such as integers, floats, booleans, and strings, are **immutable**, meaning their values cannot be changed after they are created. If you appear to modify one of these values, Python actually creates a new object instead with the same variable name. This makes primitive types simple and predictable to work with, especially for beginners. 
+
+In contrast, composite data types (like lists, tuples, sets, and dictionaries) can be either **mutable** or **immutable**. Two types that are **mutable**, and so can be changed after they are created are lists and dictionaries. We will look at composite data types in more detail in the next section.
+
+::: {.callout-note}
 
-Use the console to test different operators from the tables. 
-Try adjusting the operators in the expenses_calculator.py script and seeing how the behaviour of the script changes.
+To demonstrate that the primitive data types are immutable you ca change their value and use the id() function to check where they are located in memory.
 
+```{python}
+
+x = 10
+print("Initial value:", x)
+print("Initial memory location:", id(x))
+
+# "Modify" the integer
+x = 15
+
+print("New value:", x)
+print("New memory location:", id(x))
+
+```
 :::
 
 
 ## Composite Data Types - The exciting stuff!
 
-Complex data types is where things really become interesting and the basis for more complex programming
+Composite data types are where things start to become more interesting and form the foundation for more complex programming.
 
-In Python, composite data types allow you to store multiple values in a single variable. They can hold a collection of items, which can be of different data types. The main composite data types in Python are:
+In Python, composite data types allow you to store multiple values within a single variable. These values are grouped together as a collection, and they can even be of different data types. The main composite data types in Python are:
 
 **Lists**
 
@@ -88,7 +131,7 @@ In Python, composite data types allow you to store multiple values in a single v
 
 Let's initialize one of each composite data type with a list of 10 animals, and then demonstrate some of the main differences.
 
-```
+```python
 # Initialize a list of animals
 animal_list = ["Dog", "Cat", "Elephant", "Lion", "Tiger", "Giraffe", "Zebra", "Monkey", "Snake", "Rabbit"]
 
@@ -213,11 +256,114 @@ Get the number of elements in the list.
 
 `length = len(my_list)  # 8`
 
-**Numeric operators e.g. Append multiple repeats**
+**Numeric operations e.g. Append multiple repeats**
 
 `my_list * 2  # [20, 8, 7, 6, 5, 4, 3, 1, 20, 8, 7, 6, 5, 4, 3, 1]`
 
 
+## Converting between data types
+
+All built-in data types in Python have associated built-in functions that allow you to convert values from one data type to another or explicitly create an object of that type. Examples of converting between data types are presented below.
+
+It is not possible to convert between all data types; some conversions require additional information and input.
+
+Resources about data types can be found in the python documentation: 
+https://docs.python.org/3/library/functions.html
+https://docs.python.org/3/library/stdtypes.html
+ 
+Examples of converting between data types: 
+
+
+
+**1. Converting int to float**
+```
+x = 5  # integer
+y = float(x)  # converting to float
+print(y)  
+```
+Output: 
+```
+5.0
+```
+
+**2. Converting float to int**
+```
+x = 3.23  # float
+y = int(x)  # converting to int
+print(b)
+``` 
+Output: 
+```
+3
+```
+
+**3. Converting int to str**
+```
+x = 10  # integer
+y = str(x)  # converting to string
+print(y)
+```
+Output: 
+```
+'10'
+```
+
+**4. Converting str to int**
+```
+x = "123"  # string
+y = int(x)  # converting to int
+print(y)
+```
+Output: 
+```
+123
+```
+
+**5. Converting str to float**
+```
+x = "45.67"  # string
+y = float(x)  # converting to float
+print(x)  
+```
+Output: 
+```
+45.67
+```
+
+**6. Converting list to tuple**
+```
+my_list = [1, 2, 3]  # list
+my_tuple = tuple(my_list)  # converting to tuple
+print(my_tuple)
+```
+Output: 
+```
+(1, 2, 3)
+```
+
+**7. Converting tuple to list**
+```
+my_tuple2 = (4, 5, 6)  # tuple
+my_list2 = list(my_tuple2)  # converting to list
+print(my_list2)  
+```
+Output: 
+```
+[4, 5, 6]
+```
+
+**8. Converting int to bool**
+```
+num_bool = 0  # integer
+bool_value = bool(num_bool)  # converting to boolean
+print(bool_value)  
+```
+Output: 
+```
+False
+```
+
+
 ## Exercises
 
 

materials/03_python_data_types.md materials/02_python_data_types.mdmaterials/03_python_data_types.md renamed to materials/02_python_data_types.md

@@ -0,0 +1,33 @@
+---
+title: Data Types and Operators
+---
+
+::: {.callout-tip}
+#### Learning Objectives
+
+- Learn about python data types and operators
+- Learn when to use different data types
+
+:::
+
+
+
+## Python operators
+
+**operators** are symbols or keywords used to perform operations on data and variables, like calculations or comparisons. 
+This of mathematical singles like ```+``` 0r ```<```.
+
+Most of the operators in python make sense. Use the cheat sheet table to look them up if you need.
+
+::: {.callout-exercise}
+#### Using operators
+
+Use the console to test different operators from the tables. 
+Try adjusting the operators in the expenses_calculator.py script and seeing how the behaviour of the script changes.
+
+:::
+
+::: {.callout-warning}
+Strings in Python are immutable, meaning they cannot be changed after they are created. When a string is modified—such as through concatenation or other operations—Python creates a new string object instead of altering the original one. Because of this, repeatedly building strings using operations like + in loops can be inefficient in both time and memory, since many intermediate string objects may be created. Python automatically manages memory using a process called garbage collection, which is how it reclaims memory from objects that are no longer needed. More specifically, garbage collection removes objects that are no longer reachable in the program—meaning there are no variable names or references pointing to them anymore, either because they were reassigned or deleted. In most cases, you do not need to manage this process manually. Instead, for efficiently building large strings, it is better to use tools designed for this purpose, such as ''.join() or io.StringIO, which reduce the number of temporary string objects created.
+``` 
+