tutorials/GitHub_MD_rendering/Dunder methods.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "23fe02ed",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n",
""   ]
  },
  {
   "cell_type": "markdown",
   "id": "3978ffd8",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06ba2536",
   "metadata": {},
   "source": [
    "\n",
    "**What?** Dunder (double underscore) methods\n",
    "\n",
""   ]
  },
  {
   "cell_type": "markdown",
   "id": "089f47ef",
   "metadata": {},
   "source": [
    "# Things to know about python functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ddb9e58b",
   "metadata": {},
   "source": [
    "- Each function in python is treated as an object.\n",
    "- Each function in python has special method identified by a preceeding and trainling dunder: `__`\n",
    "- Dunder (Doble UNDERscore) methods are also called **magic method**.\n",
    "- This notebook explore each one of them through examples.\n",
    "- Python functions are first class objects."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "deb594e2",
   "metadata": {},
   "source": [
    "# List of function special methods"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5658cf87",
   "metadata": {},
   "source": [
    "- Let us create a dummy function which takes no arguments and returns nothing.\n",
    "- We'll then apply the method `dir` and explore what methods are available.\n",
    "- The **common pattern** here is that the magic method is there to customise the result of python built-in funciton. So for instance, - `__subclasscheck__` is one of the methods to customise the result of `issubclass()` built-in function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b04f4d92",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.627095Z",
     "start_time": "2022-04-14T06:54:35.624112Z"
    }
   },
   "outputs": [],
   "source": [
    "def func():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "869bf4f4",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.640347Z",
     "start_time": "2022-04-14T06:54:35.629511Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__annotations__',\n",
       " '__call__',\n",
       " '__class__',\n",
       " '__closure__',\n",
       " '__code__',\n",
       " '__defaults__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__get__',\n",
       " '__getattribute__',\n",
       " '__globals__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__kwdefaults__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__name__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__qualname__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(func)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67f1991f",
   "metadata": {},
   "source": [
    "- Just in case you are wondering.\n",
    "- This looks fairly similar to the output of `dir(class_instantiation)`.\n",
    "- What are the differences?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7bf5a689",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.645655Z",
     "start_time": "2022-04-14T06:54:35.643103Z"
    }
   },
   "outputs": [],
   "source": [
    "class A():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "07504e07",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.650088Z",
     "start_time": "2022-04-14T06:54:35.647473Z"
    }
   },
   "outputs": [],
   "source": [
    "a = A()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fbcad88d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.657027Z",
     "start_time": "2022-04-14T06:54:35.653040Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6867d44",
   "metadata": {},
   "source": [
    "# `__annotations__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4cc6dd8",
   "metadata": {},
   "source": [
    "- They are generally used to attach metadata to functions describing their parameters and return values.\n",
    "- The symbol0 `->` marks the return function annotation.\n",
    "- Annotation are dictionary.\n",
    "- You can also provide another dictionary rather than a simple string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "41ce1fdb",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.661766Z",
     "start_time": "2022-04-14T06:54:35.659135Z"
    }
   },
   "outputs": [],
   "source": [
    "def func_1(a: \"this is argument a\") -> \"This is a squared\":\n",
    "    return a**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b547c181",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.667947Z",
     "start_time": "2022-04-14T06:54:35.664305Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.func_1(a: 'this is argument a') -> 'This is a squared'>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# first way to call\n",
    "func_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bb8d22fd",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.673496Z",
     "start_time": "2022-04-14T06:54:35.670033Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'this is argument a', 'return': 'This is a squared'}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# second way to call\n",
    "func_1.__annotations__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f770b792",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.680139Z",
     "start_time": "2022-04-14T06:54:35.676500Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'4 This is a squared'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Annotations is a dictionary\n",
    "'{:,} {}'.format(func_1(2),\n",
    "                 func_1.__annotations__['return'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "37d9ede3",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.685079Z",
     "start_time": "2022-04-14T06:54:35.682074Z"
    }
   },
   "outputs": [],
   "source": [
    "rd = {'type': float, 'units': 'Joules',\n",
    "      'docstring': 'Given mass and velocity returns kinetic energy in Joules'}\n",
    "\n",
    "def func_2() -> rd:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "38036d4a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.690282Z",
     "start_time": "2022-04-14T06:54:35.686985Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n",
      "Joules\n",
      "Given mass and velocity returns kinetic energy in Joules\n"
     ]
    }
   ],
   "source": [
    "for i in ['type', \"units\", \"docstring\"]:\n",
    "    print(func_2.__annotations__['return'][i])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c316ab1f",
   "metadata": {},
   "source": [
    "# `__call__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "343c1819",
   "metadata": {},
   "source": [
    "- `__call__` is a built-in method which enables to write classes where the **instances behave like functions** and can be called like a function.\n",
    "- In practice: `object()` is shorthand for `object.__call__()`\n",
    "- `__init__()` is properly defined as Class Constructor which builds an instance of a class, whereas `__call__` makes such a instance callable as a function and therefore can be modifiable.\n",
    "- Technically `__init__` is called once by `__new__` when object is created, so that it can be initialised\n",
    "- But there are many scenarios where you might want to redefine your object, say you are done with your object, and may find a need for a new object. With `__call__` you can redefine the same object as if it were new."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6cc7dfa3",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.697625Z",
     "start_time": "2022-04-14T06:54:35.694229Z"
    }
   },
   "outputs": [],
   "source": [
    "class Product():\n",
    "    def __init__(self):\n",
    "        print(\"Instance created\")\n",
    "\n",
    "    # Defining __call__ method\n",
    "    def __call__(self, a, b):\n",
    "        print(\"Instance is called via special method __call__\")\n",
    "        print(a*b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "1d5f83d4",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.702196Z",
     "start_time": "2022-04-14T06:54:35.699756Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Instance created\n"
     ]
    }
   ],
   "source": [
    "p = Product()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "c4fa5666",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.707004Z",
     "start_time": "2022-04-14T06:54:35.704323Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Instance created\n"
     ]
    }
   ],
   "source": [
    "# This is equivalent to\n",
    "p.__init__()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "009611f0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.713531Z",
     "start_time": "2022-04-14T06:54:35.710624Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Instance is called via special method __call__\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# Since Product has  a __call_ method, p can be called like a function\n",
    "p(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "dde980f1",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.718623Z",
     "start_time": "2022-04-14T06:54:35.715766Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Instance is called via special method __call__\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# The cell above is equivalent to this call\n",
    "p.__call__(2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85e1a4b6",
   "metadata": {},
   "source": [
    "# `__class__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "362a582f",
   "metadata": {},
   "source": [
    "- `__class__` is an attribute on the object that refers to the class from which the object was created.\n",
    "- As functions are also objects in Python, we can find their `type` or class using the type function or the `__class__` attribute."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "6a76682a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.723172Z",
     "start_time": "2022-04-14T06:54:35.720649Z"
    }
   },
   "outputs": [],
   "source": [
    "def simple_function():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "180c3c9a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.729536Z",
     "start_time": "2022-04-14T06:54:35.726122Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(simple_function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e78f85f2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.735463Z",
     "start_time": "2022-04-14T06:54:35.731443Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "simple_function.__class__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83699c87",
   "metadata": {},
   "source": [
    "# `__closure__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31211e92",
   "metadata": {},
   "source": [
    "- A closure is a function object **that remembers values** in enclosing scopes **even if** they are not present in memory. \n",
    "- The `__closure__` attribute of a closure function returns a tuple of cell objects. \n",
    "- This cell object also has an attribute called cell_contents, which returns returns the contents of the cell.\n",
    "- In the above example, the nested function power has `__closure__` attribute associated with it and it returns a tuple of cell objects. \n",
    "- The cell_contents attribute returns the value 3 as it was closed inside the cell object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2a80e5d7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.741222Z",
     "start_time": "2022-04-14T06:54:35.738048Z"
    }
   },
   "outputs": [],
   "source": [
    "# this is a nested function\n",
    "def gfg(raise_power_to):\n",
    "\n",
    "    def power(number):\n",
    "        return number ** raise_power_to\n",
    "    return power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "66004116",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.745477Z",
     "start_time": "2022-04-14T06:54:35.743095Z"
    }
   },
   "outputs": [],
   "source": [
    "raise_power_to_3 = gfg(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c3fb0ba3",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.750562Z",
     "start_time": "2022-04-14T06:54:35.747355Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(<cell at 0x7fbe5b2176d0: int object at 0x7fbe54121970>,)\n"
     ]
    }
   ],
   "source": [
    "print(raise_power_to_3.__closure__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "9a3869cd",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.756556Z",
     "start_time": "2022-04-14T06:54:35.753412Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(raise_power_to_3.__closure__[0].cell_contents)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e73e69a",
   "metadata": {},
   "source": [
    "# `__code__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca21b761",
   "metadata": {},
   "source": [
    "- Every function in Python has a __code__ attribute that holds its code object.\n",
    "- When called, we get back some representation of the code object, which is almost useless to us. What's a lot more useful is to inspect further attributes on this code object:\n",
    "    \n",
    "    - `co_nlocals` — is the number of local variables used by the function (including arguments).\n",
    "    - `co_argcount` — is the total number of positional arguments (including positional-only arguments and arguments with default values).\n",
    "    - `co_varnames` — is a tuple containing the names of the local variables (starting with the argument names).\n",
    "    - `co_names` — is a tuple containing the names used by the bytecode.\n",
    "    - `co_cellvars` — is a tuple containing the names of local variables that are referenced by nested functions.\n",
    "    - `co_freevars` — is a tuple containing the names of free variables; co_code is a string representing the sequence of bytecode instructions.\n",
    "    - `co_posonlyargcount` — is the number of positional-only arguments (including arguments with default values).\n",
    "    - `co_kwonlyargcount` — is the number of keyword-only arguments (including arguments with default values).\n",
    "    - `co_firstlineno` — is the first line number of the function.\n",
    "    - `co_lnotab` — is a string encoding the mapping from bytecode offsets to line numbers (for details see the source code of the interpreter).\n",
    "    - `co_stacksize` — is the required stack size.\n",
    "    - `co_code' — is a string representing the sequence of bytecode instructions.\n",
    "    - `co_consts` — is a tuple containing the literals used by the bytecode.\n",
    "    - `co_flags` — is an integer encoding a number of flags for the interpreter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "2564ad63",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.761024Z",
     "start_time": "2022-04-14T06:54:35.758629Z"
    }
   },
   "outputs": [],
   "source": [
    "def func_3(x):\n",
    "    return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "392b2269",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.766796Z",
     "start_time": "2022-04-14T06:54:35.763102Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<code object func_3 at 0x7fbe5b212ea0, file \"/var/folders/5x/lyqr8wv507n43bnwpsz4dq_c0000gn/T/ipykernel_4751/407776788.py\", line 1>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func_3.__code__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "1915cffe",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.772134Z",
     "start_time": "2022-04-14T06:54:35.768751Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func_3.__code__.co_nlocals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "75218096",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.779126Z",
     "start_time": "2022-04-14T06:54:35.775426Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func_3.__code__.co_argcount"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa61d9fc",
   "metadata": {},
   "source": [
    "# `__defaults__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "407784ac",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-11T10:57:04.879944Z",
     "start_time": "2022-04-11T10:57:04.875935Z"
    }
   },
   "source": [
    "- Shows the default attribute of the function.\n",
    "- `__defaults__` is a tuple containing default argument values for those arguments that have defaults (r None if no arguments have a default value.\n",
    "- Their default arguments values are evaluated on definition and stored in the special attributes.`__defaults__` and `__kwdefaults__`.\n",
    "- Default argument values are stored in the function object and not the code object (since they represent values calculated at runtime)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "e87ba8fa",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.783385Z",
     "start_time": "2022-04-14T06:54:35.781120Z"
    }
   },
   "outputs": [],
   "source": [
    "def func(a, b):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "f3c4b445",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.787909Z",
     "start_time": "2022-04-14T06:54:35.785115Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(func.__defaults__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "18cd78fd",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.794776Z",
     "start_time": "2022-04-14T06:54:35.791099Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func.__defaults__ is None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "fc393b54",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.799486Z",
     "start_time": "2022-04-14T06:54:35.796716Z"
    }
   },
   "outputs": [],
   "source": [
    "def foobar(element, data=[]):\n",
    "    data.append(element)\n",
    "    return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "f3728069",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.804705Z",
     "start_time": "2022-04-14T06:54:35.801323Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([],)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Before execution\n",
    "foobar.__defaults__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "b98dfe03",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.810050Z",
     "start_time": "2022-04-14T06:54:35.806670Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[12]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foobar(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "9b55bfd7",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.817019Z",
     "start_time": "2022-04-14T06:54:35.813361Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[12, 12]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foobar(12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "3abb1183",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.822308Z",
     "start_time": "2022-04-14T06:54:35.818953Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([12, 12],)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "foobar.__defaults__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3dd9567",
   "metadata": {},
   "source": [
    "# `__delattr__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ba5f5f3",
   "metadata": {},
   "source": [
    "- Called when an attribute deletion is attempted.\n",
    "- Like `__setattr__()` but for attribute deletion instead of assignment. \n",
    "- This should only be implemented if del `obj.name` is meaningful for the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "c45a7e05",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.827365Z",
     "start_time": "2022-04-14T06:54:35.824241Z"
    }
   },
   "outputs": [],
   "source": [
    "class Frob():\n",
    "    def __delattr__(self, name):\n",
    "        print(\"deleting `{}`\".format(str(name)))\n",
    "        del self.__dict__[name]\n",
    "        print(\"`{}` deleted\".format(str(name)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "3847fd9d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.831722Z",
     "start_time": "2022-04-14T06:54:35.829300Z"
    }
   },
   "outputs": [],
   "source": [
    "f = Frob()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "d818f31d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.839230Z",
     "start_time": "2022-04-14T06:54:35.834973Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__']"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "c849c391",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.843555Z",
     "start_time": "2022-04-14T06:54:35.841130Z"
    }
   },
   "outputs": [],
   "source": [
    "# Adding a class (instance?) attribute\n",
    "f.dummy = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "e25cdcdd",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.849317Z",
     "start_time": "2022-04-14T06:54:35.845502Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__class__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " '__weakref__',\n",
       " 'dummy']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Now you show be able to see \"dummy\" listed there\n",
    "dir(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "fb4c09a2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.854115Z",
     "start_time": "2022-04-14T06:54:35.851270Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deleting `dummy`\n",
      "`dummy` deleted\n"
     ]
    }
   ],
   "source": [
    "del f.dummy"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60e41bf9",
   "metadata": {},
   "source": [
    "# `__dict__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d388396d",
   "metadata": {},
   "source": [
    "- Basically it contains all the attributes which describe the object in question. It can be used to alter or read the attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "abf19f3b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-21T12:48:51.781397Z",
     "start_time": "2023-06-21T12:48:51.778162Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'temp': 1}\n"
     ]
    }
   ],
   "source": [
    "def func_1():\n",
    "    pass\n",
    "\n",
    "func_1.temp = 1\n",
    "\n",
    "print(func_1.__dict__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1171f167",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-21T12:48:52.747880Z",
     "start_time": "2023-06-21T12:48:52.745100Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{}\n"
     ]
    }
   ],
   "source": [
    "def func_2():\n",
    "    pass\n",
    "\n",
    "print(func_2.__dict__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e7eb3366",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-21T12:48:53.333205Z",
     "start_time": "2023-06-21T12:48:53.330211Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'__module__': '__main__', 'a': 1, 'temp_function': <function TempClass.temp_function at 0x7fe325492ca0>, '__dict__': <attribute '__dict__' of 'TempClass' objects>, '__weakref__': <attribute '__weakref__' of 'TempClass' objects>, '__doc__': None}\n"
     ]
    }
   ],
   "source": [
    "class TempClass:\n",
    "    a = 1\n",
    "\n",
    "    def temp_function(self):\n",
    "        pass\n",
    "\n",
    "\n",
    "print(TempClass.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cab4f9a5",
   "metadata": {},
   "source": [
    "- As we saw above, the namespace can be accessed with `__dict__`.\n",
    "- Another way to see its contents is to type `vars()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "07718110",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-21T12:50:14.625924Z",
     "start_time": "2023-06-21T12:50:14.622367Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('__name__', 'math'), ('__doc__', 'This module provides access to the mathematical functions\\ndefined by the C standard.'), ('__package__', ''), ('__loader__', <_frozen_importlib_external.ExtensionFileLoader object at 0x7fe3214c4910>), ('__spec__', ModuleSpec(name='math', loader=<_frozen_importlib_external.ExtensionFileLoader object at 0x7fe3214c4910>, origin='/opt/anaconda3/envs/trainingAI/lib/python3.9/lib-dynload/math.cpython-39-darwin.so')), ('acos', <built-in function acos>), ('acosh', <built-in function acosh>), ('asin', <built-in function asin>), ('asinh', <built-in function asinh>), ('atan', <built-in function atan>), ('atan2', <built-in function atan2>), ('atanh', <built-in function atanh>), ('ceil', <built-in function ceil>), ('copysign', <built-in function copysign>), ('cos', <built-in function cos>), ('cosh', <built-in function cosh>), ('degrees', <built-in function degrees>), ('dist', <built-in function dist>), ('erf', <built-in function erf>), ('erfc', <built-in function erfc>), ('exp', <built-in function exp>), ('expm1', <built-in function expm1>), ('fabs', <built-in function fabs>), ('factorial', <built-in function factorial>), ('floor', <built-in function floor>), ('fmod', <built-in function fmod>), ('frexp', <built-in function frexp>), ('fsum', <built-in function fsum>), ('gamma', <built-in function gamma>), ('gcd', <built-in function gcd>), ('hypot', <built-in function hypot>), ('isclose', <built-in function isclose>), ('isfinite', <built-in function isfinite>), ('isinf', <built-in function isinf>), ('isnan', <built-in function isnan>), ('isqrt', <built-in function isqrt>), ('lcm', <built-in function lcm>), ('ldexp', <built-in function ldexp>), ('lgamma', <built-in function lgamma>), ('log', <built-in function log>), ('log1p', <built-in function log1p>), ('log10', <built-in function log10>), ('log2', <built-in function log2>), ('modf', <built-in function modf>), ('pow', <built-in function pow>), ('radians', <built-in function radians>), ('remainder', <built-in function remainder>), ('sin', <built-in function sin>), ('sinh', <built-in function sinh>), ('sqrt', <built-in function sqrt>), ('tan', <built-in function tan>), ('tanh', <built-in function tanh>), ('trunc', <built-in function trunc>), ('prod', <built-in function prod>), ('perm', <built-in function perm>), ('comb', <built-in function comb>), ('nextafter', <built-in function nextafter>), ('ulp', <built-in function ulp>), ('__file__', '/opt/anaconda3/envs/trainingAI/lib/python3.9/lib-dynload/math.cpython-39-darwin.so'), ('pi', 3.141592653589793), ('e', 2.718281828459045), ('tau', 6.283185307179586), ('inf', inf), ('nan', nan)])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "vars(math).items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "cf663611",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-21T12:50:23.199988Z",
     "start_time": "2023-06-21T12:50:23.195330Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'acos',\n",
       " 'acosh',\n",
       " 'asin',\n",
       " 'asinh',\n",
       " 'atan',\n",
       " 'atan2',\n",
       " 'atanh',\n",
       " 'ceil',\n",
       " 'comb',\n",
       " 'copysign',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'degrees',\n",
       " 'dist',\n",
       " 'e',\n",
       " 'erf',\n",
       " 'erfc',\n",
       " 'exp',\n",
       " 'expm1',\n",
       " 'fabs',\n",
       " 'factorial',\n",
       " 'floor',\n",
       " 'fmod',\n",
       " 'frexp',\n",
       " 'fsum',\n",
       " 'gamma',\n",
       " 'gcd',\n",
       " 'hypot',\n",
       " 'inf',\n",
       " 'isclose',\n",
       " 'isfinite',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'isqrt',\n",
       " 'lcm',\n",
       " 'ldexp',\n",
       " 'lgamma',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'modf',\n",
       " 'nan',\n",
       " 'nextafter',\n",
       " 'perm',\n",
       " 'pi',\n",
       " 'pow',\n",
       " 'prod',\n",
       " 'radians',\n",
       " 'remainder',\n",
       " 'sin',\n",
       " 'sinh',\n",
       " 'sqrt',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tau',\n",
       " 'trunc',\n",
       " 'ulp']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80cbd61c",
   "metadata": {},
   "source": [
    "# `__dir__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb3c979a",
   "metadata": {},
   "source": [
    "- `dir([object])`¶ Without arguments, return the list of names in the current local scope. With an argument, attempt to return a list of valid attributes for that object.\n",
    "\n",
    "- If the object has a method named `__dir__()`, this method will be called and must return the list of attributes. This allows objects that implement a custom `__getattr__()` or `__getattribute__()` function to customize the way `dir()` reports their attributes.\n",
    "\n",
    "- If the object does not provide `__dir__()`, the function tries its best to gather information from the object’s `__dict__`attribute, if defined, and from its type object. The resulting list is not necessarily complete, and may be inaccurate when the object has a custom `__getattr__()`.\n",
    "\n",
    "- `dir` calls `__dir__` internally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "9a9db887",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.875976Z",
     "start_time": "2022-04-14T06:54:35.873097Z"
    }
   },
   "outputs": [],
   "source": [
    "class Hello():\n",
    "    def __dir__(self):\n",
    "        print(\"calling __dir__\")\n",
    "        return [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "6cef672e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.880329Z",
     "start_time": "2022-04-14T06:54:35.877894Z"
    }
   },
   "outputs": [],
   "source": [
    "hello = Hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "69e7cee5",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.887429Z",
     "start_time": "2022-04-14T06:54:35.883543Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling __dir__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(hello)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "20f8b936",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.893333Z",
     "start_time": "2022-04-14T06:54:35.889526Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling __dir__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hello.__dir__()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df7499c8",
   "metadata": {},
   "source": [
    "# `__doc__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8c178d5",
   "metadata": {},
   "source": [
    "- Python objects have an attribute called __doc__ that provides a documentation of the object. \n",
    "- For example, you simply call Dog.__doc__ on your class Dog to retrieve its documentation as a string. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "5084b1b4",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.898570Z",
     "start_time": "2022-04-14T06:54:35.895714Z"
    }
   },
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    \"\"\"Your best friend.\"\"\"\n",
    "\n",
    "    def do_nothing(self):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "068b0e9e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.903318Z",
     "start_time": "2022-04-14T06:54:35.900474Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your best friend.\n"
     ]
    }
   ],
   "source": [
    "print(Dog.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "bf70266a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.909138Z",
     "start_time": "2022-04-14T06:54:35.905400Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Your best friend.'"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# It works the same even after instantiation\n",
    "dog = Dog()\n",
    "dog.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4a40522",
   "metadata": {},
   "source": [
    "# `__eq__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b06f899",
   "metadata": {},
   "source": [
    "- Implement the Python `__eq__` method to define the equality logic for comparing two objects using the equal operator `==`.\n",
    "- Python automatically calls the `__eq__` method of a class when you use the `==` operator to compare the instances of the class. By default, Python uses the is operator if you don’t provide a specific implementation for the `__eq__` method.\n",
    "- "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "a5ed1dae",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.916573Z",
     "start_time": "2022-04-14T06:54:35.912865Z"
    }
   },
   "outputs": [],
   "source": [
    "class Person:\n",
    "    \"\"\"\n",
    "    The following shows how to implement the __eq__ method \n",
    "    in the Person class that returns True if two person \n",
    "    objects have the same age:\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, first_name, last_name, age):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "        self.age = age\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        print(\"calling dunder method __eq__\")\n",
    "        return self.age == other.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "b78e50a5",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.921816Z",
     "start_time": "2022-04-14T06:54:35.918655Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling dunder method __eq__\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "john = Person('John', 'Doe', 25)\n",
    "jane = Person('Jane', 'Doe', 25)\n",
    "print(john == jane)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56f27a6a",
   "metadata": {},
   "source": [
    "# `__format__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dc5b31f",
   "metadata": {},
   "source": [
    "- Each Python type can control formatting of its instances by defining a __format__ method. \n",
    "\n",
    "- The `__format__` method is responsible for interpreting the format specifier, formatting the value, and returning the resulting string.\n",
    "\n",
    "- The new, global built-in function `format` simply calls this special method, similar to how `len()` and `str()` simply call their respective special methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "e13eca7c",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.926444Z",
     "start_time": "2022-04-14T06:54:35.923827Z"
    }
   },
   "outputs": [],
   "source": [
    "# custom __format__() method\n",
    "class Person:\n",
    "    def __format__(self, format):\n",
    "        if(format == 'age'):\n",
    "            return '23'\n",
    "        return 'None'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "506af550",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.931870Z",
     "start_time": "2022-04-14T06:54:35.928412Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'23'"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The format() function internally runs Person().__format__(\"age\") to return 23.\n",
    "format(Person(), \"age\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16ecdb4d",
   "metadata": {},
   "source": [
    "# `__ge__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d6e42a54",
   "metadata": {},
   "source": [
    "- To customize the behavior of the greather than or equal to operator x >= y, override the `__ge__()` dunder method in your class definition.\n",
    "- Python internally calls `x.__ge__(y)` to obtain a return value when comparing two objects using `x >= y`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "855a9922",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.938351Z",
     "start_time": "2022-04-14T06:54:35.935194Z"
    }
   },
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, age):\n",
    "        self.age = age\n",
    "\n",
    "    def __ge__(self, other):\n",
    "        print(\"Calling dunder method __ge__\")\n",
    "        return self.age >= other.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "b7537f26",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.943181Z",
     "start_time": "2022-04-14T06:54:35.940569Z"
    }
   },
   "outputs": [],
   "source": [
    "alice = Person(18)\n",
    "bob = Person(17)\n",
    "carl = Person(18)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "7d2b1326",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.948841Z",
     "start_time": "2022-04-14T06:54:35.945129Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Calling dunder method __ge__\n",
      "True\n",
      "Calling dunder method __ge__\n",
      "True\n",
      "Calling dunder method __ge__\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(alice >= bob)\n",
    "print(alice >= carl)\n",
    "print(bob >= alice)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f11dedc",
   "metadata": {},
   "source": [
    "# `__get__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f175e79",
   "metadata": {},
   "source": [
    "- Called to get the attribute of the owner class (class attribute access) or of an instance of that class (instance attribute access)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "b712f230",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.955506Z",
     "start_time": "2022-04-14T06:54:35.951121Z"
    }
   },
   "outputs": [],
   "source": [
    "# This is our descriptor object\n",
    "class Bar():\n",
    "    def __init__(self):\n",
    "        self.value = ''\n",
    "\n",
    "    def __get__(self, instance, owner):\n",
    "        print(\"returned from descriptor object\")\n",
    "        return self.value\n",
    "\n",
    "    def __set__(self, instance, value):\n",
    "        print(\"set in descriptor object\")\n",
    "        self.value = value\n",
    "\n",
    "    def __delete__(self, instance):\n",
    "        print(\"deleted in descriptor object\")\n",
    "        del self.value\n",
    "\n",
    "\n",
    "class Foo(object):\n",
    "    bar = Bar()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "bbc35609",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.962361Z",
     "start_time": "2022-04-14T06:54:35.959795Z"
    }
   },
   "outputs": [],
   "source": [
    "f = Foo()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "faac0fbc",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.967034Z",
     "start_time": "2022-04-14T06:54:35.964253Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "set in descriptor object\n"
     ]
    }
   ],
   "source": [
    "f.bar = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "720c5462",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.972072Z",
     "start_time": "2022-04-14T06:54:35.969272Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "returned from descriptor object\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "print(f.bar)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "6dbf88fe",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.977167Z",
     "start_time": "2022-04-14T06:54:35.974333Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "deleted in descriptor object\n"
     ]
    }
   ],
   "source": [
    "del f.bar"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "441fa9ee",
   "metadata": {},
   "source": [
    "# `__getattribute__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "190479c9",
   "metadata": {},
   "source": [
    "- `__getattr__` called when an attribute lookup **has not found** the attribute in the usual places.\n",
    "- Note that if the attribute is found through the normal mechanism, `__getattr__()` is not called. \n",
    "- This is done both for efficiency reasons and because otherwise `__getattr__()` would have no way to access other attributes of the instance.\n",
    "- Note that at least for instance variables, you can fake total control by not inserting any values in the instance attribute dictionary (but instead inserting them in another object). See the `__getattribute__()` method below for a way to actually get total control in new-style classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "d3f41763",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.983351Z",
     "start_time": "2022-04-14T06:54:35.979218Z"
    }
   },
   "outputs": [],
   "source": [
    "class Yeah(object):\n",
    "    def __init__(self, name):\n",
    "        # Gets called when an attribute is accessed\n",
    "        self.name = name\n",
    "\n",
    "    def __getattribute__(self, item):\n",
    "        print('__getattribute__ ', item)\n",
    "        # Calling the super class to avoid recursion\n",
    "        # Gets called when the item is not found via __getattribute__\n",
    "        return super(Yeah, self).__getattribute__(item)\n",
    "\n",
    "    def __getattr__(self, item):\n",
    "        print('__getattr__ ', item)\n",
    "        return super(Yeah, self).__setattr__(item, 'orphan')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "6723472a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.991203Z",
     "start_time": "2022-04-14T06:54:35.987109Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__getattribute__  name\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'yes'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y1 = Yeah('yes')\n",
    "y1.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "a2f3a80a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:35.996009Z",
     "start_time": "2022-04-14T06:54:35.993244Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__getattribute__  foo\n",
      "__getattr__  foo\n"
     ]
    }
   ],
   "source": [
    "y1.foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "4a6b9624",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.001980Z",
     "start_time": "2022-04-14T06:54:35.997990Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__getattribute__  foo\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'orphan'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y1.foo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "22f10ea8",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.007062Z",
     "start_time": "2022-04-14T06:54:36.004185Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__getattribute__  goo\n",
      "__getattr__  goo\n"
     ]
    }
   ],
   "source": [
    "y1.goo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "a9abff34",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.013315Z",
     "start_time": "2022-04-14T06:54:36.009342Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__getattribute__  __dict__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'name': 'yes', 'foo': 'orphan', 'goo': 'orphan'}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y1.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10e4682d",
   "metadata": {},
   "source": [
    "# `__globals__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4bd29951",
   "metadata": {},
   "source": [
    "- Python functions keep a reference to the non-local variables used in the following attributes\n",
    "    - `__globals__` This is a reference to the module globals dict.\n",
    "    - `__closure__` Variables used in the function closure.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "e51d6754",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.018684Z",
     "start_time": "2022-04-14T06:54:36.015279Z"
    }
   },
   "outputs": [],
   "source": [
    "def one():\n",
    "    return 'one'\n",
    "\n",
    "def three(param):\n",
    "    def two():\n",
    "        print(one(), param)\n",
    "    return two"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "8c3d09aa",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.026336Z",
     "start_time": "2022-04-14T06:54:36.023753Z"
    }
   },
   "outputs": [],
   "source": [
    "inst = three('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "bd1135eb",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.030881Z",
     "start_time": "2022-04-14T06:54:36.028451Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one hello\n"
     ]
    }
   ],
   "source": [
    "inst()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "fe39f556",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.052254Z",
     "start_time": "2022-04-14T06:54:36.032937Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__getattribute__  __class__\n",
      "__getattribute__  __class__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'__name__': '__main__',\n",
       " '__doc__': 'Automatically created module for IPython interactive environment',\n",
       " '__package__': None,\n",
       " '__loader__': None,\n",
       " '__spec__': None,\n",
       " '__builtin__': <module 'builtins' (built-in)>,\n",
       " '__builtins__': <module 'builtins' (built-in)>,\n",
       " '_ih': ['',\n",
       "  'def func():\\n    pass',\n",
       "  'dir(func)',\n",
       "  'class A():\\n    pass',\n",
       "  'a = A()',\n",
       "  'dir(a)',\n",
       "  'def func_1(a: \"this is argument a\") -> \"This is a squared\":\\n    return a**2',\n",
       "  '# first way to call\\nfunc_1',\n",
       "  '# second way to call\\nfunc_1.__annotations__',\n",
       "  \"# Annotations is a dictionary\\n'{:,} {}'.format(func_1(2),\\n                 func_1.__annotations__['return'])\",\n",
       "  \"rd = {'type': float, 'units': 'Joules',\\n      'docstring': 'Given mass and velocity returns kinetic energy in Joules'}\\n\\ndef func_2() -> rd:\\n    pass\",\n",
       "  'for i in [\\'type\\', \"units\", \"docstring\"]:\\n    print(func_2.__annotations__[\\'return\\'][i])',\n",
       "  'class Product():\\n    def __init__(self):\\n        print(\"Instance created\")\\n\\n    # Defining __call__ method\\n    def __call__(self, a, b):\\n        print(\"Instance is called via special method __call__\")\\n        print(a*b)',\n",
       "  'p = Product()',\n",
       "  '# This is equivalent to\\np.__init__()',\n",
       "  '# Since Product has  a __call_ method, p can be called like a function\\np(2,3)',\n",
       "  '# The cell above is equivalent to this call\\np.__call__(2,3)',\n",
       "  'def simple_function():\\n    pass',\n",
       "  'type(simple_function)',\n",
       "  'simple_function.__class__',\n",
       "  '# this is a nested function\\ndef gfg(raise_power_to):\\n\\n    def power(number):\\n        return number ** raise_power_to\\n    return power',\n",
       "  'raise_power_to_3 = gfg(3)',\n",
       "  'print(raise_power_to_3.__closure__)',\n",
       "  'print(raise_power_to_3.__closure__[0].cell_contents)',\n",
       "  'def func_3(x):\\n    return x',\n",
       "  'func_3.__code__',\n",
       "  'func_3.__code__.co_nlocals',\n",
       "  'func_3.__code__.co_argcount',\n",
       "  'def func(a, b):\\n    pass',\n",
       "  'print(func.__defaults__)',\n",
       "  'func.__defaults__ is None',\n",
       "  'def foobar(element, data=[]):\\n    data.append(element)\\n    return data',\n",
       "  '# Before execution\\nfoobar.__defaults__',\n",
       "  'foobar(12)',\n",
       "  'foobar(12)',\n",
       "  'foobar.__defaults__',\n",
       "  'class Frob():\\n    def __delattr__(self, name):\\n        print(\"deleting `{}`\".format(str(name)))\\n        del self.__dict__[name]\\n        print(\"`{}` deleted\".format(str(name)))',\n",
       "  'f = Frob()',\n",
       "  'dir(f)',\n",
       "  '# Adding a class (instance?) attribute\\nf.dummy = 10',\n",
       "  '# Now you show be able to see \"dummy\" listed there\\ndir(f)',\n",
       "  'del f.dummy',\n",
       "  'def func_1():\\n    pass\\n\\nfunc_1.temp = 1\\n\\nprint(func_1.__dict__)',\n",
       "  'def func_2():\\n    pass\\n\\nprint(func_2.__dict__)',\n",
       "  'class TempClass:\\n    a = 1\\n\\n    def temp_function(self):\\n        pass\\n\\n\\nprint(TempClass.__dict__)',\n",
       "  'class Hello():\\n    def __dir__(self):\\n        print(\"calling __dir__\")\\n        return [1, 2, 3]',\n",
       "  'hello = Hello()',\n",
       "  'dir(hello)',\n",
       "  'hello.__dir__()',\n",
       "  'class Dog:\\n    \"\"\"Your best friend.\"\"\"\\n\\n    def do_nothing(self):\\n        pass',\n",
       "  'print(Dog.__doc__)',\n",
       "  '# It works the same even after instantiation\\ndog = Dog()\\ndog.__doc__',\n",
       "  'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __eq__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age',\n",
       "  \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 25)\\nprint(john == jane)\",\n",
       "  \"# custom __format__() method\\nclass Person:\\n    def __format__(self, format):\\n        if(format == 'age'):\\n            return '23'\\n        return 'None'\",\n",
       "  '# The format() function internally runs Person().__format__(\"age\") to return 23.\\nformat(Person(), \"age\")',\n",
       "  'class Person:\\n    def __init__(self, age):\\n        self.age = age\\n\\n    def __ge__(self, other):\\n        print(\"Calling dunder method __ge__\")\\n        return self.age >= other.age',\n",
       "  'alice = Person(18)\\nbob = Person(17)\\ncarl = Person(18)',\n",
       "  'print(alice >= bob)\\nprint(alice >= carl)\\nprint(bob >= alice)',\n",
       "  '# This is our descriptor object\\nclass Bar():\\n    def __init__(self):\\n        self.value = \\'\\'\\n\\n    def __get__(self, instance, owner):\\n        print(\"returned from descriptor object\")\\n        return self.value\\n\\n    def __set__(self, instance, value):\\n        print(\"set in descriptor object\")\\n        self.value = value\\n\\n    def __delete__(self, instance):\\n        print(\"deleted in descriptor object\")\\n        del self.value\\n\\n\\nclass Foo(object):\\n    bar = Bar()',\n",
       "  'f = Foo()',\n",
       "  'f.bar = 10',\n",
       "  'print(f.bar)',\n",
       "  'del f.bar',\n",
       "  \"class Yeah(object):\\n    def __init__(self, name):\\n        # Gets called when an attribute is accessed\\n        self.name = name\\n\\n    def __getattribute__(self, item):\\n        print('__getattribute__ ', item)\\n        # Calling the super class to avoid recursion\\n        # Gets called when the item is not found via __getattribute__\\n        return super(Yeah, self).__getattribute__(item)\\n\\n    def __getattr__(self, item):\\n        print('__getattr__ ', item)\\n        return super(Yeah, self).__setattr__(item, 'orphan')\",\n",
       "  \"y1 = Yeah('yes')\\ny1.name\",\n",
       "  'y1.foo',\n",
       "  'y1.foo',\n",
       "  'y1.goo',\n",
       "  'y1.__dict__',\n",
       "  \"def one():\\n    return 'one'\\n\\ndef three(param):\\n    def two():\\n        print(one(), param)\\n    return two\",\n",
       "  \"inst = three('hello')\",\n",
       "  'inst()',\n",
       "  '# This would not work well in a notebook as it keeping all the variables run in this notebook!\\ninst.__globals__'],\n",
       " '_oh': {2: ['__annotations__',\n",
       "   '__call__',\n",
       "   '__class__',\n",
       "   '__closure__',\n",
       "   '__code__',\n",
       "   '__defaults__',\n",
       "   '__delattr__',\n",
       "   '__dict__',\n",
       "   '__dir__',\n",
       "   '__doc__',\n",
       "   '__eq__',\n",
       "   '__format__',\n",
       "   '__ge__',\n",
       "   '__get__',\n",
       "   '__getattribute__',\n",
       "   '__globals__',\n",
       "   '__gt__',\n",
       "   '__hash__',\n",
       "   '__init__',\n",
       "   '__init_subclass__',\n",
       "   '__kwdefaults__',\n",
       "   '__le__',\n",
       "   '__lt__',\n",
       "   '__module__',\n",
       "   '__name__',\n",
       "   '__ne__',\n",
       "   '__new__',\n",
       "   '__qualname__',\n",
       "   '__reduce__',\n",
       "   '__reduce_ex__',\n",
       "   '__repr__',\n",
       "   '__setattr__',\n",
       "   '__sizeof__',\n",
       "   '__str__',\n",
       "   '__subclasshook__'],\n",
       "  5: ['__class__',\n",
       "   '__delattr__',\n",
       "   '__dict__',\n",
       "   '__dir__',\n",
       "   '__doc__',\n",
       "   '__eq__',\n",
       "   '__format__',\n",
       "   '__ge__',\n",
       "   '__getattribute__',\n",
       "   '__gt__',\n",
       "   '__hash__',\n",
       "   '__init__',\n",
       "   '__init_subclass__',\n",
       "   '__le__',\n",
       "   '__lt__',\n",
       "   '__module__',\n",
       "   '__ne__',\n",
       "   '__new__',\n",
       "   '__reduce__',\n",
       "   '__reduce_ex__',\n",
       "   '__repr__',\n",
       "   '__setattr__',\n",
       "   '__sizeof__',\n",
       "   '__str__',\n",
       "   '__subclasshook__',\n",
       "   '__weakref__'],\n",
       "  7: <function __main__.func_1(a: 'this is argument a') -> 'This is a squared'>,\n",
       "  8: {'a': 'this is argument a', 'return': 'This is a squared'},\n",
       "  9: '4 This is a squared',\n",
       "  18: function,\n",
       "  19: function,\n",
       "  25: <code object func_3 at 0x7fbe5b212ea0, file \"/var/folders/5x/lyqr8wv507n43bnwpsz4dq_c0000gn/T/ipykernel_4751/407776788.py\", line 1>,\n",
       "  26: 1,\n",
       "  27: 1,\n",
       "  30: True,\n",
       "  32: ([12, 12],),\n",
       "  33: [12, 12],\n",
       "  34: [12, 12],\n",
       "  35: ([12, 12],),\n",
       "  38: ['__class__',\n",
       "   '__delattr__',\n",
       "   '__dict__',\n",
       "   '__dir__',\n",
       "   '__doc__',\n",
       "   '__eq__',\n",
       "   '__format__',\n",
       "   '__ge__',\n",
       "   '__getattribute__',\n",
       "   '__gt__',\n",
       "   '__hash__',\n",
       "   '__init__',\n",
       "   '__init_subclass__',\n",
       "   '__le__',\n",
       "   '__lt__',\n",
       "   '__module__',\n",
       "   '__ne__',\n",
       "   '__new__',\n",
       "   '__reduce__',\n",
       "   '__reduce_ex__',\n",
       "   '__repr__',\n",
       "   '__setattr__',\n",
       "   '__sizeof__',\n",
       "   '__str__',\n",
       "   '__subclasshook__',\n",
       "   '__weakref__'],\n",
       "  40: ['__class__',\n",
       "   '__delattr__',\n",
       "   '__dict__',\n",
       "   '__dir__',\n",
       "   '__doc__',\n",
       "   '__eq__',\n",
       "   '__format__',\n",
       "   '__ge__',\n",
       "   '__getattribute__',\n",
       "   '__gt__',\n",
       "   '__hash__',\n",
       "   '__init__',\n",
       "   '__init_subclass__',\n",
       "   '__le__',\n",
       "   '__lt__',\n",
       "   '__module__',\n",
       "   '__ne__',\n",
       "   '__new__',\n",
       "   '__reduce__',\n",
       "   '__reduce_ex__',\n",
       "   '__repr__',\n",
       "   '__setattr__',\n",
       "   '__sizeof__',\n",
       "   '__str__',\n",
       "   '__subclasshook__',\n",
       "   '__weakref__',\n",
       "   'dummy'],\n",
       "  47: [1, 2, 3],\n",
       "  48: [1, 2, 3],\n",
       "  51: 'Your best friend.',\n",
       "  55: '23',\n",
       "  65: 'yes',\n",
       "  67: 'orphan',\n",
       "  69: {'name': 'yes', 'foo': 'orphan', 'goo': 'orphan'}},\n",
       " '_dh': ['/Users/gm_main/Desktop/DataScienceFolder/GitHub/Python-Programming'],\n",
       " 'In': ['',\n",
       "  'def func():\\n    pass',\n",
       "  'dir(func)',\n",
       "  'class A():\\n    pass',\n",
       "  'a = A()',\n",
       "  'dir(a)',\n",
       "  'def func_1(a: \"this is argument a\") -> \"This is a squared\":\\n    return a**2',\n",
       "  '# first way to call\\nfunc_1',\n",
       "  '# second way to call\\nfunc_1.__annotations__',\n",
       "  \"# Annotations is a dictionary\\n'{:,} {}'.format(func_1(2),\\n                 func_1.__annotations__['return'])\",\n",
       "  \"rd = {'type': float, 'units': 'Joules',\\n      'docstring': 'Given mass and velocity returns kinetic energy in Joules'}\\n\\ndef func_2() -> rd:\\n    pass\",\n",
       "  'for i in [\\'type\\', \"units\", \"docstring\"]:\\n    print(func_2.__annotations__[\\'return\\'][i])',\n",
       "  'class Product():\\n    def __init__(self):\\n        print(\"Instance created\")\\n\\n    # Defining __call__ method\\n    def __call__(self, a, b):\\n        print(\"Instance is called via special method __call__\")\\n        print(a*b)',\n",
       "  'p = Product()',\n",
       "  '# This is equivalent to\\np.__init__()',\n",
       "  '# Since Product has  a __call_ method, p can be called like a function\\np(2,3)',\n",
       "  '# The cell above is equivalent to this call\\np.__call__(2,3)',\n",
       "  'def simple_function():\\n    pass',\n",
       "  'type(simple_function)',\n",
       "  'simple_function.__class__',\n",
       "  '# this is a nested function\\ndef gfg(raise_power_to):\\n\\n    def power(number):\\n        return number ** raise_power_to\\n    return power',\n",
       "  'raise_power_to_3 = gfg(3)',\n",
       "  'print(raise_power_to_3.__closure__)',\n",
       "  'print(raise_power_to_3.__closure__[0].cell_contents)',\n",
       "  'def func_3(x):\\n    return x',\n",
       "  'func_3.__code__',\n",
       "  'func_3.__code__.co_nlocals',\n",
       "  'func_3.__code__.co_argcount',\n",
       "  'def func(a, b):\\n    pass',\n",
       "  'print(func.__defaults__)',\n",
       "  'func.__defaults__ is None',\n",
       "  'def foobar(element, data=[]):\\n    data.append(element)\\n    return data',\n",
       "  '# Before execution\\nfoobar.__defaults__',\n",
       "  'foobar(12)',\n",
       "  'foobar(12)',\n",
       "  'foobar.__defaults__',\n",
       "  'class Frob():\\n    def __delattr__(self, name):\\n        print(\"deleting `{}`\".format(str(name)))\\n        del self.__dict__[name]\\n        print(\"`{}` deleted\".format(str(name)))',\n",
       "  'f = Frob()',\n",
       "  'dir(f)',\n",
       "  '# Adding a class (instance?) attribute\\nf.dummy = 10',\n",
       "  '# Now you show be able to see \"dummy\" listed there\\ndir(f)',\n",
       "  'del f.dummy',\n",
       "  'def func_1():\\n    pass\\n\\nfunc_1.temp = 1\\n\\nprint(func_1.__dict__)',\n",
       "  'def func_2():\\n    pass\\n\\nprint(func_2.__dict__)',\n",
       "  'class TempClass:\\n    a = 1\\n\\n    def temp_function(self):\\n        pass\\n\\n\\nprint(TempClass.__dict__)',\n",
       "  'class Hello():\\n    def __dir__(self):\\n        print(\"calling __dir__\")\\n        return [1, 2, 3]',\n",
       "  'hello = Hello()',\n",
       "  'dir(hello)',\n",
       "  'hello.__dir__()',\n",
       "  'class Dog:\\n    \"\"\"Your best friend.\"\"\"\\n\\n    def do_nothing(self):\\n        pass',\n",
       "  'print(Dog.__doc__)',\n",
       "  '# It works the same even after instantiation\\ndog = Dog()\\ndog.__doc__',\n",
       "  'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __eq__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age',\n",
       "  \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 25)\\nprint(john == jane)\",\n",
       "  \"# custom __format__() method\\nclass Person:\\n    def __format__(self, format):\\n        if(format == 'age'):\\n            return '23'\\n        return 'None'\",\n",
       "  '# The format() function internally runs Person().__format__(\"age\") to return 23.\\nformat(Person(), \"age\")',\n",
       "  'class Person:\\n    def __init__(self, age):\\n        self.age = age\\n\\n    def __ge__(self, other):\\n        print(\"Calling dunder method __ge__\")\\n        return self.age >= other.age',\n",
       "  'alice = Person(18)\\nbob = Person(17)\\ncarl = Person(18)',\n",
       "  'print(alice >= bob)\\nprint(alice >= carl)\\nprint(bob >= alice)',\n",
       "  '# This is our descriptor object\\nclass Bar():\\n    def __init__(self):\\n        self.value = \\'\\'\\n\\n    def __get__(self, instance, owner):\\n        print(\"returned from descriptor object\")\\n        return self.value\\n\\n    def __set__(self, instance, value):\\n        print(\"set in descriptor object\")\\n        self.value = value\\n\\n    def __delete__(self, instance):\\n        print(\"deleted in descriptor object\")\\n        del self.value\\n\\n\\nclass Foo(object):\\n    bar = Bar()',\n",
       "  'f = Foo()',\n",
       "  'f.bar = 10',\n",
       "  'print(f.bar)',\n",
       "  'del f.bar',\n",
       "  \"class Yeah(object):\\n    def __init__(self, name):\\n        # Gets called when an attribute is accessed\\n        self.name = name\\n\\n    def __getattribute__(self, item):\\n        print('__getattribute__ ', item)\\n        # Calling the super class to avoid recursion\\n        # Gets called when the item is not found via __getattribute__\\n        return super(Yeah, self).__getattribute__(item)\\n\\n    def __getattr__(self, item):\\n        print('__getattr__ ', item)\\n        return super(Yeah, self).__setattr__(item, 'orphan')\",\n",
       "  \"y1 = Yeah('yes')\\ny1.name\",\n",
       "  'y1.foo',\n",
       "  'y1.foo',\n",
       "  'y1.goo',\n",
       "  'y1.__dict__',\n",
       "  \"def one():\\n    return 'one'\\n\\ndef three(param):\\n    def two():\\n        print(one(), param)\\n    return two\",\n",
       "  \"inst = three('hello')\",\n",
       "  'inst()',\n",
       "  '# This would not work well in a notebook as it keeping all the variables run in this notebook!\\ninst.__globals__'],\n",
       " 'Out': {2: ['__annotations__',\n",
       "   '__call__',\n",
       "   '__class__',\n",
       "   '__closure__',\n",
       "   '__code__',\n",
       "   '__defaults__',\n",
       "   '__delattr__',\n",
       "   '__dict__',\n",
       "   '__dir__',\n",
       "   '__doc__',\n",
       "   '__eq__',\n",
       "   '__format__',\n",
       "   '__ge__',\n",
       "   '__get__',\n",
       "   '__getattribute__',\n",
       "   '__globals__',\n",
       "   '__gt__',\n",
       "   '__hash__',\n",
       "   '__init__',\n",
       "   '__init_subclass__',\n",
       "   '__kwdefaults__',\n",
       "   '__le__',\n",
       "   '__lt__',\n",
       "   '__module__',\n",
       "   '__name__',\n",
       "   '__ne__',\n",
       "   '__new__',\n",
       "   '__qualname__',\n",
       "   '__reduce__',\n",
       "   '__reduce_ex__',\n",
       "   '__repr__',\n",
       "   '__setattr__',\n",
       "   '__sizeof__',\n",
       "   '__str__',\n",
       "   '__subclasshook__'],\n",
       "  5: ['__class__',\n",
       "   '__delattr__',\n",
       "   '__dict__',\n",
       "   '__dir__',\n",
       "   '__doc__',\n",
       "   '__eq__',\n",
       "   '__format__',\n",
       "   '__ge__',\n",
       "   '__getattribute__',\n",
       "   '__gt__',\n",
       "   '__hash__',\n",
       "   '__init__',\n",
       "   '__init_subclass__',\n",
       "   '__le__',\n",
       "   '__lt__',\n",
       "   '__module__',\n",
       "   '__ne__',\n",
       "   '__new__',\n",
       "   '__reduce__',\n",
       "   '__reduce_ex__',\n",
       "   '__repr__',\n",
       "   '__setattr__',\n",
       "   '__sizeof__',\n",
       "   '__str__',\n",
       "   '__subclasshook__',\n",
       "   '__weakref__'],\n",
       "  7: <function __main__.func_1(a: 'this is argument a') -> 'This is a squared'>,\n",
       "  8: {'a': 'this is argument a', 'return': 'This is a squared'},\n",
       "  9: '4 This is a squared',\n",
       "  18: function,\n",
       "  19: function,\n",
       "  25: <code object func_3 at 0x7fbe5b212ea0, file \"/var/folders/5x/lyqr8wv507n43bnwpsz4dq_c0000gn/T/ipykernel_4751/407776788.py\", line 1>,\n",
       "  26: 1,\n",
       "  27: 1,\n",
       "  30: True,\n",
       "  32: ([12, 12],),\n",
       "  33: [12, 12],\n",
       "  34: [12, 12],\n",
       "  35: ([12, 12],),\n",
       "  38: ['__class__',\n",
       "   '__delattr__',\n",
       "   '__dict__',\n",
       "   '__dir__',\n",
       "   '__doc__',\n",
       "   '__eq__',\n",
       "   '__format__',\n",
       "   '__ge__',\n",
       "   '__getattribute__',\n",
       "   '__gt__',\n",
       "   '__hash__',\n",
       "   '__init__',\n",
       "   '__init_subclass__',\n",
       "   '__le__',\n",
       "   '__lt__',\n",
       "   '__module__',\n",
       "   '__ne__',\n",
       "   '__new__',\n",
       "   '__reduce__',\n",
       "   '__reduce_ex__',\n",
       "   '__repr__',\n",
       "   '__setattr__',\n",
       "   '__sizeof__',\n",
       "   '__str__',\n",
       "   '__subclasshook__',\n",
       "   '__weakref__'],\n",
       "  40: ['__class__',\n",
       "   '__delattr__',\n",
       "   '__dict__',\n",
       "   '__dir__',\n",
       "   '__doc__',\n",
       "   '__eq__',\n",
       "   '__format__',\n",
       "   '__ge__',\n",
       "   '__getattribute__',\n",
       "   '__gt__',\n",
       "   '__hash__',\n",
       "   '__init__',\n",
       "   '__init_subclass__',\n",
       "   '__le__',\n",
       "   '__lt__',\n",
       "   '__module__',\n",
       "   '__ne__',\n",
       "   '__new__',\n",
       "   '__reduce__',\n",
       "   '__reduce_ex__',\n",
       "   '__repr__',\n",
       "   '__setattr__',\n",
       "   '__sizeof__',\n",
       "   '__str__',\n",
       "   '__subclasshook__',\n",
       "   '__weakref__',\n",
       "   'dummy'],\n",
       "  47: [1, 2, 3],\n",
       "  48: [1, 2, 3],\n",
       "  51: 'Your best friend.',\n",
       "  55: '23',\n",
       "  65: 'yes',\n",
       "  67: 'orphan',\n",
       "  69: {'name': 'yes', 'foo': 'orphan', 'goo': 'orphan'}},\n",
       " 'get_ipython': <bound method InteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7fbe59fa00d0>>,\n",
       " 'exit': <IPython.core.autocall.ZMQExitAutocall at 0x7fbe59fb51f0>,\n",
       " 'quit': <IPython.core.autocall.ZMQExitAutocall at 0x7fbe59fb51f0>,\n",
       " '_': {'name': 'yes', 'foo': 'orphan', 'goo': 'orphan'},\n",
       " '__': 'orphan',\n",
       " '___': 'yes',\n",
       " 'json': <module 'json' from '/opt/anaconda3/envs/trainingAI/lib/python3.9/json/__init__.py'>,\n",
       " 'autopep8': <module 'autopep8' from '/opt/anaconda3/envs/trainingAI/lib/python3.9/site-packages/autopep8.py'>,\n",
       " '_i': 'inst()',\n",
       " '_ii': \"inst = three('hello')\",\n",
       " '_iii': \"def one():\\n    return 'one'\\n\\ndef three(param):\\n    def two():\\n        print(one(), param)\\n    return two\",\n",
       " '_i1': 'def func():\\n    pass',\n",
       " 'func': <function __main__.func(a, b)>,\n",
       " '_i2': 'dir(func)',\n",
       " '_2': ['__annotations__',\n",
       "  '__call__',\n",
       "  '__class__',\n",
       "  '__closure__',\n",
       "  '__code__',\n",
       "  '__defaults__',\n",
       "  '__delattr__',\n",
       "  '__dict__',\n",
       "  '__dir__',\n",
       "  '__doc__',\n",
       "  '__eq__',\n",
       "  '__format__',\n",
       "  '__ge__',\n",
       "  '__get__',\n",
       "  '__getattribute__',\n",
       "  '__globals__',\n",
       "  '__gt__',\n",
       "  '__hash__',\n",
       "  '__init__',\n",
       "  '__init_subclass__',\n",
       "  '__kwdefaults__',\n",
       "  '__le__',\n",
       "  '__lt__',\n",
       "  '__module__',\n",
       "  '__name__',\n",
       "  '__ne__',\n",
       "  '__new__',\n",
       "  '__qualname__',\n",
       "  '__reduce__',\n",
       "  '__reduce_ex__',\n",
       "  '__repr__',\n",
       "  '__setattr__',\n",
       "  '__sizeof__',\n",
       "  '__str__',\n",
       "  '__subclasshook__'],\n",
       " '_i3': 'class A():\\n    pass',\n",
       " 'A': __main__.A,\n",
       " '_i4': 'a = A()',\n",
       " 'a': <__main__.A at 0x7fbe5b0cc910>,\n",
       " '_i5': 'dir(a)',\n",
       " '_5': ['__class__',\n",
       "  '__delattr__',\n",
       "  '__dict__',\n",
       "  '__dir__',\n",
       "  '__doc__',\n",
       "  '__eq__',\n",
       "  '__format__',\n",
       "  '__ge__',\n",
       "  '__getattribute__',\n",
       "  '__gt__',\n",
       "  '__hash__',\n",
       "  '__init__',\n",
       "  '__init_subclass__',\n",
       "  '__le__',\n",
       "  '__lt__',\n",
       "  '__module__',\n",
       "  '__ne__',\n",
       "  '__new__',\n",
       "  '__reduce__',\n",
       "  '__reduce_ex__',\n",
       "  '__repr__',\n",
       "  '__setattr__',\n",
       "  '__sizeof__',\n",
       "  '__str__',\n",
       "  '__subclasshook__',\n",
       "  '__weakref__'],\n",
       " '_i6': 'def func_1(a: \"this is argument a\") -> \"This is a squared\":\\n    return a**2',\n",
       " 'func_1': <function __main__.func_1()>,\n",
       " '_i7': '# first way to call\\nfunc_1',\n",
       " '_7': <function __main__.func_1(a: 'this is argument a') -> 'This is a squared'>,\n",
       " '_i8': '# second way to call\\nfunc_1.__annotations__',\n",
       " '_8': {'a': 'this is argument a', 'return': 'This is a squared'},\n",
       " '_i9': \"# Annotations is a dictionary\\n'{:,} {}'.format(func_1(2),\\n                 func_1.__annotations__['return'])\",\n",
       " '_9': '4 This is a squared',\n",
       " '_i10': \"rd = {'type': float, 'units': 'Joules',\\n      'docstring': 'Given mass and velocity returns kinetic energy in Joules'}\\n\\ndef func_2() -> rd:\\n    pass\",\n",
       " 'rd': {'type': float,\n",
       "  'units': 'Joules',\n",
       "  'docstring': 'Given mass and velocity returns kinetic energy in Joules'},\n",
       " 'func_2': <function __main__.func_2()>,\n",
       " '_i11': 'for i in [\\'type\\', \"units\", \"docstring\"]:\\n    print(func_2.__annotations__[\\'return\\'][i])',\n",
       " 'i': 'docstring',\n",
       " '_i12': 'class Product():\\n    def __init__(self):\\n        print(\"Instance created\")\\n\\n    # Defining __call__ method\\n    def __call__(self, a, b):\\n        print(\"Instance is called via special method __call__\")\\n        print(a*b)',\n",
       " 'Product': __main__.Product,\n",
       " '_i13': 'p = Product()',\n",
       " 'p': <__main__.Product at 0x7fbe5b2178e0>,\n",
       " '_i14': '# This is equivalent to\\np.__init__()',\n",
       " '_i15': '# Since Product has  a __call_ method, p can be called like a function\\np(2,3)',\n",
       " '_i16': '# The cell above is equivalent to this call\\np.__call__(2,3)',\n",
       " '_i17': 'def simple_function():\\n    pass',\n",
       " 'simple_function': <function __main__.simple_function()>,\n",
       " '_i18': 'type(simple_function)',\n",
       " '_18': function,\n",
       " '_i19': 'simple_function.__class__',\n",
       " '_19': function,\n",
       " '_i20': '# this is a nested function\\ndef gfg(raise_power_to):\\n\\n    def power(number):\\n        return number ** raise_power_to\\n    return power',\n",
       " 'gfg': <function __main__.gfg(raise_power_to)>,\n",
       " '_i21': 'raise_power_to_3 = gfg(3)',\n",
       " 'raise_power_to_3': <function __main__.gfg.<locals>.power(number)>,\n",
       " '_i22': 'print(raise_power_to_3.__closure__)',\n",
       " '_i23': 'print(raise_power_to_3.__closure__[0].cell_contents)',\n",
       " '_i24': 'def func_3(x):\\n    return x',\n",
       " 'func_3': <function __main__.func_3(x)>,\n",
       " '_i25': 'func_3.__code__',\n",
       " '_25': <code object func_3 at 0x7fbe5b212ea0, file \"/var/folders/5x/lyqr8wv507n43bnwpsz4dq_c0000gn/T/ipykernel_4751/407776788.py\", line 1>,\n",
       " '_i26': 'func_3.__code__.co_nlocals',\n",
       " '_26': 1,\n",
       " '_i27': 'func_3.__code__.co_argcount',\n",
       " '_27': 1,\n",
       " '_i28': 'def func(a, b):\\n    pass',\n",
       " '_i29': 'print(func.__defaults__)',\n",
       " '_i30': 'func.__defaults__ is None',\n",
       " '_30': True,\n",
       " '_i31': 'def foobar(element, data=[]):\\n    data.append(element)\\n    return data',\n",
       " 'foobar': <function __main__.foobar(element, data=[12, 12])>,\n",
       " '_i32': '# Before execution\\nfoobar.__defaults__',\n",
       " '_32': ([12, 12],),\n",
       " '_i33': 'foobar(12)',\n",
       " '_33': [12, 12],\n",
       " '_i34': 'foobar(12)',\n",
       " '_34': [12, 12],\n",
       " '_i35': 'foobar.__defaults__',\n",
       " '_35': ([12, 12],),\n",
       " '_i36': 'class Frob():\\n    def __delattr__(self, name):\\n        print(\"deleting `{}`\".format(str(name)))\\n        del self.__dict__[name]\\n        print(\"`{}` deleted\".format(str(name)))',\n",
       " 'Frob': __main__.Frob,\n",
       " '_i37': 'f = Frob()',\n",
       " 'f': <__main__.Foo at 0x7fbe5b217e50>,\n",
       " '_i38': 'dir(f)',\n",
       " '_38': ['__class__',\n",
       "  '__delattr__',\n",
       "  '__dict__',\n",
       "  '__dir__',\n",
       "  '__doc__',\n",
       "  '__eq__',\n",
       "  '__format__',\n",
       "  '__ge__',\n",
       "  '__getattribute__',\n",
       "  '__gt__',\n",
       "  '__hash__',\n",
       "  '__init__',\n",
       "  '__init_subclass__',\n",
       "  '__le__',\n",
       "  '__lt__',\n",
       "  '__module__',\n",
       "  '__ne__',\n",
       "  '__new__',\n",
       "  '__reduce__',\n",
       "  '__reduce_ex__',\n",
       "  '__repr__',\n",
       "  '__setattr__',\n",
       "  '__sizeof__',\n",
       "  '__str__',\n",
       "  '__subclasshook__',\n",
       "  '__weakref__'],\n",
       " '_i39': '# Adding a class (instance?) attribute\\nf.dummy = 10',\n",
       " '_i40': '# Now you show be able to see \"dummy\" listed there\\ndir(f)',\n",
       " '_40': ['__class__',\n",
       "  '__delattr__',\n",
       "  '__dict__',\n",
       "  '__dir__',\n",
       "  '__doc__',\n",
       "  '__eq__',\n",
       "  '__format__',\n",
       "  '__ge__',\n",
       "  '__getattribute__',\n",
       "  '__gt__',\n",
       "  '__hash__',\n",
       "  '__init__',\n",
       "  '__init_subclass__',\n",
       "  '__le__',\n",
       "  '__lt__',\n",
       "  '__module__',\n",
       "  '__ne__',\n",
       "  '__new__',\n",
       "  '__reduce__',\n",
       "  '__reduce_ex__',\n",
       "  '__repr__',\n",
       "  '__setattr__',\n",
       "  '__sizeof__',\n",
       "  '__str__',\n",
       "  '__subclasshook__',\n",
       "  '__weakref__',\n",
       "  'dummy'],\n",
       " '_i41': 'del f.dummy',\n",
       " '_i42': 'def func_1():\\n    pass\\n\\nfunc_1.temp = 1\\n\\nprint(func_1.__dict__)',\n",
       " '_i43': 'def func_2():\\n    pass\\n\\nprint(func_2.__dict__)',\n",
       " '_i44': 'class TempClass:\\n    a = 1\\n\\n    def temp_function(self):\\n        pass\\n\\n\\nprint(TempClass.__dict__)',\n",
       " 'TempClass': __main__.TempClass,\n",
       " '_i45': 'class Hello():\\n    def __dir__(self):\\n        print(\"calling __dir__\")\\n        return [1, 2, 3]',\n",
       " 'Hello': __main__.Hello,\n",
       " '_i46': 'hello = Hello()',\n",
       " 'hello': <__main__.Hello at 0x7fbe5b220100>,\n",
       " '_i47': 'dir(hello)',\n",
       " '_47': [1, 2, 3],\n",
       " '_i48': 'hello.__dir__()',\n",
       " '_48': [1, 2, 3],\n",
       " '_i49': 'class Dog:\\n    \"\"\"Your best friend.\"\"\"\\n\\n    def do_nothing(self):\\n        pass',\n",
       " 'Dog': __main__.Dog,\n",
       " '_i50': 'print(Dog.__doc__)',\n",
       " '_i51': '# It works the same even after instantiation\\ndog = Dog()\\ndog.__doc__',\n",
       " 'dog': <__main__.Dog at 0x7fbe5b2204f0>,\n",
       " '_51': 'Your best friend.',\n",
       " '_i52': 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __eq__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age',\n",
       " 'Person': __main__.Person,\n",
       " '_i53': \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 25)\\nprint(john == jane)\",\n",
       " 'john': <__main__.Person at 0x7fbe5b2202b0>,\n",
       " 'jane': <__main__.Person at 0x7fbe5b0cc400>,\n",
       " '_i54': \"# custom __format__() method\\nclass Person:\\n    def __format__(self, format):\\n        if(format == 'age'):\\n            return '23'\\n        return 'None'\",\n",
       " '_i55': '# The format() function internally runs Person().__format__(\"age\") to return 23.\\nformat(Person(), \"age\")',\n",
       " '_55': '23',\n",
       " '_i56': 'class Person:\\n    def __init__(self, age):\\n        self.age = age\\n\\n    def __ge__(self, other):\\n        print(\"Calling dunder method __ge__\")\\n        return self.age >= other.age',\n",
       " '_i57': 'alice = Person(18)\\nbob = Person(17)\\ncarl = Person(18)',\n",
       " 'alice': <__main__.Person at 0x7fbe5b217d60>,\n",
       " 'bob': <__main__.Person at 0x7fbe5b217610>,\n",
       " 'carl': <__main__.Person at 0x7fbe59fd9940>,\n",
       " '_i58': 'print(alice >= bob)\\nprint(alice >= carl)\\nprint(bob >= alice)',\n",
       " '_i59': '# This is our descriptor object\\nclass Bar():\\n    def __init__(self):\\n        self.value = \\'\\'\\n\\n    def __get__(self, instance, owner):\\n        print(\"returned from descriptor object\")\\n        return self.value\\n\\n    def __set__(self, instance, value):\\n        print(\"set in descriptor object\")\\n        self.value = value\\n\\n    def __delete__(self, instance):\\n        print(\"deleted in descriptor object\")\\n        del self.value\\n\\n\\nclass Foo(object):\\n    bar = Bar()',\n",
       " 'Bar': __main__.Bar,\n",
       " 'Foo': __main__.Foo,\n",
       " '_i60': 'f = Foo()',\n",
       " '_i61': 'f.bar = 10',\n",
       " '_i62': 'print(f.bar)',\n",
       " '_i63': 'del f.bar',\n",
       " '_i64': \"class Yeah(object):\\n    def __init__(self, name):\\n        # Gets called when an attribute is accessed\\n        self.name = name\\n\\n    def __getattribute__(self, item):\\n        print('__getattribute__ ', item)\\n        # Calling the super class to avoid recursion\\n        # Gets called when the item is not found via __getattribute__\\n        return super(Yeah, self).__getattribute__(item)\\n\\n    def __getattr__(self, item):\\n        print('__getattr__ ', item)\\n        return super(Yeah, self).__setattr__(item, 'orphan')\",\n",
       " 'Yeah': __main__.Yeah,\n",
       " '_i65': \"y1 = Yeah('yes')\\ny1.name\",\n",
       " 'y1': <__main__.Yeah at 0x7fbe5b2200a0>,\n",
       " '_65': 'yes',\n",
       " '_i66': 'y1.foo',\n",
       " '_i67': 'y1.foo',\n",
       " '_67': 'orphan',\n",
       " '_i68': 'y1.goo',\n",
       " '_i69': 'y1.__dict__',\n",
       " '_69': {'name': 'yes', 'foo': 'orphan', 'goo': 'orphan'},\n",
       " '_i70': \"def one():\\n    return 'one'\\n\\ndef three(param):\\n    def two():\\n        print(one(), param)\\n    return two\",\n",
       " 'one': <function __main__.one()>,\n",
       " 'three': <function __main__.three(param)>,\n",
       " '_i71': \"inst = three('hello')\",\n",
       " 'inst': <function __main__.three.<locals>.two()>,\n",
       " '_i72': 'inst()',\n",
       " '_i73': '# This would not work well in a notebook as it keeping all the variables run in this notebook!\\ninst.__globals__'}"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This would not work well in a notebook as it keeping all the variables run in this notebook!\n",
    "inst.__globals__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "d4fa05d9",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.058065Z",
     "start_time": "2022-04-14T06:54:36.054559Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(<cell at 0x7fbe5b220160: str object at 0x7fbe59cce2f0>,)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inst.__closure__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "d34da15e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.063698Z",
     "start_time": "2022-04-14T06:54:36.060244Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inst.__closure__[0].cell_contents"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc2667e0",
   "metadata": {},
   "source": [
    "# `__gt__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f009fba",
   "metadata": {},
   "source": [
    "- To customize the behavior of the greather than operator `x > y`, override the `__gt__()` dunder method in your class definition.\n",
    "- Python internally calls `x.__gt__(y)` to obtain a return value when comparing two objects using `x > y`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "8fa879b5",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.068701Z",
     "start_time": "2022-04-14T06:54:36.065647Z"
    }
   },
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, age):\n",
    "        self.age = age\n",
    "\n",
    "    def __gt__(self, other):\n",
    "        return self.age > other.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "ae7d88b0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.073227Z",
     "start_time": "2022-04-14T06:54:36.070850Z"
    }
   },
   "outputs": [],
   "source": [
    "alice = Person(18)\n",
    "bob = Person(17)\n",
    "carl = Person(18)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "dc040293",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.081347Z",
     "start_time": "2022-04-14T06:54:36.078308Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(alice > bob)\n",
    "print(alice > carl)\n",
    "print(bob > alice)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bca9b1c3",
   "metadata": {},
   "source": [
    "# `__hash__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe5c7be5",
   "metadata": {},
   "source": [
    "- An object hash is an integer number representing the value of the object and can be obtained using the `hash()` function if the object is hashable.\n",
    "- To make a class hashable, it has to implement both the `__hash__(self)` method and the aforementioned `__eq__(self, other)` method. \n",
    "- As with equality, the inherited `object.__hash__` method works by identity only: barring the unlikely event of a hash collision, two instances of the same class will always have different hashes, no matter what data they carry.\n",
    "- So hashes are important because sets and dictionaries use them for their lookup tables to quickly find their keys. To do that effectively, they make an important assumption that leads to our first gotcha:\n",
    "- The hash of an object must never change during its lifetime."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "fc4723e6",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.087050Z",
     "start_time": "2022-04-14T06:54:36.083377Z"
    }
   },
   "outputs": [],
   "source": [
    "class C:\n",
    "    def __init__(self, x):\n",
    "        self.x = x\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"C({self.x})\"\n",
    "\n",
    "    def __hash__(self):\n",
    "        return hash(self.x)\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        return (\n",
    "            self.__class__ == other.__class__ and\n",
    "            self.x == other.x\n",
    "        )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "35496618",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.091864Z",
     "start_time": "2022-04-14T06:54:36.089186Z"
    }
   },
   "outputs": [],
   "source": [
    "d = dict()\n",
    "s = set()\n",
    "c = C(1)\n",
    "d[c] = 42\n",
    "s.add(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "db9a2c81",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.097447Z",
     "start_time": "2022-04-14T06:54:36.093775Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({C(1): 42}, {C(1)})"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d, s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "975d98d6",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.103078Z",
     "start_time": "2022-04-14T06:54:36.099384Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c in s and c in d  # c is in both!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "eba415ce",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.107142Z",
     "start_time": "2022-04-14T06:54:36.105010Z"
    }
   },
   "outputs": [],
   "source": [
    "c.x = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "01ae68b2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.113276Z",
     "start_time": "2022-04-14T06:54:36.109832Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c in s or c in d   # c is in neither!?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "c46dfda2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:36.127882Z",
     "start_time": "2022-04-14T06:54:36.115239Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "C(2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m/opt/anaconda3/envs/trainingAI/lib/python3.9/site-packages/IPython/core/formatters.py\u001b[0m in \u001b[0;36m__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m    700\u001b[0m                 \u001b[0mtype_pprinters\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype_printers\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    701\u001b[0m                 deferred_pprinters=self.deferred_printers)\n\u001b[0;32m--> 702\u001b[0;31m             \u001b[0mprinter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpretty\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    703\u001b[0m             \u001b[0mprinter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflush\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    704\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mstream\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgetvalue\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/anaconda3/envs/trainingAI/lib/python3.9/site-packages/IPython/lib/pretty.py\u001b[0m in \u001b[0;36mpretty\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m    375\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mcls\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype_pprinters\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    376\u001b[0m                     \u001b[0;31m# printer registered in self.type_pprinters\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 377\u001b[0;31m                     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype_pprinters\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcycle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    378\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    379\u001b[0m                     \u001b[0;31m# deferred printer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/anaconda3/envs/trainingAI/lib/python3.9/site-packages/IPython/lib/pretty.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(obj, p, cycle)\u001b[0m\n\u001b[1;32m    553\u001b[0m                 \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m','\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    554\u001b[0m                 \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbreakable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 555\u001b[0;31m             \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpretty\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    556\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0mtuple\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    557\u001b[0m             \u001b[0;31m# Special case for 1-item tuples.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/anaconda3/envs/trainingAI/lib/python3.9/site-packages/IPython/lib/pretty.py\u001b[0m in \u001b[0;36mpretty\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m    375\u001b[0m                 \u001b[0;32mif\u001b[0m \u001b[0mcls\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype_pprinters\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    376\u001b[0m                     \u001b[0;31m# printer registered in self.type_pprinters\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 377\u001b[0;31m                     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype_pprinters\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mcls\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcycle\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    378\u001b[0m                 \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    379\u001b[0m                     \u001b[0;31m# deferred printer\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m/opt/anaconda3/envs/trainingAI/lib/python3.9/site-packages/IPython/lib/pretty.py\u001b[0m in \u001b[0;36minner\u001b[0;34m(obj, p, cycle)\u001b[0m\n\u001b[1;32m    605\u001b[0m             \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpretty\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    606\u001b[0m             \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m': '\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 607\u001b[0;31m             \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpretty\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    608\u001b[0m         \u001b[0mp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mend_group\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mend\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    609\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0minner\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyError\u001b[0m: C(2)"
     ]
    }
   ],
   "source": [
    "d, s\n",
    "#({C(2): 42}, {C(2)})   # but...it's right there!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97db5c20",
   "metadata": {},
   "source": [
    "# `__init__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f68dfe1",
   "metadata": {},
   "source": [
    "- In python everything is an object, but classess and objects are not exactly the same thing. You can create an object instantiating a class though.\n",
    "- Classes can be thought as blueprint for creating object. In other words, I've created a sort of instruction manual for constructing a customer object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "07080213",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:56.846113Z",
     "start_time": "2022-04-14T06:54:56.841517Z"
    },
    "code_folding": [
     0
    ]
   },
   "outputs": [],
   "source": [
    "class Customer(object):\n",
    "    \"\"\"A customer of ABC bank with a checking. account.\n",
    "    \n",
    "    Customer have the following propperties:\n",
    "    \n",
    "    Atributes:\n",
    "        name: a string representing the custome name\n",
    "        balance: a float. tracking the current balance of the customer's account\n",
    "    \"\"\"\n",
    "    \n",
    "    def __init__(self, name, balance = 0.0):\n",
    "        \"\"\"Object initialisation.\n",
    "        \n",
    "        Returns a customers objkect whose name is name and stating\n",
    "        balance is balance.\n",
    "        \"\"\"\n",
    "        \n",
    "        self.name = name\n",
    "        self.balance = balance\n",
    "        \n",
    "    def withdraw(self, amount):\n",
    "        \"\"\"Withdraw.\n",
    "        \n",
    "        Returns the balance remaininga fter withdrawing ana mount.\n",
    "        \"\"\"\n",
    "        \n",
    "        if amount > self.balance:\n",
    "            raise RuntimeError(\"Amount requested is greater than the current balance\")\n",
    "        self.balance -= amount\n",
    "        \n",
    "        return self.balance\n",
    "    \n",
    "    def deposit(self, amount):\n",
    "        \"\"\"Deposit.\n",
    "        \n",
    "        Returns the balance remaining after depositing some monies.\n",
    "        \"\"\"\n",
    "        \n",
    "        self.balance += amount\n",
    "        \n",
    "        return sel.balance"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f905e6f6",
   "metadata": {},
   "source": [
    "- The class Customer(object) does not create a new customer, as we have created a blueprint only.\n",
    "- How do we create a real customer then? We;ll have to call the special class method __init__ to create one.\n",
    "- This method is call automtically when we. instantiate the obejct with (for instance) Customer(\"Charlier\", 100). This is saying \"hey create a customer named Charlie with 100GBP in his account!."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "0ee2f5ec",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:57.140267Z",
     "start_time": "2022-04-14T06:54:57.137453Z"
    }
   },
   "outputs": [],
   "source": [
    "custormerA = Customer(\"Charlier\", 100)\n",
    "custormerB = Customer(\"Maria\", 200)\n",
    "customerNull = Customer(\"Null\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "bce43b0c",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:57.359205Z",
     "start_time": "2022-04-14T06:54:57.355381Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Charlier', 'balance': 100}"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "custormerA.__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "19c199b6",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:57.516547Z",
     "start_time": "2022-04-14T06:54:57.513121Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Maria', 'balance': 200}"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "custormerB.__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "4915c720",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:57.680786Z",
     "start_time": "2022-04-14T06:54:57.676528Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'name': 'Null', 'balance': 0.0}"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "customerNull.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cbc844e9",
   "metadata": {},
   "source": [
    "# `__init_subclass__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c22292e",
   "metadata": {},
   "source": [
    "- It offers a simpler form of customization for classes. \n",
    "- This is like a shortcut to extend the functionalities of base classes without having to handle with metaclasses."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "6f07f102",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:58.040343Z",
     "start_time": "2022-04-14T06:54:58.035247Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Called __init_subclass(<class '__main__.AustralianPhilosopher'>, Bruce)\n",
      "Set name to Hegel\n",
      "Called __init_subclass(<class '__main__.GermanPhilosopher'>, Nietzsche)\n"
     ]
    }
   ],
   "source": [
    "class Philosopher:\n",
    "    def __init_subclass__(cls, default_name, **kwargs):\n",
    "        super().__init_subclass__(**kwargs)\n",
    "        print(f\"Called __init_subclass({cls}, {default_name})\")\n",
    "        cls.default_name = default_name\n",
    "\n",
    "\n",
    "class AustralianPhilosopher(Philosopher, default_name=\"Bruce\"):\n",
    "    pass\n",
    "\n",
    "\n",
    "class GermanPhilosopher(Philosopher, default_name=\"Nietzsche\"):\n",
    "    default_name = \"Hegel\"\n",
    "    print(\"Set name to Hegel\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "3719c7ef",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:58.257666Z",
     "start_time": "2022-04-14T06:54:58.253580Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bruce\n",
      "Nietzsche\n"
     ]
    }
   ],
   "source": [
    "Bruce = AustralianPhilosopher()\n",
    "Mistery = GermanPhilosopher()\n",
    "print(Bruce.default_name)\n",
    "print(Mistery.default_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31c763cb",
   "metadata": {},
   "source": [
    "# `__kwdefaults__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6f84a79",
   "metadata": {},
   "source": [
    "- The `__kwdefaults__` attribute holds a dict containing defaults for keyword-only arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "d0f3a9fc",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:58.946116Z",
     "start_time": "2022-04-14T06:54:58.943573Z"
    }
   },
   "outputs": [],
   "source": [
    "def func(a, b='Default value'):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "117c612f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:59.162300Z",
     "start_time": "2022-04-14T06:54:59.158671Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Default value',)"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func.__defaults__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "29424138",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:59.320969Z",
     "start_time": "2022-04-14T06:54:59.318133Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(func.__kwdefaults__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f4a1cc5",
   "metadata": {},
   "source": [
    "# `__le__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "4f331b24",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:59.477321Z",
     "start_time": "2022-04-14T06:54:59.473838Z"
    }
   },
   "outputs": [],
   "source": [
    "class Person:\n",
    "    \"\"\"\n",
    "    The following shows how to implement the __eq__ method \n",
    "    in the Person class that returns True if two person \n",
    "    objects have the same age:\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, first_name, last_name, age):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "        self.age = age\n",
    "\n",
    "    def __le__(self, other):\n",
    "        print(\"calling dunder method __eq__\")\n",
    "        return self.age == other.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "a7ba4964",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:59.669717Z",
     "start_time": "2022-04-14T06:54:59.666525Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling dunder method __eq__\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "john = Person('John', 'Doe', 25)\n",
    "jane = Person('Jane', 'Doe', 26)\n",
    "print(john <= jane)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21a43e0a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-12T06:54:22.937842Z",
     "start_time": "2022-04-12T06:54:22.925471Z"
    }
   },
   "source": [
    "# `__lt__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "6474d87a",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:54:59.864613Z",
     "start_time": "2022-04-14T06:54:59.860843Z"
    }
   },
   "outputs": [],
   "source": [
    "class Person:\n",
    "    \"\"\"\n",
    "    The following shows how to implement the __eq__ method \n",
    "    in the Person class that returns True if two person \n",
    "    objects have the same age:\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, first_name, last_name, age):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "        self.age = age\n",
    "\n",
    "    def __lt__(self, other):\n",
    "        print(\"calling dunder method __eq__\")\n",
    "        return self.age == other.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "bea65e3c",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:00.090253Z",
     "start_time": "2022-04-14T06:55:00.086960Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling dunder method __eq__\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "john = Person('John', 'Doe', 25)\n",
    "jane = Person('Jane', 'Doe', 26)\n",
    "print(john < jane)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25026026",
   "metadata": {},
   "source": [
    "# `__name__`\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99ead7e2",
   "metadata": {},
   "source": [
    "    \n",
    "- `__name__` is a variable defined for each script that defines whether the script is being run as the main module or it is being run as an imported module.\n",
    "\n",
    "- `__name__` variable points to the namespace wherever the Python interpreter happens to be at the moment.\n",
    "\n",
    "- The global variable, name, in the module that is the entry point to your program, is __main__.\n",
    "\n",
    "- So, the code under the if block runs if the module is the entry point to your program.\n",
    "\n",
    "- **In practice?** It allows the code in the module to be importable by other modules, without executing the code block beneath on import.\n",
    "    \n",
    "- In other words, the statement `if__name__==\"__main__\"` is a very Pythonic way of making sure some code only\n",
    "runs if the program is ran directly.\n",
    "\n",
""   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "id": "7b79a036",
   "metadata": {},
   "source": [
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e61cef44",
   "metadata": {},
   "source": [
    "\n",
    "- **If you are not** using the construct `__name__ == \"__main__\"` the name` is assigned to the name you import the module by.\n",
    "\n",
""   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "f310f211",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:00.364589Z",
     "start_time": "2022-04-14T06:55:00.362100Z"
    }
   },
   "outputs": [],
   "source": [
    "def func_3():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "99da5cb1",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:00.587264Z",
     "start_time": "2022-04-14T06:55:00.583753Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'func_3'"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func_3.__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d2c1f79c",
   "metadata": {},
   "source": [
    "# `__module__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e469b857",
   "metadata": {},
   "source": [
    "- Every Python class has a built-in class attribute __module__ which is the name of the module in which the class is defined. \n",
    "- A module in Python is a file (ending in .py) that contains a set of definitions (variables and functions) that you can use when they are imported. \n",
    "- Modules are considered as objects, just as everything else is in Python. \n",
    "- Many methods can operate on modules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "873e29b6",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:00.790607Z",
     "start_time": "2022-04-14T06:55:00.786434Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'math'"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sin\n",
    "# Function sin() came from the math module.\n",
    "sin.__module__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "b4c8d833",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:01.019017Z",
     "start_time": "2022-04-14T06:55:01.013841Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'__main__'"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Define a dummy class\n",
    "class A:    \n",
    "    pass\n",
    "\n",
    "\n",
    "a = A\n",
    "a.__module__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5205c0cd",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "995af2dd",
   "metadata": {},
   "source": [
    "# `__ne__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d684762",
   "metadata": {},
   "source": [
    "- Equality in Python is more complicated than most people realize but at its core you have to implement a `__eq__` (self, other) method. \n",
    "\n",
    "- It should return either a boolean value if your class knows how to compare itself to other or `NotImplemented` if it doesn’t. \n",
    "\n",
    "- For inequality checks using `!=`, the corresponding method is `__ne__(self, other)`.\n",
    "\n",
    "- By default, those methods are inherited from the object class that compares two instances by their identity – therefore instances are only equal to themselves.\n",
    "\n",
    "- A common mistake in Python 2 was to override only `__eq__()` and forget about `__ne__()`. Python 3 is friendly enough to implement an obvious `__ne__()` for you, if you don’t yourself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "2077c410",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:01.366972Z",
     "start_time": "2022-04-14T06:55:01.363326Z"
    }
   },
   "outputs": [],
   "source": [
    "class Person:\n",
    "    \"\"\"\n",
    "    The following shows how to implement the __eq__ method \n",
    "    in the Person class that returns True if two person \n",
    "    objects have the same age:\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, first_name, last_name, age):\n",
    "        self.first_name = first_name\n",
    "        self.last_name = last_name\n",
    "        self.age = age\n",
    "\n",
    "    def __ne__(self, other):\n",
    "        print(\"calling dunder method __ne__\")\n",
    "        return self.age != other.age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "77100ca5",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:01.586934Z",
     "start_time": "2022-04-14T06:55:01.583556Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling dunder method __ne__\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "john = Person('John', 'Doe', 25)\n",
    "jane = Person('Jane', 'Doe', 26)\n",
    "print(john != jane)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "963df765",
   "metadata": {},
   "source": [
    "# `__new__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dc8c109",
   "metadata": {},
   "source": [
    "- Transforming from class to an object is called instantiation.\n",
    "- `__init__` is used to objects initialization and provide a classs witha contructor.\n",
    "    - During object creation `__init__` method doesn’t get executed first, the method which gets executed first is __new__\n",
    "    - `__new__()` method gets most of the same arguments at init and it is responsible for actually creating the new object (prior to initializing object) .\n",
    "- We can use `__new__` when we need to control the creation of a new instance.\n",
    "- Consider this problem:\n",
    "    - Let we have a 3 classes, File ,TextFile(File) and ImageFile(File) . We need instantiate TextFile for Text files, ImageFile for image file, and File for other type of files. We can obtain this by instantiating them directly.\n",
    "    - But what if we could instantiate them only using the parent class (File ) depending the file content? Yes, we want to instantiate child classes using parent class!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "0f40a139",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:01.872609Z",
     "start_time": "2022-04-14T06:55:01.866646Z"
    }
   },
   "outputs": [],
   "source": [
    "class File:\n",
    "    def __new__(cls, *args, **kwargs):\n",
    "        file_type = kwargs.get(\"file_name\").split(\".\")[-1]\n",
    "\n",
    "        if file_type == \"txt\":\n",
    "            for i in cls.__subclasses__():\n",
    "                if i.__name__ == \"TextFile\":\n",
    "                    return super().__new__(i)\n",
    "        elif file_type in [\"jpg\", \"png\", \"jpeg\"]:\n",
    "            for i in cls.__subclasses__():\n",
    "                if i.__name__ == \"ImageFile\":\n",
    "                    return super().__new__(i)\n",
    "        else:\n",
    "            return super().__new__(File)\n",
    "\n",
    "    def __init__(self, file_name=\"\"):\n",
    "        self.file_name = file_name\n",
    "\n",
    "\n",
    "class ImageFile(File):\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        self.height = kwargs.get(\"height\")\n",
    "        self.width = kwargs.get(\"width\")\n",
    "\n",
    "\n",
    "class TextFile(File):\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        self.file_size = kwargs.get(\"file_size\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "fe24243e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:02.086623Z",
     "start_time": "2022-04-14T06:55:02.083417Z"
    }
   },
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Here, we are instantiating the TextFile, ImageFile and File classes using the File (parent)\n",
    "class depending on content of file (file_type). \n",
    "\"\"\"\n",
    "text_file = File(file_name=\"testfile.txt\", height=100, width=100)\n",
    "image_file = File(file_name=\"imagefile.png\", file_size=500)\n",
    "other_file = File(file_name=\"video_file.mp4\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "ab84643e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:02.243194Z",
     "start_time": "2022-04-14T06:55:02.240256Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.TextFile object at 0x7fbe5c62ba00>\n",
      "<__main__.ImageFile object at 0x7fbe5c62b0d0>\n",
      "<__main__.File object at 0x7fbe5c62bfd0>\n"
     ]
    }
   ],
   "source": [
    "print(text_file)\n",
    "print(image_file)\n",
    "print(other_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a01b89da",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-21T14:06:33.026455Z",
     "start_time": "2023-06-21T14:06:33.023920Z"
    }
   },
   "source": [
    "# `__next__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7fd21778",
   "metadata": {},
   "source": [
    "- All iterators can be placed to the right of the in keyword in for loop statements.\n",
    "- The interpreter calls `iterator.___next___()` and repeats until a `StopIteration` error occurs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ca7e4818",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-21T14:13:31.892044Z",
     "start_time": "2023-06-21T14:13:31.889678Z"
    }
   },
   "outputs": [],
   "source": [
    "a = [1,2,3,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "39915fec",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-21T14:13:32.273156Z",
     "start_time": "2023-06-21T14:13:32.270194Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in a:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "382425e0",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-21T14:13:34.864823Z",
     "start_time": "2023-06-21T14:13:34.858135Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/5x/lyqr8wv507n43bnwpsz4dq_c0000gn/T/ipykernel_2703/845858392.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0miter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__next__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "a = iter(a)\n",
    "while True:\n",
    "    print(a.__next__())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fb7b84c",
   "metadata": {},
   "source": [
    "# `__qualname__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4c92579c",
   "metadata": {},
   "source": [
    "- The `__qualname__` attribute means qualified name in Python. \n",
    "- It gives you a **dotted path** to the name of the target object.\n",
    "- Using `__qualname__` is useful with nested structures, such as when you have a method inside a class\n",
    "- **Difference?** With nested structures:\n",
    "    - The `__qualname__` returns a path to the object\n",
    "    - The `__name__` attribute does not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "6e491965",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:02.458124Z",
     "start_time": "2022-04-14T06:55:02.455238Z"
    }
   },
   "outputs": [],
   "source": [
    "class Example:\n",
    "    def something_level_1():\n",
    "        def something_level_2():\n",
    "            pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "ca1ac872",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:02.675558Z",
     "start_time": "2022-04-14T06:55:02.672929Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Example.something_level_1\n"
     ]
    }
   ],
   "source": [
    "print(Example.something_level_1.__qualname__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "1dc45f98",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:02.844682Z",
     "start_time": "2022-04-14T06:55:02.841411Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "something\n",
      "Example.something\n"
     ]
    }
   ],
   "source": [
    "class Example:\n",
    "    def something():\n",
    "        pass\n",
    "print(Example.something.__name__)\n",
    "print(Example.something.__qualname__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c59857fb",
   "metadata": {},
   "source": [
    "- Using `__qualname__` is useful if you have a function and a method with the same names. \n",
    "- Using `__qualname__` you are able to see the difference between the method and the function based on the path it returns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "c05c8ec6",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:03.038773Z",
     "start_time": "2022-04-14T06:55:03.035677Z"
    }
   },
   "outputs": [],
   "source": [
    "def something():\n",
    "    pass\n",
    "\n",
    "\n",
    "class Example:\n",
    "    def something():\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "627f8472",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:03.268161Z",
     "start_time": "2022-04-14T06:55:03.265305Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "something\n",
      "something\n"
     ]
    }
   ],
   "source": [
    "# Using __name__ you would not be able to tell the difference\n",
    "print(something.__name__)\n",
    "print(Example.something.__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "35265b06",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:03.418839Z",
     "start_time": "2022-04-14T06:55:03.415951Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "something\n",
      "Example.something\n"
     ]
    }
   ],
   "source": [
    "# Using __qualname__ you would not be able to tell the difference\n",
    "print(something.__qualname__)\n",
    "print(Example.something.__qualname__)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "492185a1",
   "metadata": {},
   "source": [
    "# `__reduce__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad4e0687",
   "metadata": {},
   "source": [
    "- When you try to pickle an object, there might be some properties that don't serialize well. \n",
    "- One example of this is an open file handle. Pickle won't know how to handle the object and will throw an error.\n",
    "- You can tell the pickle module how to handle these types of objects natively within a class directly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "0c68b987",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:03.639065Z",
     "start_time": "2022-04-14T06:55:03.622471Z"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "cannot pickle '_io.BufferedWriter' object",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/5x/lyqr8wv507n43bnwpsz4dq_c0000gn/T/ipykernel_4751/818801063.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0mmy_test\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mTest\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0;31m# Now, watch what happens when we try to pickle this object: it should throw an error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 12\u001b[0;31m \u001b[0mpickle\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdumps\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_test\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: cannot pickle '_io.BufferedWriter' object"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "\n",
    "\n",
    "class Test(object):\n",
    "    def __init__(self, file_path=\"test1234567890.txt\"):\n",
    "        # An open file in write mode\n",
    "        self.some_file_i_have_opened = open(file_path, 'wb')\n",
    "\n",
    "\n",
    "my_test = Test()\n",
    "# Now, watch what happens when we try to pickle this object: it should throw an error\n",
    "pickle.dumps(my_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "fafbd077",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:03.863765Z",
     "start_time": "2022-04-14T06:55:03.856545Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b'\\x80\\x04\\x95.\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x8c\\x08__main__\\x94\\x8c\\x04Test\\x94\\x93\\x94\\x8c\\x12test1234567890.txt\\x94\\x85\\x94R\\x94.'\n"
     ]
    }
   ],
   "source": [
    "import pickle\n",
    "\n",
    "\n",
    "class Test(object):\n",
    "    def __init__(self, file_path=\"test1234567890.txt\"):\n",
    "        # Used later in __reduce__\n",
    "        self._file_name_we_opened = file_path\n",
    "        # An open file in write mode\n",
    "        self.some_file_i_have_opened = open(self._file_name_we_opened, 'wb')\n",
    "\n",
    "    def __reduce__(self):\n",
    "        # we return a tuple of class_name to call,\n",
    "        # and optional parameters to pass when re-creating\n",
    "        return (self.__class__, (self._file_name_we_opened, ))\n",
    "\n",
    "\n",
    "my_test = Test()\n",
    "saved_object = pickle.dumps(my_test)\n",
    "# Just print the representation of the string of the object,\n",
    "# because it contains newlines.\n",
    "print(repr(saved_object))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "id": "0c833029",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:04.155104Z",
     "start_time": "2022-04-14T06:55:04.016301Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A collection of not-so-obvious Python stuff.ipynb\r\n",
      "Abstract and virtual abstarct class.ipynb\r\n",
      "Args and kwargs.ipynb\r\n",
      "Broadcasting.ipynb\r\n",
      "Built-in iterators.ipynb\r\n",
      "Class definition and syntax.ipynb\r\n",
      "\u001b[34mCode_Style\u001b[m\u001b[m\r\n",
      "\u001b[34mCoding_Interview_exercises\u001b[m\u001b[m\r\n",
      "Control flow statements.ipynb\r\n",
      "\u001b[31mData structure stacks, queues, linked list.ipynb\u001b[m\u001b[m\r\n",
      "Declaring private variables.ipynb\r\n",
      "\u001b[34mDecorators\u001b[m\u001b[m\r\n",
      "Docstrings.ipynb\r\n",
      "Dunder methods.ipynb\r\n",
      "Errors and exceptions.ipynb\r\n",
      "\u001b[31mFirst class functions.ipynb\u001b[m\u001b[m\r\n",
      "Function annotation.ipynb\r\n",
      "Generators.ipynb\r\n",
      "\u001b[34mGitHub_MD_rendering\u001b[m\u001b[m\r\n",
      "How to show status bar.ipynb\r\n",
      "Inheritance in all its flavours.ipynb\r\n",
      "Inspect your class.ipynb\r\n",
      "\u001b[34mInstallation\u001b[m\u001b[m\r\n",
      "\u001b[34mIntroduction to __init__.py\u001b[m\u001b[m\r\n",
      "\u001b[31mIterables, Iterators and Generators.ipynb\u001b[m\u001b[m\r\n",
      "Lambda, map and filter functions.ipynb\r\n",
      "List and set comprehensions.ipynb\r\n",
      "Lists, sets, dictionaries and tuples.ipynb\r\n",
      "\u001b[31mLogging module.ipynb\u001b[m\u001b[m\r\n",
      "Namespaces, scope resolution, and the LEGB rule.ipynb\r\n",
      "\u001b[34mNotable_methods_in_python\u001b[m\u001b[m\r\n",
      "Object-Oriented Programming (OOP) in Python.ipynb\r\n",
      "Operators.ipynb\r\n",
      "\u001b[34mOther_Info\u001b[m\u001b[m\r\n",
      "Overwriting vs. Overloading vs. Overriding.ipynb\r\n",
      "Partial function.ipynb\r\n",
      "\u001b[31mPublic, Private, Protected attributes.ipynb\u001b[m\u001b[m\r\n",
      "Python 2.7.x and Python 3.x.ipynb\r\n",
      "README.md\r\n",
      "Strings and regular expressions.ipynb\r\n",
      "Super() __init__ and __new__.ipynb\r\n",
      "Super().ipynb\r\n",
      "\u001b[34mThe __all__ construct\u001b[m\u001b[m\r\n",
      "The __future__ module.ipynb\r\n",
      "Variables and Objects.ipynb\r\n",
      "Wildcards in Python.ipynb\r\n",
      "Yield.ipynb\r\n",
      "\u001b[34m___Algorithms\u001b[m\u001b[m\r\n",
      "\u001b[34m___unittest\u001b[m\u001b[m\r\n",
      "__call__ method.ipynb\r\n",
      "\u001b[34m__name__ == '__main__'\u001b[m\u001b[m\r\n",
      "__repr__ vs. __str__.ipynb\r\n",
      "default_dictionary.ipynb\r\n",
      "\u001b[31mlog_timing.py\u001b[m\u001b[m\r\n",
      "self and __init__.ipynb\r\n",
      "test1234567890.txt\r\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "68e2858f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:04.447936Z",
     "start_time": "2022-04-14T06:55:04.316772Z"
    }
   },
   "outputs": [],
   "source": [
    "# Getting rid of the save file\n",
    "!rm  ./test1234567890.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "471058a7",
   "metadata": {},
   "source": [
    "# `__reduce_ex__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21a085dc",
   "metadata": {},
   "source": [
    "- `__reduce_ex__` is what `__reduce__` should have been but never became. \n",
    "- `__reduce_ex__` works like `__reduce__` but the pickle protocol is passed.\n",
    "- At pickling time `__reduce__()` will be called with no arguments, and it must return either a string or a tuple.\n",
    "- It is sometimes useful to know the protocol version and this can be done by implementing a method named `__reduce_ex__`.\n",
    "- `__reduce_ex__` is preferred over over `__reduce__` (you may still provide `__reduce__` for backwards compatibility). \n",
    "- The `__reduce_ex__` method will be called with a single integer argument, the protocol version."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc9e1076",
   "metadata": {},
   "source": [
    "# `__repr__` & `__str__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18974ced",
   "metadata": {},
   "source": [
    "- They both represent the object but the `__repr__` method tells you more.\n",
    "- So much more that you can also reconstruct the object based on that information.\n",
    "- Also Python interpreter sessions use `__repr__` to inspect objects.\n",
    "- `__str__` should have a readable output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "91f8077d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:04.712563Z",
     "start_time": "2022-04-14T06:55:04.707303Z"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "class Tensor(object):\n",
    "    \n",
    "    def __init__(self, data):\n",
    "        \"\"\"__init__ method\n",
    "        Given a list, tunrs it into an array\n",
    "        \"\"\"        \n",
    "        self.data = np.array(data)\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        \"\"\"__add__ method        \n",
    "        Add two tensor together\n",
    "        \"\"\"\n",
    "        return Tensor(self.data + other.data)\n",
    "    \n",
    "    def __repr__(self):\n",
    "        print(\"calling __repr__\")\n",
    "        \"\"\"__repr__ method\n",
    "        Returns the object representation in string format.\n",
    "        Retunrs and official string representation of the object,\n",
    "        which can be ised to construt the object again.\n",
    "        \"\"\"\n",
    "        return str(self.data.__repr__())\n",
    "    \n",
    "    def __str__(self):\n",
    "        print(\"calling __str__\")\n",
    "        \"\"\"\n",
    "        Returns the string representation of the object. This method is called\n",
    "        when print() or str() function is invoked on an object. Retunrs a \n",
    "        human-redeable string format.\n",
    "        \"\"\"\n",
    "        return str(self.data.__str__())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "09d983b5",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:04.932562Z",
     "start_time": "2022-04-14T06:55:04.927664Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling __repr__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = Tensor([1,2,3,4,5])\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "cd1097ec",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:05.106441Z",
     "start_time": "2022-04-14T06:55:05.102692Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling __repr__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'array([1, 2, 3, 4, 5])'"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repr(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "61c7cff3",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:05.282025Z",
     "start_time": "2022-04-14T06:55:05.277637Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling __str__\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'[1 2 3 4 5]'"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "d4deee6f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:05.469304Z",
     "start_time": "2022-04-14T06:55:05.466147Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "calling __str__\n",
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5475fdbc",
   "metadata": {},
   "source": [
    "# `__setitem__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfb3c33a",
   "metadata": {},
   "source": [
    "- The square bracket assignment notation is just a convenient interface to a method call.\n",
    "- What actually happens is that Python calls the `__setitem__` method.\n",
    "- If you wanted to you could modify the __setitem__ method, so that square bracket assignment does something totally different."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "5553bc2f",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-21T12:46:24.475744Z",
     "start_time": "2023-06-21T12:46:24.465868Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['aa', 'b']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = ['a', 'b']\n",
    "x[0] = 'aa'  # Item assignment using square bracket notation\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cdc2ed7d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-06-21T12:46:32.120346Z",
     "start_time": "2023-06-21T12:46:32.116586Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['aa', 'b']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = ['a', 'b']\n",
    "x.__setitem__(0, 'aa')  # Equivalent to x[0] = 'aa'\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2acf43f",
   "metadata": {},
   "source": [
    "# `__setattr__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "72bdd870",
   "metadata": {},
   "source": [
    "- Python’s magic method `__setattr__()` implements the built-in `setattr()` function that takes an object and an attribute name as arguments and **removes the attribute from the object**.\n",
    "- Let’s have a look at an example where you override the `__setattr__` magic method of a custom class.\n",
    "- Person to simply print out the arguments rather than really changing the attributes of the class as the default `setattr()` function would do."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "4b7d3cf2",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:05.874798Z",
     "start_time": "2022-04-14T06:55:05.871915Z"
    }
   },
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __setattr__(self, attr_name, attr_value):\n",
    "        print(attr_name, attr_value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "65b36940",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:06.106204Z",
     "start_time": "2022-04-14T06:55:06.103441Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "age 32\n"
     ]
    }
   ],
   "source": [
    "alice = Person()\n",
    "setattr(alice, 'age', 32)\n",
    "# age 32"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8318d406",
   "metadata": {},
   "source": [
    "- If we did not  overridden the `__setattr__()` magic method, Python would’ve created a new attribute for the alice instance, so when calling `alice.age`, you’d have obtained the value 32. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "9751ca84",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:06.341257Z",
     "start_time": "2022-04-14T06:55:06.338507Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class Person_diff:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "9a126280",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:06.569785Z",
     "start_time": "2022-04-14T06:55:06.567274Z"
    }
   },
   "outputs": [],
   "source": [
    "alice_diff = Person_diff()\n",
    "setattr(alice_diff, 'age', 32)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "d5810468",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:06.735149Z",
     "start_time": "2022-04-14T06:55:06.731404Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'age': 32}"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alice_diff.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8ccda05",
   "metadata": {},
   "source": [
    "# `__sizeof__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c399640a",
   "metadata": {},
   "source": [
    "- So let us look at the two ways of getting the size of a particular object in Python. These are `getsizeof()` method and `__sizeof()` method. \n",
    "- The `getsizeof()` is a system-specific method and hence we have to import the sys module to use it. A sample code is as shown below for calculating the size of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "e7128d2b",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:07.081276Z",
     "start_time": "2022-04-14T06:55:07.076947Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "72\n",
      "120\n",
      "120\n",
      "120\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "a = [1, 2]\n",
    "b = [1, 2, 3, 4]\n",
    "c = [1, 2, 3, 4]\n",
    "d = [2, 3, 1, 4, 66, 54, 45, 89]\n",
    "print(sys.getsizeof(a))\n",
    "print(sys.getsizeof(b))\n",
    "print(sys.getsizeof(c))\n",
    "print(sys.getsizeof(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8de4ef69",
   "metadata": {},
   "source": [
    "- `getsizeof()` method calls the `__sizeof__()` method o the object with an additional garbage collector overhead. \n",
    "- Hence the size returned by the `getsize()` method will be more than that returned by the `__sizeof()__` method. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "75536719",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:07.358040Z",
     "start_time": "2022-04-14T06:55:07.353246Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "56\n",
      "104\n",
      "104\n",
      "104\n"
     ]
    }
   ],
   "source": [
    "w = [1, 2]\n",
    "x = [4, 5, 7, 9]\n",
    "y = [2, 8, 6, 56, 45, 89, 88]\n",
    "z = [54, 45, 12, 23, 24, 90, 20, 40]\n",
    "print(w.__sizeof__())\n",
    "print(x.__sizeof__())\n",
    "print(y.__sizeof__())\n",
    "print(z.__sizeof__())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdcfebe0",
   "metadata": {},
   "source": [
    "# `__subclasshook__`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a76e033b",
   "metadata": {},
   "source": [
    "- `__subclasscheck__` is one of the methods to customize the result of `issubclass()` built-in function. \n",
    "- It is a method to check whether a class is a subclass or not and returns True if the class is considered as a subclass(direct or indirect) of another class, otherwise, returns False. \n",
    "- It cannot be defined as a class method in the actual/real class. It is implemented in the metaclass, as it is not for ordinary classes. \n",
    "- **Example** consider a situation where you want to check if a certain value is present as an attribute inside a class using the `issubclass()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "id": "fb819d2d",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:07.910752Z",
     "start_time": "2022-04-14T06:55:07.906262Z"
    }
   },
   "outputs": [],
   "source": [
    "class A(type):\n",
    "\n",
    "    # __subclasscheck__() defined\n",
    "    def __subclasscheck__(cls, sub):\n",
    "\n",
    "        # Getting the L attribute of\n",
    "        # subclass\n",
    "        attr = getattr(cls, 'L', [])\n",
    "\n",
    "        # Checking if the subclass\n",
    "        # is present in the L attribute\n",
    "        # of subclass or not\n",
    "        if sub in attr:\n",
    "            return True\n",
    "\n",
    "        return False\n",
    "\n",
    "\n",
    "class B(metaclass=A):\n",
    "\n",
    "    # L Attribute\n",
    "    L = [1, 2, 3, 4, 5]\n",
    "\n",
    "\n",
    "class C(metaclass=A):\n",
    "\n",
    "    # L Attribute\n",
    "    L = [\"Geeks\", \"For\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "12b2ed33",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:08.144007Z",
     "start_time": "2022-04-14T06:55:08.140414Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Driver's code\n",
    "print(issubclass(1, B))\n",
    "print(issubclass(\"Geeks\", B))\n",
    "print(issubclass(\"Geeks\", C))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "519e4493",
   "metadata": {},
   "source": [
    "# Check them all in a loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "id": "476f6c64",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:15.296324Z",
     "start_time": "2022-04-14T06:55:15.293846Z"
    }
   },
   "outputs": [],
   "source": [
    "def check_in_a_loop():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "id": "7e8f624e",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:15.534632Z",
     "start_time": "2022-04-14T06:55:15.530734Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__annotations__',\n",
       " '__call__',\n",
       " '__class__',\n",
       " '__closure__',\n",
       " '__code__',\n",
       " '__defaults__',\n",
       " '__delattr__',\n",
       " '__dict__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__get__',\n",
       " '__getattribute__',\n",
       " '__globals__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__kwdefaults__',\n",
       " '__le__',\n",
       " '__lt__',\n",
       " '__module__',\n",
       " '__name__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__qualname__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__']"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(check_in_a_loop)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "4c313c89",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:15.740074Z",
     "start_time": "2022-04-14T06:55:15.736692Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "check_in_a_loop.__dict__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "531526d3",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-14T06:55:15.948667Z",
     "start_time": "2022-04-14T06:55:15.938228Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__annotations__\n",
      "{}\n",
      "__call__\n",
      "<method-wrapper '__call__' of function object at 0x7fbe5c628160>\n",
      "__class__\n",
      "<class 'function'>\n",
      "__closure__\n",
      "None\n",
      "__code__\n",
      "<code object check_in_a_loop at 0x7fbe5d0e5d40, file \"/var/folders/5x/lyqr8wv507n43bnwpsz4dq_c0000gn/T/ipykernel_4751/905980305.py\", line 1>\n",
      "__defaults__\n",
      "None\n",
      "__delattr__\n",
      "<method-wrapper '__delattr__' of function object at 0x7fbe5c628160>\n",
      "__dict__\n",
      "{}\n",
      "__dir__\n",
      "<built-in method __dir__ of function object at 0x7fbe5c628160>\n",
      "__doc__\n",
      "None\n",
      "__eq__\n",
      "<method-wrapper '__eq__' of function object at 0x7fbe5c628160>\n",
      "__format__\n",
      "<built-in method __format__ of function object at 0x7fbe5c628160>\n",
      "__ge__\n",
      "<method-wrapper '__ge__' of function object at 0x7fbe5c628160>\n",
      "__get__\n",
      "<method-wrapper '__get__' of function object at 0x7fbe5c628160>\n",
      "__getattribute__\n",
      "<method-wrapper '__getattribute__' of function object at 0x7fbe5c628160>\n",
      "__globals__\n",
      "calling __repr__\n",
      "calling __repr__\n",
      "calling __repr__\n",
      "{'__name__': '__main__', '__doc__': '\\nHere, we are instantiating the TextFile, ImageFile and File classes using the File (parent)\\nclass depending on content of file (file_type). \\n', '__package__': None, '__loader__': None, '__spec__': None, '__builtin__': <module 'builtins' (built-in)>, '__builtins__': <module 'builtins' (built-in)>, '_ih': ['', 'def func():\\n    pass', 'dir(func)', 'class A():\\n    pass', 'a = A()', 'dir(a)', 'def func_1(a: \"this is argument a\") -> \"This is a squared\":\\n    return a**2', '# first way to call\\nfunc_1', '# second way to call\\nfunc_1.__annotations__', \"# Annotations is a dictionary\\n'{:,} {}'.format(func_1(2),\\n                 func_1.__annotations__['return'])\", \"rd = {'type': float, 'units': 'Joules',\\n      'docstring': 'Given mass and velocity returns kinetic energy in Joules'}\\n\\ndef func_2() -> rd:\\n    pass\", 'for i in [\\'type\\', \"units\", \"docstring\"]:\\n    print(func_2.__annotations__[\\'return\\'][i])', 'class Product():\\n    def __init__(self):\\n        print(\"Instance created\")\\n\\n    # Defining __call__ method\\n    def __call__(self, a, b):\\n        print(\"Instance is called via special method __call__\")\\n        print(a*b)', 'p = Product()', '# This is equivalent to\\np.__init__()', '# Since Product has  a __call_ method, p can be called like a function\\np(2,3)', '# The cell above is equivalent to this call\\np.__call__(2,3)', 'def simple_function():\\n    pass', 'type(simple_function)', 'simple_function.__class__', '# this is a nested function\\ndef gfg(raise_power_to):\\n\\n    def power(number):\\n        return number ** raise_power_to\\n    return power', 'raise_power_to_3 = gfg(3)', 'print(raise_power_to_3.__closure__)', 'print(raise_power_to_3.__closure__[0].cell_contents)', 'def func_3(x):\\n    return x', 'func_3.__code__', 'func_3.__code__.co_nlocals', 'func_3.__code__.co_argcount', 'def func(a, b):\\n    pass', 'print(func.__defaults__)', 'func.__defaults__ is None', 'def foobar(element, data=[]):\\n    data.append(element)\\n    return data', '# Before execution\\nfoobar.__defaults__', 'foobar(12)', 'foobar(12)', 'foobar.__defaults__', 'class Frob():\\n    def __delattr__(self, name):\\n        print(\"deleting `{}`\".format(str(name)))\\n        del self.__dict__[name]\\n        print(\"`{}` deleted\".format(str(name)))', 'f = Frob()', 'dir(f)', '# Adding a class (instance?) attribute\\nf.dummy = 10', '# Now you show be able to see \"dummy\" listed there\\ndir(f)', 'del f.dummy', 'def func_1():\\n    pass\\n\\nfunc_1.temp = 1\\n\\nprint(func_1.__dict__)', 'def func_2():\\n    pass\\n\\nprint(func_2.__dict__)', 'class TempClass:\\n    a = 1\\n\\n    def temp_function(self):\\n        pass\\n\\n\\nprint(TempClass.__dict__)', 'class Hello():\\n    def __dir__(self):\\n        print(\"calling __dir__\")\\n        return [1, 2, 3]', 'hello = Hello()', 'dir(hello)', 'hello.__dir__()', 'class Dog:\\n    \"\"\"Your best friend.\"\"\"\\n\\n    def do_nothing(self):\\n        pass', 'print(Dog.__doc__)', '# It works the same even after instantiation\\ndog = Dog()\\ndog.__doc__', 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __eq__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 25)\\nprint(john == jane)\", \"# custom __format__() method\\nclass Person:\\n    def __format__(self, format):\\n        if(format == 'age'):\\n            return '23'\\n        return 'None'\", '# The format() function internally runs Person().__format__(\"age\") to return 23.\\nformat(Person(), \"age\")', 'class Person:\\n    def __init__(self, age):\\n        self.age = age\\n\\n    def __ge__(self, other):\\n        print(\"Calling dunder method __ge__\")\\n        return self.age >= other.age', 'alice = Person(18)\\nbob = Person(17)\\ncarl = Person(18)', 'print(alice >= bob)\\nprint(alice >= carl)\\nprint(bob >= alice)', '# This is our descriptor object\\nclass Bar():\\n    def __init__(self):\\n        self.value = \\'\\'\\n\\n    def __get__(self, instance, owner):\\n        print(\"returned from descriptor object\")\\n        return self.value\\n\\n    def __set__(self, instance, value):\\n        print(\"set in descriptor object\")\\n        self.value = value\\n\\n    def __delete__(self, instance):\\n        print(\"deleted in descriptor object\")\\n        del self.value\\n\\n\\nclass Foo(object):\\n    bar = Bar()', 'f = Foo()', 'f.bar = 10', 'print(f.bar)', 'del f.bar', \"class Yeah(object):\\n    def __init__(self, name):\\n        # Gets called when an attribute is accessed\\n        self.name = name\\n\\n    def __getattribute__(self, item):\\n        print('__getattribute__ ', item)\\n        # Calling the super class to avoid recursion\\n        # Gets called when the item is not found via __getattribute__\\n        return super(Yeah, self).__getattribute__(item)\\n\\n    def __getattr__(self, item):\\n        print('__getattr__ ', item)\\n        return super(Yeah, self).__setattr__(item, 'orphan')\", \"y1 = Yeah('yes')\\ny1.name\", 'y1.foo', 'y1.foo', 'y1.goo', 'y1.__dict__', \"def one():\\n    return 'one'\\n\\ndef three(param):\\n    def two():\\n        print(one(), param)\\n    return two\", \"inst = three('hello')\", 'inst()', '# This would not work well in a notebook as it keeping all the variables run in this notebook!\\ninst.__globals__', 'inst.__closure__', 'inst.__closure__[0].cell_contents', 'class Person:\\n    def __init__(self, age):\\n        self.age = age\\n\\n    def __gt__(self, other):\\n        return self.age > other.age', 'alice = Person(18)\\nbob = Person(17)\\ncarl = Person(18)', 'print(alice > bob)\\nprint(alice > carl)\\nprint(bob > alice)', 'class C:\\n    def __init__(self, x):\\n        self.x = x\\n\\n    def __repr__(self):\\n        return f\"C({self.x})\"\\n\\n    def __hash__(self):\\n        return hash(self.x)\\n\\n    def __eq__(self, other):\\n        return (\\n            self.__class__ == other.__class__ and\\n            self.x == other.x\\n        )', 'd = dict()\\ns = set()\\nc = C(1)\\nd[c] = 42\\ns.add(c)', 'd, s', 'c in s and c in d  # c is in both!', 'c.x = 2', 'c in s or c in d   # c is in neither!?', \"d, s\\n#({C(2): 42}, {C(2)})   # but...it's right there!\", 'class Customer(object):\\n    \"\"\"A customer of ABC bank with a checking. account.\\n    \\n    Customer have the following propperties:\\n    \\n    Atributes:\\n        name: a string representing the custome name\\n        balance: a float. tracking the current balance of the customer\\'s account\\n    \"\"\"\\n    \\n    def __init__(self, name, balance = 0.0):\\n        \"\"\"Object initialisation.\\n        \\n        Returns a customers objkect whose name is name and stating\\n        balance is balance.\\n        \"\"\"\\n        \\n        self.name = name\\n        self.balance = balance\\n        \\n    def withdraw(self, amount):\\n        \"\"\"Withdraw.\\n        \\n        Returns the balance remaininga fter withdrawing ana mount.\\n        \"\"\"\\n        \\n        if amount > self.balance:\\n            raise RuntimeError(\"Amount requested is greater than the current balance\")\\n        self.balance -= amount\\n        \\n        return self.balance\\n    \\n    def deposit(self, amount):\\n        \"\"\"Deposit.\\n        \\n        Returns the balance remaining after depositing some monies.\\n        \"\"\"\\n        \\n        self.balance += amount\\n        \\n        return sel.balance', 'custormerA = Customer(\"Charlier\", 100)\\ncustormerB = Customer(\"Maria\", 200)\\ncustomerNull = Customer(\"Null\")', 'custormerA.__dict__', 'custormerB.__dict__', 'customerNull.__dict__', 'class Philosopher:\\n    def __init_subclass__(cls, default_name, **kwargs):\\n        super().__init_subclass__(**kwargs)\\n        print(f\"Called __init_subclass({cls}, {default_name})\")\\n        cls.default_name = default_name\\n\\n\\nclass AustralianPhilosopher(Philosopher, default_name=\"Bruce\"):\\n    pass\\n\\n\\nclass GermanPhilosopher(Philosopher, default_name=\"Nietzsche\"):\\n    default_name = \"Hegel\"\\n    print(\"Set name to Hegel\")', 'Bruce = AustralianPhilosopher()\\nMistery = GermanPhilosopher()\\nprint(Bruce.default_name)\\nprint(Mistery.default_name)', \"def func(a, b='Default value'):\\n    pass\", 'func.__defaults__', 'print(func.__kwdefaults__)', 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __le__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john <= jane)\", 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __lt__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john < jane)\", 'def func_3():\\n    pass', 'func_3.__name__', 'from math import sin\\n# Function sin() came from the math module.\\nsin.__module__', '# Define a dummy class\\nclass A:    \\n    pass\\n\\n\\na = A\\na.__module__', 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __ne__(self, other):\\n        print(\"calling dunder method __ne__\")\\n        return self.age != other.age', \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john != jane)\", 'class File:\\n    def __new__(cls, *args, **kwargs):\\n        file_type = kwargs.get(\"file_name\").split(\".\")[-1]\\n\\n        if file_type == \"txt\":\\n            for i in cls.__subclasses__():\\n                if i.__name__ == \"TextFile\":\\n                    return super().__new__(i)\\n        elif file_type in [\"jpg\", \"png\", \"jpeg\"]:\\n            for i in cls.__subclasses__():\\n                if i.__name__ == \"ImageFile\":\\n                    return super().__new__(i)\\n        else:\\n            return super().__new__(File)\\n\\n    def __init__(self, file_name=\"\"):\\n        self.file_name = file_name\\n\\n\\nclass ImageFile(File):\\n    def __init__(self, *args, **kwargs):\\n        self.height = kwargs.get(\"height\")\\n        self.width = kwargs.get(\"width\")\\n\\n\\nclass TextFile(File):\\n    def __init__(self, *args, **kwargs):\\n        self.file_size = kwargs.get(\"file_size\")', '\"\"\"\\nHere, we are instantiating the TextFile, ImageFile and File classes using the File (parent)\\nclass depending on content of file (file_type). \\n\"\"\"\\ntext_file = File(file_name=\"testfile.txt\", height=100, width=100)\\nimage_file = File(file_name=\"imagefile.png\", file_size=500)\\nother_file = File(file_name=\"video_file.mp4\")', 'print(text_file)\\nprint(image_file)\\nprint(other_file)', 'class Example:\\n    def something_level_1():\\n        def something_level_2():\\n            pass', 'print(Example.something_level_1.__qualname__)', 'class Example:\\n    def something():\\n        pass\\nprint(Example.something.__name__)\\nprint(Example.something.__qualname__)', 'def something():\\n    pass\\n\\n\\nclass Example:\\n    def something():\\n        pass', '# Using __name__ you would not be able to tell the difference\\nprint(something.__name__)\\nprint(Example.something.__name__)', '# Using __qualname__ you would not be able to tell the difference\\nprint(something.__qualname__)\\nprint(Example.something.__qualname__)', 'import pickle\\n\\n\\nclass Test(object):\\n    def __init__(self, file_path=\"test1234567890.txt\"):\\n        # An open file in write mode\\n        self.some_file_i_have_opened = open(file_path, \\'wb\\')\\n\\n\\nmy_test = Test()\\n# Now, watch what happens when we try to pickle this object: it should throw an error\\npickle.dumps(my_test)', 'class Customer(object):\\n    \"\"\"A customer of ABC bank with a checking. account.\\n    \\n    Customer have the following propperties:\\n    \\n    Atributes:\\n        name: a string representing the custome name\\n        balance: a float. tracking the current balance of the customer\\'s account\\n    \"\"\"\\n    \\n    def __init__(self, name, balance = 0.0):\\n        \"\"\"Object initialisation.\\n        \\n        Returns a customers objkect whose name is name and stating\\n        balance is balance.\\n        \"\"\"\\n        \\n        self.name = name\\n        self.balance = balance\\n        \\n    def withdraw(self, amount):\\n        \"\"\"Withdraw.\\n        \\n        Returns the balance remaininga fter withdrawing ana mount.\\n        \"\"\"\\n        \\n        if amount > self.balance:\\n            raise RuntimeError(\"Amount requested is greater than the current balance\")\\n        self.balance -= amount\\n        \\n        return self.balance\\n    \\n    def deposit(self, amount):\\n        \"\"\"Deposit.\\n        \\n        Returns the balance remaining after depositing some monies.\\n        \"\"\"\\n        \\n        self.balance += amount\\n        \\n        return sel.balance', 'custormerA = Customer(\"Charlier\", 100)\\ncustormerB = Customer(\"Maria\", 200)\\ncustomerNull = Customer(\"Null\")', 'custormerA.__dict__', 'custormerB.__dict__', 'customerNull.__dict__', 'class Philosopher:\\n    def __init_subclass__(cls, default_name, **kwargs):\\n        super().__init_subclass__(**kwargs)\\n        print(f\"Called __init_subclass({cls}, {default_name})\")\\n        cls.default_name = default_name\\n\\n\\nclass AustralianPhilosopher(Philosopher, default_name=\"Bruce\"):\\n    pass\\n\\n\\nclass GermanPhilosopher(Philosopher, default_name=\"Nietzsche\"):\\n    default_name = \"Hegel\"\\n    print(\"Set name to Hegel\")', 'Bruce = AustralianPhilosopher()\\nMistery = GermanPhilosopher()\\nprint(Bruce.default_name)\\nprint(Mistery.default_name)', \"def func(a, b='Default value'):\\n    pass\", 'func.__defaults__', 'print(func.__kwdefaults__)', 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __le__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john <= jane)\", 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __lt__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john < jane)\", 'def func_3():\\n    pass', 'func_3.__name__', 'from math import sin\\n# Function sin() came from the math module.\\nsin.__module__', '# Define a dummy class\\nclass A:    \\n    pass\\n\\n\\na = A\\na.__module__', 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __ne__(self, other):\\n        print(\"calling dunder method __ne__\")\\n        return self.age != other.age', \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john != jane)\", 'class File:\\n    def __new__(cls, *args, **kwargs):\\n        file_type = kwargs.get(\"file_name\").split(\".\")[-1]\\n\\n        if file_type == \"txt\":\\n            for i in cls.__subclasses__():\\n                if i.__name__ == \"TextFile\":\\n                    return super().__new__(i)\\n        elif file_type in [\"jpg\", \"png\", \"jpeg\"]:\\n            for i in cls.__subclasses__():\\n                if i.__name__ == \"ImageFile\":\\n                    return super().__new__(i)\\n        else:\\n            return super().__new__(File)\\n\\n    def __init__(self, file_name=\"\"):\\n        self.file_name = file_name\\n\\n\\nclass ImageFile(File):\\n    def __init__(self, *args, **kwargs):\\n        self.height = kwargs.get(\"height\")\\n        self.width = kwargs.get(\"width\")\\n\\n\\nclass TextFile(File):\\n    def __init__(self, *args, **kwargs):\\n        self.file_size = kwargs.get(\"file_size\")', '\"\"\"\\nHere, we are instantiating the TextFile, ImageFile and File classes using the File (parent)\\nclass depending on content of file (file_type). \\n\"\"\"\\ntext_file = File(file_name=\"testfile.txt\", height=100, width=100)\\nimage_file = File(file_name=\"imagefile.png\", file_size=500)\\nother_file = File(file_name=\"video_file.mp4\")', 'print(text_file)\\nprint(image_file)\\nprint(other_file)', 'class Example:\\n    def something_level_1():\\n        def something_level_2():\\n            pass', 'print(Example.something_level_1.__qualname__)', 'class Example:\\n    def something():\\n        pass\\nprint(Example.something.__name__)\\nprint(Example.something.__qualname__)', 'def something():\\n    pass\\n\\n\\nclass Example:\\n    def something():\\n        pass', '# Using __name__ you would not be able to tell the difference\\nprint(something.__name__)\\nprint(Example.something.__name__)', '# Using __qualname__ you would not be able to tell the difference\\nprint(something.__qualname__)\\nprint(Example.something.__qualname__)', 'import pickle\\n\\n\\nclass Test(object):\\n    def __init__(self, file_path=\"test1234567890.txt\"):\\n        # An open file in write mode\\n        self.some_file_i_have_opened = open(file_path, \\'wb\\')\\n\\n\\nmy_test = Test()\\n# Now, watch what happens when we try to pickle this object: it should throw an error\\npickle.dumps(my_test)', 'import pickle\\n\\n\\nclass Test(object):\\n    def __init__(self, file_path=\"test1234567890.txt\"):\\n        # Used later in __reduce__\\n        self._file_name_we_opened = file_path\\n        # An open file in write mode\\n        self.some_file_i_have_opened = open(self._file_name_we_opened, \\'wb\\')\\n\\n    def __reduce__(self):\\n        # we return a tuple of class_name to call,\\n        # and optional parameters to pass when re-creating\\n        return (self.__class__, (self._file_name_we_opened, ))\\n\\n\\nmy_test = Test()\\nsaved_object = pickle.dumps(my_test)\\n# Just print the representation of the string of the object,\\n# because it contains newlines.\\nprint(repr(saved_object))', \"get_ipython().system('ls')\", \"# Getting rid of the save file\\nget_ipython().system('rm  ./test1234567890.txt')\", 'import numpy as np\\n\\nclass Tensor(object):\\n    \\n    def __init__(self, data):\\n        \"\"\"__init__ method\\n        Given a list, tunrs it into an array\\n        \"\"\"        \\n        self.data = np.array(data)\\n    \\n    def __add__(self, other):\\n        \"\"\"__add__ method        \\n        Add two tensor together\\n        \"\"\"\\n        return Tensor(self.data + other.data)\\n    \\n    def __repr__(self):\\n        print(\"calling __repr__\")\\n        \"\"\"__repr__ method\\n        Returns the object representation in string format.\\n        Retunrs and official string representation of the object,\\n        which can be ised to construt the object again.\\n        \"\"\"\\n        return str(self.data.__repr__())\\n    \\n    def __str__(self):\\n        print(\"calling __str__\")\\n        \"\"\"\\n        Returns the string representation of the object. This method is called\\n        when print() or str() function is invoked on an object. Retunrs a \\n        human-redeable string format.\\n        \"\"\"\\n        return str(self.data.__str__())', 'x = Tensor([1,2,3,4,5])\\nx', 'repr(x)', 'str(x)', 'print(x)', 'class Person:\\n    def __setattr__(self, attr_name, attr_value):\\n        print(attr_name, attr_value)', \"alice = Person()\\nsetattr(alice, 'age', 32)\\n# age 32\", 'class Person_diff:\\n    pass', \"alice_diff = Person_diff()\\nsetattr(alice_diff, 'age', 32)\", 'alice_diff.__dict__', 'import sys\\na = [1, 2]\\nb = [1, 2, 3, 4]\\nc = [1, 2, 3, 4]\\nd = [2, 3, 1, 4, 66, 54, 45, 89]\\nprint(sys.getsizeof(a))\\nprint(sys.getsizeof(b))\\nprint(sys.getsizeof(c))\\nprint(sys.getsizeof(d))', 'w = [1, 2]\\nx = [4, 5, 7, 9]\\ny = [2, 8, 6, 56, 45, 89, 88]\\nz = [54, 45, 12, 23, 24, 90, 20, 40]\\nprint(w.__sizeof__())\\nprint(x.__sizeof__())\\nprint(y.__sizeof__())\\nprint(z.__sizeof__())', 'class A(type):\\n\\n    # __subclasscheck__() defined\\n    def __subclasscheck__(cls, sub):\\n\\n        # Getting the L attribute of\\n        # subclass\\n        attr = getattr(cls, \\'L\\', [])\\n\\n        # Checking if the subclass\\n        # is present in the L attribute\\n        # of subclass or not\\n        if sub in attr:\\n            return True\\n\\n        return False\\n\\n\\nclass B(metaclass=A):\\n\\n    # L Attribute\\n    L = [1, 2, 3, 4, 5]\\n\\n\\nclass C(metaclass=A):\\n\\n    # L Attribute\\n    L = [\"Geeks\", \"For\"]', '# Driver\\'s code\\nprint(issubclass(1, B))\\nprint(issubclass(\"Geeks\", B))\\nprint(issubclass(\"Geeks\", C))', 'def check_in_a_loop():\\n    pass', 'def check_in_a_loop():\\n    pass', 'dir(check_in_a_loop)', 'check_in_a_loop.__dict__', 'for i in dir(check_in_a_loop):\\n    print(i)\\n    print(eval(\"check_in_a_loop.\"+str(i)))'], '_oh': {2: ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'], 5: ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__'], 7: <function func_1 at 0x7fbe5b0d7790>, 8: {'a': 'this is argument a', 'return': 'This is a squared'}, 9: '4 This is a squared', 18: <class 'function'>, 19: <class 'function'>, 25: <code object func_3 at 0x7fbe5b212ea0, file \"/var/folders/5x/lyqr8wv507n43bnwpsz4dq_c0000gn/T/ipykernel_4751/407776788.py\", line 1>, 26: 1, 27: 1, 30: True, 32: ([12, 12],), 33: [12, 12], 34: [12, 12], 35: ([12, 12],), 38: ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__'], 40: ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'dummy'], 47: [1, 2, 3], 48: [1, 2, 3], 51: 'Your best friend.', 55: '23', 65: 'yes', 67: 'orphan', 69: {'name': 'yes', 'foo': 'orphan', 'goo': 'orphan', 'shape': 'orphan'}, 73: {...}, 74: (<cell at 0x7fbe5b220160: str object at 0x7fbe59cce2f0>,), 75: 'hello', 81: ({C(2): 42}, {C(2)}), 82: True, 84: False, 85: ({C(2): 42}, {C(2)}), 88: {'name': 'Charlier', 'balance': 100}, 89: {'name': 'Maria', 'balance': 200}, 90: {'name': 'Null', 'balance': 0.0}, 94: ('Default value',), 101: 'func_3', 102: 'math', 103: '__main__', 118: {'name': 'Charlier', 'balance': 100}, 119: {'name': 'Maria', 'balance': 200}, 120: {'name': 'Null', 'balance': 0.0}, 124: ('Default value',), 131: 'func_3', 132: 'math', 133: '__main__', 150: array([1, 2, 3, 4, 5]), 151: 'array([1, 2, 3, 4, 5])', 152: '[1 2 3 4 5]', 158: {'age': 32}, 165: ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'], 166: {}}, '_dh': ['/Users/gm_main/Desktop/DataScienceFolder/GitHub/Python-Programming'], 'In': ['', 'def func():\\n    pass', 'dir(func)', 'class A():\\n    pass', 'a = A()', 'dir(a)', 'def func_1(a: \"this is argument a\") -> \"This is a squared\":\\n    return a**2', '# first way to call\\nfunc_1', '# second way to call\\nfunc_1.__annotations__', \"# Annotations is a dictionary\\n'{:,} {}'.format(func_1(2),\\n                 func_1.__annotations__['return'])\", \"rd = {'type': float, 'units': 'Joules',\\n      'docstring': 'Given mass and velocity returns kinetic energy in Joules'}\\n\\ndef func_2() -> rd:\\n    pass\", 'for i in [\\'type\\', \"units\", \"docstring\"]:\\n    print(func_2.__annotations__[\\'return\\'][i])', 'class Product():\\n    def __init__(self):\\n        print(\"Instance created\")\\n\\n    # Defining __call__ method\\n    def __call__(self, a, b):\\n        print(\"Instance is called via special method __call__\")\\n        print(a*b)', 'p = Product()', '# This is equivalent to\\np.__init__()', '# Since Product has  a __call_ method, p can be called like a function\\np(2,3)', '# The cell above is equivalent to this call\\np.__call__(2,3)', 'def simple_function():\\n    pass', 'type(simple_function)', 'simple_function.__class__', '# this is a nested function\\ndef gfg(raise_power_to):\\n\\n    def power(number):\\n        return number ** raise_power_to\\n    return power', 'raise_power_to_3 = gfg(3)', 'print(raise_power_to_3.__closure__)', 'print(raise_power_to_3.__closure__[0].cell_contents)', 'def func_3(x):\\n    return x', 'func_3.__code__', 'func_3.__code__.co_nlocals', 'func_3.__code__.co_argcount', 'def func(a, b):\\n    pass', 'print(func.__defaults__)', 'func.__defaults__ is None', 'def foobar(element, data=[]):\\n    data.append(element)\\n    return data', '# Before execution\\nfoobar.__defaults__', 'foobar(12)', 'foobar(12)', 'foobar.__defaults__', 'class Frob():\\n    def __delattr__(self, name):\\n        print(\"deleting `{}`\".format(str(name)))\\n        del self.__dict__[name]\\n        print(\"`{}` deleted\".format(str(name)))', 'f = Frob()', 'dir(f)', '# Adding a class (instance?) attribute\\nf.dummy = 10', '# Now you show be able to see \"dummy\" listed there\\ndir(f)', 'del f.dummy', 'def func_1():\\n    pass\\n\\nfunc_1.temp = 1\\n\\nprint(func_1.__dict__)', 'def func_2():\\n    pass\\n\\nprint(func_2.__dict__)', 'class TempClass:\\n    a = 1\\n\\n    def temp_function(self):\\n        pass\\n\\n\\nprint(TempClass.__dict__)', 'class Hello():\\n    def __dir__(self):\\n        print(\"calling __dir__\")\\n        return [1, 2, 3]', 'hello = Hello()', 'dir(hello)', 'hello.__dir__()', 'class Dog:\\n    \"\"\"Your best friend.\"\"\"\\n\\n    def do_nothing(self):\\n        pass', 'print(Dog.__doc__)', '# It works the same even after instantiation\\ndog = Dog()\\ndog.__doc__', 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __eq__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 25)\\nprint(john == jane)\", \"# custom __format__() method\\nclass Person:\\n    def __format__(self, format):\\n        if(format == 'age'):\\n            return '23'\\n        return 'None'\", '# The format() function internally runs Person().__format__(\"age\") to return 23.\\nformat(Person(), \"age\")', 'class Person:\\n    def __init__(self, age):\\n        self.age = age\\n\\n    def __ge__(self, other):\\n        print(\"Calling dunder method __ge__\")\\n        return self.age >= other.age', 'alice = Person(18)\\nbob = Person(17)\\ncarl = Person(18)', 'print(alice >= bob)\\nprint(alice >= carl)\\nprint(bob >= alice)', '# This is our descriptor object\\nclass Bar():\\n    def __init__(self):\\n        self.value = \\'\\'\\n\\n    def __get__(self, instance, owner):\\n        print(\"returned from descriptor object\")\\n        return self.value\\n\\n    def __set__(self, instance, value):\\n        print(\"set in descriptor object\")\\n        self.value = value\\n\\n    def __delete__(self, instance):\\n        print(\"deleted in descriptor object\")\\n        del self.value\\n\\n\\nclass Foo(object):\\n    bar = Bar()', 'f = Foo()', 'f.bar = 10', 'print(f.bar)', 'del f.bar', \"class Yeah(object):\\n    def __init__(self, name):\\n        # Gets called when an attribute is accessed\\n        self.name = name\\n\\n    def __getattribute__(self, item):\\n        print('__getattribute__ ', item)\\n        # Calling the super class to avoid recursion\\n        # Gets called when the item is not found via __getattribute__\\n        return super(Yeah, self).__getattribute__(item)\\n\\n    def __getattr__(self, item):\\n        print('__getattr__ ', item)\\n        return super(Yeah, self).__setattr__(item, 'orphan')\", \"y1 = Yeah('yes')\\ny1.name\", 'y1.foo', 'y1.foo', 'y1.goo', 'y1.__dict__', \"def one():\\n    return 'one'\\n\\ndef three(param):\\n    def two():\\n        print(one(), param)\\n    return two\", \"inst = three('hello')\", 'inst()', '# This would not work well in a notebook as it keeping all the variables run in this notebook!\\ninst.__globals__', 'inst.__closure__', 'inst.__closure__[0].cell_contents', 'class Person:\\n    def __init__(self, age):\\n        self.age = age\\n\\n    def __gt__(self, other):\\n        return self.age > other.age', 'alice = Person(18)\\nbob = Person(17)\\ncarl = Person(18)', 'print(alice > bob)\\nprint(alice > carl)\\nprint(bob > alice)', 'class C:\\n    def __init__(self, x):\\n        self.x = x\\n\\n    def __repr__(self):\\n        return f\"C({self.x})\"\\n\\n    def __hash__(self):\\n        return hash(self.x)\\n\\n    def __eq__(self, other):\\n        return (\\n            self.__class__ == other.__class__ and\\n            self.x == other.x\\n        )', 'd = dict()\\ns = set()\\nc = C(1)\\nd[c] = 42\\ns.add(c)', 'd, s', 'c in s and c in d  # c is in both!', 'c.x = 2', 'c in s or c in d   # c is in neither!?', \"d, s\\n#({C(2): 42}, {C(2)})   # but...it's right there!\", 'class Customer(object):\\n    \"\"\"A customer of ABC bank with a checking. account.\\n    \\n    Customer have the following propperties:\\n    \\n    Atributes:\\n        name: a string representing the custome name\\n        balance: a float. tracking the current balance of the customer\\'s account\\n    \"\"\"\\n    \\n    def __init__(self, name, balance = 0.0):\\n        \"\"\"Object initialisation.\\n        \\n        Returns a customers objkect whose name is name and stating\\n        balance is balance.\\n        \"\"\"\\n        \\n        self.name = name\\n        self.balance = balance\\n        \\n    def withdraw(self, amount):\\n        \"\"\"Withdraw.\\n        \\n        Returns the balance remaininga fter withdrawing ana mount.\\n        \"\"\"\\n        \\n        if amount > self.balance:\\n            raise RuntimeError(\"Amount requested is greater than the current balance\")\\n        self.balance -= amount\\n        \\n        return self.balance\\n    \\n    def deposit(self, amount):\\n        \"\"\"Deposit.\\n        \\n        Returns the balance remaining after depositing some monies.\\n        \"\"\"\\n        \\n        self.balance += amount\\n        \\n        return sel.balance', 'custormerA = Customer(\"Charlier\", 100)\\ncustormerB = Customer(\"Maria\", 200)\\ncustomerNull = Customer(\"Null\")', 'custormerA.__dict__', 'custormerB.__dict__', 'customerNull.__dict__', 'class Philosopher:\\n    def __init_subclass__(cls, default_name, **kwargs):\\n        super().__init_subclass__(**kwargs)\\n        print(f\"Called __init_subclass({cls}, {default_name})\")\\n        cls.default_name = default_name\\n\\n\\nclass AustralianPhilosopher(Philosopher, default_name=\"Bruce\"):\\n    pass\\n\\n\\nclass GermanPhilosopher(Philosopher, default_name=\"Nietzsche\"):\\n    default_name = \"Hegel\"\\n    print(\"Set name to Hegel\")', 'Bruce = AustralianPhilosopher()\\nMistery = GermanPhilosopher()\\nprint(Bruce.default_name)\\nprint(Mistery.default_name)', \"def func(a, b='Default value'):\\n    pass\", 'func.__defaults__', 'print(func.__kwdefaults__)', 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __le__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john <= jane)\", 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __lt__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john < jane)\", 'def func_3():\\n    pass', 'func_3.__name__', 'from math import sin\\n# Function sin() came from the math module.\\nsin.__module__', '# Define a dummy class\\nclass A:    \\n    pass\\n\\n\\na = A\\na.__module__', 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __ne__(self, other):\\n        print(\"calling dunder method __ne__\")\\n        return self.age != other.age', \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john != jane)\", 'class File:\\n    def __new__(cls, *args, **kwargs):\\n        file_type = kwargs.get(\"file_name\").split(\".\")[-1]\\n\\n        if file_type == \"txt\":\\n            for i in cls.__subclasses__():\\n                if i.__name__ == \"TextFile\":\\n                    return super().__new__(i)\\n        elif file_type in [\"jpg\", \"png\", \"jpeg\"]:\\n            for i in cls.__subclasses__():\\n                if i.__name__ == \"ImageFile\":\\n                    return super().__new__(i)\\n        else:\\n            return super().__new__(File)\\n\\n    def __init__(self, file_name=\"\"):\\n        self.file_name = file_name\\n\\n\\nclass ImageFile(File):\\n    def __init__(self, *args, **kwargs):\\n        self.height = kwargs.get(\"height\")\\n        self.width = kwargs.get(\"width\")\\n\\n\\nclass TextFile(File):\\n    def __init__(self, *args, **kwargs):\\n        self.file_size = kwargs.get(\"file_size\")', '\"\"\"\\nHere, we are instantiating the TextFile, ImageFile and File classes using the File (parent)\\nclass depending on content of file (file_type). \\n\"\"\"\\ntext_file = File(file_name=\"testfile.txt\", height=100, width=100)\\nimage_file = File(file_name=\"imagefile.png\", file_size=500)\\nother_file = File(file_name=\"video_file.mp4\")', 'print(text_file)\\nprint(image_file)\\nprint(other_file)', 'class Example:\\n    def something_level_1():\\n        def something_level_2():\\n            pass', 'print(Example.something_level_1.__qualname__)', 'class Example:\\n    def something():\\n        pass\\nprint(Example.something.__name__)\\nprint(Example.something.__qualname__)', 'def something():\\n    pass\\n\\n\\nclass Example:\\n    def something():\\n        pass', '# Using __name__ you would not be able to tell the difference\\nprint(something.__name__)\\nprint(Example.something.__name__)', '# Using __qualname__ you would not be able to tell the difference\\nprint(something.__qualname__)\\nprint(Example.something.__qualname__)', 'import pickle\\n\\n\\nclass Test(object):\\n    def __init__(self, file_path=\"test1234567890.txt\"):\\n        # An open file in write mode\\n        self.some_file_i_have_opened = open(file_path, \\'wb\\')\\n\\n\\nmy_test = Test()\\n# Now, watch what happens when we try to pickle this object: it should throw an error\\npickle.dumps(my_test)', 'class Customer(object):\\n    \"\"\"A customer of ABC bank with a checking. account.\\n    \\n    Customer have the following propperties:\\n    \\n    Atributes:\\n        name: a string representing the custome name\\n        balance: a float. tracking the current balance of the customer\\'s account\\n    \"\"\"\\n    \\n    def __init__(self, name, balance = 0.0):\\n        \"\"\"Object initialisation.\\n        \\n        Returns a customers objkect whose name is name and stating\\n        balance is balance.\\n        \"\"\"\\n        \\n        self.name = name\\n        self.balance = balance\\n        \\n    def withdraw(self, amount):\\n        \"\"\"Withdraw.\\n        \\n        Returns the balance remaininga fter withdrawing ana mount.\\n        \"\"\"\\n        \\n        if amount > self.balance:\\n            raise RuntimeError(\"Amount requested is greater than the current balance\")\\n        self.balance -= amount\\n        \\n        return self.balance\\n    \\n    def deposit(self, amount):\\n        \"\"\"Deposit.\\n        \\n        Returns the balance remaining after depositing some monies.\\n        \"\"\"\\n        \\n        self.balance += amount\\n        \\n        return sel.balance', 'custormerA = Customer(\"Charlier\", 100)\\ncustormerB = Customer(\"Maria\", 200)\\ncustomerNull = Customer(\"Null\")', 'custormerA.__dict__', 'custormerB.__dict__', 'customerNull.__dict__', 'class Philosopher:\\n    def __init_subclass__(cls, default_name, **kwargs):\\n        super().__init_subclass__(**kwargs)\\n        print(f\"Called __init_subclass({cls}, {default_name})\")\\n        cls.default_name = default_name\\n\\n\\nclass AustralianPhilosopher(Philosopher, default_name=\"Bruce\"):\\n    pass\\n\\n\\nclass GermanPhilosopher(Philosopher, default_name=\"Nietzsche\"):\\n    default_name = \"Hegel\"\\n    print(\"Set name to Hegel\")', 'Bruce = AustralianPhilosopher()\\nMistery = GermanPhilosopher()\\nprint(Bruce.default_name)\\nprint(Mistery.default_name)', \"def func(a, b='Default value'):\\n    pass\", 'func.__defaults__', 'print(func.__kwdefaults__)', 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __le__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john <= jane)\", 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __lt__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john < jane)\", 'def func_3():\\n    pass', 'func_3.__name__', 'from math import sin\\n# Function sin() came from the math module.\\nsin.__module__', '# Define a dummy class\\nclass A:    \\n    pass\\n\\n\\na = A\\na.__module__', 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __ne__(self, other):\\n        print(\"calling dunder method __ne__\")\\n        return self.age != other.age', \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john != jane)\", 'class File:\\n    def __new__(cls, *args, **kwargs):\\n        file_type = kwargs.get(\"file_name\").split(\".\")[-1]\\n\\n        if file_type == \"txt\":\\n            for i in cls.__subclasses__():\\n                if i.__name__ == \"TextFile\":\\n                    return super().__new__(i)\\n        elif file_type in [\"jpg\", \"png\", \"jpeg\"]:\\n            for i in cls.__subclasses__():\\n                if i.__name__ == \"ImageFile\":\\n                    return super().__new__(i)\\n        else:\\n            return super().__new__(File)\\n\\n    def __init__(self, file_name=\"\"):\\n        self.file_name = file_name\\n\\n\\nclass ImageFile(File):\\n    def __init__(self, *args, **kwargs):\\n        self.height = kwargs.get(\"height\")\\n        self.width = kwargs.get(\"width\")\\n\\n\\nclass TextFile(File):\\n    def __init__(self, *args, **kwargs):\\n        self.file_size = kwargs.get(\"file_size\")', '\"\"\"\\nHere, we are instantiating the TextFile, ImageFile and File classes using the File (parent)\\nclass depending on content of file (file_type). \\n\"\"\"\\ntext_file = File(file_name=\"testfile.txt\", height=100, width=100)\\nimage_file = File(file_name=\"imagefile.png\", file_size=500)\\nother_file = File(file_name=\"video_file.mp4\")', 'print(text_file)\\nprint(image_file)\\nprint(other_file)', 'class Example:\\n    def something_level_1():\\n        def something_level_2():\\n            pass', 'print(Example.something_level_1.__qualname__)', 'class Example:\\n    def something():\\n        pass\\nprint(Example.something.__name__)\\nprint(Example.something.__qualname__)', 'def something():\\n    pass\\n\\n\\nclass Example:\\n    def something():\\n        pass', '# Using __name__ you would not be able to tell the difference\\nprint(something.__name__)\\nprint(Example.something.__name__)', '# Using __qualname__ you would not be able to tell the difference\\nprint(something.__qualname__)\\nprint(Example.something.__qualname__)', 'import pickle\\n\\n\\nclass Test(object):\\n    def __init__(self, file_path=\"test1234567890.txt\"):\\n        # An open file in write mode\\n        self.some_file_i_have_opened = open(file_path, \\'wb\\')\\n\\n\\nmy_test = Test()\\n# Now, watch what happens when we try to pickle this object: it should throw an error\\npickle.dumps(my_test)', 'import pickle\\n\\n\\nclass Test(object):\\n    def __init__(self, file_path=\"test1234567890.txt\"):\\n        # Used later in __reduce__\\n        self._file_name_we_opened = file_path\\n        # An open file in write mode\\n        self.some_file_i_have_opened = open(self._file_name_we_opened, \\'wb\\')\\n\\n    def __reduce__(self):\\n        # we return a tuple of class_name to call,\\n        # and optional parameters to pass when re-creating\\n        return (self.__class__, (self._file_name_we_opened, ))\\n\\n\\nmy_test = Test()\\nsaved_object = pickle.dumps(my_test)\\n# Just print the representation of the string of the object,\\n# because it contains newlines.\\nprint(repr(saved_object))', \"get_ipython().system('ls')\", \"# Getting rid of the save file\\nget_ipython().system('rm  ./test1234567890.txt')\", 'import numpy as np\\n\\nclass Tensor(object):\\n    \\n    def __init__(self, data):\\n        \"\"\"__init__ method\\n        Given a list, tunrs it into an array\\n        \"\"\"        \\n        self.data = np.array(data)\\n    \\n    def __add__(self, other):\\n        \"\"\"__add__ method        \\n        Add two tensor together\\n        \"\"\"\\n        return Tensor(self.data + other.data)\\n    \\n    def __repr__(self):\\n        print(\"calling __repr__\")\\n        \"\"\"__repr__ method\\n        Returns the object representation in string format.\\n        Retunrs and official string representation of the object,\\n        which can be ised to construt the object again.\\n        \"\"\"\\n        return str(self.data.__repr__())\\n    \\n    def __str__(self):\\n        print(\"calling __str__\")\\n        \"\"\"\\n        Returns the string representation of the object. This method is called\\n        when print() or str() function is invoked on an object. Retunrs a \\n        human-redeable string format.\\n        \"\"\"\\n        return str(self.data.__str__())', 'x = Tensor([1,2,3,4,5])\\nx', 'repr(x)', 'str(x)', 'print(x)', 'class Person:\\n    def __setattr__(self, attr_name, attr_value):\\n        print(attr_name, attr_value)', \"alice = Person()\\nsetattr(alice, 'age', 32)\\n# age 32\", 'class Person_diff:\\n    pass', \"alice_diff = Person_diff()\\nsetattr(alice_diff, 'age', 32)\", 'alice_diff.__dict__', 'import sys\\na = [1, 2]\\nb = [1, 2, 3, 4]\\nc = [1, 2, 3, 4]\\nd = [2, 3, 1, 4, 66, 54, 45, 89]\\nprint(sys.getsizeof(a))\\nprint(sys.getsizeof(b))\\nprint(sys.getsizeof(c))\\nprint(sys.getsizeof(d))', 'w = [1, 2]\\nx = [4, 5, 7, 9]\\ny = [2, 8, 6, 56, 45, 89, 88]\\nz = [54, 45, 12, 23, 24, 90, 20, 40]\\nprint(w.__sizeof__())\\nprint(x.__sizeof__())\\nprint(y.__sizeof__())\\nprint(z.__sizeof__())', 'class A(type):\\n\\n    # __subclasscheck__() defined\\n    def __subclasscheck__(cls, sub):\\n\\n        # Getting the L attribute of\\n        # subclass\\n        attr = getattr(cls, \\'L\\', [])\\n\\n        # Checking if the subclass\\n        # is present in the L attribute\\n        # of subclass or not\\n        if sub in attr:\\n            return True\\n\\n        return False\\n\\n\\nclass B(metaclass=A):\\n\\n    # L Attribute\\n    L = [1, 2, 3, 4, 5]\\n\\n\\nclass C(metaclass=A):\\n\\n    # L Attribute\\n    L = [\"Geeks\", \"For\"]', '# Driver\\'s code\\nprint(issubclass(1, B))\\nprint(issubclass(\"Geeks\", B))\\nprint(issubclass(\"Geeks\", C))', 'def check_in_a_loop():\\n    pass', 'def check_in_a_loop():\\n    pass', 'dir(check_in_a_loop)', 'check_in_a_loop.__dict__', 'for i in dir(check_in_a_loop):\\n    print(i)\\n    print(eval(\"check_in_a_loop.\"+str(i)))'], 'Out': {2: ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'], 5: ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__'], 7: <function func_1 at 0x7fbe5b0d7790>, 8: {'a': 'this is argument a', 'return': 'This is a squared'}, 9: '4 This is a squared', 18: <class 'function'>, 19: <class 'function'>, 25: <code object func_3 at 0x7fbe5b212ea0, file \"/var/folders/5x/lyqr8wv507n43bnwpsz4dq_c0000gn/T/ipykernel_4751/407776788.py\", line 1>, 26: 1, 27: 1, 30: True, 32: ([12, 12],), 33: [12, 12], 34: [12, 12], 35: ([12, 12],), 38: ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__'], 40: ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'dummy'], 47: [1, 2, 3], 48: [1, 2, 3], 51: 'Your best friend.', 55: '23', 65: 'yes', 67: 'orphan', 69: {'name': 'yes', 'foo': 'orphan', 'goo': 'orphan', 'shape': 'orphan'}, 73: {...}, 74: (<cell at 0x7fbe5b220160: str object at 0x7fbe59cce2f0>,), 75: 'hello', 81: ({C(2): 42}, {C(2)}), 82: True, 84: False, 85: ({C(2): 42}, {C(2)}), 88: {'name': 'Charlier', 'balance': 100}, 89: {'name': 'Maria', 'balance': 200}, 90: {'name': 'Null', 'balance': 0.0}, 94: ('Default value',), 101: 'func_3', 102: 'math', 103: '__main__', 118: {'name': 'Charlier', 'balance': 100}, 119: {'name': 'Maria', 'balance': 200}, 120: {'name': 'Null', 'balance': 0.0}, 124: ('Default value',), 131: 'func_3', 132: 'math', 133: '__main__', 150: array([1, 2, 3, 4, 5]), 151: 'array([1, 2, 3, 4, 5])', 152: '[1 2 3 4 5]', 158: {'age': 32}, 165: ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'], 166: {}}, 'get_ipython': <function get_ipython at 0x7fbe588a2ca0>, 'exit': <IPython.core.autocall.ZMQExitAutocall object at 0x7fbe59fb51f0>, 'quit': <IPython.core.autocall.ZMQExitAutocall object at 0x7fbe59fb51f0>, '_': {}, '__': ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'], '___': {'age': 32}, 'json': <module 'json' from '/opt/anaconda3/envs/trainingAI/lib/python3.9/json/__init__.py'>, 'autopep8': <module 'autopep8' from '/opt/anaconda3/envs/trainingAI/lib/python3.9/site-packages/autopep8.py'>, '_i': 'check_in_a_loop.__dict__', '_ii': 'dir(check_in_a_loop)', '_iii': 'def check_in_a_loop():\\n    pass', '_i1': 'def func():\\n    pass', 'func': <function func at 0x7fbe5c23c0d0>, '_i2': 'dir(func)', '_2': ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'], '_i3': 'class A():\\n    pass', 'A': <class '__main__.A'>, '_i4': 'a = A()', 'a': [1, 2], '_i5': 'dir(a)', '_5': ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__'], '_i6': 'def func_1(a: \"this is argument a\") -> \"This is a squared\":\\n    return a**2', 'func_1': <function func_1 at 0x7fbe5b0d7a60>, '_i7': '# first way to call\\nfunc_1', '_7': <function func_1 at 0x7fbe5b0d7790>, '_i8': '# second way to call\\nfunc_1.__annotations__', '_8': {'a': 'this is argument a', 'return': 'This is a squared'}, '_i9': \"# Annotations is a dictionary\\n'{:,} {}'.format(func_1(2),\\n                 func_1.__annotations__['return'])\", '_9': '4 This is a squared', '_i10': \"rd = {'type': float, 'units': 'Joules',\\n      'docstring': 'Given mass and velocity returns kinetic energy in Joules'}\\n\\ndef func_2() -> rd:\\n    pass\", 'rd': {'type': <class 'float'>, 'units': 'Joules', 'docstring': 'Given mass and velocity returns kinetic energy in Joules'}, 'func_2': <function func_2 at 0x7fbe5b20a940>, '_i11': 'for i in [\\'type\\', \"units\", \"docstring\"]:\\n    print(func_2.__annotations__[\\'return\\'][i])', 'i': '__globals__', '_i12': 'class Product():\\n    def __init__(self):\\n        print(\"Instance created\")\\n\\n    # Defining __call__ method\\n    def __call__(self, a, b):\\n        print(\"Instance is called via special method __call__\")\\n        print(a*b)', 'Product': <class '__main__.Product'>, '_i13': 'p = Product()', 'p': <__main__.Product object at 0x7fbe5b2178e0>, '_i14': '# This is equivalent to\\np.__init__()', '_i15': '# Since Product has  a __call_ method, p can be called like a function\\np(2,3)', '_i16': '# The cell above is equivalent to this call\\np.__call__(2,3)', '_i17': 'def simple_function():\\n    pass', 'simple_function': <function simple_function at 0x7fbe5b20a160>, '_i18': 'type(simple_function)', '_18': <class 'function'>, '_i19': 'simple_function.__class__', '_19': <class 'function'>, '_i20': '# this is a nested function\\ndef gfg(raise_power_to):\\n\\n    def power(number):\\n        return number ** raise_power_to\\n    return power', 'gfg': <function gfg at 0x7fbe5b0d7040>, '_i21': 'raise_power_to_3 = gfg(3)', 'raise_power_to_3': <function gfg.<locals>.power at 0x7fbe5b0d7ca0>, '_i22': 'print(raise_power_to_3.__closure__)', '_i23': 'print(raise_power_to_3.__closure__[0].cell_contents)', '_i24': 'def func_3(x):\\n    return x', 'func_3': <function func_3 at 0x7fbe5c2384c0>, '_i25': 'func_3.__code__', '_25': <code object func_3 at 0x7fbe5b212ea0, file \"/var/folders/5x/lyqr8wv507n43bnwpsz4dq_c0000gn/T/ipykernel_4751/407776788.py\", line 1>, '_i26': 'func_3.__code__.co_nlocals', '_26': 1, '_i27': 'func_3.__code__.co_argcount', '_27': 1, '_i28': 'def func(a, b):\\n    pass', '_i29': 'print(func.__defaults__)', '_i30': 'func.__defaults__ is None', '_30': True, '_i31': 'def foobar(element, data=[]):\\n    data.append(element)\\n    return data', 'foobar': <function foobar at 0x7fbe5b20a280>, '_i32': '# Before execution\\nfoobar.__defaults__', '_32': ([12, 12],), '_i33': 'foobar(12)', '_33': [12, 12], '_i34': 'foobar(12)', '_34': [12, 12], '_i35': 'foobar.__defaults__', '_35': ([12, 12],), '_i36': 'class Frob():\\n    def __delattr__(self, name):\\n        print(\"deleting `{}`\".format(str(name)))\\n        del self.__dict__[name]\\n        print(\"`{}` deleted\".format(str(name)))', 'Frob': <class '__main__.Frob'>, '_i37': 'f = Frob()', 'f': <__main__.Foo object at 0x7fbe5b217e50>, '_i38': 'dir(f)', '_38': ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__'], '_i39': '# Adding a class (instance?) attribute\\nf.dummy = 10', '_i40': '# Now you show be able to see \"dummy\" listed there\\ndir(f)', '_40': ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'dummy'], '_i41': 'del f.dummy', '_i42': 'def func_1():\\n    pass\\n\\nfunc_1.temp = 1\\n\\nprint(func_1.__dict__)', '_i43': 'def func_2():\\n    pass\\n\\nprint(func_2.__dict__)', '_i44': 'class TempClass:\\n    a = 1\\n\\n    def temp_function(self):\\n        pass\\n\\n\\nprint(TempClass.__dict__)', 'TempClass': <class '__main__.TempClass'>, '_i45': 'class Hello():\\n    def __dir__(self):\\n        print(\"calling __dir__\")\\n        return [1, 2, 3]', 'Hello': <class '__main__.Hello'>, '_i46': 'hello = Hello()', 'hello': <__main__.Hello object at 0x7fbe5b220100>, '_i47': 'dir(hello)', '_47': [1, 2, 3], '_i48': 'hello.__dir__()', '_48': [1, 2, 3], '_i49': 'class Dog:\\n    \"\"\"Your best friend.\"\"\"\\n\\n    def do_nothing(self):\\n        pass', 'Dog': <class '__main__.Dog'>, '_i50': 'print(Dog.__doc__)', '_i51': '# It works the same even after instantiation\\ndog = Dog()\\ndog.__doc__', 'dog': <__main__.Dog object at 0x7fbe5b2204f0>, '_51': 'Your best friend.', '_i52': 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __eq__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', 'Person': <class '__main__.Person'>, '_i53': \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 25)\\nprint(john == jane)\", 'john': <__main__.Person object at 0x7fbe5c62b8e0>, 'jane': <__main__.Person object at 0x7fbe5c62ba60>, '_i54': \"# custom __format__() method\\nclass Person:\\n    def __format__(self, format):\\n        if(format == 'age'):\\n            return '23'\\n        return 'None'\", '_i55': '# The format() function internally runs Person().__format__(\"age\") to return 23.\\nformat(Person(), \"age\")', '_55': '23', '_i56': 'class Person:\\n    def __init__(self, age):\\n        self.age = age\\n\\n    def __ge__(self, other):\\n        print(\"Calling dunder method __ge__\")\\n        return self.age >= other.age', '_i57': 'alice = Person(18)\\nbob = Person(17)\\ncarl = Person(18)', 'alice': <__main__.Person object at 0x7fbe5c2451c0>, 'bob': <__main__.Person object at 0x7fbe5b234c10>, 'carl': <__main__.Person object at 0x7fbe5b217d60>, '_i58': 'print(alice >= bob)\\nprint(alice >= carl)\\nprint(bob >= alice)', '_i59': '# This is our descriptor object\\nclass Bar():\\n    def __init__(self):\\n        self.value = \\'\\'\\n\\n    def __get__(self, instance, owner):\\n        print(\"returned from descriptor object\")\\n        return self.value\\n\\n    def __set__(self, instance, value):\\n        print(\"set in descriptor object\")\\n        self.value = value\\n\\n    def __delete__(self, instance):\\n        print(\"deleted in descriptor object\")\\n        del self.value\\n\\n\\nclass Foo(object):\\n    bar = Bar()', 'Bar': <class '__main__.Bar'>, 'Foo': <class '__main__.Foo'>, '_i60': 'f = Foo()', '_i61': 'f.bar = 10', '_i62': 'print(f.bar)', '_i63': 'del f.bar', '_i64': \"class Yeah(object):\\n    def __init__(self, name):\\n        # Gets called when an attribute is accessed\\n        self.name = name\\n\\n    def __getattribute__(self, item):\\n        print('__getattribute__ ', item)\\n        # Calling the super class to avoid recursion\\n        # Gets called when the item is not found via __getattribute__\\n        return super(Yeah, self).__getattribute__(item)\\n\\n    def __getattr__(self, item):\\n        print('__getattr__ ', item)\\n        return super(Yeah, self).__setattr__(item, 'orphan')\", 'Yeah': <class '__main__.Yeah'>, '_i65': \"y1 = Yeah('yes')\\ny1.name\", 'y1': <__main__.Yeah object at 0x7fbe5b2200a0>, '_65': 'yes', '_i66': 'y1.foo', '_i67': 'y1.foo', '_67': 'orphan', '_i68': 'y1.goo', '_i69': 'y1.__dict__', '_69': {'name': 'yes', 'foo': 'orphan', 'goo': 'orphan', 'shape': 'orphan'}, '_i70': \"def one():\\n    return 'one'\\n\\ndef three(param):\\n    def two():\\n        print(one(), param)\\n    return two\", 'one': <function one at 0x7fbe5b22df70>, 'three': <function three at 0x7fbe5b23c040>, '_i71': \"inst = three('hello')\", 'inst': <function three.<locals>.two at 0x7fbe5b20a790>, '_i72': 'inst()', '_i73': '# This would not work well in a notebook as it keeping all the variables run in this notebook!\\ninst.__globals__', '_73': {...}, '_i74': 'inst.__closure__', '_74': (<cell at 0x7fbe5b220160: str object at 0x7fbe59cce2f0>,), '_i75': 'inst.__closure__[0].cell_contents', '_75': 'hello', '_i76': 'class Person:\\n    def __init__(self, age):\\n        self.age = age\\n\\n    def __gt__(self, other):\\n        return self.age > other.age', '_i77': 'alice = Person(18)\\nbob = Person(17)\\ncarl = Person(18)', '_i78': 'print(alice > bob)\\nprint(alice > carl)\\nprint(bob > alice)', '_i79': 'class C:\\n    def __init__(self, x):\\n        self.x = x\\n\\n    def __repr__(self):\\n        return f\"C({self.x})\"\\n\\n    def __hash__(self):\\n        return hash(self.x)\\n\\n    def __eq__(self, other):\\n        return (\\n            self.__class__ == other.__class__ and\\n            self.x == other.x\\n        )', 'C': <class '__main__.C'>, '_i80': 'd = dict()\\ns = set()\\nc = C(1)\\nd[c] = 42\\ns.add(c)', 'd': [2, 3, 1, 4, 66, 54, 45, 89], 's': {C(2)}, 'c': [1, 2, 3, 4], '_i81': 'd, s', '_81': ({C(2): 42}, {C(2)}), '_i82': 'c in s and c in d  # c is in both!', '_82': True, '_i83': 'c.x = 2', '_i84': 'c in s or c in d   # c is in neither!?', '_84': False, '_i85': \"d, s\\n#({C(2): 42}, {C(2)})   # but...it's right there!\", '_85': ({C(2): 42}, {C(2)}), '_i86': 'class Customer(object):\\n    \"\"\"A customer of ABC bank with a checking. account.\\n    \\n    Customer have the following propperties:\\n    \\n    Atributes:\\n        name: a string representing the custome name\\n        balance: a float. tracking the current balance of the customer\\'s account\\n    \"\"\"\\n    \\n    def __init__(self, name, balance = 0.0):\\n        \"\"\"Object initialisation.\\n        \\n        Returns a customers objkect whose name is name and stating\\n        balance is balance.\\n        \"\"\"\\n        \\n        self.name = name\\n        self.balance = balance\\n        \\n    def withdraw(self, amount):\\n        \"\"\"Withdraw.\\n        \\n        Returns the balance remaininga fter withdrawing ana mount.\\n        \"\"\"\\n        \\n        if amount > self.balance:\\n            raise RuntimeError(\"Amount requested is greater than the current balance\")\\n        self.balance -= amount\\n        \\n        return self.balance\\n    \\n    def deposit(self, amount):\\n        \"\"\"Deposit.\\n        \\n        Returns the balance remaining after depositing some monies.\\n        \"\"\"\\n        \\n        self.balance += amount\\n        \\n        return sel.balance', 'Customer': <class '__main__.Customer'>, '_i87': 'custormerA = Customer(\"Charlier\", 100)\\ncustormerB = Customer(\"Maria\", 200)\\ncustomerNull = Customer(\"Null\")', 'custormerA': <__main__.Customer object at 0x7fbe5c245430>, 'custormerB': <__main__.Customer object at 0x7fbe5c245fd0>, 'customerNull': <__main__.Customer object at 0x7fbe5b27a520>, '_i88': 'custormerA.__dict__', '_88': {'name': 'Charlier', 'balance': 100}, '_i89': 'custormerB.__dict__', '_89': {'name': 'Maria', 'balance': 200}, '_i90': 'customerNull.__dict__', '_90': {'name': 'Null', 'balance': 0.0}, '_i91': 'class Philosopher:\\n    def __init_subclass__(cls, default_name, **kwargs):\\n        super().__init_subclass__(**kwargs)\\n        print(f\"Called __init_subclass({cls}, {default_name})\")\\n        cls.default_name = default_name\\n\\n\\nclass AustralianPhilosopher(Philosopher, default_name=\"Bruce\"):\\n    pass\\n\\n\\nclass GermanPhilosopher(Philosopher, default_name=\"Nietzsche\"):\\n    default_name = \"Hegel\"\\n    print(\"Set name to Hegel\")', 'Philosopher': <class '__main__.Philosopher'>, 'AustralianPhilosopher': <class '__main__.AustralianPhilosopher'>, 'GermanPhilosopher': <class '__main__.GermanPhilosopher'>, '_i92': 'Bruce = AustralianPhilosopher()\\nMistery = GermanPhilosopher()\\nprint(Bruce.default_name)\\nprint(Mistery.default_name)', 'Bruce': <__main__.AustralianPhilosopher object at 0x7fbe5c2450d0>, 'Mistery': <__main__.GermanPhilosopher object at 0x7fbe5c2456a0>, '_i93': \"def func(a, b='Default value'):\\n    pass\", '_i94': 'func.__defaults__', '_94': ('Default value',), '_i95': 'print(func.__kwdefaults__)', '_i96': 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __le__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', '_i97': \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john <= jane)\", '_i98': 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __lt__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', '_i99': \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john < jane)\", '_i100': 'def func_3():\\n    pass', '_i101': 'func_3.__name__', '_101': 'func_3', '_i102': 'from math import sin\\n# Function sin() came from the math module.\\nsin.__module__', 'sin': <built-in function sin>, '_102': 'math', '_i103': '# Define a dummy class\\nclass A:    \\n    pass\\n\\n\\na = A\\na.__module__', '_103': '__main__', '_i104': 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __ne__(self, other):\\n        print(\"calling dunder method __ne__\")\\n        return self.age != other.age', '_i105': \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john != jane)\", '_i106': 'class File:\\n    def __new__(cls, *args, **kwargs):\\n        file_type = kwargs.get(\"file_name\").split(\".\")[-1]\\n\\n        if file_type == \"txt\":\\n            for i in cls.__subclasses__():\\n                if i.__name__ == \"TextFile\":\\n                    return super().__new__(i)\\n        elif file_type in [\"jpg\", \"png\", \"jpeg\"]:\\n            for i in cls.__subclasses__():\\n                if i.__name__ == \"ImageFile\":\\n                    return super().__new__(i)\\n        else:\\n            return super().__new__(File)\\n\\n    def __init__(self, file_name=\"\"):\\n        self.file_name = file_name\\n\\n\\nclass ImageFile(File):\\n    def __init__(self, *args, **kwargs):\\n        self.height = kwargs.get(\"height\")\\n        self.width = kwargs.get(\"width\")\\n\\n\\nclass TextFile(File):\\n    def __init__(self, *args, **kwargs):\\n        self.file_size = kwargs.get(\"file_size\")', 'File': <class '__main__.File'>, 'ImageFile': <class '__main__.ImageFile'>, 'TextFile': <class '__main__.TextFile'>, '_i107': '\"\"\"\\nHere, we are instantiating the TextFile, ImageFile and File classes using the File (parent)\\nclass depending on content of file (file_type). \\n\"\"\"\\ntext_file = File(file_name=\"testfile.txt\", height=100, width=100)\\nimage_file = File(file_name=\"imagefile.png\", file_size=500)\\nother_file = File(file_name=\"video_file.mp4\")', 'text_file': <__main__.TextFile object at 0x7fbe5c62ba00>, 'image_file': <__main__.ImageFile object at 0x7fbe5c62b0d0>, 'other_file': <__main__.File object at 0x7fbe5c62bfd0>, '_i108': 'print(text_file)\\nprint(image_file)\\nprint(other_file)', '_i109': 'class Example:\\n    def something_level_1():\\n        def something_level_2():\\n            pass', 'Example': <class '__main__.Example'>, '_i110': 'print(Example.something_level_1.__qualname__)', '_i111': 'class Example:\\n    def something():\\n        pass\\nprint(Example.something.__name__)\\nprint(Example.something.__qualname__)', '_i112': 'def something():\\n    pass\\n\\n\\nclass Example:\\n    def something():\\n        pass', 'something': <function something at 0x7fbe5c618700>, '_i113': '# Using __name__ you would not be able to tell the difference\\nprint(something.__name__)\\nprint(Example.something.__name__)', '_i114': '# Using __qualname__ you would not be able to tell the difference\\nprint(something.__qualname__)\\nprint(Example.something.__qualname__)', '_i115': 'import pickle\\n\\n\\nclass Test(object):\\n    def __init__(self, file_path=\"test1234567890.txt\"):\\n        # An open file in write mode\\n        self.some_file_i_have_opened = open(file_path, \\'wb\\')\\n\\n\\nmy_test = Test()\\n# Now, watch what happens when we try to pickle this object: it should throw an error\\npickle.dumps(my_test)', 'pickle': <module 'pickle' from '/opt/anaconda3/envs/trainingAI/lib/python3.9/pickle.py'>, 'Test': <class '__main__.Test'>, 'my_test': <__main__.Test object at 0x7fbe5c2450a0>, 'getsizeof': <built-in function getsizeof>, 'NamespaceMagics': <class 'IPython.core.magics.namespace.NamespaceMagics'>, '_nms': <IPython.core.magics.namespace.NamespaceMagics object at 0x7fbe5c62f040>, '_Jupyter': <ipykernel.zmqshell.ZMQInteractiveShell object at 0x7fbe59fa00d0>, 'np': <module 'numpy' from '/opt/anaconda3/envs/trainingAI/lib/python3.9/site-packages/numpy/__init__.py'>, '_getsizeof': <function _getsizeof at 0x7fbe5c6304c0>, '_getshapeof': <function _getshapeof at 0x7fbe59ffe3a0>, 'var_dic_list': <function var_dic_list at 0x7fbe5c253700>, '_i116': 'class Customer(object):\\n    \"\"\"A customer of ABC bank with a checking. account.\\n    \\n    Customer have the following propperties:\\n    \\n    Atributes:\\n        name: a string representing the custome name\\n        balance: a float. tracking the current balance of the customer\\'s account\\n    \"\"\"\\n    \\n    def __init__(self, name, balance = 0.0):\\n        \"\"\"Object initialisation.\\n        \\n        Returns a customers objkect whose name is name and stating\\n        balance is balance.\\n        \"\"\"\\n        \\n        self.name = name\\n        self.balance = balance\\n        \\n    def withdraw(self, amount):\\n        \"\"\"Withdraw.\\n        \\n        Returns the balance remaininga fter withdrawing ana mount.\\n        \"\"\"\\n        \\n        if amount > self.balance:\\n            raise RuntimeError(\"Amount requested is greater than the current balance\")\\n        self.balance -= amount\\n        \\n        return self.balance\\n    \\n    def deposit(self, amount):\\n        \"\"\"Deposit.\\n        \\n        Returns the balance remaining after depositing some monies.\\n        \"\"\"\\n        \\n        self.balance += amount\\n        \\n        return sel.balance', '_i117': 'custormerA = Customer(\"Charlier\", 100)\\ncustormerB = Customer(\"Maria\", 200)\\ncustomerNull = Customer(\"Null\")', '_i118': 'custormerA.__dict__', '_118': {'name': 'Charlier', 'balance': 100}, '_i119': 'custormerB.__dict__', '_119': {'name': 'Maria', 'balance': 200}, '_i120': 'customerNull.__dict__', '_120': {'name': 'Null', 'balance': 0.0}, '_i121': 'class Philosopher:\\n    def __init_subclass__(cls, default_name, **kwargs):\\n        super().__init_subclass__(**kwargs)\\n        print(f\"Called __init_subclass({cls}, {default_name})\")\\n        cls.default_name = default_name\\n\\n\\nclass AustralianPhilosopher(Philosopher, default_name=\"Bruce\"):\\n    pass\\n\\n\\nclass GermanPhilosopher(Philosopher, default_name=\"Nietzsche\"):\\n    default_name = \"Hegel\"\\n    print(\"Set name to Hegel\")', '_i122': 'Bruce = AustralianPhilosopher()\\nMistery = GermanPhilosopher()\\nprint(Bruce.default_name)\\nprint(Mistery.default_name)', '_i123': \"def func(a, b='Default value'):\\n    pass\", '_i124': 'func.__defaults__', '_124': ('Default value',), '_i125': 'print(func.__kwdefaults__)', '_i126': 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __le__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', '_i127': \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john <= jane)\", '_i128': 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __lt__(self, other):\\n        print(\"calling dunder method __eq__\")\\n        return self.age == other.age', '_i129': \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john < jane)\", '_i130': 'def func_3():\\n    pass', '_i131': 'func_3.__name__', '_131': 'func_3', '_i132': 'from math import sin\\n# Function sin() came from the math module.\\nsin.__module__', '_132': 'math', '_i133': '# Define a dummy class\\nclass A:    \\n    pass\\n\\n\\na = A\\na.__module__', '_133': '__main__', '_i134': 'class Person:\\n    \"\"\"\\n    The following shows how to implement the __eq__ method \\n    in the Person class that returns True if two person \\n    objects have the same age:\\n    \"\"\"\\n\\n    def __init__(self, first_name, last_name, age):\\n        self.first_name = first_name\\n        self.last_name = last_name\\n        self.age = age\\n\\n    def __ne__(self, other):\\n        print(\"calling dunder method __ne__\")\\n        return self.age != other.age', '_i135': \"john = Person('John', 'Doe', 25)\\njane = Person('Jane', 'Doe', 26)\\nprint(john != jane)\", '_i136': 'class File:\\n    def __new__(cls, *args, **kwargs):\\n        file_type = kwargs.get(\"file_name\").split(\".\")[-1]\\n\\n        if file_type == \"txt\":\\n            for i in cls.__subclasses__():\\n                if i.__name__ == \"TextFile\":\\n                    return super().__new__(i)\\n        elif file_type in [\"jpg\", \"png\", \"jpeg\"]:\\n            for i in cls.__subclasses__():\\n                if i.__name__ == \"ImageFile\":\\n                    return super().__new__(i)\\n        else:\\n            return super().__new__(File)\\n\\n    def __init__(self, file_name=\"\"):\\n        self.file_name = file_name\\n\\n\\nclass ImageFile(File):\\n    def __init__(self, *args, **kwargs):\\n        self.height = kwargs.get(\"height\")\\n        self.width = kwargs.get(\"width\")\\n\\n\\nclass TextFile(File):\\n    def __init__(self, *args, **kwargs):\\n        self.file_size = kwargs.get(\"file_size\")', '_i137': '\"\"\"\\nHere, we are instantiating the TextFile, ImageFile and File classes using the File (parent)\\nclass depending on content of file (file_type). \\n\"\"\"\\ntext_file = File(file_name=\"testfile.txt\", height=100, width=100)\\nimage_file = File(file_name=\"imagefile.png\", file_size=500)\\nother_file = File(file_name=\"video_file.mp4\")', '_i138': 'print(text_file)\\nprint(image_file)\\nprint(other_file)', '_i139': 'class Example:\\n    def something_level_1():\\n        def something_level_2():\\n            pass', '_i140': 'print(Example.something_level_1.__qualname__)', '_i141': 'class Example:\\n    def something():\\n        pass\\nprint(Example.something.__name__)\\nprint(Example.something.__qualname__)', '_i142': 'def something():\\n    pass\\n\\n\\nclass Example:\\n    def something():\\n        pass', '_i143': '# Using __name__ you would not be able to tell the difference\\nprint(something.__name__)\\nprint(Example.something.__name__)', '_i144': '# Using __qualname__ you would not be able to tell the difference\\nprint(something.__qualname__)\\nprint(Example.something.__qualname__)', '_i145': 'import pickle\\n\\n\\nclass Test(object):\\n    def __init__(self, file_path=\"test1234567890.txt\"):\\n        # An open file in write mode\\n        self.some_file_i_have_opened = open(file_path, \\'wb\\')\\n\\n\\nmy_test = Test()\\n# Now, watch what happens when we try to pickle this object: it should throw an error\\npickle.dumps(my_test)', '_i146': 'import pickle\\n\\n\\nclass Test(object):\\n    def __init__(self, file_path=\"test1234567890.txt\"):\\n        # Used later in __reduce__\\n        self._file_name_we_opened = file_path\\n        # An open file in write mode\\n        self.some_file_i_have_opened = open(self._file_name_we_opened, \\'wb\\')\\n\\n    def __reduce__(self):\\n        # we return a tuple of class_name to call,\\n        # and optional parameters to pass when re-creating\\n        return (self.__class__, (self._file_name_we_opened, ))\\n\\n\\nmy_test = Test()\\nsaved_object = pickle.dumps(my_test)\\n# Just print the representation of the string of the object,\\n# because it contains newlines.\\nprint(repr(saved_object))', 'saved_object': b'\\x80\\x04\\x95.\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x8c\\x08__main__\\x94\\x8c\\x04Test\\x94\\x93\\x94\\x8c\\x12test1234567890.txt\\x94\\x85\\x94R\\x94.', '_i147': '!ls', '_exit_code': 0, '_i148': '# Getting rid of the save file\\n!rm  ./test1234567890.txt', '_i149': 'import numpy as np\\n\\nclass Tensor(object):\\n    \\n    def __init__(self, data):\\n        \"\"\"__init__ method\\n        Given a list, tunrs it into an array\\n        \"\"\"        \\n        self.data = np.array(data)\\n    \\n    def __add__(self, other):\\n        \"\"\"__add__ method        \\n        Add two tensor together\\n        \"\"\"\\n        return Tensor(self.data + other.data)\\n    \\n    def __repr__(self):\\n        print(\"calling __repr__\")\\n        \"\"\"__repr__ method\\n        Returns the object representation in string format.\\n        Retunrs and official string representation of the object,\\n        which can be ised to construt the object again.\\n        \"\"\"\\n        return str(self.data.__repr__())\\n    \\n    def __str__(self):\\n        print(\"calling __str__\")\\n        \"\"\"\\n        Returns the string representation of the object. This method is called\\n        when print() or str() function is invoked on an object. Retunrs a \\n        human-redeable string format.\\n        \"\"\"\\n        return str(self.data.__str__())', 'Tensor': <class '__main__.Tensor'>, '_i150': 'x = Tensor([1,2,3,4,5])\\nx', 'x': [4, 5, 7, 9], '_150': array([1, 2, 3, 4, 5]), '_i151': 'repr(x)', '_151': 'array([1, 2, 3, 4, 5])', '_i152': 'str(x)', '_152': '[1 2 3 4 5]', '_i153': 'print(x)', '_i154': 'class Person:\\n    def __setattr__(self, attr_name, attr_value):\\n        print(attr_name, attr_value)', '_i155': \"alice = Person()\\nsetattr(alice, 'age', 32)\\n# age 32\", '_i156': 'class Person_diff:\\n    pass', 'Person_diff': <class '__main__.Person_diff'>, '_i157': \"alice_diff = Person_diff()\\nsetattr(alice_diff, 'age', 32)\", 'alice_diff': <__main__.Person_diff object at 0x7fbe5c61e820>, '_i158': 'alice_diff.__dict__', '_158': {'age': 32}, '_i159': 'import sys\\na = [1, 2]\\nb = [1, 2, 3, 4]\\nc = [1, 2, 3, 4]\\nd = [2, 3, 1, 4, 66, 54, 45, 89]\\nprint(sys.getsizeof(a))\\nprint(sys.getsizeof(b))\\nprint(sys.getsizeof(c))\\nprint(sys.getsizeof(d))', 'sys': <module 'sys' (built-in)>, 'b': [1, 2, 3, 4], '_i160': 'w = [1, 2]\\nx = [4, 5, 7, 9]\\ny = [2, 8, 6, 56, 45, 89, 88]\\nz = [54, 45, 12, 23, 24, 90, 20, 40]\\nprint(w.__sizeof__())\\nprint(x.__sizeof__())\\nprint(y.__sizeof__())\\nprint(z.__sizeof__())', 'w': [1, 2], 'y': [2, 8, 6, 56, 45, 89, 88], 'z': [54, 45, 12, 23, 24, 90, 20, 40], '_i161': 'class A(type):\\n\\n    # __subclasscheck__() defined\\n    def __subclasscheck__(cls, sub):\\n\\n        # Getting the L attribute of\\n        # subclass\\n        attr = getattr(cls, \\'L\\', [])\\n\\n        # Checking if the subclass\\n        # is present in the L attribute\\n        # of subclass or not\\n        if sub in attr:\\n            return True\\n\\n        return False\\n\\n\\nclass B(metaclass=A):\\n\\n    # L Attribute\\n    L = [1, 2, 3, 4, 5]\\n\\n\\nclass C(metaclass=A):\\n\\n    # L Attribute\\n    L = [\"Geeks\", \"For\"]', 'B': <class '__main__.B'>, '_i162': '# Driver\\'s code\\nprint(issubclass(1, B))\\nprint(issubclass(\"Geeks\", B))\\nprint(issubclass(\"Geeks\", C))', '_i163': 'def check_in_a_loop():\\n    pass', 'check_in_a_loop': <function check_in_a_loop at 0x7fbe5c628160>, '_i164': 'def check_in_a_loop():\\n    pass', '_i165': 'dir(check_in_a_loop)', '_165': ['__annotations__', '__call__', '__class__', '__closure__', '__code__', '__defaults__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__get__', '__getattribute__', '__globals__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__kwdefaults__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__'], '_i166': 'check_in_a_loop.__dict__', '_166': {}, '_i167': 'for i in dir(check_in_a_loop):\\n    print(i)\\n    print(eval(\"check_in_a_loop.\"+str(i)))'}\n",
      "__gt__\n",
      "<method-wrapper '__gt__' of function object at 0x7fbe5c628160>\n",
      "__hash__\n",
      "<method-wrapper '__hash__' of function object at 0x7fbe5c628160>\n",
      "__init__\n",
      "<method-wrapper '__init__' of function object at 0x7fbe5c628160>\n",
      "__init_subclass__\n",
      "<built-in method __init_subclass__ of type object at 0x10d949308>\n",
      "__kwdefaults__\n",
      "None\n",
      "__le__\n",
      "<method-wrapper '__le__' of function object at 0x7fbe5c628160>\n",
      "__lt__\n",
      "<method-wrapper '__lt__' of function object at 0x7fbe5c628160>\n",
      "__module__\n",
      "__main__\n",
      "__name__\n",
      "check_in_a_loop\n",
      "__ne__\n",
      "<method-wrapper '__ne__' of function object at 0x7fbe5c628160>\n",
      "__new__\n",
      "<built-in method __new__ of type object at 0x10d949308>\n",
      "__qualname__\n",
      "check_in_a_loop\n",
      "__reduce__\n",
      "<built-in method __reduce__ of function object at 0x7fbe5c628160>\n",
      "__reduce_ex__\n",
      "<built-in method __reduce_ex__ of function object at 0x7fbe5c628160>\n",
      "__repr__\n",
      "<method-wrapper '__repr__' of function object at 0x7fbe5c628160>\n",
      "__setattr__\n",
      "<method-wrapper '__setattr__' of function object at 0x7fbe5c628160>\n",
      "__sizeof__\n",
      "<built-in method __sizeof__ of function object at 0x7fbe5c628160>\n",
      "__str__\n",
      "<method-wrapper '__str__' of function object at 0x7fbe5c628160>\n",
      "__subclasshook__\n",
      "<built-in method __subclasshook__ of type object at 0x10d949308>\n"
     ]
    }
   ],
   "source": [
    "for i in dir(check_in_a_loop):\n",
    "    print(i)\n",
    "    print(eval(\"check_in_a_loop.\"+str(i)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b9bbb6b3",
   "metadata": {},
   "source": [
    "# References\n",
    "<hr style = \"border:2px solid black\" ></hr>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48705036",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2022-04-11T14:30:33.287615Z",
     "start_time": "2022-04-11T14:30:33.281189Z"
    }
   },
   "source": [
    "\n",
    "- https://www.honeybadger.io/blog/python-instantiation-metaclass/\n",
    "- [`__closure__`](https://www.geeksforgeeks.org/__closure__-magic-function-in-python/)\n",
    "- [`__code__`](https://www.codeguage.com/courses/python/functions-code-objects)\n",
    "- [`__default__` #1](https://betterprogramming.pub/mutable-default-arguments-in-python-643ae2583e00)\n",
    "- [`__default__` #2](https://mdawar.dev/blog/mock-python-default-function-argument)\n",
    "- [`__deleteattr`](https://python-reference.readthedocs.io/en/latest/docs/dunderattr/delattr.html)\n",
    "- [`__dir__`](https://stackoverflow.com/questions/19703335/whats-the-difference-between-dir-and-dir)\n",
    "- [`__doc__`](https://blog.finxter.com/what-is-__-doc-__-in-python/)\n",
    "- [`__eq_`](https://www.pythontutorial.net/python-oop/python-__eq__/)\n",
    "- [`__format__`](https://peps.python.org/pep-3101/)\n",
    "- [`__get__`](https://python-reference.readthedocs.io/en/latest/docs/dunderdsc/get.html)\n",
    "- [`__getattribute__`]()\n",
    "- [`__globals__`](https://javier.gr/blog/2014/04/python-patching-function-globals/)\n",
    "- [`__gt__`](https://blog.finxter.com/python-__gt__-magic-method/)\n",
    "- [`__hash__` #1](https://hynek.me/articles/hashes-and-equality/)\n",
    "- [`__hash__` #2](https://stackoverflow.com/questions/2909106/whats-a-correct-and-good-way-to-implement-hash)\n",
    "- [`__init_subclass__`](https://stackoverflow.com/questions/45400284/understanding-init-subclass)\n",
    "- [`__module__`](http://www.stephaniehicks.com/learnPython/pages/modules.html)\n",
    "- [`__new__`](https://medium.com/@taohidulii/playing-with-inheritance-in-python-73ea4f3b669e)\n",
    "- [`__qualname__`](https://www.codingem.com/qualname-in-python/)\n",
    "- [`__reduce__`](https://stackoverflow.com/questions/19855156/whats-the-exact-usage-of-reduce-in-pickler)\n",
    "- [`__reduce_ex__`](https://stackoverflow.com/questions/150284/what-is-the-difference-between-reduce-and-reduce-ex)\n",
    "- [`__repr__` & `__str__`](https://www.journaldev.com/22460/python-str-repr-functions)\n",
    "- [`__setattr__`](https://blog.finxter.com/python-__setattr__-magic-method/)\n",
    "- [`__sizeof__`](https://www.geeksforgeeks.org/difference-between-__sizeof__-and-getsizeof-method-python/)\n",
    "- [`__subclasshook__`](https://www.geeksforgeeks.org/__subclasscheck__-and-__subclasshook__-in-python/)\n",
    "\n",
""   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bf786213",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "trainingAI",
   "language": "python",
   "name": "trainingai"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "346.05px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}