OOP-Methods.py

########## OOP - METHODS ##########   

# we know now that methods are functions embedded into classes
# the method must have at least a parameter and if only one, it should be "self"


### SELF

# The keyword "self" is used to indicate that this variable is created coherently and individually for the instance to make it independent 
# from other instances of the same class

class Demo:
    def __init__(self, value):
        self.instance_var = value
d1 = Demo(100)
d2 = Demo(200)
print("d1's instance variable is equal to:", d1.instance_var)
# 100
print("d2's instance variable is equal to:", d2.instance_var)
# 200
# ==> we instantiate the class twice, each time passing a different value to be stored inside the object
#     the print instructions prove the fact that instance variable values are kept independently because the printed values differ

class Example:
    def __init__(self, value):
        self.__internal = value

    def get_internal(self):
        return self.__internal

example1 = Example(10)
example2 = Example(99)
print(example1.get_internal())
# 10
print(example2.get_internal())
# 99


# self parameter is used to obtain access to the object's instance and class variables
class Classy:
    varia = 2
    def method(self):
        print(self.varia, self.var)
 
obj = Classy()
obj.var = 3
obj.method()
# 2 3


# 2 ways for print

# ==> with return, clean and the best for clarity

class Storage:
    def __init__(self):
        self.rack = 1

    def get(self):
        return self.rack

    def prin(self):
        return(self.get())    # via self.attribute 

stuff = Storage()
print(stuff.prin())  
# 1

class Storage:
    def __init__(self):
        self.rack = 1

    def get(self):
        return self.rack

    def prin(self):
        return(Storage.get(self))  # via Class.attribute(self)

stuff = Storage()
print(stuff.prin())  
# 1

# ==> with print, a bit weirdy, to avoid but good to understandthe mechanism

class Storage:
    def __init__(self):
        self.rack = 1

    def get(self):
        return self.rack

    def prin(self):
        print(self.get())     # via self.attribute

stuff = Storage()
print(stuff.prin())  
# 1
# None ==> print None as not any defined action to be returned

class Storage:
    def __init__(self):
        self.rack = 1

    def get(self):
        return self.rack

    def prin(self):
        print(Storage.get(self))    # via Class.attribute(self) 

stuff = Storage()
print(stuff.prin())  
# 1
# None ==> print None as not any defined action to be returned


# a method wich calls an other method in the same class

class Classy:
    def other(self):
        print("other")
 
    def method(self):
        print("method")
        self.other()
 
obj = Classy() # links the "obj" object to the Classy() class
obj.method()
# method
# other



## 1*parameter, self

class Classy:
    def method(self):
        print("method")

obj = Classy()
obj.method()
# method



## 2*parameters, self & par
class Classy:
    def method(self, par):
        print("method:", par)
 
obj = Classy()
obj.method(1)
obj.method(2)
obj.method(3)
# method: 1
# method: 2
# method: 3



### __INIT__ 

# = constructor

# If a class has a constructor, it is invoked automatically and implicitly when the object of the class is instantiated

# constructor:
#   MUST have the self parameter (it's set automatically, as usual)
#   MAY have more parameters than just self; if this happens, the way in which the class name
#       is used to create the object must reflect the __init__ definition;
#   CAN be used to set up the object, i.e., properly initialize its internal state, create 
#       instance variables, instantiate any other objects if their existence is needed, etc.
#   CAN raise an Exception
#   CANNOT return a result


## __init__ avec 1*parameter en + de self
class Classy:
    def __init__(self, value):
        self.var = value

obj_1 = Classy("object") # 1*parameter mandatory 
print(obj_1.var)
# object


## __init__ avec 1*parameter (with default value)  + self
class Classy:
    def __init__(self, value = None):
        self.var = value

obj_1 = Classy("object")
obj_2 = Classy()
print(obj_1.var)
# object
print(obj_2.var)
# None



### STATIC & CLASS methods

# These alternative types of method should be understood as tool methods, extending our ability to use classes,
# and not necessarily requiring the creation of class instances to use them



### CLASS methods

# use cases:
#    control access to class variables
#    control access to a class variable containing information about the number of created instances or the serial number given to the last produced object
#    modify the state of the class variables
#    create a class instance in an alternative way, so the class method can be implemented by an alternative constructor.
#    etc

# to distinguish a class method from an instance method, we signal it with the @classmethod decorator preceding the class method definition

class Example:
    __internal_counter = 0

    def __init__(self, value):
        Example.__internal_counter +=1

    @classmethod
    def get_internal(cls):
        return '# of objects created: {}'.format(cls.__internal_counter)

print(Example.get_internal()) # __init__ is not invoked 
# of objects created: 0

