Python Classes and Objects

If you’re new to Python, you might have heard about classes and objects, but they can seem confusing at first. Don’t worry! This guide will explain classes and objects in a simple, beginner-friendly way with plenty of examples. By the end, you’ll understand how to create classes, make objects, use attributes and methods, and even customize your objects with special methods. We’ll also include a practical exercise to solidify your learning. Let’s get started!

Part A: The Basics of Classes and Objects

What is a Class?

A class is like a blueprint or template for creating objects. It defines what an object can do (its behaviors) and what information it holds (its properties). For example, if you think of a car, the class would describe the general idea of a car: it has a brand, a model, and it can drive. The class doesn’t represent a specific car—it’s just the plan.

What is an Object?

An object is a specific instance of a class. Using the car analogy, if the class is the blueprint for a car, an object is a real car built from that blueprint, like a Toyota Corolla or a Ford Mustang. Each object can have its own specific data but follows the structure defined by the class.

Here’s a simple analogy:

• Class: A recipe for chocolate chip cookies (describes ingredients and steps).

• Object: An actual batch of cookies you bake using the recipe.

Part B: Key Concepts to Learn

Let’s dive into the key components of classes and objects in Python, with examples to make everything clear.

Defining a Class with class

You define a class in Python using the class keyword, followed by the class name and a colon :. The code inside the class is indented, just like with functions.

Here’s a basic example:

class Car:
    pass  # Placeholder for now

This creates an empty Car class. The name Car is typically capitalized (a Python convention for class names).

The __init__ Method (Constructor)

The __init__ method is a special method called a constructor. It runs automatically when you create a new object from a class. You use it to set up the object’s initial data (attributes).

Here’s an example:

class Car:
    def __init__(self, brand, model):
        self.brand = brand  # Instance attribute
        self.model = model  # Instance attribute

In this example:

• self refers to the object being created. It’s a way for the object to refer to itself.

• brand and model are parameters passed when creating the object.

• self.brand and self.model are instance attributes, which store data specific to each object.

Creating Objects from a Class

To create an object (an instance of a class), you call the class like a function, passing any required arguments for __init__.

Example:

# Create two Car objects
car1 = Car("Toyota", "Corolla")
car2 = Car("Ford", "Mustang")

print(car1.brand)  # Output: Toyota
print(car2.model)  # Output: Mustang

Here, car1 and car2 are objects. Each has its own brand and model attributes, set when the objects were created.

Attributes: Instance and Class Attributes

Attributes are variables that belong to a class or its objects. There are two types:

Instance Attributes

These belong to a specific object and are defined in __init__ using self. Each object can have different values for these attributes.

Example:

class Car:
    def __init__(self, brand, model):
        self.brand = brand  # Instance attribute
        self.model = model  # Instance attribute

car1 = Car("Honda", "Civic")
car2 = Car("BMW", "X5")

print(car1.brand)  # Output: Honda
print(car2.brand)  # Output: BMW

Here, brand and model are instance attributes, unique to each Car object.

Class Attributes

These belong to the class itself and are shared by all objects of that class. You define them directly in the class body, outside any method.

Example:

class Car:
    wheels = 4  # Class attribute (shared by all cars)

    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

car1 = Car("Toyota", "Corolla")
car2 = Car("Ford", "Mustang")

print(car1.wheels)  # Output: 4
print(car2.wheels)  # Output: 4
print(Car.wheels)   # Output: 4

Here, wheels is a class attribute. All Car objects share the same value (4), and you can also access it directly through the class (Car.wheels).

Methods: Functions Inside a Class

A method is a function defined inside a class. It always takes self as its first parameter, which refers to the object calling the method.

Example:

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def drive(self):
        return f"The {self.brand} {self.model} is driving!"

car1 = Car("Toyota", "Corolla")
print(car1.drive())  # Output: The Toyota Corolla is driving!

The drive method uses self to access the object’s brand and model attributes.

Special Methods (Magic/Dunder Methods)

Special methods, also called magic methods or dunder methods (because they start and end with double underscores, like __something__), let you customize how your objects behave. They make your objects act like Python’s built-in types.

Some common special methods:

• __str__: Defines a human-readable string representation of the object.

• __repr__: Defines a detailed string representation, useful for debugging.

• __len__: Defines what len() returns for the object.

• __eq__: Defines how objects are compared for equality.

Let’s look at examples of these methods in the Car class.

__str__: Human-Readable String

The __str__ method defines what gets printed when you use print() on an object. It’s meant to be readable for humans.

Example:

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def __str__(self):
        return f"{self.brand} {self.model}"

car1 = Car("Honda", "Civic")
print(car1)  # Output: Honda Civic

Without __str__, printing car1 would show something like <__main__.Car object at 0x7f8b5c0f3d30>. The __str__ method makes the output clear and user-friendly.

__repr__: Detailed String for Debugging

The __repr__ method provides a detailed string representation of the object, often used by developers for debugging. Ideally, the string it returns could be used to recreate the object.

Example:

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def __repr__(self):
        return f"Car(brand='{self.brand}', model='{self.model}')"

car1 = Car("Honda", "Civic")
print(repr(car1))  # Output: Car(brand='Honda', model='Civic')

Here, __repr__ provides a string that shows exactly how to create the Car object. You can even evaluate it with eval() (though this is rarely needed).

