Exe_Python_OOP.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Exe_Python_OOP.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "Bài 1. Thực hiện theo yêu cầu như Class Diagram bên dưới."
      ],
      "metadata": {
        "id": "LbFxXiFpFLad"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "![image.png](data:image/png;base64,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)"
      ],
      "metadata": {
        "id": "2QKvYDo-NtBB"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ncEIh1I3EzRH",
        "outputId": "e2a3b3eb-009b-4dbb-de59-94519a82d5b6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name: mouse - Price: 2.5\n",
            "Identity: 9725 - Location: Vietnam\n",
            "Name: monitor - Price: 12.5\n",
            "Identity: 11 - Location: Germany\n"
          ]
        }
      ],
      "source": [
        "class Manufacturer:\n",
        "  def __init__(self,identity,location): \n",
        "      self.__identity = identity\n",
        "      self.__location = location\n",
        "      \n",
        "  def describe(self):\n",
        "      print(f'Identity: {self.__identity} - Location: {self.__location}')\n",
        "     \n",
        "\n",
        "class Device:\n",
        "  def __init__(self,name,price,identity,location): \n",
        "      self._name = name\n",
        "      self._price = price      \n",
        "      self.__manufacturer = Manufacturer(identity,location)\n",
        "   \n",
        "\n",
        "  def describe(self):\n",
        "      print(f'Name: {self._name}' + ' - ' + f'Price: {self._price}')\n",
        "      self.__manufacturer.describe()\n",
        "\n",
        "device1 = Device(name='mouse', price=2.5, identity=9725, location='Vietnam')\n",
        "device1.describe()\n",
        "\n",
        "device2 = Device(name='monitor', price=12.5, identity=11, location='Germany')\n",
        "device2.describe()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Bài 2. Một Ward gồm có name (string) và danh sách của mọi người trong Ward. Một người\n",
        "person có thể là student, doctor, hoặc teacher. Một student gồm có name, yob (int)\n",
        "(năm sinh), và grade (string). Một teacher gồm có name, yob, và subject (string).\n",
        "Một doctor gồm có name, yob, và specialist (string). Lưu ý cần sử dụng a list để chứa\n",
        "danh sách của mọi người trong Ward.\n",
        "- (a) Thực hiện các class student, doctor, và teacher theo mô tả trên. Thực hiện describe() method\n",
        "để print ra tất cả thông tin của các objects.\n",
        "- (b) Viết addPerson(person) method trong Ward class để add thêm một người mới với nghề\n",
        "nghiệp bất kỳ (student, teacher, doctor) vào danh sách người của ward. Tạo ra một ward\n",
        "object, và thêm vào 1 student, 2 teacher, và 2 doctor. Thực hiện describe() method để in ra\n",
        "tên ward (name) và toàn bộ thông tin của từng người trong ward.\n",
        "- (c) Viết countDoctor() method để đếm số lượng doctor trong ward.\n",
        "- (d) Viết sortAge() method để sort mọi người trong ward theo tuổi của họ với thứ tự tăng dần.\n",
        "(hint: Có thể sử dụng sort của list hoặc viết thêm function đều được)\n",
        "- (e) Viết aveTeacherYearOfBirth() method để tính trung bình năm sinh của các teachers trong\n",
        "ward."
      ],
      "metadata": {
        "id": "rKZ2EnWcFUO7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Person:\n",
        "  def __init__(self,name:str,yob:int):            \n",
        "      self._name = name\n",
        "      self._yob = yob\n",
        "  \n",
        "  def describe(self):\n",
        "      print(f'Name: {self._name}' + ' - ' + f'yob: {self._yob}')\n",
        "\n",
        "class Student(Person): \n",
        "  def __init__(self,name:str,yob:int,grade:str):       \n",
        "      self._name = name\n",
        "      self._yob = yob\n",
        "      self._grade  = grade \n",
        "  \n",
        "  def describe(self):\n",
        "      print(f'Name: {self._name}' + ' - ' + f'yob: {self._yob}' +  ' - ' + f'grade: {self._grade}')\n",
        "\n",
        "class Teacher(Person): \n",
        "  def __init__(self,name:str,yob:int,subject:str):       \n",
        "      self._name = name\n",
        "      self._yob = yob\n",
        "      self._subject  = subject\n",
        "  \n",
        "  def describe(self):\n",
        "      print(f'Name: {self._name}' + ' - ' + f'yob: {self._yob}' +  ' - ' + f'subject: {self._subject}')\n",
        "\n",
        "class Doctor(Person):\n",
        "  def __init__(self,name:str,yob:int,specialist:str): \n",
        "      self._name = name\n",
        "      self._yob = yob\n",
        "      self._specialist  = specialist \n",
        "\n",
        "  def describe(self):\n",
        "      print(f'Name: {self._name}' + ' - ' + f'yob: {self._yob}' +  ' - ' + f'specialist: {self._specialist}')\n",
        "\n",
        "class Ward():\n",
        "  def __init__(self,name:str):       \n",
        "      self._name = name\n",
        "      self._listPeople = list()\n",
        "\n",
        "  def describe(self):\n",
        "      print(f'Ward Name: {self._name}')\n",
        "      for i in self._listPeople:\n",
        "          i.describe()\n",
        "    \n",
        "  def addPerson(self,person:Person):\n",
        "      self._listPeople.append(person)\n",
        "  \n",
        "  def countDoctor(self):\n",
        "      count = 0\n",
        "      for i in self._listPeople:\n",
        "          if isinstance(i,Doctor): \n",
        "             count = count + 1 \n",
        "      return count \n",
        "\n",
        "  def sortAge(self,ascending=True):\n",
        "      self._listPeople.sort(key = lambda x: x._yob, reverse=True)\n",
        "\n",
        "  def aveTeacherYearOfBirth(self):\n",
        "      count = 0\n",
        "      total_year = 0\n",
        "      for i in self._listPeople:\n",
        "          if isinstance(i,Teacher):\n",
        "             count = count + 1\n",
        "             total_year = i._yob + total_year \n",
        "      return total_year/count"
      ],
      "metadata": {
        "id": "GQy1LUosFMAr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 2(a)\n",
        "student1 = Student(name='studentA', yob=2010, grade=7)\n",
        "student1.describe()\n",
        "\n",
        "teacher1 = Teacher(name='teacherA', yob=1969, subject='Math')\n",
        "teacher1.describe()\n",
        "\n",
        "doctor1 = Doctor(name='doctorA', yob=1945, specialist='Endocrinologists')\n",
        "doctor1.describe()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TfbasshZF4it",
        "outputId": "d26781cc-06b4-413a-adc9-23c77e02d282"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name: studentA - yob: 2010 - grade: 7\n",
            "Name: teacherA - yob: 1969 - subject: Math\n",
            "Name: doctorA - yob: 1945 - specialist: Endocrinologists\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2(b)\n",
        "teacher2 = Teacher(name='Bill Gates', yob=1955, subject='IT')\n",
        "doctor2 = Doctor(name='K', yob=1980, specialist='Surgery')\n",
        "teacher3 = Teacher(name='Huấn Hoa Hồng', yob=1975, subject='Múa mỏ')\n",
        "doctor3 = Doctor(name='Ai biết đâu', yob=2002, specialist='Bắt lỗi chính tả')\n",
        "\n",
        "ward1 = Ward(name='Ward 1')\n",
        "ward1.addPerson(teacher2)\n",
        "ward1.addPerson(doctor2)\n",
        "ward1.addPerson(teacher3)\n",
        "ward1.addPerson(doctor3)\n",
        "\n",
        "ward1.describe()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XTNuYEohGifU",
        "outputId": "a59bf471-d46e-4544-afec-5bc83d86fa6d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ward Name: Ward 1\n",
            "Name: Bill Gates - yob: 1955 - subject: IT\n",
            "Name: K - yob: 1980 - specialist: Surgery\n",
            "Name: Huấn Hoa Hồng - yob: 1975 - subject: Múa mỏ\n",
            "Name: Ai biết đâu - yob: 2002 - specialist: Bắt lỗi chính tả\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2(c)\n",
        "print('Number of doctors: ', ward1.countDoctor())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sA5eXfjNHToE",
        "outputId": "a0fc8e96-c315-4689-d608-2041b5a55ec5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of doctors:  2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2(d)\n",
        "print(f'After sorting Age of Ward1 people')\n",
        "ward1.sortAge()\n",
        "ward1.describe()\n",
        "\n",
        "print('-' * 20)\n",
        "print(f'After sorting Age of Ward1 people (descending)')\n",
        "ward1.sortAge(ascending=False)\n",
        "ward1.describe()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FozTfwM5HeJj",
        "outputId": "51c6dde9-bb4c-4eee-dd8b-4f70193af999"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "After sorting Age of Ward1 people\n",
            "Ward Name: Ward 1\n",
            "Name: Ai biết đâu - yob: 2002 - specialist: Bắt lỗi chính tả\n",
            "Name: K - yob: 1980 - specialist: Surgery\n",
            "Name: Huấn Hoa Hồng - yob: 1975 - subject: Múa mỏ\n",
            "Name: Bill Gates - yob: 1955 - subject: IT\n",
            "--------------------\n",
            "After sorting Age of Ward1 people (descending)\n",
            "Ward Name: Ward 1\n",
            "Name: Ai biết đâu - yob: 2002 - specialist: Bắt lỗi chính tả\n",
            "Name: K - yob: 1980 - specialist: Surgery\n",
            "Name: Huấn Hoa Hồng - yob: 1975 - subject: Múa mỏ\n",
            "Name: Bill Gates - yob: 1955 - subject: IT\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 2(e)\n",
        "print(f'Average year of birth (teachers): {ward1.aveTeacherYearOfBirth()}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DGWxfpCpHj1r",
        "outputId": "b12c5daf-803a-4a69-a59d-57508afb0d1a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Average year of birth (teachers): 1965.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Bài 3. Thực hiện xây dựng class Stack với các chức năng (method) sau đây\n",
        "- initialization method nhận một input \"capacity\": dùng để khởi tạo stack với capacity là số\n",
        "lượng element mà stack có thể chứa\n",
        "- .isEmpty(): kiểm tra stack có đang rỗng\n",
        "- .isFull(): kiểm tra stack đã full chưa\n",
        "- .pop(): loại bỏ top element và trả về giá trị đó\n",
        "- .push(value) add thêm value vào trong stack\n",
        "- .top() lấy giá trị top element hiện tại của stack, nhưng không loại bỏ giá trị đó"
      ],
      "metadata": {
        "id": "cruM34o5Fau1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Stack:\n",
        "    def __init__(self, elements=None,capacity=None): \n",
        "      if(elements == None):\n",
        "        self.elements = list()\n",
        "      elif type(elements) == list:\n",
        "        self.elements = elements\n",
        "        self.capacity = capacity\n",
        "    \n",
        "    \n",
        "    def push(self, item):\n",
        "        self.elements.append(item)\n",
        "    \n",
        "    def pop(self):\n",
        "      if(len(self.elements) > 0):\n",
        "        return self.elements.pop()\n",
        "      \n",
        "    def getTop(self):\n",
        "      if(len(self.elements) > 0):\n",
        "        return self.elements[-1]\n",
        "\n",
        "    def isEmpty(self):\n",
        "        return len(self.elements) == 0\n",
        "\n",
        "    def isFull(self):\n",
        "        return len(self.elements) >= self.capacity\n",
        "      \n",
        "    def __str__(self):\n",
        "        return str(self.elements)"
      ],
      "metadata": {
        "id": "CAx8nTDWFcA3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stack = Stack([0,1,2,85,97],6)\n",
        "print(stack) \n",
        "print(stack.isFull())\n",
        "print(stack.getTop()) \n",
        "print(stack.isEmpty()) \n",
        "stack.pop() "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y7lFslZ7FeGU",
        "outputId": "6d7c5621-408d-4d4e-b530-9b07172b07d6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 2, 85, 97]\n",
            "False\n",
            "97\n",
            "False\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "97"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Bài 4. Thực hiện xây dựng class Queue với các chức năng (method) sau đây\n",
        "- initialization method nhận một input \"capacity\": dùng để khởi tạo queue với capacity là\n",
        "số lượng element mà queue có thể chứa\n",
        "- .isEmpty(): kiểm tra queue có đang rỗng\n",
        "- .isFull(): kiểm tra queue đã full chưa\n",
        "- .dequeue(): loại bỏ first element và trả về giá trị đó\n",
        "- .enqueue(value) add thêm value vào trong queue\n",
        "- .front() lấy giá trị first element hiện tại của queue, nhưng không loại bỏ giá trị đó"
      ],
      "metadata": {
        "id": "29QuT499Ff4F"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Queue:\n",
        "    def __init__(self, elements, capacity): \n",
        "        self.elements = [] \n",
        "        self.elements = elements\n",
        "        self.capacity = capacity\n",
        "\n",
        "# Methods of Queue    \n",
        "    def enqueue(self, item):\n",
        "        self.elements.append(item)\n",
        "\n",
        "    def isFull(self):       \n",
        "        return True if len(self.elements) >= self.capacity else False\n",
        "    \n",
        "    def dequeue(self):\n",
        "      if(len(self.elements) > 0):\n",
        "        return self.elements.pop(0)\n",
        "      \n",
        "    def front(self):\n",
        "      if(len(self.elements) > 0):\n",
        "        return self.elements[0]      \n",
        "    \n",
        "    def isEmpty(self):\n",
        "        return True if len(self.elements) == 0 else False\n",
        "    \n",
        "    def __str__(self):\n",
        "        return str(self.elements)"
      ],
      "metadata": {
        "id": "RQJhgts9FhT5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "queue = Queue(elements = [0,1,2,4,5,55,80],capacity = 5)\n",
        "print(queue) \n",
        "\n",
        "queue.enqueue(20)\n",
        "queue.enqueue(18)\n",
        "\n",
        "print(queue)\n",
        "print(queue.isFull())\n",
        "\n",
        "print(queue.dequeue()) #0\n",
        "print(queue.front())  #1\n",
        "print(queue.dequeue()) #1\n",
        "print(queue.front()) #2\n",
        "print(queue.dequeue()) #2\n",
        "print(queue.front()) #4\n",
        "print(queue.dequeue()) \n",
        "print(queue.front())\n",
        "print(queue.dequeue())\n",
        "print(queue.front()) \n",
        "print(queue.dequeue()) \n",
        "print(queue.front())\n",
        "\n",
        "print(queue.isEmpty()) #False"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BchBTaKuFlws",
        "outputId": "8f193e33-afd4-45ea-b816-9d62189e9354"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 2, 4, 5, 55, 80]\n",
            "[0, 1, 2, 4, 5, 55, 80, 20, 18]\n",
            "True\n",
            "0\n",
            "1\n",
            "1\n",
            "2\n",
            "2\n",
            "4\n",
            "4\n",
            "5\n",
            "5\n",
            "55\n",
            "55\n",
            "80\n",
            "False\n"
          ]
        }
      ]
    }
  ]
}