Python_OOP-Four_Pillars_of_OOP_in_ Python_3_for_Beginners.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python OOP: Four Pillars of OOP\n",
    "<hr />\n",
    "\n",
    "### EXERCISE - CLASSES AND OBJECTS\n",
    "Write and object oriented program that performs the following\n",
    "tasks:\n",
    "    1. Define a class called \"Employee\" and create an instance of that class\n",
    "    2. Create an attribute called name and assign it with a value\n",
    "    3. Change the name you previously defined within a method and call this method by making use of the object you created"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:    \n",
    "    name = \"Ben\"\n",
    "    \n",
    "    def changeName(self, str):        \n",
    "        self.name = str\n",
    "        return(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ben'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "employee = Employee()\n",
    "employee.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'John'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "newName = 'John'\n",
    "employee.changeName(newName)\n",
    "employee.name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EXERCISE - ATTRIBUTES AND METHODS\n",
    "Write an object oriented program to create a precious stone.\n",
    "Not more than 5 precious stones can be held in possession at a\n",
    "given point of time. If there are more than 5 precious stones,\n",
    "delete the first stone and store the new one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the name of precious stone, Print to list all stones or Exit to close\n",
      "\n",
      "Esmerald\n",
      "Object Esmerald seted\n",
      "Object Esmerald geted\n",
      "onix\n",
      "Object Onix seted\n",
      "Object Onix geted\n",
      "amber\n",
      "Object Amber seted\n",
      "Object Amber geted\n",
      "ruby\n",
      "Object Ruby seted\n",
      "Object Ruby geted\n",
      "sapphire\n",
      "Object Sapphire seted\n",
      "Object Sapphire geted\n",
      "amethyst\n",
      "Object Amethyst seted\n",
      "Object Amethyst geted\n",
      "Object Esmerald seted\n",
      "Object Esmerald deleted\n",
      "{'name': 'Onix'}\n",
      "{'name': 'Amber'}\n",
      "{'name': 'Ruby'}\n",
      "{'name': 'Sapphire'}\n",
      "{'name': 'Amethyst'}\n",
      "diamond\n",
      "Object Diamond seted\n",
      "Object Diamond geted\n",
      "Object Onix seted\n",
      "Object Onix deleted\n",
      "{'name': 'Amber'}\n",
      "{'name': 'Ruby'}\n",
      "{'name': 'Sapphire'}\n",
      "{'name': 'Amethyst'}\n",
      "{'name': 'Diamond'}\n",
      "exit\n"
     ]
    }
   ],
   "source": [
    "class Stone(object):\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    \n",
    "    def __get__(self, instance, owner):\n",
    "        print('Object {} geted'.format(self.name))\n",
    "        return(self.name)\n",
    "    \n",
    "    def __set__(self, instance, name):\n",
    "        self.name = name\n",
    "        print('Object {} seted'.format(self.name))\n",
    "        \n",
    "    def __delete__(self, instance):\n",
    "        print('Object {} deleted'.format(self.name))\n",
    "        del self.name\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return(self.name)\n",
    "\n",
    "class Foo(object):\n",
    "    listStones = []\n",
    "    keyWords = ['Exit', 'Print']\n",
    "    objStone = Stone('')\n",
    "        \n",
    "    @staticmethod\n",
    "    def instructionsStone():        \n",
    "        print(\"Enter the name of precious stone, {} to list all stones or {} to close\\n\".format(Foo.keyWords[1][0], Foo.keyWords[0][0]))\n",
    "        \n",
    "    @staticmethod\n",
    "    def listCollection(list):\n",
    "        for obj in list:\n",
    "            print(dict(Stone(obj).__dict__))\n",
    "    \n",
    "    @staticmethod\n",
    "    def runProgram():\n",
    "        inp = ''\n",
    "        f.instructionsStone()\n",
    "        \n",
    "        while inp is f.keyWords[0]:\n",
    "            inp = input().title()\n",
    "            \n",
    "            if inp not in list(f.listStones):\n",
    "                if inp is f.keyWords[1]:\n",
    "                    f.listCollection(f.listStones)\n",
    "\n",
    "                elif inp not in list(f.keyWords[0]):\n",
    "                    f.objStone = inp\n",
    "                    f.listStones.append(f.objStone)\n",
    "\n",
    "                    if len(f.listStones) > 5:\n",
    "                        f.objStone = getattr(Stone(f.listStones[0]), 'name')\n",
    "                        del f.objStone\n",
    "                        f.listStones.remove(f.listStones[0])\n",
    "                        f.listCollection(f.listStones)\n",
    "            else:\n",
    "                print('The precious stone {}\\'s already instanced.'.format(inp))\n",
    "    \n",
    "f = Foo()\n",
    "f.runProgram()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EXERCISE - ABSTRACTION AND ENCAPSULATION\n",
    "Similar to a library management system, write a program to\n",
    "provide layers of abstraction for a car rental system.\n",
    "Your program should perform the following:\n",
    "    1. Hatchback, Sedan, SUV should be type of cars that are being provided for rent\n",
    "    2. Cost per day:\n",
    "        Hatchback - $30\n",
    "        Sedan - $50\n",
    "             SUV - $100\n",
    "    3. Give a prompt to the customer asking him the type of car and the number of days he would like to borrow and provide the fare details to the user."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hatchback = 30 seted\n",
      "Hatchback = 30 geted\n",
      "Hatchback = 30 geted\n",
      "Sedan = 50 seted\n",
      "Sedan = 50 geted\n",
      "Sedan = 50 geted\n",
      "SUV = 100 seted\n",
      "SUV = 100 geted\n",
      "SUV = 100 geted\n",
      "Enter 1 to check details, 2 to rent a car or 3 to exit\n",
      "1\n",
      "Cost per day: \n",
      "Hatchback = $30\n",
      "Sedan = $50\n",
      "SUV = $100\n",
      "Enter 1 to check details, 2 to rent a car or 3 to exit\n",
      "2\n",
      "Enter 1 to choose Hatchback to rent:\n",
      "Enter 2 to choose Sedan to rent:\n",
      "Enter 3 to choose SUV to rent:\n",
      "2\n",
      "Enter for how many days you'll rent the car:\n",
      "3\n",
      "The total for 3 days rental of the Sedan is $150.00\n"
     ]
    }
   ],
   "source": [
    "class Car(object):    \n",
    "    def __init__(self, style, value):\n",
    "        self.style = style\n",
    "        self.value = value    \n",
    "    \n",
    "    def __get__(self, instance, owner):\n",
    "        print('{} = {} geted'.format(self.value[0], self.value[1]))\n",
    "        return(self.style, self.value)\n",
    "    \n",
    "    def __set__(self, style, value):\n",
    "        self.style = style\n",
    "        self.value = value\n",
    "        print('{} = {} seted'.format(self.value[0], self.value[1]))\n",
    "    \n",
    "    def __delete__(self, style, value):\n",
    "        self.style = style\n",
    "        self.value = value\n",
    "    \n",
    "class Rental(object):    \n",
    "    def setCars(self, dictCars):\n",
    "        self.cars = dictCars\n",
    "            \n",
    "    def getCars(self):\n",
    "        return(self.cars)\n",
    "        \n",
    "    def displayDetails(self):\n",
    "        print('Cost per day: ')\n",
    "        for i, car in enumerate(self.cars):\n",
    "            print('{} = ${}'.format(car, self.cars[car]))\n",
    "            \n",
    "    def calculatesPrice(self, request, days):\n",
    "        total = self.cars[request] * days\n",
    "        return('The total for {} days rental of the {} is ${}'.format(int(days), request, \"%.2f\"%total))\n",
    "\n",
    "    \n",
    "class Customer(object):    \n",
    "    def requestCar(self, dict):            \n",
    "        try:        \n",
    "            for i, item in enumerate(dict):\n",
    "                print('Enter {} to choose {} to rent:'.format(i+1, item))\n",
    "\n",
    "            self.style = int(input())\n",
    "            return(list(dict.keys())[self.style-1])\n",
    "            \n",
    "        except ValueError:\n",
    "            print('Please, enter a valid number!')\n",
    "            \n",
    "        except IndexError:\n",
    "            print('Please, enter a number in the options!')\n",
    "    \n",
    "    def numberDays(self):        \n",
    "        try:\n",
    "            print('Enter for how many days you\\'ll rent the car:')\n",
    "            self.days = float(input())\n",
    "            return(self.days)\n",
    "            \n",
    "        except:\n",
    "            print('Please, enter a valid number!')\n",
    "        \n",
    "class Foo(object):\n",
    "    car = Car('','')\n",
    "    @staticmethod\n",
    "    def optionsRental():\n",
    "        try:\n",
    "            print('Enter 1 to check details, 2 to rent a car or 3 to exit')\n",
    "            option = int(input())\n",
    "            return(option)\n",
    "        except:\n",
    "            print('Please, enter a valid number!')\n",
    "            \n",
    "    @staticmethod\n",
    "    def runProgram():\n",
    "        test = dict({'Hatchback':30, 'Sedan':50, 'SUV':100})\n",
    "        rentCar = Rental()\n",
    "        dictCars = {}\n",
    "        customer = Customer()\n",
    "\n",
    "        for i, item in enumerate(test):\n",
    "            f.car = (item, test[item])\n",
    "            dictCars[f.car[1][0]] = f.car[1][1]\n",
    "            rentCar.setCars(dictCars)\n",
    "            #print(dictCars)\n",
    "\n",
    "        while True:\n",
    "            option = f.optionsRental()\n",
    "\n",
    "            if option is 1:\n",
    "                rentCar.displayDetails()\n",
    "\n",
    "            elif option is 2:\n",
    "                request = customer.requestCar(rentCar.getCars())\n",
    "                \n",
    "                if request in list(rentCar.getCars()):\n",
    "                    days = customer.numberDays()\n",
    "                    print(rentCar.calculatesPrice(request, days))\n",
    "                    break\n",
    "                    \n",
    "            elif option is 3:\n",
    "                break\n",
    "\n",
    "f = Foo()\n",
    "f.runProgram()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EXERCISE - INHERITANCE\n",
    "Write an object oriented program that performs the following tasks:\n",
    "    1. Create a class called Chair from the base class Furniture\n",
    "    2. Teakwood should be the type of furniture that is used by all furnitures by default\n",
    "    3. The user can be given an option to change the type of wood used for chair if he wishes to\n",
    "    4. The number of legs of a chair should be a property that should not be altered outside the class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Choose the wood type for your chair:\n",
      "Enter 0 for choose the Walnut\n",
      "Enter 1 for choose the Maple\n",
      "Enter 2 for choose the Mahogany\n",
      "Enter 3 for choose the Birch\n",
      "Enter 4 for choose the Oak\n",
      "Enter 5 for choose the Cherry\n",
      "Enter 6 for choose the Bamboo\n",
      "Enter 7 for choose the Pine\n",
      "1\n",
      "The chair will be made with Maple and 4 legs\n"
     ]
    }
   ],
   "source": [
    "class Furniture(object):\n",
    "    _woodType = 'Teakwood'\n",
    "    __amountLegs = 4\n",
    "\n",
    "class Chair(Furniture):\n",
    "    def __init__(self):\n",
    "        self._woodType = self._woodType\n",
    "    \n",
    "class User(object):\n",
    "    def userChoice(self):\n",
    "        woodOptions = ['Walnut','Maple','Mahogany','Birch','Oak','Cherry','Bamboo','Pine']\n",
    "        \n",
    "        for i, wood in enumerate(woodOptions):\n",
    "            print('Enter {} for choose the {}'.format(i, wood))\n",
    "            \n",
    "        while True:        \n",
    "            try:\n",
    "                choice = int(input())\n",
    "                return(woodOptions[choice])\n",
    "            except ValueError:\n",
    "                print('Please, enter a number valid number!')\n",
    "                \n",
    "            except:\n",
    "                print('Please, enter a number in the list!')\n",
    "        \n",
    "class Foo(object):\n",
    "    chair = Chair()\n",
    "    \n",
    "    @staticmethod\n",
    "    def runProgram():\n",
    "        user = User()\n",
    "        print('Choose the wood type for your chair:')\n",
    "        chosenWood = user.userChoice()\n",
    "        \n",
    "        if chosenWood is not None:\n",
    "            f.chair._woodType = chosenWood\n",
    "            print('The chair will be made with {} and {} legs'.format(f.chair._woodType, f.chair._Furniture__amountLegs))\n",
    "\n",
    "f = Foo()\n",
    "f.runProgram()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### EXERCISE - POLYMORPHISM\n",
    "Create a class called Square and perform the following tasks:\n",
    "\n",
    "    (i) Create two objects for this class squareOne and squareTwo\n",
    "    (ii) Find the result of side of squareOne to the power of side of squareTwo\n",
    "\n",
    "Example: If squareOne has length of 2cm each side and squareTwo has a length of 4cm each side, squareOne ** squareTwo should return 16, which is 2 to the power of 4.\n",
    "\n",
    "Hint: While performing SquareOne ** SquareTwo, you need to\n",
    "overload __pow__() method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the number of the shape type you wish to see the details:\n",
      "Solve task = 0\n",
      "Square = 1\n",
      "Retangle = 2\n",
      "Quit = 3\n",
      "0\n",
      "Enter the Square's size\n",
      "2\n",
      "Square1 side's 2.0\n",
      "Enter the Square's size\n",
      "4\n",
      "Square2 side's 4.0\n",
      "The result of side of squareOne to the power of side of squareTwo is 16.0\n"
     ]
    }
   ],
   "source": [
    "from abc import ABCMeta, abstractmethod\n",
    "\n",
    "class Shape(metaclass = ABCMeta):\n",
    "    \n",
    "    def __init__(self, width, length):\n",
    "        self.width = width\n",
    "        self.length = length\n",
    "        \n",
    "    def __get__(self, instance, owner):\n",
    "        return(self.width, self.length)\n",
    "    \n",
    "    def __set__(self, width, length):\n",
    "        self.width = width\n",
    "        self.length = length        \n",
    "   \n",
    "    @abstractmethod\n",
    "    def area(self, width, length):\n",
    "        return(width * length)      \n",
    "   \n",
    "    @abstractmethod    \n",
    "    def perimeter(self, width, length):\n",
    "        return((width * 2) + (length * 2))\n",
    "    \n",
    "class Square(Shape):\n",
    "    \n",
    "    def area(self, side):\n",
    "        area = Shape.area(self, side, side)\n",
    "        return(area)\n",
    "    \n",
    "    def perimeter(self, side):\n",
    "        perimeter = Shape.perimeter(self, side, side)\n",
    "        return(perimeter)\n",
    "    \n",
    "    def expoSquare(self, side1, side2):\n",
    "        result = pow(side1, side2)\n",
    "        return(result)\n",
    "    \n",
    "class Retangle(Shape):\n",
    "    \n",
    "    def area(self, width, length):\n",
    "        area = Shape.area(self, width, length)\n",
    "        return(area)\n",
    "    \n",
    "    def perimeter(self, width, length):\n",
    "        perimeter = Shape.perimeter(self, width, length)\n",
    "        return(perimeter)\n",
    "\n",
    "class User(object):\n",
    "    optionList = {0:'Solve task',1:'Square',2:'Retangle',3:'Quit'}\n",
    "    \n",
    "    def options(self):\n",
    "        print('Enter the number of the shape type you wish to see the details:')\n",
    "        \n",
    "        while True:\n",
    "            optList = [print(f.options[s], s, sep=' = ') for i, s in enumerate(f.options)]\n",
    "            \n",
    "            try:\n",
    "                option = int(input())\n",
    "                if option in list(f.options):\n",
    "                    return(option, f.options[option])\n",
    "\n",
    "                else:\n",
    "                    print('Please, enter a number in list.')\n",
    "\n",
    "            except ValueError:\n",
    "                print('Please, enter a valid number!')        \n",
    "    \n",
    "    def getSides(self, str):\n",
    "        \n",
    "        while True:\n",
    "            try:\n",
    "                if str is f.options[1] or str is f.options[0]:\n",
    "                    print('Enter the {}\\'s size'.format(f.options[1]))\n",
    "                    side = float(input())\n",
    "                    if str is f.options[0]:\n",
    "                        return(side)\n",
    "                    \n",
    "                    f.square = side\n",
    "                    return(Square.area(f.square, side), Square.perimeter(f.square, side))\n",
    "\n",
    "                elif str is f.options[2]:\n",
    "                    print('Enter the {}\\'s width'.format(f.options[2]))\n",
    "                    width = float(input())\n",
    "                    \n",
    "                    print('Enter the {}\\'s length'.format(f.options[2]))\n",
    "                    length = float(input())\n",
    "                    \n",
    "                    f.retangle = (width, length)\n",
    "                    return(Retangle.area(f.retangle, width, length),Retangle.perimeter(f.retangle, width, length))\n",
    "\n",
    "            except ValueError:\n",
    "                print('Please, enter a valid number!')\n",
    "    \n",
    "class Foo(object):\n",
    "    square = Square('','')    \n",
    "    retangle = Retangle('','')\n",
    "    user = User()\n",
    "    options = user.optionList\n",
    "    \n",
    "    @staticmethod\n",
    "    def runProgram():\n",
    "        option, shape = f.user.options()\n",
    "        \n",
    "        if option is 0:\n",
    "            i = 0\n",
    "            dictSquares = {}\n",
    "            \n",
    "            while i < 2:\n",
    "                f.square = f.user.getSides(shape)                \n",
    "                objSquare = 'Square'+str(i+1)\n",
    "                dictSquares[objSquare] = f.square[1]\n",
    "                print('{} side\\'s {}'.format(objSquare, f.square[1]))\n",
    "                i+=1\n",
    "            \n",
    "            result = Square.expoSquare(f.square, dictSquares['Square1'], dictSquares['Square2'])\n",
    "            print('The result of side of squareOne to the power of side of squareTwo is {}'.format(result))\n",
    "            \n",
    "        elif option in range(1,3):\n",
    "            area, perimeter = f.user.getSides(shape)\n",
    "            print('The {}\\'s area is {} and the perimeter is {}'.format(shape, area, perimeter))\n",
    "            \n",
    "        else:\n",
    "            return\n",
    "    \n",
    "f = Foo()\n",
    "f.runProgram()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## PROBLEM STATEMENT\n",
    "### Simulate a Banking System\n",
    "\n",
    "    1-Give a prompt to the user asking if they wish to create a new Savings Account or access an existing one;\n",
    "    2-If the user would like to create a new account, accept their name and initial deposit, and create a 5 digit random number and make it as the account number of their new Savings Account;\n",
    "    3-If they are accessing an existing account, accept their name and account number to validate the user, and give them options to withdraw, deposit or display their avalable balance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'34149': ['Andre', 7.670000000000009]}, {'75153': ['Alex', 50.06]}, {'49798': ['Alexandre', 32.37]}, {'77298': ['Bruno', 570.26]}]\n",
      "Enter the number of the action you wish to do:\n",
      "0 to Create Account.\n",
      "1 to Access Account.\n",
      "2 to Close.\n",
      "0\n",
      "Please, enter your name: Fernando\n",
      "Account 50494 init with $0.0\n",
      "Enter the number of the action you wish to do:\n",
      "0 to Withdraw.\n",
      "1 to Deposit.\n",
      "2 to Balance.\n",
      "3 to Close.\n",
      "0\n",
      "Fernando, you don't have balance to whithdraw.\n",
      "Enter the number of the action you wish to do:\n",
      "0 to Withdraw.\n",
      "1 to Deposit.\n",
      "2 to Balance.\n",
      "3 to Close.\n",
      "1\n",
      "How much do you want to deposit?\n",
      "357,31\n",
      "Deposit successfully completed!\n",
      "Your balance's $357.31\n",
      "Enter the number of the action you wish to do:\n",
      "0 to Withdraw.\n",
      "1 to Deposit.\n",
      "2 to Balance.\n",
      "3 to Close.\n",
      "0\n",
      "How much do you want to withdraw?\n",
      "43,15\n",
      "Withdraw successfully completed!\n",
      "Your balance's $314.16\n",
      "Enter the number of the action you wish to do:\n",
      "0 to Withdraw.\n",
      "1 to Deposit.\n",
      "2 to Balance.\n",
      "3 to Close.\n",
      "2\n",
      "Fernando, your balance's $314.16\n",
      "Enter the number of the action you wish to do:\n",
      "0 to Withdraw.\n",
      "1 to Deposit.\n",
      "2 to Balance.\n",
      "3 to Close.\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "import random as rd\n",
    "import json\n",
    "from abc import ABCMeta, abstractmethod\n",
    "\n",
    "class Bank(object):\n",
    "    \n",
    "    try:\n",
    "        with open('accountsBank.json','r') as file:\n",
    "            __accountsList = json.load(file)\n",
    "            print(__accountsList)\n",
    "\n",
    "    except IOError:\n",
    "        __accountsList = []\n",
    "    \n",
    "    def quitBank(self):\n",
    "        with open('accountsBank.json','w') as file:\n",
    "            json.dump(self, file)\n",
    "    \n",
    "    def __init__(self, __accountsList):\n",
    "        self.__accountsList = __accountsList\n",
    "        \n",
    "    def __get__(self, instance, owner):\n",
    "        return(self.__accountsList)\n",
    "        \n",
    "    def __set__(self, instance, __accountsList):\n",
    "        self.__accountsList = __accountsList\n",
    "        \n",
    "    def __repr__(self):\n",
    "        return(self.__accountsList)\n",
    "\n",
    "    def createAccount(self, dict):\n",
    "        self.__accountsList.append(dict)\n",
    "        return(self.__accountsList[-1])\n",
    "            \n",
    "    def closeAccount(self, Account):\n",
    "        self.__accountsList.remove(dict)\n",
    "        \n",
    "\n",
    "class Account(Bank, metaclass = ABCMeta):\n",
    "    _dictAccount = {}\n",
    "    \n",
    "    def __init__(self, number, name, balance):\n",
    "        self.number = number\n",
    "        self.name = name\n",
    "        self.balance = balance\n",
    "        print('Account {} created with ${}'.format(self.number, self.balance))\n",
    "        \n",
    "    @abstractmethod\n",
    "    def setNumber():\n",
    "        number = 0        \n",
    "        while number is 0 or number in list(Client._Bank__accountsList):\n",
    "            number = f'{rd.randrange(1, 10**5):05}'            \n",
    "        return(number)\n",
    "    \n",
    "    @abstractmethod\n",
    "    def makeDeposit(dict, value):\n",
    "        dict[list(dict.keys())[0]][1] += round(value,2)\n",
    "    \n",
    "    @abstractmethod\n",
    "    def makeWithdraw(dict, value):\n",
    "        dict[list(dict.keys())[0]][1] -= round(value,2)\n",
    "        \n",
    "class Client(Account, Bank):\n",
    "    \n",
    "    def setClient(name):\n",
    "        number = Account.setNumber()\n",
    "        balance = float('%.2f'%0)\n",
    "        clientAccount = Client(number, name, balance)\n",
    "        Account._dictAccount[number] = list([name, balance])\n",
    "        clientAccount = Bank.createAccount(clientAccount, Account._dictAccount)            \n",
    "        return(clientAccount)\n",
    "        \n",
    "    def setNumber():\n",
    "        number = Account.setNumber()\n",
    "        return(number)\n",
    "    \n",
    "    @staticmethod\n",
    "    def getClient(number, name):\n",
    "        for i, account in enumerate(Bank._Bank__accountsList):\n",
    "            if number in list(account) and name == account[number][0]:\n",
    "                return(account)\n",
    "        else:\n",
    "            print('Account not found.')\n",
    "        \n",
    "    def makeDeposit(dict, value):\n",
    "            balance = Account.makeDeposit(dict, value)\n",
    "            print('Deposit successfully completed!')            \n",
    "        \n",
    "    def makeWithdraw(dict, value): \n",
    "        if dict[list(dict.keys())[0]][1] >= value:       \n",
    "            balance = Account.makeWithdraw(dict, value)\n",
    "            print('Withdraw successfully completed!')\n",
    "            \n",
    "        else:\n",
    "            print('Your balance is not enough to withdraw ${}'.format(value))\n",
    "        \n",
    "    \n",
    "class User(object):\n",
    "    \n",
    "    @staticmethod\n",
    "    def displayOptions(object):\n",
    "        options = [['Create Account', 'Access Account', 'Close'], ['Withdraw', 'Deposit', 'Balance', 'Close']]\n",
    "        print('Enter the number of the action you wish to do:')\n",
    "        \n",
    "        if object is None:\n",
    "            display = [print('{} to {}.'.format(i, action)) for i, action in enumerate(options[0])]\n",
    "            displaySize = len(options[0])\n",
    "            \n",
    "        else:\n",
    "            display = [print('{} to {}.'.format(i, action)) for i, action in enumerate(options[1])]\n",
    "            displaySize = len(options[1])\n",
    "            \n",
    "        try:\n",
    "            choice = int(input())            \n",
    "            if choice in range(displaySize):\n",
    "                return(choice)\n",
    "\n",
    "            else:\n",
    "                print('Please, enter a number in the list!')\n",
    "\n",
    "        except ValueError:\n",
    "            print('Please, enter a valid number!')\n",
    "\n",
    "    @staticmethod\n",
    "    def newAccount():        \n",
    "        print('Please, enter your name:', end=' ')\n",
    "        name = input().title()\n",
    "        client = Client.setClient(name)\n",
    "        return(client)\n",
    "    \n",
    "    @staticmethod\n",
    "    def accessAccount():        \n",
    "        print('Please, enter your number account:', end=' ')\n",
    "        number = input()\n",
    "        print('Please, enter your name:', end=' ')\n",
    "        name = input().title()\n",
    "        client = Client.getClient(number, name)\n",
    "        return(client)\n",
    "    \n",
    "    @staticmethod\n",
    "    def getValue(action, dict):\n",
    "        option = 'deposit' if action is 1 else 'withdraw'\n",
    "        print('How much do you want to {}?'.format(option))\n",
    "        try:\n",
    "            value = input()\n",
    "            \n",
    "            if ',' in value:\n",
    "                value = value.replace(',','.')\n",
    "                \n",
    "            if action is 0:\n",
    "                Client.makeWithdraw(dict, round(float(value),2))\n",
    "                \n",
    "            elif action is 1:\n",
    "                Client.makeDeposit(dict, round(float(value),2))\n",
    "            \n",
    "        except ValueError:\n",
    "            print('Please, enter a valid value.')\n",
    "        \n",
    "class Foo(object):\n",
    "    user = User()\n",
    "    bank = Bank(object)\n",
    "    \n",
    "    def runProgram(self):\n",
    "        clientUser = None\n",
    "        while True:\n",
    "            if clientUser is None:\n",
    "                choice = f.user.displayOptions(clientUser)\n",
    "            \n",
    "            if choice is 0 and clientUser is None:\n",
    "                clientUser = f.user.newAccount()\n",
    "                choice = 1 if clientUser is not None else choice\n",
    "                \n",
    "            elif choice is 1:\n",
    "                if clientUser is None:\n",
    "                    clientUser = f.user.accessAccount()\n",
    "                    \n",
    "                else:\n",
    "                    action = f.user.displayOptions(clientUser)\n",
    "                    if action is 0:\n",
    "                        if clientUser[list(clientUser.keys())[0]][1] <= 0:\n",
    "                            print('{}, you don\\'t have balance to whithdraw.'.format(clientUser[list(clientUser.keys())[0]][0]))\n",
    "                            \n",
    "                        else:\n",
    "                            f.user.getValue(action, clientUser)\n",
    "                            print('Your balance\\'s ${}'.format('%.2f'%(clientUser[list(clientUser.keys())[0]][1])))\n",
    "                        \n",
    "                    elif action is 1:\n",
    "                        f.user.getValue(action, clientUser)\n",
    "                        print('Your balance\\'s ${}'.format('%.2f'%(clientUser[list(clientUser.keys())[0]][1])))\n",
    "                        \n",
    "                    elif action is 2:\n",
    "                        print('{}, your balance\\'s ${}'.format(clientUser[list(clientUser.keys())[0]][0],'%.2f'%(clientUser[list(clientUser.keys())[0]][1])))\n",
    "                    \n",
    "                    elif action is 3:\n",
    "                        choice = 2\n",
    "            \n",
    "            elif choice is 2:\n",
    "                Bank.quitBank(Bank._Bank__accountsList)\n",
    "                break\n",
    "                \n",
    "f = Foo()\n",
    "f.runProgram()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}