Python Classes and Objects

In Python, classes and objects are the core of object-oriented programming. A class defines the structure and behavior of objects, while objects are instances of these classes. Understanding how to create and use classes is essential for writing clean, maintainable code. In this article, we’ll cover key concepts like class variables, instance variables, methods, and more, giving you a strong foundation in Python’s object-oriented approach.

Classes and Objects

What is a Class?

A class in Python is a user-defined template for creating objects. It bundles data and functions together, making it easier to manage and use them. When we create a new class, we define a new type of object. We can then create multiple instances of this object type.

Classes are created using class keyword. Attributes are variables defined inside the class and represent the properties of the class. Attributes can be accessed using the dot . operator (e.g., MyClass.my_attribute).

# define a class
class Dog:
    sound = "bark"  # class attribute

What is an Object?

An object is a specific instance of a class. It holds its own set of data (instance variables) and can invoke the methods defined by its class. Multiple objects can be created from the same class, each with its own unique attributes.

Let's create an object from the Dog class.

class Dog:
    sound = "bark"


# Create an object from the class
dog1 = Dog()

# Access the class attribute
print(dog1.sound)

In the above sample code sound attribute is a class attribute. It is shared across all instances of Dog class, so can be directly accessed through instance dog1.

Why do we need Python Classes and Objects

• Supports object-oriented programming using reusable templates (classes) and real-world models (objects).
• Promotes code reusability and modular design with organized methods and attributes.
• Simplifies complex programs by grouping related data and behavior.
• Enables key OOP concepts like inheritance, encapsulation and polymorphism.

Using __init__() Function

In Python, class has __init__() function which automatically initializes object attributes when an object is created. The __init__() method is the constructor in Python.

class Dog:
    species = "Canine"  # Class attribute

    def __init__(self, name, age):
        self.name = name  # Instance attribute
        self.age = age  # Instance attribute

Explanation:

• class Dog: Defines a class named Dog.
• species: A class attribute shared by all instances of the class.
• __init__ method: Initializes the name and age attributes when a new object is created.

Initiate Object with __init__()

class Dog:
    species = "Canine"  # Class attribute

    def __init__(self, name, age):
        self.name = name  # Instance attribute
        self.age = age  # Instance attribute

# Creating an object of the Dog class
dog1 = Dog("Buddy", 3)

print(dog1.name)  # Output: Buddy
print(dog1.species)  # Output: Canine

Explanation:

• dog1 = Dog("Buddy", 3): Creates an object of the Dog class with name as "Buddy" and age as 3.
• dog1.name: Accesses the instance attribute name of the dog1 object.
• dog1.species: Accesses the class attribute species of the dog1 object.

Self Parameter

self parameter is a reference to the current instance of the class. It allows us to access the attributes and methods of the object.

class Dog:
    def __init__(self, name, age):  
        self.name = name 
        self.age = age

    def bark(self): 
        print(f"{self.name} is barking!")

# Creating an instance of Dog
dog1 = Dog("Buddy", 3)
dog1.bark() 

Explanation:

• Inside bark(), self.name accesses the specific dog's name and prints it.
• When we call dog1.bark(), Python automatically passes dog1 as self, allowing access to its attributes.

__str__() Method

__str__ method in Python allows us to define a custom string representation of an object. By default, when we print an object or convert it to a string using str(), Python uses the default implementation, which returns a string like <__main__.ClassName object at 0x00000123>.

class Dog:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        return f"{self.name} is {self.age} years old."  # Correct: Returning a string
      
dog1 = Dog("Buddy", 3)
dog2 = Dog("Charlie", 5)

print(dog1)  
print(dog2)  

Explanation:

• __str__ Implementation: Defined as a method in the Dog class. Uses the self parameter to access the instance's attributes (name and age).
• Readable Output: When print(dog1) is called, Python automatically uses the __str__ method to get a string representation of the object. Without __str__, calling print(dog1) would produce something like <__main__.Dog object at 0x00000123>.

Class and Instance Variables in Python

In Python, variables defined in a class can be either class variables or instance variables, and understanding the distinction between them is crucial for object-oriented programming.

Class Variables

These are the variables that are shared across all instances of a class. It is defined at the class level, outside any methods. All objects of the class share the same value for a class variable unless explicitly overridden in an object.

Instance Variables

Variables that are unique to each instance (object) of a class. These are defined within __init__() method or other instance methods. Each object maintains its own copy of instance variables, independent of other objects.

Example:

