Python Object Class

In Python, objects and classes are the two basic concepts of object-oriented programming (OOP). They help organize code into reusable and modular components. Let’s break them down:

1. What is a Class?

A class is a blue print or template for creating objects. It specifies a set of attributes, or data and methods, or functions, which objects created from the class will have.

Syntax for Defining a Class:

class ClassName:
    # Class attribute (shared by all instances)
    class_attribute = "This is a class attribute"

    # Constructor method to initialize object attributes
    def __init__(self, instance_attribute):
        self.instance_attribute = instance_attribute

    # Instance method
    def display(self):
        return f"Instance attribute: {self.instance_attribute}"

2. What is an Object?

Objects are instances of classes; when you produce an object, you instantiate a class, which means such an object has its own copy of the attributes and methods defined with that class.

Example of Creating an Object:

# Define a class
class Person:
    def __init__(self, name, age):
        self.name = name  # Instance attribute
        self.age = age    # Instance attribute

    def greet(self):
        return f"Hello, my name is {self.name} and I am {self.age} years old."

# Create an object (instance of the class)
person1 = Person("Alice", 30)

# Access attributes and call methods
print(person1.name)       # Output: Alice
print(person1.greet())    # Output: Hello, my name is Alice and I am 30 years old.

3. Key Components of Classes and Objects

a) Attributes

Attributes are the variables linked to a class or object.

• Class Attributes: Those shared among all objects.
• Instance Attributes: Each individual object.

b. Methods

Methods are functions declared in a class that can take actions based on class attributes.

• Instance Methods: Can take actions with each object attribute.
• Class Methods: Use @classmethod and depend on class attributes.
• Static Methods: Use @staticmethod and are independent of any attribute.

4. The __init__ Method

The __init__ method is the constructor in Python. It is called automatically when an object is created. It is used to initialize the object’s attributes.

class Car:
    def __init__(self, brand, model):
        self.brand = brand  # Instance attribute
        self.model = model  # Instance attribute

car1 = Car("Toyota", "Corolla")
print(car1.brand)  # Output: Toyota

5. Encapsulation, Inheritance, and Polymorphism

a) Encapsulation

Encapsulation is the bundling of data and methods into a single unit (class). It restricts access to certain components to ensure data security.

• Use _ for protected attributes.
• Use __ for private attributes.

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Private attribute

    def get_balance(self):
        return self.__balance

    def deposit(self, amount):
        self.__balance += amount

b) Inheritance

Inheritance allows a class (child class) to inherit attributes and methods from another class (parent class).

class Animal:
    def speak(self):
        return "Animal sound"

class Dog(Animal):
    def speak(self):
        return "Woof!"

dog = Dog()
print(dog.speak())  # Output: Woof!

c) Polymorphism

Polymorphism allows methods in a child class to have the same name as methods in the parent class but behave differently.

class Shape:
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius ** 2

6. Special Methods

Special methods (also called dunder methods) make objects work seamlessly with built-in functions and operators in Python.

Some Common Dunder Methods:

• _str_: defines the string representation of the object.
• _repr_: Defines the official representation of the object.
• _add_, _sub_, etc.: For operator overloading.

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

p1 = Point(1, 2)
p2 = Point(3, 4)
result = p1 + p2
print(result.x, result.y)  # Output: 4, 6

7. Example of a Complete Class and Object

class Book:
    def __init__(self, title, author, pages):
        self.title = title
        self.author = author
        self.pages = pages

    def description(self):
        return f"{self.title} by {self.author}, {self.pages} pages long."

    def is_long(self):
        return self.pages > 300

# Create an object
book1 = Book("1984", "George Orwell", 328)

# Access attributes and methods
print(book1.description())  # Output: 1984 by George Orwell, 328 pages long.
print(book1.is_long())      # Output: True

8. Advantages of Classes and Objects

1. Modularity: It organizes code into reusable components
2. Data Encapsulation: Protecting Data and Restricting Its Access
3. Inheritance: Reusing Code Across Classes
4. Polymorphism: Designing Flexible and Scalable Systems.