Classes and Objects in Python

Overview

Object-Oriented Programming (OOP) in Python: Classes and Objects introduces a paradigm where code is organized around objects—bundles of data and functionality. By defining classes, you create blueprints for objects, specifying the attributes (data) and methods (behavior) that belong to them. In this article, we’ll explore how to build and instantiate classes in Python, and see how objects make your code more intuitive, modular, and maintainable.

What Are Classes and Objects?

A class is like a blueprint or template that outlines what attributes and methods an object should have. An object (or instance) is a concrete example of that class, holding specific data in its attributes and being able to call the class’s methods.

For instance, a Car class might have attributes like make, model, and year, along with methods for starting, stopping, or honking. An object of this Car class, say my_car, would store actual values for those attributes (Toyota, Corolla, 2021) and be able to call its methods.

Defining a Class

In Python, you define a class using the class keyword. By convention, class names are written in TitleCase:

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

    def start_engine(self):
        print("Engine started for", self.model)

The __init__ method, known as the constructor, runs automatically when you create a new instance. Its first parameter is always self, representing the specific instance that’s being created.

Instantiating Objects

Once you’ve defined the class, you can create objects—often called instances—by calling the class name like a function:

my_car = Car("Toyota", "Corolla", 2021)
another_car = Car("Honda", "Civic", 2020)

print(my_car.make)      # Toyota
print(another_car.year) # 2020

my_car.start_engine()   # Engine started for Corolla

Each object holds its own data for the attributes—my_car and another_car are independent instances of the Car class.

Instance Attributes vs. Class Attributes

Variables attached to self inside __init__ are instance attributes (unique to each object). You can also define class attributes, which are shared by all instances:

class Car:
    wheels = 4  # A class attribute common to all Car objects

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

Car.wheels is the same for all cars, whereas make and model vary from one instance to another.

Methods in Classes

A method is just a function defined within a class. By convention, the first parameter of each method (except @staticmethod) is self, referring to the instance:

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

    def start_engine(self):
        print(f"{self.make} {self.model} engine started.")

    def stop_engine(self):
        print(f"{self.make} {self.model} engine stopped.")

You call methods on an object, such as my_car.start_engine(), which automatically passes the instance as self.

Encapsulation and Data Hiding

In Python, there’s no strict “private” keyword as in some languages, but you can signal a variable as “intended for internal use” by prefixing it with an underscore. This is a convention rather than enforced rule:

class BankAccount:
    def __init__(self, balance):
        self._balance = balance  # underscore denotes "private"

    def deposit(self, amount):
        self._balance += amount

    def get_balance(self):
        return self._balance

Although you can still access _balance externally, the underscore hints that you shouldn’t modify it directly without a good reason.

Practical Example

Let’s illustrate how classes and objects can model real-world data. Here, we’ll define a Book class that tracks attributes like title, author, and availability in a library system:

class Book:
    def __init__(self, title, author, copies=1):
        self.title = title
        self.author = author
        self.copies = copies

    def borrow(self):
        if self.copies > 0:
            self.copies -= 1
            print(f"Borrowed '{self.title}'. Copies left: {self.copies}")
        else:
            print(f"No copies of '{self.title}' available.")

    def return_book(self):
        self.copies += 1
        print(f"Returned '{self.title}'. Copies now: {self.copies}")

# Creating objects
book1 = Book("1984", "George Orwell", 3)
book2 = Book("Brave New World", "Aldous Huxley")

book1.borrow()       # Borrowed '1984'. Copies left: 2
book1.return_book()  # Returned '1984'. Copies now: 3
book2.borrow()       # Borrowed 'Brave New World'. Copies left: 0
book2.borrow()       # No copies of 'Brave New World' available.

Each Book instance maintains its own state (copies), and methods enforce borrowing logic within the object’s scope.

Tips and Best Practices

• Keep Classes Focused: Each class should represent a single, distinct concept. Avoid cramming too many responsibilities into one class.
• Use Meaningful Names: Class, attribute, and method names should describe their functionality clearly.
• Leverage Self for Instance Access: Always remember Python methods receive the current object as the first parameter, typically named self.
• Document with Docstrings: Provide docstrings within class and method definitions to guide future maintainers.

Conclusion

Object-Oriented Programming (OOP) in Python: Classes and Objects brings structure and clarity to your programs by grouping data and behaviors into logical entities. By defining classes with clear attributes and methods, you can create objects that neatly represent real-world concepts or programmatic abstractions. Mastering these fundamentals lays the groundwork for advanced OOP topics like inheritance, polymorphism, and encapsulation, enabling you to build robust, maintainable Python applications.