Python OOP | Classes and Objects

Classes and objects are fundamental concepts of object-oriented programming (OOP). In Python, a class is a template for creating objects. It is a blueprint that defines the state (attributes) and behavior (methods) of an object. An object is an instance of a class. It contains the actual data, or state, and the methods that operate on that data.

Here is an example of a simple class in Python:

class Dog:
    def __init__(self, name, breed):
        self.name = name
        self.breed = breed
    
    def bark(self):
        print("Woof!")

The __init__ method is a special method in Python that is called when an object is created. It is used to initialize the attributes of the object. In this example, the __init__ method takes two arguments: name and breed, which are assigned to the attributes self.name and self.breed, respectively.

The bark method is a regular method that prints "Woof!" when called.

To create an object of the Dog class, we use the Dog class as a function:

dog1 = Dog("Fido", "Labrador")

This creates a new Dog object with the name "Fido" and breed "Labrador". We can access the attributes of the object using the dot notation:

print(dog1.name)  # Output: "Fido"
print(dog1.breed)  # Output: "Labrador"

We can also call the methods of the object:

dog1.bark()  # Output: "Woof!"

We can create multiple objects of the same class. Each object will have its own set of attributes and methods:

dog2 = Dog("Buddy", "Poodle")
print(dog2.name)  # Output: "Buddy"
print(dog2.breed)  # Output: "Poodle"
dog2.bark()  # Output: "Woof!"

Classes can also have class attributes and class methods. Class attributes are shared by all objects of the class, while instance attributes are specific to each object. Class methods are methods that are called on the class itself, rather than on an instance of the class.

Here is an example of a class with a class attribute and a class method:

class Dog:
    species = "Canis familiaris"  # Class attribute

    def __init__(self, name, breed):
        self.name = name
        self.breed = breed
    
    def bark(self):
        print("Woof!")
    
    @classmethod
    def get_species(cls):  # cls is a convention for the class object
        return cls.species

We can access the class attribute using the dot notation on the class itself:

print(Dog.species)  # Output: "Canis familiaris"

We can call the class method using the dot notation on the class itself:

print(Dog.get_species())  # Output: "Canis familiaris"

We can also access the class attribute and call the class method.

In addition to class attributes and class methods, Python also supports static methods. Static methods are methods that are bound to the class and not the instance of the class. They are called on the class itself, rather than on an instance of the class.

To create a static method in Python, we use the @staticmethod decorator:

class Dog:
    species = "Canis familiaris"

    def __init__(self, name, breed):
        self.name = name
        self.breed = breed
    
    def bark(self):
        print("Woof!")
    
    @classmethod
    def get_species(cls):
        return cls.species
    
    @staticmethod
    def is_mammal():
        return True

We can call the static method using the dot notation on the class itself:

print(Dog.is_mammal())  # Output: True

We can also access the static method using an instance of the class:

dog1 = Dog("Fido", "Labrador")
print(dog1.is_mammal())  # Output: True

Inheritance is another important concept in OOP. It allows us to create a new class that is a modified version of an existing class. The new class is called the child class, and the existing class is the parent class. The child class inherits attributes and methods from the parent class and can also have additional attributes and methods of its own.

Here is an example of inheritance in Python:

class Animal:
    def __init__(self, name, species):
        self.name = name
        self.species = species
    
    def make_sound(self):
        print("Some generic sound")

class Cat(Animal):  # Cat is the child class and Animal is the parent class
    def __init__(self, name, breed, toy):
        super().__init__(name, species="Felis catus")  # Call the parent class's __init__ method
        self.breed = breed
        self.toy = toy
    
    def play(self):
        print(f"{self.name} plays with {self.toy}")

In this example, the Cat class is a child class of the Animal class. It inherits the __init__ and make_sound methods from the parent class. It also has its own __init__ method and a new method called play.

To create an object of the Cat class, we use the same syntax as for creating an object of any other class:

cat1 = Cat("Kitty", "Siamese", "Ball")

We can access the attributes and methods of the Cat class using the dot notation:

print(cat1.name)  # Output: "Kitty"
print(cat1.species)  # Output: "Felis catus"
print(cat1.breed)  # Output: "Siamese"
cat1.make_sound()  # Output: "Some generic sound"
cat1.play()  # Output: "Kitty plays with Ball"

In summary, classes and objects are essential concepts in object-oriented programming.