Python - Classes and Objects

Classes and Objects in Python

Python is an object-oriented programming language, which means it supports object-oriented programming (OOP) concepts such as classes, objects, inheritance, encapsulation, and polymorphism. OOP helps in organizing code, creating reusable components, and designing systems that are easier to maintain and scale. In Python, everything is an object, including classes themselves. This document provides a comprehensive guide to classes and objects in Python, including syntax, usage, best practices, and advanced features.

1. What is Object-Oriented Programming?

1.1 Definition

Object-oriented programming is a programming paradigm based on the concept of “objects”, which can contain data and code: data in the form of fields (attributes), and code in the form of procedures (methods). Python allows the creation and manipulation of objects using classes.

1.2 Core OOP Concepts

• Class
• Object
• Encapsulation
• Inheritance
• Polymorphism

2. Creating Classes

2.1 Defining a Class

A class in Python is defined using the class keyword:

class Person:
    pass

2.2 Creating an Object

To create an object (also called an instance) of a class:

person1 = Person()

3. The __init__ Method

3.1 Constructor in Python

The __init__ method is a special method in Python classes. It is automatically called when a new instance of the class is created. It is used for initializing the object’s attributes.

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

person1 = Person("Alice", 30)
print(person1.name)
print(person1.age)

4. Instance Variables

4.1 Definition

Instance variables are unique to each instance. They are defined inside the __init__ method using self.

class Car:
    def __init__(self, model, color):
        self.model = model
        self.color = color

car1 = Car("Tesla", "Red")
car2 = Car("BMW", "Black")
print(car1.model)
print(car2.model)

5. Class Variables

5.1 Definition

Class variables are shared across all instances of the class. They are defined directly under the class definition.

class Dog:
    species = "Canine"

    def __init__(self, name):
        self.name = name

dog1 = Dog("Rex")
dog2 = Dog("Max")
print(dog1.species)
print(dog2.species)

6. Methods

6.1 Instance Methods

Most methods you define will be instance methods. They take self as the first parameter:

class Student:
    def __init__(self, name, grade):
        self.name = name
        self.grade = grade

    def get_details(self):
        return f"{self.name} scored {self.grade}"

stu = Student("John", 85)
print(stu.get_details())

6.2 Class Methods

Use the @classmethod decorator. First argument is cls:

class Circle:
    pi = 3.14

    @classmethod
    def from_diameter(cls, diameter):
        radius = diameter / 2
        return cls(radius)

6.3 Static Methods

Use the @staticmethod decorator. No self or cls:

class Math:
    @staticmethod
    def add(x, y):
        return x + y

print(Math.add(5, 3))

7. Encapsulation

7.1 Private Attributes

Use underscore (_) to indicate protected, and double underscore (__) for private:

class Account:
    def __init__(self, balance):
        self.__balance = balance

    def get_balance(self):
        return self.__balance

acc = Account(1000)
print(acc.get_balance())
# print(acc.__balance)  # Error

7.2 Using Getter and Setter Methods

class Account:
    def __init__(self, balance):
        self.__balance = balance

    def get_balance(self):
        return self.__balance

    def set_balance(self, amount):
        if amount >= 0:
            self.__balance = amount

acc = Account(500)
acc.set_balance(700)
print(acc.get_balance())

8. Inheritance

8.1 Single Inheritance

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def bark(self):
        print("Dog barks")

d = Dog()
d.speak()
d.bark()

8.2 Overriding Methods

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

class Cat(Animal):
    def speak(self):
        print("Meow")

c = Cat()
c.speak()

8.3 super() Function

Used to call the parent class’s methods:

class Person:
    def __init__(self, name):
        self.name = name

class Employee(Person):
    def __init__(self, name, emp_id):
        super().__init__(name)
        self.emp_id = emp_id

9. Polymorphism

9.1 Method Overriding

Different classes with the same method name and signature:

class Bird:
    def fly(self):
        print("Bird can fly")

class Penguin(Bird):
    def fly(self):
        print("Penguin cannot fly")

9.2 Duck Typing

class Duck:
    def walk(self):
        print("Duck walks")

class Person:
    def walk(self):
        print("Person walks like a duck")

def test_walk(obj):
    obj.walk()

test_walk(Duck())
test_walk(Person())

10. Special Methods (Magic Methods)

10.1 __str__ and __repr__

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

    def __str__(self):
        return f"Book: {self.title}"

b = Book("Python 101")
print(b)

10.2 __add__, __len__, etc.

class Counter:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        return Counter(self.value + other.value)

c1 = Counter(10)
c2 = Counter(20)
c3 = c1 + c2
print(c3.value)

11. Composition

11.1 Using Objects Within Objects

class Engine:
    def start(self):
        print("Engine started")

class Car:
    def __init__(self):
        self.engine = Engine()

    def start(self):
        self.engine.start()
        print("Car ready")

my_car = Car()
my_car.start()

12. isinstance() and issubclass()

12.1 isinstance()

print(isinstance(10, int))

12.2 issubclass()

class A:
    pass

class B(A):
    pass

print(issubclass(B, A))

13. Class Inheritance Best Practices

• Use composition over inheritance when appropriate
• Keep parent classes as abstract and simple as possible
• Use super() for extending base class functionality

14. Abstract Classes

14.1 Using abc Module

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side * self.side

s = Square(5)
print(s.area())

15. Dataclasses

15.1 Introduction

Dataclasses reduce boilerplate code for classes that store data:

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

p = Point(10, 20)
print(p)

Understanding classes and objects is essential for building scalable and maintainable Python applications. Object-oriented programming brings modularity, reusability, and clarity to code. From defining basic classes to working with inheritance, encapsulation, and polymorphism, the knowledge of classes enables developers to design better software architectures. Python's support for magic methods, abstract classes, and data classes further enriches the power of OOP. Practicing with real-world examples will solidify your understanding of these concepts and prepare you for advanced Python programming including design patterns, GUI development, and API design.