class Dog:
    # Class variable
    species = "Canine"

    def __init__(self, name, age):
        # Instance variables
        self.name = name
        self.age = age

# Create objects
dog1 = Dog("Buddy", 3)
dog2 = Dog("Charlie", 5)

# Access class and instance variables
print(dog1.species)  # (Class variable)
print(dog1.name)     # (Instance variable)
print(dog2.name)     # (Instance variable)

# Modify instance variables
dog1.name = "Max"
print(dog1.name)     # (Updated instance variable)

# Modify class variable
Dog.species = "Feline"
print(dog1.species)  # (Updated class variable)
print(dog2.species)  

Explanation:

• Class Variable (species): Shared by all instances of the class. Changing Dog.species affects all objects, as it's a property of the class itself.
• Instance Variables (name, age): Defined in the __init__() method. Unique to each instance (e.g., dog1.name and dog2.name are different).
• Accessing Variables: Class variables can be accessed via the class name (Dog.species) or an object (dog1.species). Instance variables are accessed via the object (dog1.name).
• Updating Variables: Changing Dog.species affects all instances. Changing dog1.name only affects dog1 and does not impact dog2.

Additional Important Concepts in Python Classes and Objects

Getter and Setter Methods

Getter and Setter methods provide controlled access to an object's attributes. In Python, these methods are used to retrieve (getter) or modify (setter) the values of private attributes, allowing for data encapsulation.

Python doesn't have explicit get and set methods like other languages, but it supports this functionality using property decorators.

• Getter: Used to access the value of an attribute.
• Setter: Used to modify the value of an attribute.

class Dog:
    def __init__(self, name, age):
        self._name = name  # Conventionally private variable
        self._age = age  # Conventionally private variable

    @property
    def name(self):
        return self._name  # Getter

    @name.setter
    def name(self, value):
        self._name = value  # Setter

    @property
    def age(self):
        return self._age  # Getter

    @age.setter
    def age(self, value):
        if value < 0:
            print("Age cannot be negative!")
        else:
            self._age = value  # Setter

Method Overriding

Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass. This allows subclasses to modify or extend the behavior of inherited methods.

class Animal:
    def sound(self):
        print("Some sound")


class Dog(Animal):
    def sound(self):  # Method overriding
        print("Woof")


dog = Dog()
dog.sound()  # Output: Woof

Static Methods and Class Methods

Static methods and class methods are bound to the class, not instances of the class.

• Static Method: A method that does not require access to the instance or class. It’s defined using the @staticmethod decorator.
• Class Method: A method that receives the class as its first argument (cls). It’s defined using the @classmethod decorator.

class Dog:
    @staticmethod
    def info():
        print("Dogs are loyal animals.")

    @classmethod
    def count(cls):
        print(f"There are many dogs of class {cls}.")


dog = Dog()
dog.info()  # Static method call
dog.count()  # Class method call

Abstract Classes and Interfaces

Abstract classes provide a template for other classes. These classes can't be instantiated directly. They contain abstract methods, which are methods that must be implemented by subclasses.

Abstract classes are defined using the abc module in Python.

from abc import ABC, abstractmethod


class Animal(ABC):
    @abstractmethod
    def sound(self):
        pass


class Dog(Animal):
    def sound(self):
        print("Woof")


dog = Dog()
dog.sound()  # Output: Woof

Class Variables vs. Instance Variables

• Class Variables are shared by all instances of a class. They are defined inside the class but outside any methods.
• Instance Variables are unique to each instance and are defined in the __init__() method.

class Dog:
    species = "Canine"  # Class variable

    def __init__(self, name, age):
        self.name = name  # Instance variable
        self.age = age  # Instance variable


dog1 = Dog("Buddy", 3)
dog2 = Dog("Lucy", 2)

print(dog1.species)  # Accessing class variable
print(dog2.name)  # Accessing instance variable

class MyClass:
    def __init__(self, arg1, arg2):
        self.arg1 = arg1
        self.arg2 = arg2

    def some_method(self):
        # Method definition
        pass

Q: What is an object in OOP?

A: In Object-Oriented Programming (OOP), an object is a tangible entity that represents a particular instance of a class. It combines data (attributes) and behaviors (methods) specified by the class.

Q: Why do we need classes and objects?

A: Classes and objects provide a way to model real-world entities and abstract concepts in code. They promote code organization, encapsulation (data hiding), inheritance (code reuse), and polymorphism (method overriding), making complex systems easier to manage and extend.

Python Classes and Objects

Visit Course