Skip to content
logo
Home / Fundamentals

Python Classes

Purpose of a Class

A class is a template for creating objects. It allows you to define the characteristics and behavior of a type of object, and then create multiple objects of that type.

For example, you might define a Car class to represent the characteristics and behavior of a car. You could then create multiple car objects, each with its own unique attributes (e.g. make, model, year, color) and methods (e.g. start engine, accelerate, brake).

Using classes can help you organize and structure your code, and make it easier to reuse and modify.

Define a Class

To define a class in Python, use the class keyword followed by the name of the class. The class definition should include a init method, which is a special method in Python classes that is called when an object is created (i.e. when you call the class as a function).

Here is an example of a Car class definition:

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

Constructor

The init method is a special method in Python classes that is called when an object is created (i.e. when you call the class as a function). It is often referred to as the constructor of the class.

The constructor is used to initialize the attributes of the object. It can also accept additional arguments to set the attributes, as shown in the previous examples.

In the example above, the init method takes three arguments: self, make, and model. The self argument is a reference to the object itself, and is used to access attributes and methods of the object. The make and model arguments are the attributes of the object, which are set using the self.attribute notation.

Class Attributes

In Python, class attributes can be either public or private. Public attributes can be accessed and modified directly, while private attributes can only be accessed or modified through methods.

To define a private attribute, use the _ prefix before the attribute name (e.g. _private_attribute). This is known as name mangling, and it makes it difficult for external code to access or modify the attribute directly.

Here is an example of a Car class with public and private attributes:

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self._private_attribute = "This is a private attribute"

Class Objects

To create an object (i.e. an instance) of a class, call the class as a function and pass in any required arguments. For example:

my_car = Car("Ford", "Mustang", 1969)

This creates a new Car object with the make "Ford", model "Mustang", and year 1969. You can access the attributes of the object using the dot notation:

print(my_car.make)  # Output: "Ford"
print(my_car.model)  # Output: "Mustang"
print(my_car.year)  # Output: 1969

Self

The self keyword is used to refer to the object itself within the class definition. It is used to access and modify attributes and methods of the object.

For example, you might define a method to set the color of a car:

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.__private_attribute = "This is a private attribute"

    def set_color(self, color):
        self.color = color

    def get_color(self):
        return self.color

# Create a new Car object
my_car = Car("Ford", "Mustang", 1969)

# Set the color of the car
my_car.set_color("Red")

# Get the color of the car
print(my_car.get_color())  # Output: "Red"

In this example, the set_color method takes a color argument and sets it as an attribute of the object using the self.attribute notation. The get_color method returns the color attribute of the object.

The self keyword is used to refer to the object itself within the class definition, and is required when defining methods that access or modify object attributes.

Class Methods

A class method is a method that is bound to the class and not the object of the class. It can be called by either an object of the class or the class itself.

To define a class method, use the @classmethod decorator followed by the cls argument, which is a reference to the class itself.

Here is an example of a class method in the Car class:

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.__private_attribute = "This is a private attribute"

    @classmethod
    def get_number_of_wheels(cls):
        return 4

You can call the get_number_of_wheels method on the class itself, or on an object of the class:

print(Car.get_number_of_wheels())  # Output: 4

my_car = Car("Ford", "Mustang", 1969)
print(my_car.get_number_of_wheels())  # Output: 4

Staticmethod & Classmethod

A static method is a method that is bound to the class and not the object of the class. It can be called by either an object of the class or the class itself, but it does not have access to the class or object state.

To define a static method, use the @staticmethod decorator.

Here is an example of a static method in the Car class:

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.__private_attribute = "This is a private attribute"

    @classmethod
    def get_number_of_wheels(cls):
        return 4

    @staticmethod
    def get_engine_type():
        return "Internal combustion"

You can call the get_engine_type static method on the class itself, or on an object of the class:

print(Car.get_engine_type())  # Output: "Internal combustion"

my_car = Car("Ford", "Mustang", 1969)
print(my_car.get_engine_type())  # Output: "Internal combustion"

Best Practices

  • Use clear and descriptive names for your classes and methods.
  • Include docstrings describing the purpose and functionality of your classes and methods.
  • Use the self keyword consistently to refer to the object itself within the class definition.
  • Use private attributes (i.e. those with the _ prefix) to protect the internal state of the object and to hide implementation details.
  • Use the @classmethod decorator to define class methods, and the @staticmethod decorator to define static methods.
  • Use the init method as the constructor of the class to initialize the attributes of the object.
  • Follow the PEP 8 style guide for naming conventions and formatting.