Solutions Encaptiolation exercises

Ex 1: Car object

# car.py (solution)

# 1. Car object
# Create a Car class. 
# When instanciated the object should be able to take 4 attributes (Make, Model, bhp, mph).
# They all 4 should be properties.

db = {
    "Audi": {"A3", "A4", "A6", "Q5", "Q7"},
    "BMW": {"3 Series", "5 Series", "7 Series", "X3", "X5"},
    "Mercedes-Benz": {"C-Class", "E-Class", "S-Class", "GLC", "GLE"},
    "Volkswagen": {"Golf", "Passat", "Polo", "Tiguan", "Arteon"},
    "Volvo": {"S60", "S90", "V60", "XC60", "XC90"},
    "Toyota": {"Corolla", "Camry", "RAV4", "Prius", "Hilux"},
    "Honda": {"Civic", "Accord", "CR-V", "Fit", "HR-V"},
    "Ford": {"Focus", "Fiesta", "Mustang", "Escape", "Explorer"},
    "Nissan": {"Altima", "Rogue", "Sentra", "Maxima", "Murano"},
    "Mazda": {"Mazda3", "Mazda6", "CX-5", "CX-9", "MX-5"}
}


class Car:
    def __init__(self, make, model, bhp, mph):
        self.make = make
        self.model = model
        self.bhp = bhp
        self.mph = mph

    # make
    @property 
    def make(self):
        return self._make
    
    @make.setter
    def make(self, make):
        if make not in db.keys():
            raise ValueError('Make is not in valid list')
        self._make = make

    # model
    @property 
    def model(self):
        return self._model
    
    @model.setter
    def model(self, model):
        if model not in db[self.make]: 
            raise ValueError(f'No model named {model} belongs to {self.make}')
        self._model = model
    
    # bhp
    @property 
    def bhp(self):
        return self._bhp
    
    @bhp.setter
    def bhp(self, bhp):
        if bhp < 0:
            raise ValueError('bhp can not be negative')
        self._bhp = bhp

    # mph
    @property 
    def mph(self):
        return self._mph
    
    @mph.setter
    def mph(self, mph):
        if mph < 0:
            raise ValueError('mph can not be negative')
        self._mph = mph

Ex 2: Bank

"""
2. Bank 
In the exercise from last monday with the bank, account and customer, change the code to use properties instead of the public variables.  
The bank class should futher be change into not taking any accounts as parameters at initialization. The accouts should be added afterwards, eithers as a single account one at a time, or as a collection of accounts (many at the sametime).      
Somewhere you should change the code so that a customer only can create one account.     
The Customer class should make sure that the customer is over 18 year of age.

"""

class Bank:    
    def __init__(self):
        self._accounts = []  # When bank is initialized it has  the abillity to hold many accounts
    
    @property
    def accounts(self):
        return self._accounts

    @accounts.setter
    def accounts(self, acc):
        if type(acc) in [list, tuple, set]:
            for i in acc:
                self._has_account(i)
                self._accounts.append(i)
        else:
            self._has_account(acc)
            self._accounts.append(acc)

    def _has_account(self, acc):
        for i in self._accounts:
            if acc.cust.name == i.cust.name:
                raise ValueError('Customer aleready has an account!')
        return False
    
    def __repr__(self):
        return str(self.__dict__)

class Account:
    def __init__(self, no, cust):
        self.no = no
        self.cust = cust

    def __repr__(self):
        return str(self.__dict__)


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

    @property
    def age(self):
        return self._age

    @age.setter
    def age(self, age):
        if age < 18:
            raise ValueError('You must be 18 or above to create an account')
        
        self._age = age     # create a variable with the name _age

    def __repr__(self):
        return str(self.__dict__)

Ex 3: Machine -> printer

# printer.py (solution)

"""
    3. Machine -> printer
    Create a Machine class that takes care of powering on and off a the machine.   
    Create a printer class that is a subclass of the Machine super class.   
    The printer should be able to print to console.  
    The printer should have a papertray, which should be in its own class. The papertray class should keep track of the paper, it should have the abillity to use paper and and load new paper in the tray if empty.  
"""

class Machine:
    """ takes care of turning on and off  """

    def __init__(self):
        self._is_on = False  # one _ = protected (to be used only in subclasses) 
    
    def power(self):
        self._is_on = not self._is_on

class Printer(Machine):
    def __init__(self):
        Machine.__init__(self)
        self._pt = Papertray()

    def print(self, text):
        if self._pt.paper == 0:
            print('Papertray is empty')
        else:
            if self._is_on:
                print(text)
                self._pt.paper = self._pt.paper - 1
            else:
                print('Printer is off')

    @property
    def load(self):
        return self._pt.paper

    @load.setter
    def load(self, no):
        self._pt.paper = no

class Papertray:
    def __init__(self):
        self.paper = 2

    @property
    def paper(self):
        return self._paper

    @paper.setter
    def paper(self, paper):
        self._paper = paper

Ex 4: Rectangle

# Your code should include:
# A class called Rectangle
# width and height attributes with property decorators
# A get_area method that calculates the area of the rectangle
# Appropriate error handling for non-positive width and height values

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    @property
    def width(self):
        return self._width
    
    @width.setter
    def width(self, width):
        if width < 0:
            raise ValueError('Witdh can not be negative')
        self._width = width
    
    @property
    def height(self):
        return self._height
    
    @height.setter
    def height(self, height):
        if height < 0:
            raise ValueError('Height can not be negative')
        self._height = height

    @property
    def area(self):
        return (self.height + self.width)**2

Ex 5: Color converter

class Color:
    def __init__(self, r, g, b):
            self.r = r
            self.g = g
            self.b = b

    @property
    def hex(self):
        return f'#{hex(self.r)[2:]}{hex(self.g)[2:]}{hex(self.b)[2:]}'