Classes in Python

Classes are blueprints for creating objects in Python. They define the attributes (data) and methods (functions) that objects will have.

Creating Classes

Python

class MyClass:

  def __init__(self, attribute1, attribute2):

    self.attribute1 = attribute1

    self.attribute2 = attribute2

  def method1(self):

    # Method implementation

    pass

  def method2(self):

    # Method implementation

    pass

Creating Objects

Python

object1 = MyClass(value1, value2)

object2 = MyClass(value3, value4)

Accessing Attributes and Methods

Python

print(object1.attribute1)

object1.method1()

Inheritance

Python

class ChildClass(ParentClass):

  def __init__(self, attribute1, attribute2, attribute3):

    super().__init__(attribute1, attribute2)

    self.attribute3 = attribute3  

  def method3(self):

    # Method implementation

    pass

Polymorphism

Python

class Animal:

  def make_sound(self):

    pass

class Dog(Animal):

  def make_sound(self):

    print("Woof!")

class Cat(Animal):

  def make_sound(self):

    print("Meow!")  

# Creating objects

dog = Dog()

cat = Cat()

# Calling the same method on different objects

dog.make_sound()  # Output: Woof!

cat.make_sound()  # Output: Meow!

Best Practices:

• Use descriptive class and method names.

• Encapsulate data within classes.

• Follow the principle of single responsibility (SRP).

• Use inheritance judiciously.

• Write clear and concise docstrings.

Defining Classes

Classes are blueprints for creating objects in object-oriented programming. They define the attributes (data) and methods (functions) that objects will have.

Syntax:

Python

class MyClass:

  def __init__(self, attribute1, attribute2):

    self.attribute1 = attribute1

    self.attribute2 = attribute2

  def method1(self):

    # Method  

implementation

  def method2(self):

    # Method implementation

Key Components:

• Class Name: The name of the class, typically capitalized.

• __init__() Method: The constructor method, called when an object is created. It initializes the object's attributes.

• Attributes: Data members that store information about the object.

• Methods: Functions that define the object's behavior.

Example:

Python

class Person:

  def __init__(self, name, age):

    self.name = name

    self.age = age

  def greet(self):

    print(f"Hello, my name is {self.name}.")  

  def get_age(self):

    return self.age

Creating Objects:

Python

person1 = Person("Alice", 30)

person2 = Person("Bob", 25)

Accessing Attributes and Methods:

Python

print(person1.name)  # Output: Alice

person1.greet()  # Output: Hello, my name is Alice.

Best Practices:

• Use descriptive class and method names.

• Encapsulate data within classes.

• Follow the principle of single responsibility (SRP).

• Use inheritance judiciously.

• Write clear and concise docstrings.

By understanding these concepts, you can effectively define classes and create well-structured object-oriented programs in Python.

Class Properties

Properties are a way to control access to object attributes in Python. They provide a more flexible and encapsulated way to interact with data.

Using Property Decorators:

Python

class MyClass:

  def __init__(self, value):

    self._value = value  # Private attribute

  @property

  def value(self):

    return self._value

  @value.setter

  def value(self, new_value):

    if new_value < 0:

      raise ValueError("Value cannot be negative")

    self._value = new_value  

Key Points:

• The @property decorator defines a getter method.

• The @value.setter decorator defines a setter method.

• The setter method can implement validation logic or modify the value before assigning it.

• Private attributes (starting with __) are generally used to hide implementation details.

Example:

Python

obj = MyClass(10)

print(obj.value)  # Output: 10

obj.value = 20

print(obj.value)  # Output: 20

obj.value = -5  # Raises ValueError

Benefits of Using Properties:

• Encapsulation: Hides the implementation details of accessing and modifying attributes.

• Data Validation: Allows you to enforce constraints on attribute values.

• Calculated Properties: Derives values from other attributes.

• Control Over Access: Determines how attributes can be accessed and modified.

By understanding properties in Python, you can create more robust and flexible class designs.