Python - Object-Oriented Programming: Classes

Python | Object-Oriented Programming: Classes

Basic class definition:

Classes are blueprints for creating objects in Python.
They bundle data (attributes) and behavior (methods), enabling object-oriented programming concepts like encapsulation, inheritance, and polymorphism.

Defining a class:

__init__: this constructor method is called automatically when an instance of the class is created.
self: is a reference to the current instance. It is automatically passed to methods.
Instance variables: they are variables defined with self and are accessible to all methods in the class and to all instances of the class.

class Math:
  # class variable (shared by all instances)
  name = 'Simple Math'

  def __init__(self, i, j):
    # instance variables
    self.i = i
    self.j = j

  def set_i(self, i):
    self.i = i

  def set_j(self, j):
    self.j = j

  def add(self):
    return self.i + self.j

  def multiply(self):
    return self.i * self.j

  @classmethod
  def get_name(cls):
    return cls.name

  @staticmethod
  def validate_name(name):
    return isinstance(name, str)

  # string representation (if not defined, __repr__ is used)
  def __str__(self):
    return f"Math({self.i}, {self.j})"

  # developer representation (also used as string representation if __str__ is not defined)
  def __repr__(self):
    return f"Math(i={self.i}, j={self.j})"

Creating an instance:
```
math1 = Math(2, 3)
```

Calling methods:

print(math1.add()) # Output: 5
print(math1.multiply()) # Output: 6

Accessing attributes:

print(math1.i) # Output: 2
print(math1.j) # Output: 3

Modifying attributes:

math1.i = 3
math1.set_j(7)
print(math1.add()) # Output: 10
print(math1.multiply()) # Output: 21

String representation

# string representation
print(math1) # Output: Math(3, 7)

# developer representation
print(repr(math1)) # Output: Math(i=3, j=7)

Using class/static methods/attributes

# access class variable
print(Math.name) # Output: Simple Math

# access class method
print(Math.get_name()) # Output: Simple Math

# access static method
print(Math.validate_name("Math")) # Output: True

Property decorators:

class Audit:
  def __init__(self, msg):
    self._msg = msg

  @property
  def message(self):
    return self._msg

  @message.setter
  def message(self, msg):
    self._msg = msg

audit = Audit('Hello')

# access property
print(audit.message) # Output: Hello

# set property
audit.message = "Python"

print(audit.message) # Output: Python

Inheritance:

Inheritance allows a class to inherit attributes and methods from a parent class.

Defining a subclass:

class Operations(Math):
  def __init__(self, i, j):
    super().__init__(i, j)
    self.code = 'undefined'

  # define new method
  def set_code(self, code):
    self.code = code

  # define new method
  def calculate(self, code='add'):
    if code == 'add':
      return super().add()
    elif code == 'multiply':
      return super().multiply()
    else:
      return 'Unknown operation'

Creating an instance of the subclass:
```
operation = Operations(4, 9)
```

Accessing attributes of the subclass:

print(operation.i) # Output: 4
print(operation.j) # Output: 9
print(operation.code) # Output: undefined

Calling methods of the subclass:

# calling parent class method
print(operation.add()) # Output: 13

# calling subclass methods
print(operation.calculate()) # Output: 13
print(operation.calculate('multiply')) # Output: 36
print(operation.calculate('divide')) # Output: Unknown operation

Method overriding:

Subclasses can override methods from their parent class to provide specialized behavior.

Overriding methods from the parent class:

class SpecialMath(Math):
  def __init__(self, i, j, multiplier=10):
    super().__init__(i, j)
    self.multiplier = multiplier

  # override parent method
  def multiply(self):
    return self.i * self.j * self.multiplier

Calling override methods of an instance of a subclass:

specialMath = SpecialMath(4, 6)
print(specialMath.multiply()) # Output: 240

# custom multiplier
specialMath = SpecialMath(4, 6, 100)
print(specialMath.multiply()) # Output: 2400

Modules and imports

Creating a module:

Create a file class_module_1.py that contains the definition of two classes:

$ vi class_module_1.py

class MyClassA():
  def __init__(self):
    self.name = 'My Class A'

class MyClassB():
  def __init__(self):
    self.name = 'My Class B'

# Module-level function
def get_module_file_name():
  return "class_module_1.py"

Import entire module:

Create a file class_import_1.py that imports the module class_module_1 (class_module_1.py):

$ vi class_import_1.py

# all classes defined in the module will be accessible using the prefix class_module_1
import class_module_1

# referencing the classes using the name of the module name as a prefix
myclassa = class_module_1.MyClassA()
myclassb = class_module_1.MyClassB()

print(myclassa.name) # Output: My Class A
print(myclassb.name) # Output: My Class B

# calling module function
print(class_module_1.get_module_file_name()) # Output: class_module_1.py

Import specific classes:

Create a file class_import_2.py that imports specific classes defined in the module class_module_1 (class_module_1.py):

$ vi class_import_2.py

# importing the classes MyClassA and MyClassB from the module class_module_1
from class_module_1 import MyClassA, MyClassB

# referencing directly the classes without specifying the module name
myclassa = MyClassA()
myclassb = MyClassB()

print(myclassa.name) # Output: My Class A
print(myclassb.name) # Output: My Class B

Import all:

Create a file class_import_3.py that imports all classes defined in the module class_module_1 (class_module_1.py):

$ vi class_import_3.py

# importing all public names from the module class_module_1
from class_module_1 import *

# referencing directly the classes without specifying the module name
myclassa = MyClassA()
myclassb = MyClassB()

print(myclassa.name) # Output: My Class A
print(myclassb.name) # Output: My Class B

# calling module function without prefix
print(get_module_file_name()) # Output: class_module_1.py

Module aliases

Using the keyword as to define an alias for a module.
Create a file class_import_4.py that imports the module class_module_1 (class_module_1.py) and give it an alias f1:

$ vi class_import_4.py

# defining the alias f1 for the module class_module_1
import class_module_1 as f1

# referencing the class MyClassA using the alias of the module as a prefix
myclassa = f1.MyClassA()
myclassb = f1.MyClassB()

print(myclassa.name) # Output: My Class A
print(myclassb.name) # Output: My Class B

# calling module function using prefix
print(f1.get_module_file_name()) # Output: class_module_1.py

Class aliases:

Using the keyword as to define an alias for a class.
Create a file class_import_5.py that imports specific classes defined in the module class_module_1 (class_module_1.py) and give them aliases:

$ vi class_import_5.py

# defining the alias A for the class MyClassA and the alias B for the class MyClassB
from class_module_1 import MyClassA as A, MyClassB as B

# referencing directly the classes using its alias A
myclassa = A()
myclassb = B()

print(myclassa.name) # Output: My Class A
print(myclassb.name) # Output: My Class B