01-OOP-Basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "<div class=\"alert alert-info\">\n",
    "    <h1 align=\"center\">Basic Concepts: Classes and Objects</h1>\n",
    "    <h3 align=\"center\"> Object-Oriented Programming in Python</h3>\n",
    "    <h5 align=\"center\">Seyed Naser Razavi (http://www.snrazavi.ir/)</h5>\n",
    "</div>"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Object Oriented Programming in Python\n",
    "- Class\n",
    "- Object (instance)\n",
    "  - attributes\n",
    "  - methods\n",
    "- instance variable, class variable\n",
    "- instance methods, class method, static method\n",
    "- inheritance\n",
    "- python special methods\n",
    "- properties, seeters, getters\n",
    "- documentation"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Why OOP?\n",
    "- A more clear and more understandable code (by hiding details from user).\n",
    "- You can create a class in one application and easily use it in other applications (code reuseability).\n",
    "- Easy maintainance: you can easily change your class and add more attributes and methods to it.\n",
    "- Inheritance"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## What is a class?\n",
    " - We use classes to define a set of **related data** along with the **operations** for those data.\n",
    "\n",
    "### Car\n",
    "<img src=\"imgs/car-race.jpg\" width=\"80%\" />\n",
    "\n",
    "For example consider a car object:\n",
    "- Data (attributes): \n",
    "  - `model`: Toyota\n",
    "  - `year`: 2021\n",
    "  - `price`: 30000\n",
    "  - `fuel_type`: Gasoline\n",
    "  - `gearbox_type`: manual\n",
    "  - `current_amount_of_fuel`: 20 litres\n",
    "  - `current_speed`: 120\n",
    "  - `current_gear`: 5\n",
    "  - `color`: black\n",
    "  - `photos`: a list of images of the car (useful for applications like \"Divar\")\n",
    "  - etc.\n",
    "- Operations (methods):\n",
    "  - `accelerte` : changes `current_speed`\n",
    "  - `brake`: changes `current_speed`\n",
    "  - `add_fuel`: changes `current_amount_of_fuel`\n",
    "  - etc."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Which attributes and methods?\n",
    "- Completely depends on the application\n",
    "- For a sale application: `color`, `model`, `year`, `price`, `gearbox_type`, `photos`, `insurance`, etc.\n",
    "- For a gaming application: `color`, `weight`, `current_speed`, `current_gear`, `position`, a 3D model, etc."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Employee\n",
    "Consider an employee object for a payroll system:\n",
    "- Data (attributes):\n",
    "  - `name`\n",
    "  - `surname`\n",
    "  - `email`\n",
    "  - `hours_worked` during a month\n",
    "  - `hourly_wage`\n",
    "- Operations (methods):\n",
    "  - `compute_salary`: uses `hours_worked` and `hourly_wage`\n",
    "  - `give_raise`: changes `hourly_wage`\n",
    "  - `display_fullname`: uses `name`, `surname`\n",
    "  - `print_payslip`: uses `name`, `surname`, `compute_salary` etc."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Defining a class\n",
    "- A class is like a blueprint that tells us what kind of data and operations an object has."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "class Employee:\n",
    "    pass"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "employee1 = Employee()  # creating object (instansiation)\n",
    "employee2 = Employee()  # creating object (instansiation)\n",
    "\n",
    "print(employee1)\n",
    "print(employee2)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "<__main__.Employee object at 0x7f9081336d30>\n",
      "<__main__.Employee object at 0x7f9081336e80>\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "- That's great. Now we know how to define a class and create several objects (instances) from that class.\n",
    "- But if you can't store data in your object, the object will be useless.\n",
    "- Let's see how we can store data in our objects."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Instance variables\n",
    "- contains data that is specific to each instance"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "# initialize first object (store data in it)\n",
    "employee1.name = \"John\"\n",
    "employee1.surname = \"Smith\"\n",
    "employee1.email = \"John.smith@email.com\"\n",
    "\n",
    "# initialize second object (store data in it)\n",
    "employee2.name = \"David\"\n",
    "employee2.surname = \"Johnson\"\n",
    "employee2.email = \"David.johnson@email.com\"\n",
    "\n",
    "# use your objects\n",
    "print(employee1.email)\n",
    "print(employee2.email)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "John.smith@email.com\n",
      "David.johnson@email.com\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "- Everytime you want to create an object, you have to write these 3 lines of code which is not good. \n",
    "- In this situation, one solution in Python is to write a `function` to initialize the object for you.\n",
    "  - So, you write the function once and use it again and again.\n",
    "- However, there is a better solution which we will see later. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "# one possible solution \n",
    "def initialize_employee(employee, name, surname):\n",
    "    employee.name = name\n",
    "    employee.surname = surname\n",
    "    employee.email = f\"{employee.name}.{employee.surname}@email.com\"\n",
    "\n",
    "\n",
    "# create objects\n",
    "employee1 = Employee()\n",
    "employee2 = Employee()\n",
    "\n",
    "# init objects\n",
    "initialize_employee(employee1, \"John\", \"Smith\")\n",
    "initialize_employee(employee2, \"David\", \"Johnson\")\n",
    "\n",
    "# use objects\n",
    "print(employee1.email)\n",
    "print(employee2.email)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "John.Smith@email.com\n",
      "David.Johnson@email.com\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "- The `initialize_employee()` function is an operation related to `Employee` objects.\n",
    "- So, it's better to put that in the `Employee` class.\n",
    "- We said a class is a mechanisme to group related data and operations."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Constructor: create an object and initialize it at once\n",
    "- A method which is run automatically when you want to create an instance of the class.\n",
    "- The main goal of constructor is to initialize the object attributes (instance variables). \n",
    "- In Python, the constructor method has always a specific name `__init__()`. \n",
    "- This way, Python knows which method to execute when you create an object from a given class.\n",
    "  - So, you don't need to call it explicitly when creating an object.\n",
    "  - Whenver you create an instance of a class, python executes the `__init__()` method for you."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "class Employee:\n",
    "    \n",
    "    def __init__(self, name, surname):\n",
    "        self.name = name\n",
    "        self.surname = surname\n",
    "        self.email = f\"{self.name}.{self.surname}@email.com\""
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "# create object and initialize it\n",
    "employee1 = Employee(\"John\", \"Smith\")\n",
    "\n",
    "# use the object\n",
    "print(employee1.name)\n",
    "print(employee1.surname)\n",
    "print(employee1.email)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "John\n",
      "Smith\n",
      "John.Smith@email.com\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### `self` argument in instance methods"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "Employee.__init__(employee1, \"John\", \"Smith\") # equal to employee1 = Employee(\"John\", \"Smith\")\n",
    "\n",
    "print(employee1.name)\n",
    "print(employee1.surname)\n",
    "print(employee1.email)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "John\n",
      "Smith\n",
      "John.Smith@email.com\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "employee2 = Employee(\"David\", \"Johnson\")\n",
    "\n",
    "print(employee2.name)\n",
    "print(employee2.surname)\n",
    "print(employee2.email)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "David\n",
      "Johnson\n",
      "David.Johnson@email.com\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Instance methods: adding behaviour to the class\n",
    "- In addition to attributes (data), classes also have behaviours.\n",
    "- We define behaviours by implementing methods.\n",
    "- A method is a function that is associated to a class."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "class Employee:\n",
    "    \n",
    "    def __init__(self, name, surname):\n",
    "        self.name = name\n",
    "        self.surname = surname\n",
    "        self.email = f\"{self.name}.{self.surname}@email.com\"\n",
    "\n",
    "    def fullname(self):\n",
    "        return f\"{self.name} {self.surname}\""
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "employee1 = Employee(\"John\", \"Smith\")\n",
    "\n",
    "print(employee1.fullname())"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "John Smith\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### `self` argument in methods\n",
    "- The first argument of a (instance) method is always `self`.\n",
    "- It's a very common mistake to forget the `self` argument.\n",
    "- When, you run `employee1.fullname()`, Python runs `Employee.fullname(employee1)` in the background."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "source": [
    "print(Employee.fullname(employee1))  # Equal to employee1.fullname()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "John Smith\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "### Question: What happens if you forget to pass in `self` as the first argument in a method?\n",
    "- Let's see the answer!"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "source": [
    "class Employee:\n",
    "    \n",
    "    def __init__(self, name, surname):\n",
    "        self.name = name\n",
    "        self.surname = surname\n",
    "        self.email = f\"{self.name}.{self.surname}@email.com\"\n",
    "\n",
    "    # here, self argument is missed diliberately\n",
    "    def fullname():\n",
    "        return f\"{self.name} {self.surname}\""
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "source": [
    "employee1 = Employee(\"John\", \"Smith\")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Now, what happens if we run the following cell?\n",
    "- hint: think how Python runs this code? "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "source": [
    "employee1.fullname()  # runing this will result in error"
   ],
   "outputs": [
    {
     "output_type": "error",
     "ename": "TypeError",
     "evalue": "fullname() takes 0 positional arguments but 1 was given",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/yp/6jvrnsq53596z8h0zc64zkn00000gn/T/ipykernel_25287/2541904170.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0memployee1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfullname\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# runing this will result in error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: fullname() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "**Answer:**\n",
    "- Python replaces `employee1.fullname()` with `Employee.fullname(employee1)`\n",
    "- As you can see, in the background the `employee1` object is passed in as an argument.\n",
    "- But if you see the implementation of `fullename()` method in `Employee` class, this method takes no argument. \n",
    "\n",
    "Therefore, whenver you see this error:\n",
    "```python\n",
    "TypeError: fullname() takes \"n\" positional arguments but \"n+1\" was given\n",
    "```\n",
    "most of the time, the reason is forgetting to pass in the `self` argument."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Next: instance variables and class variables\n",
    "- So far, we have seen how to define and use instance variables.\n",
    "- In OOP, there is another type of variable which we will see in the next lesson:\n",
    "  - Class variable: unlike an instance variable, a class variable belongs to the class itself; however it's value is shared among all instances of the class.\n",
    "- In the next lesson, we will see some use cases for class variables. \n"
   ],
   "metadata": {}
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.9.7 64-bit"
  },
  "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}