Python Programming Classes And Objects Complete Guide

Python Programming Classes and Objects

What Are Classes and Objects?

Classes and objects are the building blocks of object-oriented programming. A class is a blueprint for creating objects (a particular data structure), providing initial values for state (member variables), and implementations of behavior (member functions or methods). An object is an instance of a class, meaning it is a specific realization of the class with actual values rather than variables.

Defining a Class

To define a class in Python, you use the class keyword followed by the class name and a colon. Inside the class, you define methods (functions tied to the class) and attributes (data tied to the class).

class Dog:
    # Class attribute
    species = "Canis familiaris"
    
    # Initializer / Instance attributes
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # Instance method
    def description(self):
        return f"{self.name} is {self.age} years old."
    
    # Another instance method
    def speak(self, sound):
        return f"{self.name} says {sound}"

• Class Attribute: species is a class attribute shared by all instances of the class.
• Initializer (__init__ method): Called when an instance (object) of the class is created. It initializes the object's attributes.
• Instance Attributes: name and age are instance attributes specific to each instance.
• Instance Methods: description() and speak() are instance methods that operate on an instance of the class.

Creating Objects

An object is created from a class using the class name followed by parentheses. If the class has an initializer, you can pass arguments to create the object in a specific state.

my_dog = Dog(name="Buddy", age=3)
print(my_dog.description())  # Output: Buddy is 3 years old.
print(my_dog.speak("Woof Woof"))  # Output: Buddy says Woof Woof

Class Methods

Class methods are methods that are bound to the class and not the object of the class. They can modify a class state that applies across all instances of the class.

class Dog:
    species = "Canis familiaris"
    all_dogs = []
    
    def __init__(self, name, age):
        self.name = name
        self.age = age
        Dog.all_dogs.append(self)
    
    @classmethod
    def num_dogs(cls):
        return len(cls.all_dogs)

my_dog = Dog(name="Buddy", age=3)
another_dog = Dog(name="Max", age=5)
print(Dog.num_dogs())  # Output: 2

• Class Method (@classmethod): The num_dogs method uses the @classmethod decorator and is bound to the class rather than the instance.

Static Methods

Static methods are functions that belong to a class but do not modify or reference class or instance attributes. They are defined using the @staticmethod decorator.

class Dog:
    @staticmethod
    def is_suitable_pet(person_age):
        return person_age >= 18

print(Dog.is_suitable_pet(17))  # Output: False

• Static Method (@staticmethod): The is_suitable_pet method does not depend on any class or instance-specific data.

Inheritance

Inheritance allows a new class, known as a child or subclass, to inherit attributes and methods from an existing class, known as a parent or superclass.

class Animal:
    def __init__(self, species):
        self.species = species
    
    def make_sound(self):
        pass

class Dog(Animal):
    def __init__(self, species, name, age):
        super().__init__(species)  # Calls the constructor of the parent class
        self.name = name
        self.age = age
    
    def make_sound(self):
        return "Woof!"

• Inheritance (class ChildClass(ParentClass)): The Dog class inherits from the Animal class.
• Super Function (super()): Used in the subclass to call a method from the superclass.

Polymorphism

Polymorphism allows objects of different classes to be treated as objects of a common superclass. This concept is often implemented using method overriding.