1_adv_features_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T07:17:17.571570Z",
     "iopub.status.busy": "2021-09-01T07:17:17.570576Z",
     "iopub.status.idle": "2021-09-01T07:17:17.585569Z",
     "shell.execute_reply": "2021-09-01T07:17:17.584584Z",
     "shell.execute_reply.started": "2021-09-01T07:17:17.571570Z"
    }
   },
   "source": [
    "<font size=6> <b> Advanced Python : week #1/#2 </b> </font>\n",
    "<div class=\"alert alert-block alert-success\">\n",
    "   Advanced Python features <br>\n",
    "    <ol>\n",
    "    <li> Named Tuple </li>\n",
    "    <li> DefaultDict </li>\n",
    "    <li> List Comprehension </li>\n",
    "    <li> Context Manager </li>\n",
    "    <li> Function argument : Args, Kwargs, Unpacking Operators</li>\n",
    "    <li> Class Methods </li>\n",
    "    </ol>\n",
    "</div>\n",
    "\n",
    "<p style=\"text-align:right;\"> sumyeon@gmail.com </p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- import frequently used modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:35.117032Z",
     "iopub.status.busy": "2021-09-01T13:55:35.116014Z",
     "iopub.status.idle": "2021-09-01T13:55:35.127026Z",
     "shell.execute_reply": "2021-09-01T13:55:35.126026Z",
     "shell.execute_reply.started": "2021-09-01T13:55:35.117032Z"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NamedTuple (vs. DataClass)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "- just a tuple, but the fields are named\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## tuple : immutable data structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:36.454787Z",
     "iopub.status.busy": "2021-09-01T13:55:36.454787Z",
     "iopub.status.idle": "2021-09-01T13:55:36.469779Z",
     "shell.execute_reply": "2021-09-01T13:55:36.468768Z",
     "shell.execute_reply.started": "2021-09-01T13:55:36.454787Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1 = (1, 2)\n",
    "\n",
    "p1[0], p1[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:36.653767Z",
     "iopub.status.busy": "2021-09-01T13:55:36.652768Z",
     "iopub.status.idle": "2021-09-01T13:55:36.661768Z",
     "shell.execute_reply": "2021-09-01T13:55:36.660784Z",
     "shell.execute_reply.started": "2021-09-01T13:55:36.653767Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## namedtuple: immutable and tuple-like data structure with field names\n",
    " - friendlier representation, field name as attributes, similar memory consumption to regular tuples\n",
    " - namedtuple returns a new data class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:37.010774Z",
     "iopub.status.busy": "2021-09-01T13:55:37.009769Z",
     "iopub.status.idle": "2021-09-01T13:55:37.025773Z",
     "shell.execute_reply": "2021-09-01T13:55:37.024779Z",
     "shell.execute_reply.started": "2021-09-01T13:55:37.010774Z"
    }
   },
   "outputs": [],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "Point = namedtuple(\"Point\", ['x','y'])  # class name, field names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:37.191050Z",
     "iopub.status.busy": "2021-09-01T13:55:37.191050Z",
     "iopub.status.idle": "2021-09-01T13:55:37.200064Z",
     "shell.execute_reply": "2021-09-01T13:55:37.199058Z",
     "shell.execute_reply.started": "2021-09-01T13:55:37.191050Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "issubclass(Point, tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:37.360242Z",
     "iopub.status.busy": "2021-09-01T13:55:37.359228Z",
     "iopub.status.idle": "2021-09-01T13:55:37.375240Z",
     "shell.execute_reply": "2021-09-01T13:55:37.374235Z",
     "shell.execute_reply.started": "2021-09-01T13:55:37.360242Z"
    }
   },
   "outputs": [],
   "source": [
    "p2 = Point(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:37.547778Z",
     "iopub.status.busy": "2021-09-01T13:55:37.547778Z",
     "iopub.status.idle": "2021-09-01T13:55:37.560762Z",
     "shell.execute_reply": "2021-09-01T13:55:37.559765Z",
     "shell.execute_reply.started": "2021-09-01T13:55:37.547778Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(x=1, y=2)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:37.719779Z",
     "iopub.status.busy": "2021-09-01T13:55:37.719779Z",
     "iopub.status.idle": "2021-09-01T13:55:37.736762Z",
     "shell.execute_reply": "2021-09-01T13:55:37.735771Z",
     "shell.execute_reply.started": "2021-09-01T13:55:37.719779Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('x', 'y')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2._fields"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:37.906779Z",
     "iopub.status.busy": "2021-09-01T13:55:37.905781Z",
     "iopub.status.idle": "2021-09-01T13:55:37.926764Z",
     "shell.execute_reply": "2021-09-01T13:55:37.925762Z",
     "shell.execute_reply.started": "2021-09-01T13:55:37.906779Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 1, 2, 2)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p2[0], p2.x, p2[1], p2.y "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- feild names should not start with '_' and not be reserved word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:38.257191Z",
     "iopub.status.busy": "2021-09-01T13:55:38.257191Z",
     "iopub.status.idle": "2021-09-01T13:55:38.404183Z",
     "shell.execute_reply": "2021-09-01T13:55:38.402191Z",
     "shell.execute_reply.started": "2021-09-01T13:55:38.257191Z"
    }
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Field names cannot start with an underscore: '_y'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-10-173b2e656a4a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mNtuple\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnamedtuple\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Ntuple\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'x'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'_y'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\collections\\__init__.py\u001b[0m in \u001b[0;36mnamedtuple\u001b[1;34m(typename, field_names, rename, defaults, module)\u001b[0m\n\u001b[0;32m    368\u001b[0m     \u001b[1;32mfor\u001b[0m \u001b[0mname\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mfield_names\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    369\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'_'\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mand\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0mrename\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 370\u001b[1;33m             raise ValueError('Field names cannot start with an underscore: '\n\u001b[0m\u001b[0;32m    371\u001b[0m                              f'{name!r}')\n\u001b[0;32m    372\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mseen\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: Field names cannot start with an underscore: '_y'"
     ]
    }
   ],
   "source": [
    "Ntuple = namedtuple(\"Ntuple\",['x','_y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:38.516287Z",
     "iopub.status.busy": "2021-09-01T13:55:38.515287Z",
     "iopub.status.idle": "2021-09-01T13:55:38.530271Z",
     "shell.execute_reply": "2021-09-01T13:55:38.528269Z",
     "shell.execute_reply.started": "2021-09-01T13:55:38.516287Z"
    }
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Type names and field names cannot be a keyword: 'class'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-5c7e00043ecf>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mNtuple\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnamedtuple\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Ntuple\"\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m'x'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'class'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32mC:\\ProgramData\\Anaconda3\\lib\\collections\\__init__.py\u001b[0m in \u001b[0;36mnamedtuple\u001b[1;34m(typename, field_names, rename, defaults, module)\u001b[0m\n\u001b[0;32m    362\u001b[0m                              f'identifiers: {name!r}')\n\u001b[0;32m    363\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0m_iskeyword\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 364\u001b[1;33m             raise ValueError('Type names and field names cannot be a '\n\u001b[0m\u001b[0;32m    365\u001b[0m                              f'keyword: {name!r}')\n\u001b[0;32m    366\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: Type names and field names cannot be a keyword: 'class'"
     ]
    }
   ],
   "source": [
    "Ntuple = namedtuple(\"Ntuple\", ['x','class'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- if you have to use invalid field names, 'rename' option would be a help\n",
    " > sometimes, we have to create a namedtuple 'dynamically', then "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:38.777708Z",
     "iopub.status.busy": "2021-09-01T13:55:38.777708Z",
     "iopub.status.idle": "2021-09-01T13:55:38.797710Z",
     "shell.execute_reply": "2021-09-01T13:55:38.796706Z",
     "shell.execute_reply.started": "2021-09-01T13:55:38.777708Z"
    }
   },
   "outputs": [],
   "source": [
    "Ntuple = namedtuple(\"Ntuple\", ['_x','class'], rename=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:38.963708Z",
     "iopub.status.busy": "2021-09-01T13:55:38.963708Z",
     "iopub.status.idle": "2021-09-01T13:55:38.974710Z",
     "shell.execute_reply": "2021-09-01T13:55:38.972707Z",
     "shell.execute_reply.started": "2021-09-01T13:55:38.963708Z"
    }
   },
   "outputs": [],
   "source": [
    "ntuple = Ntuple(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:39.141710Z",
     "iopub.status.busy": "2021-09-01T13:55:39.140714Z",
     "iopub.status.idle": "2021-09-01T13:55:39.161707Z",
     "shell.execute_reply": "2021-09-01T13:55:39.160709Z",
     "shell.execute_reply.started": "2021-09-01T13:55:39.141710Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('_0', '_1')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ntuple._fields"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- default value can be set for fields"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:39.452723Z",
     "iopub.status.busy": "2021-09-01T13:55:39.452723Z",
     "iopub.status.idle": "2021-09-01T13:55:39.459707Z",
     "shell.execute_reply": "2021-09-01T13:55:39.458723Z",
     "shell.execute_reply.started": "2021-09-01T13:55:39.452723Z"
    }
   },
   "outputs": [],
   "source": [
    "Ntuple = namedtuple(\"Ntuple\", \"x  y\", defaults=[0,0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:39.620708Z",
     "iopub.status.busy": "2021-09-01T13:55:39.620708Z",
     "iopub.status.idle": "2021-09-01T13:55:39.631712Z",
     "shell.execute_reply": "2021-09-01T13:55:39.630722Z",
     "shell.execute_reply.started": "2021-09-01T13:55:39.620708Z"
    }
   },
   "outputs": [],
   "source": [
    "p3 = Ntuple()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:39.780143Z",
     "iopub.status.busy": "2021-09-01T13:55:39.779141Z",
     "iopub.status.idle": "2021-09-01T13:55:39.790126Z",
     "shell.execute_reply": "2021-09-01T13:55:39.789137Z",
     "shell.execute_reply.started": "2021-09-01T13:55:39.780143Z"
    }
   },
   "outputs": [],
   "source": [
    "p4 = Ntuple(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:39.958341Z",
     "iopub.status.busy": "2021-09-01T13:55:39.957341Z",
     "iopub.status.idle": "2021-09-01T13:55:39.964340Z",
     "shell.execute_reply": "2021-09-01T13:55:39.963338Z",
     "shell.execute_reply.started": "2021-09-01T13:55:39.958341Z"
    }
   },
   "outputs": [],
   "source": [
    "p5 = Ntuple(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:40.132641Z",
     "iopub.status.busy": "2021-09-01T13:55:40.131636Z",
     "iopub.status.idle": "2021-09-01T13:55:40.153636Z",
     "shell.execute_reply": "2021-09-01T13:55:40.152647Z",
     "shell.execute_reply.started": "2021-09-01T13:55:40.132641Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Ntuple(x=0, y=0)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- provide additional attributes : _make(), _asdict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:40.472276Z",
     "iopub.status.busy": "2021-09-01T13:55:40.471259Z",
     "iopub.status.idle": "2021-09-01T13:55:40.487262Z",
     "shell.execute_reply": "2021-09-01T13:55:40.486269Z",
     "shell.execute_reply.started": "2021-09-01T13:55:40.472276Z"
    }
   },
   "outputs": [],
   "source": [
    "# create namedtuple instance from iterables\n",
    "\n",
    "p4 = Point._make([2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:40.638267Z",
     "iopub.status.busy": "2021-09-01T13:55:40.637273Z",
     "iopub.status.idle": "2021-09-01T13:55:40.644264Z",
     "shell.execute_reply": "2021-09-01T13:55:40.643259Z",
     "shell.execute_reply.started": "2021-09-01T13:55:40.638267Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('x', 2), ('y', 3)])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# convert named tuple into dictionary\n",
    "\n",
    "p4._asdict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- memory consumption"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:40.989680Z",
     "iopub.status.busy": "2021-09-01T13:55:40.989680Z",
     "iopub.status.idle": "2021-09-01T13:55:41.006682Z",
     "shell.execute_reply": "2021-09-01T13:55:41.005692Z",
     "shell.execute_reply.started": "2021-09-01T13:55:40.989680Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((1, 2), Point(x=1, y=2))"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1, p2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:41.151682Z",
     "iopub.status.busy": "2021-09-01T13:55:41.151682Z",
     "iopub.status.idle": "2021-09-01T13:55:41.164678Z",
     "shell.execute_reply": "2021-09-01T13:55:41.163678Z",
     "shell.execute_reply.started": "2021-09-01T13:55:41.151682Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(64, 64)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.getsizeof(p1), sys.getsizeof(p2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dataclass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:41.491107Z",
     "iopub.status.busy": "2021-09-01T13:55:41.491107Z",
     "iopub.status.idle": "2021-09-01T13:55:41.496091Z",
     "shell.execute_reply": "2021-09-01T13:55:41.495106Z",
     "shell.execute_reply.started": "2021-09-01T13:55:41.491107Z"
    }
   },
   "outputs": [],
   "source": [
    "from dataclasses import dataclass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:41.660293Z",
     "iopub.status.busy": "2021-09-01T13:55:41.660293Z",
     "iopub.status.idle": "2021-09-01T13:55:41.667303Z",
     "shell.execute_reply": "2021-09-01T13:55:41.666300Z",
     "shell.execute_reply.started": "2021-09-01T13:55:41.660293Z"
    }
   },
   "outputs": [],
   "source": [
    "@dataclass\n",
    "class CPoint:\n",
    "    x: int\n",
    "    y: int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:41.828863Z",
     "iopub.status.busy": "2021-09-01T13:55:41.828863Z",
     "iopub.status.idle": "2021-09-01T13:55:41.840853Z",
     "shell.execute_reply": "2021-09-01T13:55:41.839850Z",
     "shell.execute_reply.started": "2021-09-01T13:55:41.828863Z"
    }
   },
   "outputs": [],
   "source": [
    "cp = CPoint(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:42.003863Z",
     "iopub.status.busy": "2021-09-01T13:55:42.002846Z",
     "iopub.status.idle": "2021-09-01T13:55:42.014849Z",
     "shell.execute_reply": "2021-09-01T13:55:42.013861Z",
     "shell.execute_reply.started": "2021-09-01T13:55:42.003863Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cp.x, cp.y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:42.188850Z",
     "iopub.status.busy": "2021-09-01T13:55:42.187849Z",
     "iopub.status.idle": "2021-09-01T13:55:42.206852Z",
     "shell.execute_reply": "2021-09-01T13:55:42.205865Z",
     "shell.execute_reply.started": "2021-09-01T13:55:42.188850Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "CPoint(x=10, y=2)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cp.x = 10\n",
    "\n",
    "cp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T07:17:17.571570Z",
     "iopub.status.busy": "2021-09-01T07:17:17.570576Z",
     "iopub.status.idle": "2021-09-01T07:17:17.585569Z",
     "shell.execute_reply": "2021-09-01T07:17:17.584584Z",
     "shell.execute_reply.started": "2021-09-01T07:17:17.571570Z"
    }
   },
   "source": [
    "## Summary\n",
    "<div class=\"alert alert-block alert-info\">\n",
    "    namedtuple and dataclass are both very good at less-code policy. <br>\n",
    "    The difference would be on the immutability (namedtuple) and mutability (dataclass) feature. <br>\n",
    "    Also, it is known that the performance of dataclass a little bit better than that of namedtuple. <br>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quzz\n",
    "- which field match the given default value 'None'?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:42.712118Z",
     "iopub.status.busy": "2021-09-01T13:55:42.711117Z",
     "iopub.status.idle": "2021-09-01T13:55:42.727126Z",
     "shell.execute_reply": "2021-09-01T13:55:42.726116Z",
     "shell.execute_reply.started": "2021-09-01T13:55:42.711117Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.TestNT"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "namedtuple('TestNT',['args1st','args2nd','args3rd','args4th'], defaults=[None])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Defaultdict (vs. dict's get method)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"alert alert-block alert-info\">\n",
    "- just a dict, but every possible keys are initialzed as default value\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- dict : built-in data structure which supports key-value pairs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:43.557674Z",
     "iopub.status.busy": "2021-09-01T13:55:43.557674Z",
     "iopub.status.idle": "2021-09-01T13:55:43.568675Z",
     "shell.execute_reply": "2021-09-01T13:55:43.567673Z",
     "shell.execute_reply.started": "2021-09-01T13:55:43.557674Z"
    }
   },
   "outputs": [],
   "source": [
    "normaldict = {'yj' : 'Female', 'tw' : 'Male', 'kc' : 'Male'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:43.736330Z",
     "iopub.status.busy": "2021-09-01T13:55:43.736330Z",
     "iopub.status.idle": "2021-09-01T13:55:43.756312Z",
     "shell.execute_reply": "2021-09-01T13:55:43.755322Z",
     "shell.execute_reply.started": "2021-09-01T13:55:43.736330Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Female'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "normaldict['yj']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:43.904320Z",
     "iopub.status.busy": "2021-09-01T13:55:43.903335Z",
     "iopub.status.idle": "2021-09-01T13:55:43.929312Z",
     "shell.execute_reply": "2021-09-01T13:55:43.927322Z",
     "shell.execute_reply.started": "2021-09-01T13:55:43.904320Z"
    }
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'sm'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-32-a53b560dc676>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnormaldict\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'sm'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'sm'"
     ]
    }
   ],
   "source": [
    "normaldict['sm']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defaultdict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- a subclass of the dict class. It is almost same as dict but put the default value if a key is not in dict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:44.402233Z",
     "iopub.status.busy": "2021-09-01T13:55:44.402233Z",
     "iopub.status.idle": "2021-09-01T13:55:44.416217Z",
     "shell.execute_reply": "2021-09-01T13:55:44.414216Z",
     "shell.execute_reply.started": "2021-09-01T13:55:44.402233Z"
    }
   },
   "outputs": [],
   "source": [
    "from collections import defaultdict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:44.573409Z",
     "iopub.status.busy": "2021-09-01T13:55:44.573409Z",
     "iopub.status.idle": "2021-09-01T13:55:44.591412Z",
     "shell.execute_reply": "2021-09-01T13:55:44.590412Z",
     "shell.execute_reply.started": "2021-09-01T13:55:44.573409Z"
    }
   },
   "outputs": [],
   "source": [
    "# first argument : callable object which return the default value\n",
    "\n",
    "ddict = defaultdict(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:44.748611Z",
     "iopub.status.busy": "2021-09-01T13:55:44.747610Z",
     "iopub.status.idle": "2021-09-01T13:55:44.764613Z",
     "shell.execute_reply": "2021-09-01T13:55:44.763611Z",
     "shell.execute_reply.started": "2021-09-01T13:55:44.748611Z"
    }
   },
   "outputs": [],
   "source": [
    "ddict.update(normaldict)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:44.919613Z",
     "iopub.status.busy": "2021-09-01T13:55:44.919613Z",
     "iopub.status.idle": "2021-09-01T13:55:44.937614Z",
     "shell.execute_reply": "2021-09-01T13:55:44.936620Z",
     "shell.execute_reply.started": "2021-09-01T13:55:44.919613Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "''"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ddict['sm']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- a typical situation where the defaultdict is useful\n",
    " > let's count the frequency of characters in a given sentence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:45.249611Z",
     "iopub.status.busy": "2021-09-01T13:55:45.249611Z",
     "iopub.status.idle": "2021-09-01T13:55:45.269612Z",
     "shell.execute_reply": "2021-09-01T13:55:45.268610Z",
     "shell.execute_reply.started": "2021-09-01T13:55:45.249611Z"
    }
   },
   "outputs": [],
   "source": [
    "sentence = \"when in rome, do as romans do.\"\n",
    "\n",
    "char_count = defaultdict(int)\n",
    "\n",
    "for char in sentence:\n",
    "    char_count[char] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:45.426818Z",
     "iopub.status.busy": "2021-09-01T13:55:45.426818Z",
     "iopub.status.idle": "2021-09-01T13:55:45.439816Z",
     "shell.execute_reply": "2021-09-01T13:55:45.438827Z",
     "shell.execute_reply.started": "2021-09-01T13:55:45.426818Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(int,\n",
       "            {'w': 1,\n",
       "             'h': 1,\n",
       "             'e': 2,\n",
       "             'n': 3,\n",
       "             ' ': 6,\n",
       "             'i': 1,\n",
       "             'r': 2,\n",
       "             'o': 4,\n",
       "             'm': 2,\n",
       "             ',': 1,\n",
       "             'd': 2,\n",
       "             'a': 2,\n",
       "             's': 2,\n",
       "             '.': 1})"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "char_count"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- without defaultdict, how we can code the same problem with just 'dict'\n",
    "\n",
    "<pre>\n",
    "char_count = dict()\n",
    "\n",
    "for char in sentence:\n",
    "    if char not in char_count:\n",
    "        char_count[char] = 0\n",
    "    char_count[char] += 1\n",
    "</pre> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- more on first arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:45.939316Z",
     "iopub.status.busy": "2021-09-01T13:55:45.938293Z",
     "iopub.status.idle": "2021-09-01T13:55:45.944291Z",
     "shell.execute_reply": "2021-09-01T13:55:45.943293Z",
     "shell.execute_reply.started": "2021-09-01T13:55:45.939316Z"
    }
   },
   "outputs": [],
   "source": [
    "listdict = defaultdict(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:46.127297Z",
     "iopub.status.busy": "2021-09-01T13:55:46.127297Z",
     "iopub.status.idle": "2021-09-01T13:55:46.134293Z",
     "shell.execute_reply": "2021-09-01T13:55:46.133301Z",
     "shell.execute_reply.started": "2021-09-01T13:55:46.127297Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "listdict['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:46.319717Z",
     "iopub.status.busy": "2021-09-01T13:55:46.318733Z",
     "iopub.status.idle": "2021-09-01T13:55:46.338701Z",
     "shell.execute_reply": "2021-09-01T13:55:46.336715Z",
     "shell.execute_reply.started": "2021-09-01T13:55:46.319717Z"
    }
   },
   "outputs": [],
   "source": [
    "ddict = defaultdict(lambda : 'Unknown')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:46.503929Z",
     "iopub.status.busy": "2021-09-01T13:55:46.503929Z",
     "iopub.status.idle": "2021-09-01T13:55:46.511916Z",
     "shell.execute_reply": "2021-09-01T13:55:46.510925Z",
     "shell.execute_reply.started": "2021-09-01T13:55:46.503929Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Unknown'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ddict['sm']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Get method of dictionary\n",
    "- dict raise exception if unknown key is given as index. you can use 'get' method for such situation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:46.882879Z",
     "iopub.status.busy": "2021-09-01T13:55:46.881894Z",
     "iopub.status.idle": "2021-09-01T13:55:46.900879Z",
     "shell.execute_reply": "2021-09-01T13:55:46.898879Z",
     "shell.execute_reply.started": "2021-09-01T13:55:46.882879Z"
    }
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'sm'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-43-a53b560dc676>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnormaldict\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'sm'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'sm'"
     ]
    }
   ],
   "source": [
    "normaldict['sm']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:47.074106Z",
     "iopub.status.busy": "2021-09-01T13:55:47.074106Z",
     "iopub.status.idle": "2021-09-01T13:55:47.088098Z",
     "shell.execute_reply": "2021-09-01T13:55:47.087101Z",
     "shell.execute_reply.started": "2021-09-01T13:55:47.074106Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Unknown'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "normaldict.get('sm', 'Unknown')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quzz\n",
    "- we can use list as the key of dict/defaultdict? Yes or No\n",
    "- we can use tuple as the key of dict/defaultdict? Yes or No \n",
    "<br>\n",
    "<b> Do you know why? </b>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Deque, Counter\n",
    "- other useful data structures \n",
    "- Deque can be used as both Queue, Stack\n",
    "- Counter can be used as counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Deque"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-02T00:56:47.963746Z",
     "iopub.status.busy": "2021-09-02T00:56:47.963746Z",
     "iopub.status.idle": "2021-09-02T00:56:47.979744Z",
     "shell.execute_reply": "2021-09-02T00:56:47.978753Z",
     "shell.execute_reply.started": "2021-09-02T00:56:47.963746Z"
    }
   },
   "outputs": [],
   "source": [
    "from collections import deque"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-02T00:58:19.838802Z",
     "iopub.status.busy": "2021-09-02T00:58:19.837799Z",
     "iopub.status.idle": "2021-09-02T00:58:19.851806Z",
     "shell.execute_reply": "2021-09-02T00:58:19.850799Z",
     "shell.execute_reply.started": "2021-09-02T00:58:19.838802Z"
    }
   },
   "outputs": [],
   "source": [
    "queue = deque(['yj','tw','kc'])  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-02T00:59:45.897094Z",
     "iopub.status.busy": "2021-09-02T00:59:45.897094Z",
     "iopub.status.idle": "2021-09-02T00:59:45.913092Z",
     "shell.execute_reply": "2021-09-02T00:59:45.912089Z",
     "shell.execute_reply.started": "2021-09-02T00:59:45.897094Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque(['yj', 'tw', 'kc', 'sm', 'sm'])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "queue.append('sm')\n",
    "queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-02T01:00:08.945738Z",
     "iopub.status.busy": "2021-09-02T01:00:08.945738Z",
     "iopub.status.idle": "2021-09-02T01:00:08.961757Z",
     "shell.execute_reply": "2021-09-02T01:00:08.960746Z",
     "shell.execute_reply.started": "2021-09-02T01:00:08.945738Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque(['jh', 'yj', 'tw', 'kc', 'sm', 'sm'])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "queue.appendleft('jh')\n",
    "queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-02T01:00:38.826328Z",
     "iopub.status.busy": "2021-09-02T01:00:38.825327Z",
     "iopub.status.idle": "2021-09-02T01:00:38.847326Z",
     "shell.execute_reply": "2021-09-02T01:00:38.846325Z",
     "shell.execute_reply.started": "2021-09-02T01:00:38.826328Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque(['jh', 'yj', 'tw', 'kc', 'sm'])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "queue.pop()\n",
    "queue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-02T01:00:49.628296Z",
     "iopub.status.busy": "2021-09-02T01:00:49.628296Z",
     "iopub.status.idle": "2021-09-02T01:00:49.648292Z",
     "shell.execute_reply": "2021-09-02T01:00:49.647300Z",
     "shell.execute_reply.started": "2021-09-02T01:00:49.628296Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque(['yj', 'tw', 'kc', 'sm'])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "queue.popleft()\n",
    "queue"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-02T01:03:45.409603Z",
     "iopub.status.busy": "2021-09-02T01:03:45.409603Z",
     "iopub.status.idle": "2021-09-02T01:03:45.424604Z",
     "shell.execute_reply": "2021-09-02T01:03:45.423608Z",
     "shell.execute_reply.started": "2021-09-02T01:03:45.409603Z"
    }
   },
   "outputs": [],
   "source": [
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-02T01:05:37.134473Z",
     "iopub.status.busy": "2021-09-02T01:05:37.134473Z",
     "iopub.status.idle": "2021-09-02T01:05:37.151474Z",
     "shell.execute_reply": "2021-09-02T01:05:37.150481Z",
     "shell.execute_reply.started": "2021-09-02T01:05:37.134473Z"
    }
   },
   "outputs": [],
   "source": [
    "c = Counter(['abc', 'aba', 'acd', 'aca', 'abc', 'adc', 'aca', 'abc', 'adc', 'acd', 'abc', 'aba', 'aca'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-02T01:05:40.381608Z",
     "iopub.status.busy": "2021-09-02T01:05:40.381608Z",
     "iopub.status.idle": "2021-09-02T01:05:40.396910Z",
     "shell.execute_reply": "2021-09-02T01:05:40.395905Z",
     "shell.execute_reply.started": "2021-09-02T01:05:40.381608Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'abc': 4, 'aba': 2, 'acd': 2, 'aca': 3, 'adc': 2})"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-02T01:05:45.342301Z",
     "iopub.status.busy": "2021-09-02T01:05:45.341300Z",
     "iopub.status.idle": "2021-09-02T01:05:45.361303Z",
     "shell.execute_reply": "2021-09-02T01:05:45.360313Z",
     "shell.execute_reply.started": "2021-09-02T01:05:45.342301Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c['abc']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-02T01:03:46.478582Z",
     "iopub.status.busy": "2021-09-02T01:03:46.478582Z",
     "iopub.status.idle": "2021-09-02T01:03:46.487583Z",
     "shell.execute_reply": "2021-09-02T01:03:46.486585Z",
     "shell.execute_reply.started": "2021-09-02T01:03:46.478582Z"
    }
   },
   "outputs": [],
   "source": [
    "c = Counter({'red': 4, 'blue': 2})      # a new counter from a mapping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-02T01:03:48.109833Z",
     "iopub.status.busy": "2021-09-02T01:03:48.108826Z",
     "iopub.status.idle": "2021-09-02T01:03:48.127826Z",
     "shell.execute_reply": "2021-09-02T01:03:48.126835Z",
     "shell.execute_reply.started": "2021-09-02T01:03:48.108826Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'red': 4, 'blue': 2})"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-02T01:03:53.134753Z",
     "iopub.status.busy": "2021-09-02T01:03:53.134753Z",
     "iopub.status.idle": "2021-09-02T01:03:53.151753Z",
     "shell.execute_reply": "2021-09-02T01:03:53.150763Z",
     "shell.execute_reply.started": "2021-09-02T01:03:53.134753Z"
    }
   },
   "outputs": [],
   "source": [
    "c = Counter(cats=4, dogs=8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-02T01:03:54.799258Z",
     "iopub.status.busy": "2021-09-02T01:03:54.799258Z",
     "iopub.status.idle": "2021-09-02T01:03:54.818255Z",
     "shell.execute_reply": "2021-09-02T01:03:54.817263Z",
     "shell.execute_reply.started": "2021-09-02T01:03:54.799258Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({'cats': 4, 'dogs': 8})"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  List Comprehension"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- pythoniac way to create a list\n",
    "  <br>\n",
    "- list comprehension syntax <br>\n",
    " <b> [expression for item in iterable (if condition) ]   </br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:47.794781Z",
     "iopub.status.busy": "2021-09-01T13:55:47.794781Z",
     "iopub.status.idle": "2021-09-01T13:55:47.809777Z",
     "shell.execute_reply": "2021-09-01T13:55:47.808771Z",
     "shell.execute_reply.started": "2021-09-01T13:55:47.794781Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# [0, 1, 2, 3, 4]\n",
    "\n",
    "[i for i in range(5)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:47.966875Z",
     "iopub.status.busy": "2021-09-01T13:55:47.966875Z",
     "iopub.status.idle": "2021-09-01T13:55:47.986875Z",
     "shell.execute_reply": "2021-09-01T13:55:47.984890Z",
     "shell.execute_reply.started": "2021-09-01T13:55:47.966875Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 0*0 to 4*4\n",
    "\n",
    "[i*i for i in range(5)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:48.127877Z",
     "iopub.status.busy": "2021-09-01T13:55:48.126878Z",
     "iopub.status.idle": "2021-09-01T13:55:48.142881Z",
     "shell.execute_reply": "2021-09-01T13:55:48.141873Z",
     "shell.execute_reply.started": "2021-09-01T13:55:48.127877Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# [0, 2, 4, 6, 8] <= 0 to 10  but only even number\n",
    "\n",
    "[i for i in range(10) if i%2 == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- nested comprehension for nested list explosion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:48.666564Z",
     "iopub.status.busy": "2021-09-01T13:55:48.666564Z",
     "iopub.status.idle": "2021-09-01T13:55:48.675565Z",
     "shell.execute_reply": "2021-09-01T13:55:48.674573Z",
     "shell.execute_reply.started": "2021-09-01T13:55:48.666564Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [[1,2,3], [4,5,6], [7,8,9]]\n",
    "\n",
    "# how to explode => [1,2,3,4,5,6,7,8,9]\n",
    "[ y for x in numbers for y in x]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:48.837788Z",
     "iopub.status.busy": "2021-09-01T13:55:48.836789Z",
     "iopub.status.idle": "2021-09-01T13:55:48.846791Z",
     "shell.execute_reply": "2021-09-01T13:55:48.845788Z",
     "shell.execute_reply.started": "2021-09-01T13:55:48.837788Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5, 6, 7, 8, 9], dtype=object)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# TIP:  another way of explosion\n",
    "\n",
    "pd.Series(numbers).explode().values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:49.611098Z",
     "iopub.status.busy": "2021-09-01T13:55:49.611098Z",
     "iopub.status.idle": "2021-09-01T13:55:49.630095Z",
     "shell.execute_reply": "2021-09-01T13:55:49.628106Z",
     "shell.execute_reply.started": "2021-09-01T13:55:49.611098Z"
    }
   },
   "outputs": [],
   "source": [
    "# a way to avoid confusion when use comprehension\n",
    "\n",
    "# [ y for x in numbers for y in x] vs. [ y for y in x for x in numbers]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> nested for loop => nested comprehension <br>\n",
    "\n",
    "<pre>\n",
    "  for b in a:\n",
    "      for c in b:\n",
    "          for d in c:\n",
    "              print(d) \n",
    "              \n",
    "  =>\n",
    "  \n",
    "  [d for b in a for c in b for d in c]\n",
    "  \n",
    "</pre>\n",
    "    \n",
    "</b>\n",
    "                                 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- expression vs. (if condition)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:50.168226Z",
     "iopub.status.busy": "2021-09-01T13:55:50.167226Z",
     "iopub.status.idle": "2021-09-01T13:55:50.190229Z",
     "shell.execute_reply": "2021-09-01T13:55:50.189228Z",
     "shell.execute_reply.started": "2021-09-01T13:55:50.168226Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, 2, -1, 4, -1, 6, -1, 8, -1]"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i if i%2 == 0 else  -1 for sublist in numbers for i in sublist]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:50.340227Z",
     "iopub.status.busy": "2021-09-01T13:55:50.339226Z",
     "iopub.status.idle": "2021-09-01T13:55:50.348226Z",
     "shell.execute_reply": "2021-09-01T13:55:50.347225Z",
     "shell.execute_reply.started": "2021-09-01T13:55:50.340227Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i for sublist in numbers for i in sublist if i % 2 == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- another example of list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:50.710827Z",
     "iopub.status.busy": "2021-09-01T13:55:50.710827Z",
     "iopub.status.idle": "2021-09-01T13:55:50.721826Z",
     "shell.execute_reply": "2021-09-01T13:55:50.720826Z",
     "shell.execute_reply.started": "2021-09-01T13:55:50.710827Z"
    }
   },
   "outputs": [],
   "source": [
    "text = [['tw','yj','kc','SM'], ['Rome','Madrid','Seoul','NewYork'],['aa','bb','cc','dd','ee']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:50.887065Z",
     "iopub.status.busy": "2021-09-01T13:55:50.886068Z",
     "iopub.status.idle": "2021-09-01T13:55:50.909074Z",
     "shell.execute_reply": "2021-09-01T13:55:50.908072Z",
     "shell.execute_reply.started": "2021-09-01T13:55:50.887065Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['tw',\n",
       " 'yj',\n",
       " 'kc',\n",
       " 'SM',\n",
       " 'Rome',\n",
       " 'Madrid',\n",
       " 'Seoul',\n",
       " 'NewYork',\n",
       " 'aa',\n",
       " 'bb',\n",
       " 'cc',\n",
       " 'dd',\n",
       " 'ee']"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for x in text:\n",
    "#     for y in x:\n",
    "#        --- expression ---\n",
    "\n",
    "[y for x in text for y in x]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:51.074070Z",
     "iopub.status.busy": "2021-09-01T13:55:51.073069Z",
     "iopub.status.idle": "2021-09-01T13:55:51.082070Z",
     "shell.execute_reply": "2021-09-01T13:55:51.081066Z",
     "shell.execute_reply.started": "2021-09-01T13:55:51.074070Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['aa', 'bb', 'cc', 'dd', 'ee']"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for x in text:\n",
    "#    if len(x) >= 4:\n",
    "#        for y in x:\n",
    "\n",
    "[y for x in text if len(x) >= 5 for y in x]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:51.260288Z",
     "iopub.status.busy": "2021-09-01T13:55:51.260288Z",
     "iopub.status.idle": "2021-09-01T13:55:51.281279Z",
     "shell.execute_reply": "2021-09-01T13:55:51.280272Z",
     "shell.execute_reply.started": "2021-09-01T13:55:51.260288Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['TW', 'YJ', 'KC']"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# for x in text:\n",
    "#    if len(x) >= 4:\n",
    "#        for y in x:\n",
    "#           if len(y) \n",
    "\n",
    "[ y.upper() if len(y) == 2 else y for x in text if len(x) <= 4 for y in x  if y.islower()]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz\n",
    "- Given dictionary is consisted of vehicles and their price in 'won'.  <br>\n",
    "  Contruct a list of the names of vehicles with price higher than 30,000,000. <br>\n",
    "  In the resulting list comprehension make the car names all upper case.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:51.621500Z",
     "iopub.status.busy": "2021-09-01T13:55:51.620502Z",
     "iopub.status.idle": "2021-09-01T13:55:51.628490Z",
     "shell.execute_reply": "2021-09-01T13:55:51.627496Z",
     "shell.execute_reply.started": "2021-09-01T13:55:51.621500Z"
    }
   },
   "outputs": [],
   "source": [
    "cardict = {'avante': 15_700_000, 'velster': 20_960_000, 'ioniq': 22_420_000, 'sonata': 23_860_000, 'grandeur': 32_940_000,\n",
    "              'venue': 14_730_000, 'kona': 19_140_000, 'tucson': 24_350_000, 'nexxo': 68_900_000, 'santafe': 31_220_000, 'palisade': 35_730_000}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:51.812503Z",
     "iopub.status.busy": "2021-09-01T13:55:51.812503Z",
     "iopub.status.idle": "2021-09-01T13:55:51.820491Z",
     "shell.execute_reply": "2021-09-01T13:55:51.819488Z",
     "shell.execute_reply.started": "2021-09-01T13:55:51.812503Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[        ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Context Manager"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- the main purpose of contst managers is to propery manage resources\n",
    "- Using 'with' statement, context manager create a new block that resources are bound to\n",
    "- ex) in file case, a file open in a context will be automatically closed when the context block is exited"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading a file - traditional approach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:52.564724Z",
     "iopub.status.busy": "2021-09-01T13:55:52.564724Z",
     "iopub.status.idle": "2021-09-01T13:55:52.576734Z",
     "shell.execute_reply": "2021-09-01T13:55:52.575733Z",
     "shell.execute_reply.started": "2021-09-01T13:55:52.564724Z"
    }
   },
   "outputs": [],
   "source": [
    "ofile = open(\"temptemp.txt\",'w')\n",
    "ofile.write(\"hello, world!\")\n",
    "ofile.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading a file - using context manager"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:52.947135Z",
     "iopub.status.busy": "2021-09-01T13:55:52.946135Z",
     "iopub.status.idle": "2021-09-01T13:55:52.954139Z",
     "shell.execute_reply": "2021-09-01T13:55:52.953138Z",
     "shell.execute_reply.started": "2021-09-01T13:55:52.947135Z"
    }
   },
   "outputs": [],
   "source": [
    "with open(\"temptemp.txt\",'w') as ofile:\n",
    "    ofile.write(\"hello, world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lock - traditional approach"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:53.331646Z",
     "iopub.status.busy": "2021-09-01T13:55:53.331646Z",
     "iopub.status.idle": "2021-09-01T13:55:53.357631Z",
     "shell.execute_reply": "2021-09-01T13:55:53.356629Z",
     "shell.execute_reply.started": "2021-09-01T13:55:53.331646Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error occurred\n",
      "Lock is locked: True\n"
     ]
    }
   ],
   "source": [
    "from threading import Lock\n",
    "lock = Lock()\n",
    "def do_something_concurrent():\n",
    "    lock.acquire()\n",
    "    raise Exception('oops, exception')\n",
    "    lock.release()\n",
    "try:\n",
    "    do_something_concurrent()\n",
    "except:\n",
    "    print('Error occurred')\n",
    "print('Lock is locked: {}'.format(lock.locked()))\n",
    "lock.release()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lock - using context manager"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:53.710790Z",
     "iopub.status.busy": "2021-09-01T13:55:53.710790Z",
     "iopub.status.idle": "2021-09-01T13:55:53.731791Z",
     "shell.execute_reply": "2021-09-01T13:55:53.730790Z",
     "shell.execute_reply.started": "2021-09-01T13:55:53.710790Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Error occurred\n",
      "Lock is locked: False\n"
     ]
    }
   ],
   "source": [
    "from threading import Lock\n",
    "lock = Lock()\n",
    "def do_something_concurrent():\n",
    "    with lock:\n",
    "        raise Exception('oops, exception')\n",
    "try:\n",
    "    do_something_concurrent()\n",
    "except:\n",
    "    print('Error occurred')\n",
    "print('Lock is locked: {}'.format(lock.locked()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making a Context Manager"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- definition : literally, context manager is a class which has two functions - __enter__(), __exit__()\n",
    "- note: you can make any class as context manager syntaxically "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:54.296584Z",
     "iopub.status.busy": "2021-09-01T13:55:54.296584Z",
     "iopub.status.idle": "2021-09-01T13:55:54.309585Z",
     "shell.execute_reply": "2021-09-01T13:55:54.308596Z",
     "shell.execute_reply.started": "2021-09-01T13:55:54.296584Z"
    }
   },
   "outputs": [],
   "source": [
    "class SampleContextManager:\n",
    "        \n",
    "    def __enter__(self):\n",
    "        print(\"__enter__ is called\")\n",
    "        \n",
    "    def __exit__(self, *args):\n",
    "        print(\"__exit__ is called\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:54.489662Z",
     "iopub.status.busy": "2021-09-01T13:55:54.488662Z",
     "iopub.status.idle": "2021-09-01T13:55:54.500661Z",
     "shell.execute_reply": "2021-09-01T13:55:54.499661Z",
     "shell.execute_reply.started": "2021-09-01T13:55:54.489662Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__enter__ is called\n",
      "I am here\n",
      "__exit__ is called\n"
     ]
    }
   ],
   "source": [
    "with SampleContextManager() as sample:\n",
    "    print(\"I am here\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:54.662663Z",
     "iopub.status.busy": "2021-09-01T13:55:54.662663Z",
     "iopub.status.idle": "2021-09-01T13:55:54.676663Z",
     "shell.execute_reply": "2021-09-01T13:55:54.675671Z",
     "shell.execute_reply.started": "2021-09-01T13:55:54.662663Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__enter__ is called\n",
      "__exit__ is called\n"
     ]
    },
    {
     "ename": "Exception",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-65-57d83ba7571b>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mSampleContextManager\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0msample\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[1;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mException\u001b[0m: "
     ]
    }
   ],
   "source": [
    "with SampleContextManager() as sample:\n",
    "    raise Exception"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- contextlib provide a useful decorator - @contextmanager - to be helpful\n",
    "\n",
    "> code before 'yield' is considered as \"__enter__()\" block, and those after that is \"__exit__()\" block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:55.043726Z",
     "iopub.status.busy": "2021-09-01T13:55:55.042712Z",
     "iopub.status.idle": "2021-09-01T13:55:55.053715Z",
     "shell.execute_reply": "2021-09-01T13:55:55.052710Z",
     "shell.execute_reply.started": "2021-09-01T13:55:55.043726Z"
    }
   },
   "outputs": [],
   "source": [
    "from contextlib import contextmanager\n",
    "\n",
    "@contextmanager\n",
    "def helloworld():\n",
    "    \n",
    "    print(\"__enter__ is called\")\n",
    "    try:\n",
    "        yield\n",
    "    finally:\n",
    "        print(\"__exit__ is called\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:55.232710Z",
     "iopub.status.busy": "2021-09-01T13:55:55.232710Z",
     "iopub.status.idle": "2021-09-01T13:55:55.243718Z",
     "shell.execute_reply": "2021-09-01T13:55:55.242707Z",
     "shell.execute_reply.started": "2021-09-01T13:55:55.232710Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__enter__ is called\n",
      "I am here\n",
      "__exit__ is called\n"
     ]
    }
   ],
   "source": [
    "with helloworld() as ctx:\n",
    "    print(\"I am here\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:55.436116Z",
     "iopub.status.busy": "2021-09-01T13:55:55.435117Z",
     "iopub.status.idle": "2021-09-01T13:55:55.451116Z",
     "shell.execute_reply": "2021-09-01T13:55:55.449119Z",
     "shell.execute_reply.started": "2021-09-01T13:55:55.436116Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__enter__ is called\n",
      "__exit__ is called\n"
     ]
    },
    {
     "ename": "Exception",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mException\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-68-253c728322f5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mwith\u001b[0m \u001b[0mhelloworld\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mctx\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[1;32mraise\u001b[0m \u001b[0mException\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mException\u001b[0m: "
     ]
    }
   ],
   "source": [
    "with helloworld() as ctx:\n",
    "    raise Exception"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- anothe example of context manager - excution time counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:55.812575Z",
     "iopub.status.busy": "2021-09-01T13:55:55.812575Z",
     "iopub.status.idle": "2021-09-01T13:55:55.828582Z",
     "shell.execute_reply": "2021-09-01T13:55:55.827579Z",
     "shell.execute_reply.started": "2021-09-01T13:55:55.812575Z"
    }
   },
   "outputs": [],
   "source": [
    "import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:56.010573Z",
     "iopub.status.busy": "2021-09-01T13:55:56.009575Z",
     "iopub.status.idle": "2021-09-01T13:55:56.018573Z",
     "shell.execute_reply": "2021-09-01T13:55:56.017573Z",
     "shell.execute_reply.started": "2021-09-01T13:55:56.010573Z"
    }
   },
   "outputs": [],
   "source": [
    "class ExecutionTimeCounter:\n",
    "\n",
    "    def __enter__(self):\n",
    "        self.start = time.time()\n",
    "        \n",
    "    def __exit__(self, *args):\n",
    "        print(time.time() - self.start)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:56.209770Z",
     "iopub.status.busy": "2021-09-01T13:55:56.208769Z",
     "iopub.status.idle": "2021-09-01T13:55:56.224778Z",
     "shell.execute_reply": "2021-09-01T13:55:56.223778Z",
     "shell.execute_reply.started": "2021-09-01T13:55:56.209770Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "put any code here to measure the executio time\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "with ExecutionTimeCounter() as etc:\n",
    "    print(\"put any code here to measure the executio time\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz\n",
    "- How can we use open() as context manager?  <br>\n",
    "  If you see the soruce code of open fuction, it neithe implment __enter__/__exit__ and nor use contextlib.contextmanager"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function Arguments : args, kwargs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- python supports a function that takes variable number of arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### fixed number of arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:57.164248Z",
     "iopub.status.busy": "2021-09-01T13:55:57.164248Z",
     "iopub.status.idle": "2021-09-01T13:55:57.182248Z",
     "shell.execute_reply": "2021-09-01T13:55:57.180257Z",
     "shell.execute_reply.started": "2021-09-01T13:55:57.164248Z"
    }
   },
   "outputs": [],
   "source": [
    "def func(first, second):\n",
    "    print(first, ' ', second)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:57.361813Z",
     "iopub.status.busy": "2021-09-01T13:55:57.361813Z",
     "iopub.status.idle": "2021-09-01T13:55:57.370801Z",
     "shell.execute_reply": "2021-09-01T13:55:57.369806Z",
     "shell.execute_reply.started": "2021-09-01T13:55:57.361813Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1   2\n"
     ]
    }
   ],
   "source": [
    "func(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:57.566803Z",
     "iopub.status.busy": "2021-09-01T13:55:57.566803Z",
     "iopub.status.idle": "2021-09-01T13:55:57.574798Z",
     "shell.execute_reply": "2021-09-01T13:55:57.573799Z",
     "shell.execute_reply.started": "2021-09-01T13:55:57.566803Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2   1\n"
     ]
    }
   ],
   "source": [
    "func(first=2, second=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### default argumeents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:57.924058Z",
     "iopub.status.busy": "2021-09-01T13:55:57.924058Z",
     "iopub.status.idle": "2021-09-01T13:55:57.938045Z",
     "shell.execute_reply": "2021-09-01T13:55:57.936042Z",
     "shell.execute_reply.started": "2021-09-01T13:55:57.924058Z"
    }
   },
   "outputs": [],
   "source": [
    "def func2(first, second = 2):\n",
    "    print(first, ' ', second)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:58.117573Z",
     "iopub.status.busy": "2021-09-01T13:55:58.116561Z",
     "iopub.status.idle": "2021-09-01T13:55:58.139561Z",
     "shell.execute_reply": "2021-09-01T13:55:58.137572Z",
     "shell.execute_reply.started": "2021-09-01T13:55:58.117573Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1   2\n",
      "1   2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func2(1,2), func2(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:58.312558Z",
     "iopub.status.busy": "2021-09-01T13:55:58.312558Z",
     "iopub.status.idle": "2021-09-01T13:55:58.329558Z",
     "shell.execute_reply": "2021-09-01T13:55:58.327556Z",
     "shell.execute_reply.started": "2021-09-01T13:55:58.312558Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1   2\n"
     ]
    }
   ],
   "source": [
    "func(second=2, first=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:58.501562Z",
     "iopub.status.busy": "2021-09-01T13:55:58.501562Z",
     "iopub.status.idle": "2021-09-01T13:55:58.516559Z",
     "shell.execute_reply": "2021-09-01T13:55:58.515560Z",
     "shell.execute_reply.started": "2021-09-01T13:55:58.501562Z"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "non-default argument follows default argument (<ipython-input-78-3a47c2ec011f>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-78-3a47c2ec011f>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    def func3(first=2, second):\u001b[0m\n\u001b[1;37m             ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m non-default argument follows default argument\n"
     ]
    }
   ],
   "source": [
    "def func3(first=2, second):\n",
    "    print(first, ' ',second)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### arbitary arguments\n",
    "> sometimes, we do not know how many arguments are given"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:58.896548Z",
     "iopub.status.busy": "2021-09-01T13:55:58.896548Z",
     "iopub.status.idle": "2021-09-01T13:55:58.904548Z",
     "shell.execute_reply": "2021-09-01T13:55:58.903557Z",
     "shell.execute_reply.started": "2021-09-01T13:55:58.896548Z"
    }
   },
   "outputs": [],
   "source": [
    "def func4(*args):\n",
    "    # args is a tuple\n",
    "    print(args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:59.079551Z",
     "iopub.status.busy": "2021-09-01T13:55:59.078550Z",
     "iopub.status.idle": "2021-09-01T13:55:59.095548Z",
     "shell.execute_reply": "2021-09-01T13:55:59.094546Z",
     "shell.execute_reply.started": "2021-09-01T13:55:59.079551Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('hello',)\n",
      "('hello', 4, 'world', 3.14)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(None, None)"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func4(\"hello\"), func4(\"hello\", 4, \"world\", 3.14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:59.271851Z",
     "iopub.status.busy": "2021-09-01T13:55:59.271851Z",
     "iopub.status.idle": "2021-09-01T13:55:59.283864Z",
     "shell.execute_reply": "2021-09-01T13:55:59.282852Z",
     "shell.execute_reply.started": "2021-09-01T13:55:59.271851Z"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'lst' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-81-9895bb35cfd1>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mlst1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mlst2\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m6\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m7\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m8\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mfunc4\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m*\u001b[0m\u001b[0mlst\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0mlst2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m9\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'lst' is not defined"
     ]
    }
   ],
   "source": [
    "lst1 = [1,2,3,4]\n",
    "lst2 = [5,6,7,8]\n",
    "func4(*lst, *lst2, 9,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:59.464272Z",
     "iopub.status.busy": "2021-09-01T13:55:59.463285Z",
     "iopub.status.idle": "2021-09-01T13:55:59.474269Z",
     "shell.execute_reply": "2021-09-01T13:55:59.473279Z",
     "shell.execute_reply.started": "2021-09-01T13:55:59.464272Z"
    }
   },
   "outputs": [],
   "source": [
    "def func5(**kwargs):\n",
    "    print(kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:59.642726Z",
     "iopub.status.busy": "2021-09-01T13:55:59.642726Z",
     "iopub.status.idle": "2021-09-01T13:55:59.660711Z",
     "shell.execute_reply": "2021-09-01T13:55:59.659719Z",
     "shell.execute_reply.started": "2021-09-01T13:55:59.642726Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "func5() takes 0 positional arguments but 1 was given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-83-84e086c4b08e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mfunc5\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"hello\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: func5() takes 0 positional arguments but 1 was given"
     ]
    }
   ],
   "source": [
    "func5(\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:55:59.837709Z",
     "iopub.status.busy": "2021-09-01T13:55:59.836713Z",
     "iopub.status.idle": "2021-09-01T13:55:59.853712Z",
     "shell.execute_reply": "2021-09-01T13:55:59.851711Z",
     "shell.execute_reply.started": "2021-09-01T13:55:59.837709Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'first': 'Hello', 'second': 'world'}\n"
     ]
    }
   ],
   "source": [
    "func5(first='Hello', second='world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Enforcement of positional & keyword arguments ( >= Python 3.8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:00.225041Z",
     "iopub.status.busy": "2021-09-01T13:56:00.224042Z",
     "iopub.status.idle": "2021-09-01T13:56:00.342042Z",
     "shell.execute_reply": "2021-09-01T13:56:00.341043Z",
     "shell.execute_reply.started": "2021-09-01T13:56:00.225041Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Active code page: 65001\n",
      "Python 3.7.8\n"
     ]
    }
   ],
   "source": [
    "!python --version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:00.429053Z",
     "iopub.status.busy": "2021-09-01T13:56:00.429053Z",
     "iopub.status.idle": "2021-09-01T13:56:00.437044Z",
     "shell.execute_reply": "2021-09-01T13:56:00.435057Z",
     "shell.execute_reply.started": "2021-09-01T13:56:00.429053Z"
    }
   },
   "outputs": [],
   "source": [
    "def func6(a,b,c,d,e,f):\n",
    "    print(a,b,c,d,e,f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:00.613042Z",
     "iopub.status.busy": "2021-09-01T13:56:00.613042Z",
     "iopub.status.idle": "2021-09-01T13:56:00.626040Z",
     "shell.execute_reply": "2021-09-01T13:56:00.624049Z",
     "shell.execute_reply.started": "2021-09-01T13:56:00.613042Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20 30 40 50 60\n"
     ]
    }
   ],
   "source": [
    "func6(10,20,30,40,50,60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:00.799042Z",
     "iopub.status.busy": "2021-09-01T13:56:00.798042Z",
     "iopub.status.idle": "2021-09-01T13:56:00.817040Z",
     "shell.execute_reply": "2021-09-01T13:56:00.816050Z",
     "shell.execute_reply.started": "2021-09-01T13:56:00.799042Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20 30 40 50 60\n"
     ]
    }
   ],
   "source": [
    "func6(10,20,30, d=40, e=50, f=60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:00.981042Z",
     "iopub.status.busy": "2021-09-01T13:56:00.981042Z",
     "iopub.status.idle": "2021-09-01T13:56:00.991046Z",
     "shell.execute_reply": "2021-09-01T13:56:00.990040Z",
     "shell.execute_reply.started": "2021-09-01T13:56:00.981042Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20 30 40 50 60\n"
     ]
    }
   ],
   "source": [
    "func6(a=10,b=20,c=30, d=40, e=50, f=60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> '/' indicate that parameeters before that should be positional arguments <br>\n",
    "> '*' indicates that parameters after that should be keyword arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:01.367876Z",
     "iopub.status.busy": "2021-09-01T13:56:01.367876Z",
     "iopub.status.idle": "2021-09-01T13:56:01.384876Z",
     "shell.execute_reply": "2021-09-01T13:56:01.382886Z",
     "shell.execute_reply.started": "2021-09-01T13:56:01.367876Z"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-90-bb85b4a57ba0>, line 5)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-90-bb85b4a57ba0>\"\u001b[1;36m, line \u001b[1;32m5\u001b[0m\n\u001b[1;33m    def func7(a,b, / ,c, d, *, e, f):\u001b[0m\n\u001b[1;37m                   ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# a, b shoud be called as positinal arguments\n",
    "# e, f should be called as keyword arguments\n",
    "# c, d could be positional or keyword arguments\n",
    "\n",
    "def func7(a,b, / ,c, d, *, e, f):\n",
    "    print(a,b,c,d,e,f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### unpacking operators : * & **\n",
    "- unpacking operators are operators that unpack the values from iterables objects in Python\n",
    "- '*' can be used on any iterable that Python provides, while '**' can only be used on dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:01.765777Z",
     "iopub.status.busy": "2021-09-01T13:56:01.764791Z",
     "iopub.status.idle": "2021-09-01T13:56:01.777776Z",
     "shell.execute_reply": "2021-09-01T13:56:01.776786Z",
     "shell.execute_reply.started": "2021-09-01T13:56:01.765777Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "list_a = [1, 2, 3]\n",
    "\n",
    "print(*list_a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:01.958777Z",
     "iopub.status.busy": "2021-09-01T13:56:01.958777Z",
     "iopub.status.idle": "2021-09-01T13:56:01.968777Z",
     "shell.execute_reply": "2021-09-01T13:56:01.967775Z",
     "shell.execute_reply.started": "2021-09-01T13:56:01.958777Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, [2, 3, 4, 5], 6)"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_b = [1, 2, 3, 4, 5, 6]\n",
    "\n",
    "a, *b, c =  list_b\n",
    "\n",
    "a, b, c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:02.158780Z",
     "iopub.status.busy": "2021-09-01T13:56:02.157781Z",
     "iopub.status.idle": "2021-09-01T13:56:02.174777Z",
     "shell.execute_reply": "2021-09-01T13:56:02.172791Z",
     "shell.execute_reply.started": "2021-09-01T13:56:02.158780Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list_all = [*list_a, *list_b]\n",
    "list_all"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:02.338045Z",
     "iopub.status.busy": "2021-09-01T13:56:02.337045Z",
     "iopub.status.idle": "2021-09-01T13:56:02.359048Z",
     "shell.execute_reply": "2021-09-01T13:56:02.358054Z",
     "shell.execute_reply.started": "2021-09-01T13:56:02.338045Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['R', 'e', 'a', 'l', 'P', 'y', 't', 'h', 'o', 'n']"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "*a, = \"RealPython\"   #   *a = \"RealPython\" is an syntax error\n",
    "\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quiz\n",
    "- How to merge two dictionaries using unpacking operators?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:02.720516Z",
     "iopub.status.busy": "2021-09-01T13:56:02.720516Z",
     "iopub.status.idle": "2021-09-01T13:56:02.735500Z",
     "shell.execute_reply": "2021-09-01T13:56:02.734509Z",
     "shell.execute_reply.started": "2021-09-01T13:56:02.720516Z"
    }
   },
   "outputs": [],
   "source": [
    "dict_a = {'kc': 'Male', 'yj': 'Female'}\n",
    "dict_c = {'tw': 'Male', 'sm': 'Male'}\n",
    "\n",
    "# let's merge dict_a, dict_b into dict_all\n",
    "dict_all = {  }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  Class Methods : static, instance, class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- instance method: usually you can use it. it has an implicit argument - the 1st one instance itself usually named as 'self'\n",
    "> 'self' refer the instance so you can modify the instance and also the class via 'self.__class__'\n",
    "- class method: it takes an implicit argument - the class itself as the 1st argument usually named as 'cls'\n",
    "> since it can not know the instance objects, we can only modify the class\n",
    "- static method: it has no implicit arguments. \n",
    "> it knows neither of class and instance, so just used for utility-type functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:03.294302Z",
     "iopub.status.busy": "2021-09-01T13:56:03.293301Z",
     "iopub.status.idle": "2021-09-01T13:56:03.313302Z",
     "shell.execute_reply": "2021-09-01T13:56:03.312316Z",
     "shell.execute_reply.started": "2021-09-01T13:56:03.294302Z"
    }
   },
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def method(self):\n",
    "        return 'instance method called', self\n",
    "\n",
    "    @classmethod\n",
    "    def classmethod(cls):\n",
    "        return 'class method called', cls\n",
    "\n",
    "    @staticmethod\n",
    "    def staticmethod():\n",
    "        return 'static method called'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- instance method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:03.674769Z",
     "iopub.status.busy": "2021-09-01T13:56:03.674769Z",
     "iopub.status.idle": "2021-09-01T13:56:03.687787Z",
     "shell.execute_reply": "2021-09-01T13:56:03.686776Z",
     "shell.execute_reply.started": "2021-09-01T13:56:03.674769Z"
    }
   },
   "outputs": [],
   "source": [
    "obj = MyClass()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:03.861771Z",
     "iopub.status.busy": "2021-09-01T13:56:03.860788Z",
     "iopub.status.idle": "2021-09-01T13:56:03.877770Z",
     "shell.execute_reply": "2021-09-01T13:56:03.876769Z",
     "shell.execute_reply.started": "2021-09-01T13:56:03.861771Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('instance method called', <__main__.MyClass at 0x19b9a111e08>)"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj.method()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:04.062090Z",
     "iopub.status.busy": "2021-09-01T13:56:04.062090Z",
     "iopub.status.idle": "2021-09-01T13:56:04.080075Z",
     "shell.execute_reply": "2021-09-01T13:56:04.079083Z",
     "shell.execute_reply.started": "2021-09-01T13:56:04.062090Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('instance method called', <__main__.MyClass at 0x19b9a111e08>)"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyClass.method(obj)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:04.252518Z",
     "iopub.status.busy": "2021-09-01T13:56:04.252518Z",
     "iopub.status.idle": "2021-09-01T13:56:04.269520Z",
     "shell.execute_reply": "2021-09-01T13:56:04.268519Z",
     "shell.execute_reply.started": "2021-09-01T13:56:04.252518Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "method() takes 1 positional argument but 2 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-100-b248c6667315>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# warning !!!!\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mobj\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmethod\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: method() takes 1 positional argument but 2 were given"
     ]
    }
   ],
   "source": [
    "# warning !!!!\n",
    "obj.method(obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- class method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:04.632378Z",
     "iopub.status.busy": "2021-09-01T13:56:04.631362Z",
     "iopub.status.idle": "2021-09-01T13:56:04.649365Z",
     "shell.execute_reply": "2021-09-01T13:56:04.648377Z",
     "shell.execute_reply.started": "2021-09-01T13:56:04.632378Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('class method called', __main__.MyClass)"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyClass.classmethod()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:04.822379Z",
     "iopub.status.busy": "2021-09-01T13:56:04.822379Z",
     "iopub.status.idle": "2021-09-01T13:56:04.841364Z",
     "shell.execute_reply": "2021-09-01T13:56:04.840375Z",
     "shell.execute_reply.started": "2021-09-01T13:56:04.822379Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('class method called', __main__.MyClass)"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj.classmethod()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- static method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:05.219316Z",
     "iopub.status.busy": "2021-09-01T13:56:05.219316Z",
     "iopub.status.idle": "2021-09-01T13:56:05.232319Z",
     "shell.execute_reply": "2021-09-01T13:56:05.231318Z",
     "shell.execute_reply.started": "2021-09-01T13:56:05.219316Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'static method called'"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "MyClass.staticmethod()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:05.395643Z",
     "iopub.status.busy": "2021-09-01T13:56:05.394631Z",
     "iopub.status.idle": "2021-09-01T13:56:05.407627Z",
     "shell.execute_reply": "2021-09-01T13:56:05.406636Z",
     "shell.execute_reply.started": "2021-09-01T13:56:05.395643Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'static method called'"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obj.staticmethod()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class factory methods\n",
    "- Python constructor can not be overloaded. So, there must be some methods to create instances - Factory Methods\n",
    "- Class methods are usually used for factory methods (instead of constructor overriding)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:05.783364Z",
     "iopub.status.busy": "2021-09-01T13:56:05.783364Z",
     "iopub.status.idle": "2021-09-01T13:56:05.789365Z",
     "shell.execute_reply": "2021-09-01T13:56:05.788380Z",
     "shell.execute_reply.started": "2021-09-01T13:56:05.783364Z"
    }
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:06.007836Z",
     "iopub.status.busy": "2021-09-01T13:56:06.006821Z",
     "iopub.status.idle": "2021-09-01T13:56:06.026830Z",
     "shell.execute_reply": "2021-09-01T13:56:06.025828Z",
     "shell.execute_reply.started": "2021-09-01T13:56:06.007836Z"
    }
   },
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x, y, r):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self.r = r\n",
    "        \n",
    "    def area(self):\n",
    "        return 3.14 * self.r * self.r\n",
    "    \n",
    "    @classmethod\n",
    "    def fromtwopoints(cls, x1, y1, x2, y2):\n",
    "        return Point((x2-x1)/2, (y2-y1)/2, math.sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1))/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:06.178158Z",
     "iopub.status.busy": "2021-09-01T13:56:06.177141Z",
     "iopub.status.idle": "2021-09-01T13:56:06.184153Z",
     "shell.execute_reply": "2021-09-01T13:56:06.183151Z",
     "shell.execute_reply.started": "2021-09-01T13:56:06.178158Z"
    }
   },
   "outputs": [],
   "source": [
    "a = Point(0,0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:06.362140Z",
     "iopub.status.busy": "2021-09-01T13:56:06.361141Z",
     "iopub.status.idle": "2021-09-01T13:56:06.374144Z",
     "shell.execute_reply": "2021-09-01T13:56:06.373155Z",
     "shell.execute_reply.started": "2021-09-01T13:56:06.361141Z"
    }
   },
   "outputs": [],
   "source": [
    "b = Point.fromtwopoints(1,0,-1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:06.552818Z",
     "iopub.status.busy": "2021-09-01T13:56:06.552818Z",
     "iopub.status.idle": "2021-09-01T13:56:06.563805Z",
     "shell.execute_reply": "2021-09-01T13:56:06.562813Z",
     "shell.execute_reply.started": "2021-09-01T13:56:06.552818Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3.14, 3.14)"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.area(), b.area()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Today's Tip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:06.924986Z",
     "iopub.status.busy": "2021-09-01T13:56:06.923991Z",
     "iopub.status.idle": "2021-09-01T13:56:06.936986Z",
     "shell.execute_reply": "2021-09-01T13:56:06.936002Z",
     "shell.execute_reply.started": "2021-09-01T13:56:06.924986Z"
    }
   },
   "outputs": [],
   "source": [
    "from IPython.core.display import display, HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {
    "execution": {
     "iopub.execute_input": "2021-09-01T13:56:07.819388Z",
     "iopub.status.busy": "2021-09-01T13:56:07.818403Z",
     "iopub.status.idle": "2021-09-01T13:56:07.839389Z",
     "shell.execute_reply": "2021-09-01T13:56:07.838390Z",
     "shell.execute_reply.started": "2021-09-01T13:56:07.819388Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>.jp-Cell { width:100% !important; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(HTML(\"<style>.jp-Cell { width:100% !important; }</style>\"))"
   ]
  }
 ],
 "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.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}