Unlock Python's Object-Oriented Programming (OOPs) power! Learn core concepts like classes, objects, and inheritance, essential for building robust AI and ML applications.

Python Object-Oriented Programming (OOPs)

This document provides a comprehensive overview of Object-Oriented Programming (OOPs) concepts in Python.

6.1 Introduction to Python OOPs Concepts

Object-Oriented Programming (OOP) is a programming paradigm that uses "objects" – instances of classes – to design applications and computer programs. It is based on the concept of bundling data (attributes) and methods (functions) that operate on the data within a single unit called an object. Python fully supports OOP, allowing developers to create modular, reusable, and maintainable code.

The core principles of OOP include:

Classes: Blueprints or templates for creating objects. They define the attributes (data members) and methods (member functions) that an object will have.
Objects: Instances of a class. They represent real-world entities and contain the data and behavior defined by their class.
Encapsulation: Bundling data and the methods that operate on that data into a single unit (a class). It also involves restricting direct access to some of an object's components, known as data hiding.
Inheritance: A mechanism that allows a new class (child class or derived class) to inherit properties and behaviors (attributes and methods) from an existing class (parent class or base class). This promotes code reusability.
Polymorphism: The ability of an object to take on many forms. In Python, this is often achieved through method overriding and duck typing, where an object's type is less important than the methods it supports.
Abstraction: Hiding complex implementation details and exposing only the essential features of an object. This simplifies the interaction with objects.

6.2 Python Classes and Objects

Classes

A class is a user-defined blueprint from which objects are created. It defines a set of attributes that the objects of the class will have and methods that the objects can perform.

Syntax:

class ClassName:
    # Class attributes (optional)
    class_attribute = "some value"

    # Instance attributes and methods
    def __init__(self, attribute1, attribute2):
        self.attribute1 = attribute1
        self.attribute2 = attribute2

    def method_name(self, parameter1):
        # Method body
        pass

Explanation:

class ClassName:: This keyword starts the definition of a class. ClassName is the name of the class, which typically follows the PascalCase convention.
__init__(self, ...): This is a special method called the constructor. It is automatically called when an object of the class is created. The self parameter refers to the instance of the class being created. It's used to initialize instance attributes.
self: This is a conventional name for the first parameter of instance methods in a class. It refers to the instance of the class itself.
Instance Attributes: Variables that belong to a specific object. They are defined within methods (usually __init__) using self.attribute_name = value.
Class Attributes: Variables that belong to the class itself and are shared by all instances of the class. They are defined directly within the class body.

Objects

An object is an instance of a class. You create an object by calling the class name as if it were a function.

Syntax:

object_name = ClassName(arguments_for_constructor)

Example:

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

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

    # Instance method
    def bark(self):
        return f"{self.name} says Woof!"

# Creating objects (instances) of the Dog class
my_dog = Dog("Buddy", 3)
your_dog = Dog("Lucy", 5)

# Accessing attributes
print(f"My dog's name is {my_dog.name} and it's {my_dog.age} years old.")
print(f"Your dog's name is {your_dog.name} and it's {your_dog.age} years old.")

# Accessing class attribute
print(f"All dogs belong to the species: {Dog.species}")
print(f"Buddy also belongs to the species: {my_dog.species}")

# Calling methods
print(my_dog.bark())
print(your_dog.bark())

6.3 Constructors

In Python, the constructor is a special method named __init__. It is automatically called when you create a new object of a class. Its primary purpose is to initialize the instance attributes of the object.

Key points about __init__:

It is called automatically when an object is instantiated.
The first parameter of __init__ is always self, which refers to the newly created object.
You can pass arguments to the constructor when creating an object, which are then used to set the initial values of the object's attributes.
A class can have only one __init__ method. If you define multiple, only the last one will be active.

Example:

