Classes in Python

Defining the Class

class ClassName:
    # class body

class Car:
    # class body
    pass  # This is a placeholder. You need to replace it with the actual content.

Adding Methods to the Class

class Car:
    def start_engine(self):
        print("Engine started!")
    
    def stop_engine(self):
        print("Engine stopped!")

Instantiating the Class

my_car = Car()  # Instantiate the Car class
my_car.start_engine()  # Call the start_engine method
my_car.stop_engine()   # Call the stop_engine method

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
        
    def greeting(self):
        print(f"Hello, my name is {self.name} and I am {self.age} years old.")
        
    def birthday(self):
        self.age += 1
        print(f"I just turned {self.age}!")

john = Person("John", 30)
john.greeting()  # Output: Hello, my name is John and I am 30 years old.
john.birthday()  # Output: I just turned 31!

Exploring Object Class in Python

Inheritance in Python

class Animal:
    def greet(self):
        print("Hello, I am an animal!")

class Dog(Animal):
    def greet(self):
        print("Hello, I am a dog!")

dog_instance = Dog()
dog_instance.greet()  # Output: Hello, I am a dog!

The __init__ Method

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

john = Person("John", 30)
print(john.name)  # Output: John
print(john.age)   # Output: 30

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

    def greet(self):
        print(f"Hello, I am a {self.species}!")

class Dog(Animal):
    def __init__(self, name):
        super().__init__("dog")
        self.name = name

    def greet(self):
        print(f"Hello, I am {self.name}, a {self.species}!")

dog_instance = Dog("Max")
dog_instance.greet()  # Output: Hello, I am Max, a dog!

Utilising Properties in Python Classes

Implementing Read-Only Properties

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

    @property
    def area(self):
        return 3.14159 * self.radius * self.radius

my_circle = Circle(5)
print(my_circle.area)  # Output: 78.53975

Creating Setters for Python Properties

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

    @property
    def radius(self):
        return self._radius

    @radius.setter
    def radius(self, new_radius):
        if new_radius < 0:
            raise ValueError("Radius cannot be negative.")
        self._radius = new_radius

    @property
    def area(self):
        return 3.14159 * self.radius * self.radius

my_circle = Circle(5)
print(my_circle.radius)  # Output: 5
print(my_circle.area)    # Output: 78.53975
my_circle.radius = 7
print(my_circle.radius)  # Output: 7
print(my_circle.area)    # Output: 153.93807999999998

Mastering Class Method in Python

The Difference between Static and Class Methods

• Do not have access to any instance-specific data or methods. They work with the input arguments provided.
• Do not require an instance to be called.
• Are defined using the @staticmethod decorator.
• Cannot access or modify class-specific or instance-specific data.
• Are suitable for utility functions that do not rely on the state of an instance or the class.

class MyClass:
    @staticmethod
    def static_method(arg1, arg2):
        # Process the arguments
        return result

• Have access to class-level data and methods.
• Do not require an instance to be called, but instead take the class itself as the first argument, usually named cls.
• Are defined using the @classmethod decorator.
• Can modify class-specific data but cannot access instance-specific data directly.
• Are suitable for factory methods, modifying class-level data or working with inheritance.

class MyClass:
    @classmethod
    def class_method(cls, arg1, arg2):
        # Process the arguments using the class
        return result

When to Use Each Method

Class Methods and Inheritance

class Shape:
    def __init__(self, sides):
        self.sides = sides

    @classmethod
    def from_vertices(cls, vertices):
        sides = len(vertices)
        return cls(sides)

class Triangle(Shape):
    pass

class Square(Shape):
    pass

triangle = Triangle.from_vertices([(0, 0), (1, 1), (1, 2)])
square = Square.from_vertices([(0, 0), (0, 1), (1, 1), (1, 0)])

print(triangle.sides)  # Output: 3
print(square.sides)    # Output: 4

Enhancing Python Classes with Class Decorators

Implementing Custom Class Decorators

def add_greet_method(cls): 
def greet(self): 
print(f"Hello, I am an instance of the {cls.__name__} class.") 
# Add the greet method to the class cls.greet = greet 
return cls @add_greet_method class MyClass: pass instance = MyClass() instance.greet() 
# Output: Hello, I am an instance of the MyClass class.

Built-in Class Decorators in Python