No history yet

Class Foundations

From Scripts to Blueprints

So far, you've likely managed related data using structures like dictionaries or multiple lists. For a project management tool, you might have a dictionary for each project, like this:

project_alpha = {
    "name": "Website Redesign",
    "deadline": "2024-12-01",
    "status": "In Progress"
}

project_beta = {
    "name": "API Integration",
    "deadline": "2024-11-15",
    "status": "Not Started"
}

This works, but it's disconnected. The data (the dictionary) and the actions you might perform on it (functions to update the status, check the deadline, etc.) are separate. This separation can lead to messy, hard-to-maintain code as your application grows.

Object-Oriented Programming (OOP) offers a solution by bundling data and the functions that operate on that data into a single unit called an object. The blueprint for creating these objects is a class.

A class is a template for creating objects. An object is a specific instance of a class, with its own unique data.

Think of a class as an architect's blueprint for a house. The blueprint defines the structure: how many rooms, where the doors are, and so on. Each actual house built from that blueprint is an object. They share the same structure but have their own distinct attributes, like different paint colors or furniture.

Constructing an Object

To bring our blueprint to life, we need a way to construct an object and give it its initial state. In Python, this is handled by a special method called init. This method, often called a constructor, runs automatically whenever you create a new instance of a class.

class Project:
    def __init__(self, name, deadline, status="Not Started"):
        self.name = name
        self.deadline = deadline
        self.status = status

# Create two instances (objects) of the Project class
project_1 = Project("Website Redesign", "2024-12-01")
project_2 = Project("API Integration", "2024-11-15", "In Progress")

# Each object has its own data
print(project_1.name)   # Output: Website Redesign
print(project_2.status) # Output: In Progress

Let's break down that __init__ method. The first parameter is always self. The is a reference to the specific instance of the class being created. When you write self.name = name, you're saying, "Take the name value passed in and attach it to this specific object as an attribute called name."

This is how project_1 and project_2, despite being created from the same Project class, can hold different data. The self parameter ensures that when you access project_1.name, you get the name for project_1, not project_2.

State and Behavior

Attributes defined on self are called instance attributes. They represent the state of a particular object. project_1.name and project_2.name are instance attributes.

Classes can also have class attributes, which are shared by all instances of the class. They are defined directly inside the class, outside of any method. Let's add one to our Project class.

class Project:
    # This is a class attribute
    company = "Innovate Inc."

    def __init__(self, name, deadline, status="Not Started"):
        # These are instance attributes
        self.name = name
        self.deadline = deadline
        self.status = status

project_1 = Project("Website Redesign", "2024-12-01")
project_2 = Project("API Integration", "2024-11-15")

# Accessing the class attribute
print(project_1.company)  # Output: Innovate Inc.
print(project_2.company)  # Output: Innovate Inc.

Every Project object will share the same company value. If you change the class attribute (Project.company = "New Innovations"), the change will be reflected across all existing instances.

Now, let's add behavior. We can define functions inside the class called methods. These methods operate on the instance's data.

from datetime import date

class Project:
    company = "Innovate Inc."

    def __init__(self, name, deadline_str, status="Not Started"):
        self.name = name
        # Convert string to a date object for easier comparison
        self.deadline = date.fromisoformat(deadline_str)
        self.status = status

    # This is an instance method
    def mark_complete(self):
        """Sets the project's status to 'Completed'."""
        self.status = "Completed"

    # Another instance method
    def is_overdue(self):
        """Checks if the project is past its deadline and not completed."""
        return date.today() > self.deadline and self.status != "Completed"

# --- Usage ---

project = Project("Mobile App Launch", "2023-10-01")

print(f"Initial status: {project.status}")
print(f"Is overdue? {project.is_overdue()}")

project.mark_complete()

print(f"New status: {project.status}")
print(f"Is overdue now? {project.is_overdue()}") # Now false because it's complete

Notice how the methods mark_complete and is_overdue also take self as their first parameter. This gives them access to the instance's attributes like self.status and self.deadline.

We have now bundled our project's data (attributes) and its related actions (methods) into a clean, reusable Project class. This is the core idea of encapsulation and the first major step into object-oriented design.

Quiz Questions 1/5

What is the primary advantage of Object-Oriented Programming (OOP) that is highlighted?

Quiz Questions 2/5

In the analogy where a class is a 'blueprint' for a house, what does an 'object' represent?