__eq__: Comparing Objects

The __eq__ method defines how two objects are compared for equality using ==. Without it, Python compares object memory addresses, which isn’t usually what you want.

Example:

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def __eq__(self, other):
        return self.brand == other.brand and self.model == other.model

car1 = Car("Toyota", "Corolla")
car2 = Car("Toyota", "Corolla")
car3 = Car("Ford", "Mustang")

print(car1 == car2)  # Output: True
print(car1 == car3)  # Output: False

The __eq__ method checks if two Car objects have the same brand and model.

__len__: Defining Length

The __len__ method defines what len() returns for an object. For a Car, we could use __len__ to return the length of the model name (just as an example).

Example:

class Car:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model

    def __len__(self):
        return len(self.model)

car1 = Car("Toyota", "Corolla")
car2 = Car("BMW", "X5")

print(len(car1))  # Output: 7 (length of "Corolla")
print(len(car2))  # Output: 2 (length of "X5")

Here, __len__ returns the number of characters in the car’s model attribute.

Practice Exercise: Building a Car Class

Let’s put everything together with a practical exercise. We’ll create a Car class with:

• Instance attributes: brand, model, and color.

• A class attribute: wheels.

• A method: drive().

• Special methods: __str__, __repr__, __eq__, and __len__.

Here’s the complete code:

class Car:
    wheels = 4  # Class attribute

    def __init__(self, brand, model, color):
        self.brand = brand  # Instance attribute
        self.model = model  # Instance attribute
        self.color = color  # Instance attribute

    def drive(self):
        return f"The {self.color} {self.brand} {self.model} is driving on {self.wheels} wheels!"

    def __str__(self):
        return f"{self.color} {self.brand} {self.model}"

    def __repr__(self):
        return f"Car(brand='{self.brand}', model='{self.model}', color='{self.color}')"

    def __eq__(self, other):
        return self.brand == other.brand and self.model == other.model and self.color == other.color

    def __len__(self):
        return len(self.model)

# Create objects
car1 = Car("Toyota", "Corolla", "Blue")
car2 = Car("Toyota", "Corolla", "Blue")
car3 = Car("BMW", "X5", "Red")

# Test attributes and methods
print(car1)                # Output: Blue Toyota Corolla
print(car1.drive())        # Output: The Blue Toyota Corolla is driving on 4 wheels!
print(car2.wheels)         # Output: 4
print(Car.wheels)          # Output: 4
print(repr(car1))          # Output: Car(brand='Toyota', model='Corolla', color='Blue')
print(car1 == car2)        # Output: True
print(car1 == car3)        # Output: False
print(len(car1))           # Output: 7 (length of "Corolla")
print(len(car3))           # Output: 2 (length of "X5")

What’s Happening?

• Class attribute: wheels is shared by all Car objects and the class itself.

• Instance attributes: Each Car object (car1, car2, car3) has its own brand, model, and color.

• Method: The drive method uses instance and class attributes to describe the car’s action.

• Special methods:

  • __str__: Makes print(car1) show a readable string like “Blue Toyota Corolla”.

  • __repr__: Provides a detailed string for debugging, like Car(brand=’Toyota’, model=’Corolla’, color=’Blue’).

  • __eq__: Allows comparison of Car objects based on brand, model, and color.

  • __len__: Returns the length of the model string when len() is called.

Try modifying the code:

• Add a new method, like honk(), that returns “Beep beep!”.

• Modify __eq__ to compare only brand and model, ignoring color.

• Test len() with different Car objects to see how __len__ works.

Here’s an extended version with a honk method:

class Car:
    wheels = 4

    def __init__(self, brand, model, color):
        self.brand = brand
        self.model = model
        self.color = color

    def drive(self):
        return f"The {self.color} {self.brand} {self.model} is driving on {self.wheels} wheels!"

    def honk(self):
        return "Beep beep!"

    def __str__(self):
        return f"{self.color} {self.brand} {self.model}"

    def __repr__(self):
        return f"Car(brand='{self.brand}', model='{self.model}', color='{self.color}')"

    def __eq__(self, other):
        return self.brand == other.brand and self.model == other.model  # Ignore color

    def __len__(self):
        return len(self.model)

# Test the extended class
car1 = Car("Toyota", "Corolla", "Blue")
car2 = Car("Toyota", "Corolla", "Red")
car3 = Car("BMW", "X5", "Red")

print(car1)                # Output: Blue Toyota Corolla
print(car2.honk())         # Output: Beep beep!
print(car1.drive())        # Output: The Blue Toyota Corolla is driving on 4 wheels!
print(car1 == car2)        # Output: True (same brand and model, color ignored)
print(len(car1))           # Output: 7 (length of "Corolla")

Conclusion

Classes and objects are a powerful way to structure your Python code. A class defines the blueprint, while objects are specific instances with their own data. By using instance attributes for object-specific data, class attributes for shared data, methods for behaviors, and special methods like __str__, __repr__, __eq__, and __len__ to customize behavior, you can create flexible and reusable code that behaves like Python’s built-in types.

The Car class exercise shows how to combine these concepts to model real-world objects. As a beginner, start by creating simple classes with a few attributes and methods. Experiment with special methods to make your objects more powerful. With practice, you’ll find classes and objects become a natural part of your Python programming toolkit!