Principles of Object Oriented Programming for Data Developers

Programming Paradigms

Programming paradigms are a way to classify programming languages based on their features. Languages can be classified into multiple paradigms.

• Imperative in which the programmer instructs the machine on how to change its state.

• Declarative in which the programmer merely declares properties of the desired result, but not how to compute it.

hello = [1, 2, 3, 4]
result = 0
for element in hello:
	result += element

sum(hello)

Wait a minute... So what paradigm is Python?

Object Oriented Programming Basics

Object-oriented programming(OOP) is a programming paradigm based on the concept of "objects", which can contain data and code. - Wikipedia

• Classes: define the template of the objects. The classes can contain the methods and the attributes.

• Methods: are the function that belongs to a class. They usually have the object attributes available to update data or retrieve data. They basically perform the business logic of your implementation

• Attributes: are the data contained in an object.

• Instances: are the materialization of the classes.

# A class for a car
class Car:
  # Init method creates new instances
  def __init__(self, model, horse_power):
		self.horse_power = horse_power
		self.model = model
  
  # Bussiness logic method
  def transport(self, point_x1, point_x2):
		print(f"Moving from point {point_x1} to {point_x2}")

my_car = Car('ferrari', 1000)
my_car.horse_power  # instance attrbute
my_car.transport(10, 20)  # calling method

• We don’t have Car objects, so we don’t Carhave attributes. The specific data for a car will need to live separately in different data structures.

• The transport method will not have access to the car data, so we need to pass that data as a parameter, and passing the car data is complex because is not encapsulated into an object...

OOP Basic Principles: Encapsulation, Inheritance, Polymorphism

Encapsulation

Inheritance

class Car:
  def __init__(self, model, horse_power, wheels=4):
		...
  
  def transport(self, point_x1, point_x2):
		print(f"Moving from point {point_x1} to {point_x2} with a car")

class Truck:
  def __init__(self, model, horse_power, wheels=16):
		...
  
  def transport(self, point_x1, point_x2):
		print(f"Moving from point {point_x1} to {point_x2} with a Truck")

class Bicycle:
  def __init__(self, model, wheels=2):
		...
  
  def transport(self, point_x1, point_x2):
		print(f"Moving from point {point_x1} to {point_x2} with a bicycle")

....

class Vehicle:
    def __init__(self, model, wheels):
        self.model = model
        self.wheels = wheels

    def transport(self, point_x1, point_x2):
        raise NotImplementedError


class Car(Vehicle):
    def __init__(self, model, wheels, horse_power):
        super().__init__(model, wheels)
        self.horse_power = horse_power

    def transport(self, point_x1, point_x2):
        print(f"Moving from point {point_x1} to {point_x2} by car")

# We can do the same for all vehicles.

my_car = Car('ferrari', horse_power=1000, wheels=4)
my_car.model  # Model attribute is correctly setup by the parent
my_car.transport(10, 20)  # calling method with the Car implementation

• With the notation class Car(Vehicle): we told python that this class inherits from Vehicle

• The super() method allows us to call methods from the parent class. In this simple example, we only use it to call the parent __init__ so we can set up the same attributes as the parent, but we can use it for any method.

• The transport method is overwritten in the child class with the proper logic for its implementation

Polymorphism

from typing import List

class Vehicle:
    def __init__(self, model):
        ...
    def transport(self, point_x1, point_x2):
        raise NotImplementedError

# Assume for brevity that we implement these classes
class Car(Vehicle):
    ...

class Truck(Vehicle):
    ...

class Bicycle(Vehicle):
    ...

# Let's use type hints
vehicle_list: List[Vehicle] = [
    Car('ferrari'),
    Truck('ford'),
    Bicycle('bh'),
]

for v in vehcle_list:
    v.transport(10, 20)

class MotorBike(Vehicle):
    ...

vehicle_list: List[Vehicle] = [
    Car('ferrari'),
    Truck('ford'),
    Bicyle('bh'),
    MotorBike('yamaha'),
]

for v in vehcle_list:
    v.transport(10, 20)

Final Thoughts