Class Design Fundamentals

From Scripts to Blueprints

So far, you've likely written Python scripts that run from top to bottom. This works, but as programs grow, you need a better way to organize them. Object-Oriented Programming, or OOP, provides that structure by letting you model real-world concepts as objects.

The first step is defining a class. Think of a class as a blueprint for creating objects. The blueprint for a car defines its essential properties (like the number of wheels and its color) and its behaviors (like accelerating and braking). The actual car you build from that blueprint is an object, also known as an instance.

A class is the blueprint. An object (or instance) is the concrete thing created from that blueprint.

This approach bundles data (attributes) and behavior (methods) together into a single, neat package. Let's build a simple blueprint for a Dog.

class Dog:
    # This is a class attribute
    species = "Canis familiaris"

    def __init__(self, name, breed):
        # These are instance attributes
        self.name = name
        self.breed = breed

    def bark(self):
        return f"{self.name} says Woof!"

# Instantiating two Dog objects
fido = Dog("Fido", "Golden Retriever")
rex = Dog("Rex", "German Shepherd")

print(fido.name)
print(rex.breed)
print(fido.bark())

Initializing an Object

When you create an object from a class, like fido = Dog(...), Python automatically calls a special method named __init__. This method, often called the constructor, is where you set up the initial state of a new object.

Notice the first parameter of __init__ and bark is self. This is a crucial keyword in Python's OOP model.

self

pronoun

A reference to the current instance of the class. It is used to access attributes and methods that belong to the instance.

When you call fido.bark(), Python secretly translates it into Dog.bark(fido). The instance, fido, is automatically passed as the first argument, which the method receives as self. This is how the method knows which specific dog's name to use in the return string. The self keyword binds the method call to the instance.

Class vs. Instance Attributes

In our Dog class, name and breed are instance attributes. They are defined inside __init__ and are prefixed with self. This means each Dog object gets its own unique name and breed. Fido's name is "Fido," and Rex's name is "Rex."

On the other hand, species is a class attribute. It's defined directly inside the class, outside of any method. This attribute is shared by all instances of the Dog class. Every dog we create will share the same species.

Attribute Type	Definition	When to Use
Instance	Belongs to one specific object.	For data that is unique to each instance, like a dog's name or a user's email.
Class	Shared by all objects of the class.	For constants or data that should be the same for every instance, like a configuration setting or a species name.

You can access both types of attributes through an instance, but you can also access class attributes directly through the class itself.

fido = Dog("Fido", "Golden Retriever")

# Accessing an instance attribute
print(fido.name)  # Output: Fido

# Accessing a class attribute through the instance
print(fido.species) # Output: Canis familiaris

# Accessing a class attribute through the class
print(Dog.species)  # Output: Canis familiaris

By designing classes, you create modular, reusable, and organized components. Each class encapsulates its own data and behavior, making your code easier to understand, maintain, and expand.

Quiz Questions 1/4

In Object-Oriented Programming, what is the relationship between a class and an object?

Quiz Questions 2/4

What is the primary purpose of the special __init__ method in a Python class?

Python Object Oriented Programming Masterclass