Your simple recipe book is ready to become a complex factory. We will now learn how to organize our instructions into large, reusable structures called Classes and how to split our code into separate files (Departments).
X. 📐 Blueprints for Robots (Classes)
When you want to create many similar "things" (like users, cars, or particles), you don't write the same code for each one. You create a single, reusable Blueprint called a Class.
A Class is a template that defines:
Attributes: The information (Variables/Boxes) the thing must hold. (e.g., A Robot's color, name, energy level).
Methods: The actions (Functions/Recipe Steps) the thing can perform. (e.g., A Robot can
move(),report_status()).
A. Defining the Blueprint (class)
# 'Robot' is the name of our blueprint/class
class Robot:
# 1. The __init__ Method (The Constructor)
# This runs automatically when you create a NEW Robot from the blueprint.
# It sets the starting values (attributes) for this specific Robot.
def __init__(self, name_tag, initial_color):
# 'self' refers to the new object being created.
self.name = name_tag # Each robot will have a name
self.color = initial_color # Each robot will have a color
self.energy = 100 # All robots start with 100 energy
# 2. A Custom Method (An Action)
def report_status(self):
print(f"Robot {self.name} is active.")
print(f"Energy level: {self.energy}")
# 3. Another Custom Method
def expend_energy(self, amount):
self.energy -= amount
print(f"{self.name} used {amount} energy.")
B. Building the Robots (Creating Objects/Instances)
Once you have the blueprint, you can create unique working versions of it. These are called Objects or Instances.
# Create the first robot (Object 1), providing the required name and color.
robot_a = Robot("Unit-42", "Blue")
# Create the second robot (Object 2), which is completely separate.
robot_b = Robot("Guardian", "Red")
# Now we can ask each robot to perform an action (call its methods)
print("\n--- Robot A Actions ---")
robot_a.expend_energy(20)
robot_a.report_status()
# Output: Energy level: 80
print("\n--- Robot B Actions ---")
robot_b.expend_energy(5)
robot_b.report_status()
# Output: Energy level: 95
XI. 📁 Separate Departments (Modules and Files)
For small recipes, one piece of paper is fine. For a factory's operations, you organize instructions into different files (or Modules) so the main file doesn't get cluttered.
The Main Program (e.g.,
factory_control.py) needs to access instructions in the Robot Blueprint file (e.g.,robot_blueprints.py).
A. The Structure:
File 1: robot_blueprints.py
(This file contains the complete class Robot code from the section above.)
File 2:
factory_control.py(The main file that uses the blueprint)
# Inside 'factory_control.py':
# The 'import' instruction tells Python to look in the other file ('robot_blueprints')
# and bring in the 'Robot' class.
from robot_blueprints import Robot
# Now you can use the Robot class as if it were defined in this file!
# Create a new Robot instance
new_worker = Robot("Worker-01", "Yellow")
# Use its method
new_worker.report_status()
This is the foundation of organized programming. It makes large code bases manageable, reusable, and easy to maintain.
All the data we have worked with so far (variables, lists) is temporary; it vanishes when the program finishes running. To make your robot remember things forever, we need to teach it how to use a Permanent Logbook (a file).
XII. 📝 The Permanent Logbook (File I/O)
File I/O (Input/Output) is the process of reading data from a file on your computer's hard drive or writing data to it.
A. The Core Process: Opening and Closing
To work with any file, you must:
Open the file (like opening the logbook).
Read or Write data.
Close the file (like sealing the logbook). If you forget to close it, your data might be corrupted or lost.
Python has a safe way to handle this, using the with open(...) structure. This ensures the file is automatically closed, even if an error occurs.
B. Writing Data (Making a New Log Entry)
To write, you must open the file in write mode ("w"). If the file doesn't exist, Python will create it. Warning: Using "w" mode erases everything already in the file!
log_entry = "STATUS: System check complete. Time stamp: 10:00."
# 'logbook.txt' is the file name. 'w' means write mode. 'f' is the temporary file object.
with open("logbook.txt", "w") as f:
# Use the .write() method to put the text into the file
f.write(log_entry)
print("Logbook entry successfully recorded.")
# The file is automatically closed here.
C. Reading Data (Reviewing Past Entries)
To read, you must open the file in read mode ("r").
# Open the file in read mode ('r')
with open("logbook.txt", "r") as f:
# Use the .read() method to get all the content from the file
all_data = f.read()
print("\n--- Reading Logbook ---")
print(all_data)
print("-----------------------")
# The file is automatically closed here.
D. Appending Data (Adding a New Page)
If you want to add new information to the end of an existing file without deleting the old data, use append mode ("a").
new_entry = "\nSTATUS: Secondary task initiated. Time stamp: 10:05."
# Open the file in append mode ('a')
with open("logbook.txt", "a") as f:
# Use the .write() method. We added '\n' (newline) to push the new text
# onto a new line in the file, keeping it neat.
f.write(new_entry)
print("New log entry appended without overwriting the old data.")
You have now acquired all the foundational components. The final step is to combine these tools to build a practical, functioning piece of code. We will build a Simple Configuration Manager—a small program that stores and reads basic settings for a robot or system.
XIII. 🧩 Synthesis: The Configuration Manager Project
Our goal is to create two functions: one to Save settings and one to Load them. We will use a basic text file (config.txt) to store the data permanently.
A. Step 1: Saving the Settings
We will use a Dictionary to hold the settings, then write that data to the logbook file.
# Function 1: Saves the settings dictionary to the file
def save_settings(settings_data, filename="config.txt"):
print("--- Saving Settings ---")
# Use the append mode ('a') to write the configuration to the file.
# We will write each setting on a new line.
try:
with open(filename, "w") as file:
# Loop (Repetition) through every Key-Value pair in the dictionary
for key, value in settings_data.items():
# Write the setting as "key=value"
file.write(f"{key}={value}\n")
print(f"Successfully saved {len(settings_data)} settings.")
except Exception as e:
# Error Handling (Disaster Cleanup)
print(f"ERROR during save: Could not write to file. {e}")
# The settings dictionary (Our structured data)
system_settings = {
"robot_id": "Alpha-7",
"speed_limit": 50,
"security_mode": True
}
# Run the Save Function
save_settings(system_settings)
B. Step 2: Loading the Settings
This function must read the file line by line, split the key from the value, and reconstruct the Dictionary in the program's memory.
# Function 2: Loads settings from the file and rebuilds the dictionary
def load_settings(filename="config.txt"):
settings = {} # Start with an empty dictionary
print("--- Loading Settings ---")
# Use Error Handling for the risk of the file not existing
try:
# Open the file in read mode ('r')
with open(filename, "r") as file:
# Loop (Repetition) through every line in the file
for line in file:
# Remove extra spaces/newlines and split the line at the '=' sign
# Example: "speed_limit=50" becomes ["speed_limit", "50"]
key, value_str = line.strip().split("=")
# We save the key and the raw string value to the dictionary
settings[key] = value_str
print(f"Successfully loaded {len(settings)} settings.")
return settings
except FileNotFoundError:
# This specific error handles the case where the file is missing
print(f"WARNING: Configuration file '{filename}' not found. Using default settings.")
return {"robot_id": "DEFAULT", "speed_limit": 10} # Return safe defaults
except Exception as e:
print(f"CRITICAL ERROR during load: File corrupted. {e}")
return None
# Run the Load Function
loaded_data = load_settings()
# Display the results
if loaded_data:
print("\n--- Program Status ---")
# Access the loaded data (Boxes in the Dictionary)
print(f"ID is: {loaded_data['robot_id']}")
print(f"Speed Limit: {loaded_data['speed_limit']}")
# Note: loaded_data['security_mode'] is currently the text "True", not the boolean True.
XIV. 🎉 Congratulations! Next Steps
You have now mastered the fundamental tools necessary to synthesize a basic, stable program. The next step in your journey is mastering data types for parsing complex configuration files like JSON or CSV, and exploring how to display information graphically (GUI programming).