example1 = Example(10) # instance creation => class variable impacted by __init__
print(Example.get_internal()) 
# of objects created: 1

example2 = Example(99) # instance creation => class variable impacted by __init__
print(Example.get_internal())
# of objects created: 2


## Class methods & Class __init__ interaction

class Car:
    def __init__(self, vin):    # __init__, self + 1*argument
        print('Ordinary __init__ was called for', vin)
        self.vin = vin
        self.brand = "Renault"
        self.logo = "*"

    @classmethod
    def including_brand(cls, vin2, brand2, logo2):  # as "self" for instance, "cls" is a convention, is for the Class and is tagged: (parameter) cls: type[Self@Car]
        print('Class method was called')
        car = cls(vin2) # invokes __init__ => self.vin = vin2
        car.brand = brand2 # invokes __init__ => self.brand = brand
#        car.logo = logo2
        return car

# classic class instance:

#car1 = Car('ABCD1234')   # car1 instance created, __init__ invoked, car1.vin & car1.brand created ==> "ABCD1234" & ""
# Ordinary __init__ was called for ABCD1234
#print(car1.__dict__)
# {'vin': 'ABCD1234', 'brand': 'Renault', 'logo': '*'} => all attributes come from __init__ 
#print(car1.vin, car1.brand)
# ABCD1234 Renault



# class method

#   number of args in instance call = nuber of class method args 
#car2 = Car.including_brand('DEF567', 'NewBrand', "<>")  # car2 instance created using class method
# Class method was called
# Ordinary __init__ was called for DEF567
#print(car2.__dict__)
# {'vin': 'DEF567', 'brand': 'NewBrand', 'logo': '<>'}
#print(car2.vin, car2.brand)
# DEF567 NewBrand

#   number of args in instance call > number of class method args WITH # self.logo = "*"
#car3 = Car.including_brand('GHI8910', 'Tesla', "_-|-_")  # car3 instance created using class method
# Class method was called
# Ordinary __init__ was called for GHI8910
#print(car3.__dict__)
# {'vin': 'GHI8910', 'brand': 'Tesla', 'logo': '_-|-_'} # logo arg is created thru the class method
#print(car3.vin, car3.brand, car3.logo)
# GHI8910 Tesla _-|-_

#   number of args in instance call < number of class method args WITH # car.logo = logo2
car4 = Car.including_brand('JKL111213', 'Porsche', "£")  # car4 instance created using class method
# Class method was called
# Ordinary __init__ was called for JKL111213
print(car4.__dict__)
# {'vin': 'JKL111213', 'brand': 'Porsche', 'logo': '*'} # logo arg is taken from __init__, like a default 
print(car4.vin, car4.brand, car4.logo)
# JKL111213 Porsche *



### STATIC methods

# Static methods are methods that do not require (and do not expect!) a parameter indicating the class object 
# or the class itself in order to execute their code

# EX: a class that provides methods to operate on bank accounts including a method that validates 
# the correctness of the account number recorded in accordance with the IBAN standard


class Bank_Account:
    def __init__(self, iban):
        print('__init__ called')
        self.iban = iban
            
    @staticmethod
    def validate(iban):
        if len(iban) == 20:
            return True
        else:
            return False


account_numbers = ['8' * 20, '7' * 4, '2222'] # "8"*20 is an element, etc

for element in account_numbers:
    if Bank_Account.validate(element): # implicit == True
        print('We can use', element, ' to create a bank account')
    else:
        print('The account number', element, 'is invalid')
# We can use 88888888888888888888  to create a bank account
# The account number 7777 is invalid
# The account number 2222 is invalid



### STATIC vs CLASS methods

# a class method requires 'cls' as the first parameter and a static method does not
# a class method has the ability to access the state or methods of the class, and a static method does not
# a class method is decorated by '@classmethod' and a static method by '@staticmethod'
# a class method can be used as an alternative way to create objects, and a static method is only a utility method



### ABSTRACT class

# An abstract class should be a kind of contract between a class designer and a programmer
#   - the class designer sets requirements regarding methods that must be implemented by just declaring them, but not defining them in detail == abstract methods
#   - The programmer has to deliver all method definitions and the completeness would be validated by another, dedicated module
#     Method definitions by verride method declarations received from the class designer
# This contract assures you that a child class, built upon your abstract class, will be equipped with a set of concrete methods imposed by the abstract class

# Example of Polymorphism with classes
class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width
    
    def area(self):  # method "area"
        return self.length * self.width

class Circle:
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14159 * self.radius ** 2

# one function for all types
def print_area(form):
    print(f"The area is: {form.area()}")

rectangle = Rectangle(5, 3)
circle = Circle(4)