class Car:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
        self.is_running = False # Default attribute

    def start_engine(self):
        if not self.is_running:
            self.is_running = True
            print(f"The {self.year} {self.make} {self.model}'s engine has started.")
        else:
            print("The engine is already running.")

    def stop_engine(self):
        if self.is_running:
            self.is_running = False
            print(f"The {self.year} {self.make} {self.model}'s engine has stopped.")
        else:
            print("The engine is already off.")

# Create a Car object
my_car = Car("Toyota", "Camry", 2022)

# Access initialized attributes
print(f"My car is a {my_car.year} {my_car.make} {my_car.model}.")

# Call methods
my_car.start_engine()
my_car.start_engine() # Trying to start again
my_car.stop_engine()
my_car.stop_engine() # Trying to stop again

6.4 Inheritance

Inheritance is a fundamental OOP concept that allows a new class to inherit attributes and methods from an existing class. The class whose properties are inherited is called the parent class (or base class, or superclass), and the class that inherits these properties is called the child class (or derived class, or subclass).

Benefits of Inheritance:

Code Reusability: Avoids repeating code by allowing you to define common attributes and methods in a parent class and reuse them in multiple child classes.
Extensibility: Allows you to extend the functionality of an existing class without modifying it.
Hierarchical Structure: Creates a natural hierarchy for organizing classes.

Syntax:

class ParentClass:
    # Parent class attributes and methods
    pass

class ChildClass(ParentClass):
    # Child class attributes and methods
    # Can override parent methods or add new ones
    pass

Key Concepts:

Method Overriding: When a child class provides a specific implementation for a method that is already defined in its parent class.
super() function: Used to call methods of the parent class from within the child class. This is crucial for extending the parent's functionality rather than completely replacing it.

Example:

# Parent Class (Base Class)
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        raise NotImplementedError("Subclass must implement abstract method")

    def move(self):
        return f"{self.name} is moving."

# Child Class 1 (Derived Class)
class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"

# Child Class 2 (Derived Class)
class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"

# Child Class 3 inheriting from Dog (Multi-level Inheritance)
class Bulldog(Dog):
    def speak(self):
        # Call parent (Dog) speak method using super()
        return f"{super().speak()} and I'm a tough Bulldog!"

# Creating instances
animal = Animal("Generic") # This will raise an error if speak() is called directly
dog = Dog("Buddy")
cat = Cat("Whiskers")
bulldog = Bulldog("Rocky")

print(dog.speak())
print(cat.speak())
print(dog.move())
print(bulldog.speak())
print(bulldog.move())

# Demonstrating method overriding with super()
class Duck(Animal):
    def speak(self):
        return f"{self.name} says Quack!"

    def swim(self):
        return f"{self.name} is swimming."

class RobotDuck(Duck):
    def speak(self):
        # Calling the parent's (Duck) speak method first
        parent_speak = super().speak()
        return f"{parent_speak} BEEP BOOP, I am a robot duck!"

robot_duck = RobotDuck("RoboQuack")
print(robot_duck.speak())
print(robot_duck.swim())

6.5 Abstraction

Abstraction is a mechanism that hides the complex implementation details of an object and shows only the essential features to the user. It focuses on what an object does rather than how it does it.

In Python, abstraction is typically achieved using:

Abstract Base Classes (ABCs): Python's abc module provides facilities for creating abstract base classes. ABCs are classes that cannot be instantiated directly. They are intended to be subclassed.
Abstract Methods: Methods declared in an ABC but without an implementation. Subclasses must provide an implementation for these methods.

Benefits of Abstraction:

Simplifies Complexity: Users interact with objects at a high level, without needing to know the intricate details of their internal workings.
Improves Maintainability: Changes to the internal implementation of a class do not affect other classes that use its abstract interface.
Promotes Reusability: Abstract classes define a common interface that multiple concrete classes can adhere to.

Example using abc module:

from abc import ABC, abstractmethod

