Skip to main content

Classes and Objects

Object-oriented programming (OOP) is a programming paradigm that uses "objects" to model real-world entities. These objects are instances of "classes," which can be thought of as blueprints for creating specific types of objects. In this tutorial, we will explore the basics of classes and objects in Python by developing a program that models cars.

Introduction to Classes and Objects​

A class in Python defines a type of object. It encapsulates data for the object and methods to manipulate that data. An object is an instance of a class. Once a class is defined, multiple objects can be created from it, each with its own unique data but sharing the same functionality.

Defining a Car Class​

To demonstrate the concept of classes and objects, we'll create a Car class. This class will serve as a blueprint for creating car objects, each with a specific brand and number of wheels.

class Car:
    def __init__(self, brand: str, wheels: int):
        self.brand = brand
        self.wheels = wheels

    def turn_on(self):
        print(f"Turning on the {self.brand}.")

    def turn_off(self):
        print(f"Turning off the {self.brand}.")

    def drive(self, kilometers: int):
        print(f"Driving the {self.brand} for {kilometers} kilometers.")

    def describe(self):
        print(f"{self.brand} is a car with {self.wheels} wheels.")

Explanation of the Code​

  • Class Definition: The Car class is defined using the class keyword followed by the class name.
  • Initializer (__init__ method): This special method is called when a new object is instantiated. It initializes the object's attributes.
    • self: Refers to the instance of the class. It is used to access the attributes and methods of the class.
    • brand: The brand of the car.
    • wheels: The number of wheels the car has.
  • Methods: These are functions defined within the class that describe the behavior of the objects.
    • turn_on(): Prints a message indicating the car is being turned on.
    • turn_off(): Prints a message indicating the car is being turned off.
    • drive(): Prints a message indicating the car is being driven for a specified distance.
    • describe(): Prints a description of the car.

Creating and Using Car Objects​

Now that we have defined the Car class, we can create instances (objects) of this class and use its methods.

if __name__ == "__main__":
    bmw = Car("BMW", 4)
    bmw.turn_on()
    bmw.drive(10)
    bmw.turn_off()
    bmw.describe()

    volvo = Car("Volvo", 6)
    volvo.turn_on()
    volvo.drive(30)
    volvo.turn_off()
    volvo.describe()

Explanation of the Code​

  • Main Entry Point: The if __name__ == "__main__": block ensures that the code inside it runs only when the script is executed directly.
  • Creating Objects: bmw and volvo are objects of the Car class.
  • Using Methods: The methods turn_on(), drive(), turn_off(), and describe() are called on these objects to perform actions and print information.

Output​

Running the above script will produce the following output:

Turning on the BMW.
Driving the BMW for 10 kilometers.
Turning off the BMW.
BMW is a car with 4 wheels.
Turning on the Volvo.
Driving the Volvo for 30 kilometers.
Turning off the Volvo.
Volvo is a car with 6 wheels.

Benefits of Using Classes and Objects​

Using classes and objects provides several benefits:

  1. Reusability: Once a class is defined, it can be reused to create multiple objects, each with different attribute values.
  2. Modularity: Classes encapsulate data and functionality, making code easier to manage and understand.
  3. Extensibility: New functionality can be added to existing classes without modifying the existing code.
  4. Maintainability: Encapsulation helps in isolating changes to specific parts of the code, making maintenance easier.

Conclusion​

In this tutorial, we have learned the basics of classes and objects in Python by creating a Car class. We have seen how to define a class, initialize objects, and use methods to perform actions on those objects. Understanding these fundamental concepts is crucial for effective programming in Python, as they form the basis for more advanced topics in object-oriented programming.