print_area(rectangle)
# The area is: 15
print_area(circle)
# The area is: 50.26544


# We cannot instantiate a class containing an abstract method (abstract class)
import abc

class BluePrint(abc.ABC):
    @abc.abstractmethod  # ==> this is an abstract class so you can create instance from it
    def hello(self):
        pass

class GreenField(BluePrint):
    def hello(self):
        print('Welcome to Green Field!')

gf = GreenField()
gf.hello()
# Welcome to Green Field!
bp = BluePrint()
# TypeError: Can't instantiate abstract class BluePrint with abstract methods hello


# We cannot use a child class which does not include the abstract method(s)
import abc

class BluePrint(abc.ABC):
    @abc.abstractmethod
    def hello(self):
        pass

class GreenField(BluePrint):
    def hello(self):
        print('Welcome to Green Field!')

class RedField(BluePrint):  # there is not any hello
    def yellow(self): 
        pass

gf = GreenField()
gf.hello()
# Welcome to Green Field!
rf = RedField()
# TypeError: Can't instantiate abstract class RedField without an implementation for abstract method 'hello'


# we can have methods not defined in the abstract class, offered in child classes, it's ok
import abc

class BluePrint(abc.ABC):
    @abc.abstractmethod
    def hello(self):  # we MUST have a "hello" method defined in child classes
        pass

class GreenField(BluePrint):
    def hello(self):
        print('Welcome to Green Field!')

class RedField(BluePrint):
    def yellow(self):  # not defined in abstract class, it works fine
        print('The sun is yellow')
    def hello(self):
        print('Welcome to Red Field!')

gf = GreenField()
gf.hello()
# Welcome to Green Field!
rf = RedField()
rf.hello()
# Welcome to Red Field!
rf.yellow()
# The sun is yellow



### ENCAPSULATION

# Encapsulation is used to hide the attributes inside a class like in a capsule, preventing unauthorized parties' direct access to them

# Concept :
#   the code calling the proxy methods might not realize if it is "talking" to the real attributes or to the methods controlling access to the attributes
#   programmer can still get access to attributes intentionally as Python does not deliver true privacy !

# Python allows access to attributes with the built-in property() function and corresponding decorator @property:
#   - it designates a method which will be called automatically when another object wants to read the encapsulated attribute value
#   - the name of the designated method will be used as the name of the instance attribute corresponding to the encapsulated attribute
#   - it should be defined before the method responsible for setting/deleting the value of the encapsulated attribute

# getter method is decorated with '@property' => It designates the name of the attribute to be used by the external code
# setter method is decorated with '@name.setter' => The method name should be the attribute name
# deleter method is decorated with '@name.deleter' => The method name should should be the attribute name

# usecase of a water tank

class TankError(Exception): # error captation
    pass

class Tank:
    def __init__(self, capacity):
        self.capacity = capacity
        self.__level = 0  

    @property  # == getter
    def level(self):
        return self.__level   

    @level.setter  # == setter
    def level(self, amount):
        if amount > 0:
            # fueling
            if amount <= self.capacity:
                self.__level = amount  
            else:
                raise TankError('Too much liquid in the tank')
        elif amount < 0:
            raise TankError('Not possible to set negative liquid level')

    @level.deleter  # == deleter
    def level(self):
        if self.__level > 0: 
            print('It is good to remember to sanitize the remains from the tank!')
        self.__level = None    


our_tank = Tank(20)  # invokes Tank() __init__ ==> self.capacity = 20 + self.__level = 0 pour l'instance our_tank

our_tank.level = 10  # invokes the setter
print('Current liquid level:', our_tank.level)  # invokes the getter
# Current liquid level: 10

our_tank.level += 3  # invokes the setter
print('Current liquid level:', our_tank.level)  # invokes the getter
# Current liquid level: 13

try:
    our_tank.level = 21   # invokes the setter ==> above the tank capacity (==20)
except TankError as e:
    print('Trying to set liquid level to 21 units, result:', e)
# Trying to set liquid level to 21 units, result: Too much liquid in the tank

try:
    our_tank.level += 15   # invokes the setter ==> would be above the tank capacity as current is 13 => 13+15 > 20
except TankError as e:
    print('Trying to add an additional 15 units, result:', e)
# Trying to add an additional 15 units, result: Too much liquid in the tank

try:
    our_tank.level = -3    # invokes the setter ==> would be under 0, which is not possible here
except TankError as e:
    print('Trying to set liquid level to -3 units, result:', e)
# Trying to set liquid level to -3 units, result: Not possible to set negative liquid level

print('Current liquid level:', our_tank.level)
# Current liquid level: 13    # invokes the getter

del our_tank.level   # invokes the deleter