# Abstract Base Class
class Shape(ABC):
    def __init__(self, name):
        self.name = name

    @abstractmethod
    def area(self):
        """Calculate and return the area of the shape."""
        pass

    @abstractmethod
    def perimeter(self):
        """Calculate and return the perimeter of the shape."""
        pass

    def describe(self):
        """A non-abstract method."""
        return f"This is a {self.name}."

# Concrete Class 1
class Circle(Shape):
    def __init__(self, name, radius):
        super().__init__(name)
        self.radius = radius

    def area(self):
        import math
        return math.pi * self.radius**2

    def perimeter(self):
        import math
        return 2 * math.pi * self.radius

# Concrete Class 2
class Rectangle(Shape):
    def __init__(self, name, width, height):
        super().__init__(name)
        self.width = width
        self.height = height

    def area(self):
        return self.width * self.height

    def perimeter(self):
        return 2 * (self.width + self.height)

# Trying to instantiate an abstract class will raise an error
# abstract_shape = Shape("Generic") # TypeError: Can't instantiate abstract class Shape...

# Instantiate concrete classes
my_circle = Circle("MyCircle", 5)
my_rectangle = Rectangle("MyRectangle", 4, 6)

print(my_circle.describe())
print(f"Area of {my_circle.name}: {my_circle.area():.2f}")
print(f"Perimeter of {my_circle.name}: {my_circle.perimeter():.2f}")

print(my_rectangle.describe())
print(f"Area of {my_rectangle.name}: {my_rectangle.area()}")
print(f"Perimeter of {my_rectangle.name}: {my_rectangle.perimeter()}")

# Using the abstract interface
shapes = [my_circle, my_rectangle]
for shape in shapes:
    print(f"\n--- Processing {shape.name} ---")
    print(shape.describe())
    print(f"Area: {shape.area()}")
    print(f"Perimeter: {shape.perimeter()}")

6.6 Encapsulation

Encapsulation is the bundling of data (attributes) and methods that operate on the data into a single unit, called a class. It also refers to the concept of data hiding, which is restricting direct access to some of an object's components. This helps protect the internal state of an object from unauthorized access and modification.

How Encapsulation is Achieved in Python:

Python doesn't have strict private or public keywords like some other languages. Instead, it uses a convention of name mangling for attributes intended to be "private".

Single Underscore Prefix (_): By convention, attributes prefixed with a single underscore (_my_attribute) are considered "protected". This is a hint to other developers that these attributes are for internal use and should not be accessed directly from outside the class. Python does not enforce this restriction.
Double Underscore Prefix (__): Attributes prefixed with a double underscore (__my_attribute) undergo name mangling. Python renames these attributes to _ClassName__attributeName. This makes them harder to access directly from outside the class, effectively providing a level of privacy.

Benefits of Encapsulation:

Data Protection: Prevents accidental or intentional modification of an object's internal state from outside the class.
Modularity: The internal implementation of a class can be changed without affecting the code that uses the class, as long as the public interface (methods) remains the same.
Maintainability: Makes code easier to debug and maintain by isolating the data and its associated operations.

Example:

class BankAccount:
    def __init__(self, owner_name, balance=0):
        self.owner_name = owner_name  # Public attribute
        self.__balance = balance      # Private attribute (name mangled)

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            print(f"Deposited: ${amount}. New balance: ${self.__balance}")
        else:
            print("Deposit amount must be positive.")

    def withdraw(self, amount):
        if amount > 0:
            if self.__balance >= amount:
                self.__balance -= amount
                print(f"Withdrew: ${amount}. New balance: ${self.__balance}")
            else:
                print("Insufficient funds.")
        else:
            print("Withdrawal amount must be positive.")

    def get_balance(self):
        """Public method to access the private balance."""
        return self.__balance

    def __private_helper(self):
        """A private helper method."""
        print("This is a private helper method.")

# Creating an instance
account = BankAccount("Alice", 1000)

# Accessing public attributes and using public methods
print(f"Account owner: {account.owner_name}")
account.deposit(500)
account.withdraw(200)
print(f"Current balance: ${account.get_balance()}")

# Attempting to access private attributes directly (will raise AttributeError)
# print(account.__balance) # This will cause an error

# Using name mangling to access (not recommended for regular use)
print(f"Accessing balance via name mangling: ${account._BankAccount__balance}")

# Attempting to call private helper directly (will raise AttributeError)
# account.__private_helper() # This will cause an error

# Using name mangling to call private helper (not recommended)
account._BankAccount__private_helper()

6.7 Access Modifiers

Access modifiers are keywords or conventions used to control the visibility or accessibility of class members (attributes and methods) from outside the class. Python doesn't have explicit public, private, protected keywords like Java or C++. Instead, it relies on conventions and name mangling.

Here's how access is managed in Python:

Public Members:
- Definition: Members (attributes and methods) that are not prefixed with any underscore are considered public. They can be accessed and modified from anywhere, both inside and outside the class.
- Convention: This is the default behavior.
- Example: self.attribute, method_name().
Protected Members:
- Definition: Members prefixed with a single underscore (_) are conventionally considered protected. This is a signal to programmers that these members are intended for internal use within the class or by its subclasses. Python itself does not enforce this restriction, meaning they can still be accessed from outside the class.
- Convention: Use _ prefix.
- Purpose: To indicate that a member is part of the internal implementation details and might change in future versions.
- Example: _protected_attribute, _protected_method().
Private Members:
- Definition: Members prefixed with a double underscore (__) are name-mangled by Python. Python internally renames these attributes to _ClassName__attributeName. This makes them harder to access directly from outside the class, providing a form of privacy.
- Convention: Use __ prefix.
- Purpose: To prevent accidental overriding of methods in subclasses or accidental access/modification from outside the class.
- Example: __private_attribute, __private_method().

Summary of Access Modifiers in Python:

Prefix	Name in Python	Accessibility	Convention
(None)	`public_attribute`	Accessible from anywhere	Standard, intended for general use.
`_`	`_protected_attribute`	Accessible from anywhere, but treated as protected	Hint to developers: "Use with caution, internal implementation."
`__`	`_ClassName__private_attribute`	Accessible via name mangling; hard to access directly	For internal use only, prevents accidental access/overriding in subclasses.

Example illustrating access modifiers:

class MyClass:
    def __init__(self):
        self.public_var = "I am public"          # Public
        self._protected_var = "I am protected"  # Protected (by convention)
        self.__private_var = "I am private"     # Private (name-mangled)

    def public_method(self):
        print("This is a public method.")
        self._protected_method() # Can call protected methods from within the class
        self.__private_method()  # Can call private methods from within the class

    def _protected_method(self):
        print("This is a protected method.")

    def __private_method(self):
        print("This is a private method.")

# Create an instance
obj = MyClass()

# Accessing public members
print(obj.public_var)
obj.public_method()

# Accessing protected members (possible, but discouraged)
print(obj._protected_var)
obj._protected_method()

# Attempting to access private members directly (will fail)
try:
    print(obj.__private_var)
except AttributeError as e:
    print(f"Error accessing private variable directly: {e}")

try:
    obj.__private_method()
except AttributeError as e:
    print(f"Error calling private method directly: {e}")

# Accessing private members via name mangling (not recommended for regular use)
print(f"Accessing private variable via name mangling: {obj._MyClass__private_var}")
obj._MyClass__private_method()

Python OOPs: Master Object-Oriented Programming for AI

Python Object-Oriented Programming (OOPs)

6.1 Introduction to Python OOPs Concepts

6.2 Python Classes and Objects

Classes

Objects

6.3 Constructors

6.4 Inheritance

6.5 Abstraction

6.6 Encapsulation

6.7 Access Modifiers

On this page