functions_and_classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# TABLE OF CONTENTS:<a id='toc'></a>\n",
    "\n",
    "These tips are focused on function and class topics I think that I think are good to know.\n",
    "\n",
    "Please go through official documentation if you want more thorough examples.\n",
    "\n",
    "<b>Topics:</b>\n",
    " - <b>[Functions](#functions)</b>\n",
    "     - [Generators](#generators)\n",
    "     - [Args and Kwargs](#argskwargs)\n",
    "         - [Args](#args)\n",
    "         - [Kwargs](#kwargs)\n",
    "     - [Lambda Functions](#lambda)\n",
    "     - [Mutable Parameters](#mparams)\n",
    "     - [Decorators](#decorators)\n",
    "     - [Recursion](#recursion)\n",
    " - <b>[Classes](#classes)</b>\n",
    "     - [Class Inheritance](#inheritance)\n",
    "     - [\"Private Methods\"](#private)\n",
    "     - [__str__ and __repr__](#strrepr)\n",
    "     - [Static and Class Methods](#scm) \n",
    "     - [Method Chaining](#chaining)\n",
    "     - [Property Decorators](#gsd)\n",
    "         - [Getters](#get)\n",
    "         - [Setters](#set)\n",
    "         - [Deleters](#del)\n",
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Uncomment if you want to use inline pythontutor\n",
    "\n",
    "# from IPython.display import IFrame\n",
    "\n",
    "# IFrame('http://www.pythontutor.com/visualize.html#mode=display', height=1500, width=750)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions<a id=\"functions\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generators<a id='generators'></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "Most functions process a collection of data first before returning the finished result. Generators remove iteration and temporary collection to store results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Non generator function returning an operation on a list\n",
    "\n",
    "def non_generator(list_of_nums):\n",
    "    product_list = []\n",
    "    for i in list_of_nums:\n",
    "        product_list.append(i**i)\n",
    "    return product_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 27, 256]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Iterates, stores in product_list and returns product_list.\n",
    "\n",
    "non_generator([1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now using a generator\n",
    "\n",
    "def generator(list_of_nums):\n",
    "    for i in list_of_nums:\n",
    "        yield i**i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "27\n",
      "256\n"
     ]
    }
   ],
   "source": [
    "# Each time your generator is called upon using next, it will only then yield the result. \n",
    "# This will continue until your generator is exhausted.\n",
    "\n",
    "my_gen = generator([1, 2, 3, 4])\n",
    "print(next(my_gen))\n",
    "print(next(my_gen))\n",
    "print(next(my_gen))\n",
    "print(next(my_gen))\n",
    "# print(next(my_gen)) This will raise a StopIteration uncomment to run."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "27\n",
      "256\n"
     ]
    }
   ],
   "source": [
    "# You can also iterate over your generator\n",
    "\n",
    "for i in generator([1, 2, 3, 4]):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Args and Kwargs<a id=\"argskwargs\"></a>\n",
    "[Return to table of contents](#toc)<br>\n",
    "\n",
    "Args and kwargs let you create functions that take any amount of arguments or keyword arguments. Args for arguments and kwargs for keyword arguments. Note that `args` and `kwargs` are typical convention but these could techinically be named anything."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<B>Args</B><a id='args'></a>\n",
    "\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This would print all your args\n",
    "\n",
    "def print_all_args(*args):\n",
    "    print(args)\n",
    "\n",
    "\n",
    "# Print in a for loop\n",
    "\n",
    "def args_for_loop(*args):\n",
    "    for arg in args:\n",
    "        print(arg)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "# Prints all args\n",
    "\n",
    "print_all_args(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Print in a for loop\n",
    "\n",
    "args_for_loop(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calling args by index.\n",
    "\n",
    "# Showing how to call from an individual index. I don't recommend this.\n",
    "\n",
    "def call_by_index(*args):\n",
    "    print(args[0], args[1])\n",
    "\n",
    "# Better practice\n",
    "\n",
    "def args_for_loop_index(*args):\n",
    "    for i in range(0, len(args)):\n",
    "        print(args[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n"
     ]
    }
   ],
   "source": [
    "# Call each argument by index if needed.\n",
    "\n",
    "call_by_index(1, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Can handle as many arguments and called by index.\n",
    "\n",
    "args_for_loop_index(1, 2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<B>Kwargs</B><a id='kwargs'></a>\n",
    "\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This would print all your kwargs\n",
    "\n",
    "def print_all_kwargs(**kwargs):\n",
    "    print(kwargs)\n",
    "    \n",
    "# Print in a for loop\n",
    "\n",
    "def kwargs_for_loop(**kwargs):\n",
    "    for key, value in kwargs.items():\n",
    "        print(key, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'item1': 'key1', 'item2': 'key2'}\n"
     ]
    }
   ],
   "source": [
    "# Prints all kwargs\n",
    "\n",
    "print_all_kwargs(item1 = \"key1\", item2 = \"key2\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "item1 key1\n",
      "item2 key2\n"
     ]
    }
   ],
   "source": [
    "# Prints in a for loop\n",
    "\n",
    "kwargs_for_loop(item1 = \"key1\", item2 = \"key2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<B>Using them together</B> <a id='together'></a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Args, kwargs and standard parameters can be used together. The order is regular paramters, ars and then kwargs.\n",
    "\n",
    "def multiple(a, b, *args, **kwargs):\n",
    "    print(a,b,\"These come first\")\n",
    "    print(args,\"Args come second\")\n",
    "    print(kwargs,\"kwrgs come third\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a b These come first\n",
      "(1, 2, 3, 4, 5) Args come second\n",
      "{'key1': 'item1', 'key2': 'item2'} kwrgs come third\n"
     ]
    }
   ],
   "source": [
    "multiple(\"a\", \"b\", 1, 2, 3, 4, 5, key1=\"item1\", key2=\"item2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda functions<a id=\"lambda\"></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "They are used to make quick functions and do not have to be set as an object when used inside another operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Standard function\n",
    "\n",
    "def addition(a, b):\n",
    "    return a + b\n",
    "\n",
    "addition(5,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(a, b)>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# lambda functions or anonymous functions\n",
    "\n",
    "lambda a, b : a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 6, 6, 6, 6]\n"
     ]
    }
   ],
   "source": [
    "# Using map and lambda together. \n",
    "# Lambda eliminates the need for writing an entirely new function\n",
    "\n",
    "lst_1 = [1, 2, 3, 4, 5]\n",
    "lst_2 = [5, 4, 3, 2, 1]\n",
    "\n",
    "added_lists = list(map(lambda a, b : a + b , lst_1, lst_2)) \n",
    "\n",
    "print(added_lists) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutable Parameters<a id=\"mparams\"></a>\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The first time the function is called a persistent list is created. \n",
    "# Every following call appends the value to the original list.\n",
    "\n",
    "def mutable(number, num_list=[]):\n",
    "    num_list.append(number)\n",
    "    return num_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mutable(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 7]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mutable(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This way we get the intended results.\n",
    "\n",
    "def create_correctly(number, num_list=None):\n",
    "    if num_list is None:\n",
    "        num_list = []\n",
    "    num_list.append(number)\n",
    "    return num_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5]"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "create_correctly(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "create_correctly(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decorators<a id='decorators'></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "A decorator is a function that allows us to wrap another function in order to extend the behavior of the wrapped function, without permanently modifying it.\n",
    "\n",
    "Decorators work like wrappers or first class function.\n",
    "\n",
    "Let's look at outer/inner function relationships, closures then decorators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Understanding Outer/Inner Functions</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def outer():\n",
    "    \n",
    "    print(\"before\")  # happens before\n",
    "    def inner():\n",
    "        print(\"hello\")\n",
    "    print(\"before\")  # happens before\n",
    "    \n",
    "    inner()\n",
    "    print(\"after\")   # happens after"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before\n",
      "before\n",
      "hello\n",
      "after\n"
     ]
    }
   ],
   "source": [
    "outer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Closures</b>\n",
    "\n",
    "The environment is a mapping associating each free variable of the function (variables that are used locally, but defined in an enclosing scope) with the value or reference to which the name was bound when the closure was created."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def html_wrap(tag):\n",
    "    \n",
    "    def msg_to_wrap(msg):\n",
    "        return f\"<{tag}>{msg}</{tag}>\"\n",
    "    \n",
    "    return msg_to_wrap  # Returning will execute the closure, retaining the tag we put in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "p1 = html_wrap(\"p1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function html_wrap.<locals>.msg_to_wrap at 0x7f971fde1b80>\n"
     ]
    }
   ],
   "source": [
    "print(p1)  # The inner function keeps the 'p1' tag given. This is the closure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<p1>hello world</p1>'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p1(\"hello world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Decorators</b>\n",
    "\n",
    "Same functionality now using a decorator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def wrapper(func):\n",
    "    \n",
    "    def wrap(*args, **kwargs):\n",
    "        print(f\"<{args[0]}>\")\n",
    "        func(*args, **kwargs)\n",
    "        print(f\"</{args[0]}>\")\n",
    "              \n",
    "    return wrap"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def message(tag, msg, tab=True):\n",
    "    if tab:\n",
    "        print(\"\\t\", msg)\n",
    "    else:\n",
    "        print(msg)\n",
    "message = wrapper(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<p1>\n",
      "\t hello\n",
      "</p1>\n"
     ]
    }
   ],
   "source": [
    "message(\"p1\", msg=\"hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello_decorator(func):\n",
    "    def inner():\n",
    "        print(\"guten tag\")\n",
    "        func()        \n",
    "        print(\"sayonara\")\n",
    "    return inner()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "guten tag\n",
      "nice weather we got\n",
      "sayonara\n",
      "guten tag\n",
      "nice weather we got\n",
      "sayonara\n"
     ]
    }
   ],
   "source": [
    "def func_used():\n",
    "    print(\"nice weather we got\")\n",
    "    \n",
    "func_used = hello_decorator(func_used)\n",
    "\n",
    "#The above code is equivalent to the code below\n",
    "\n",
    "@hello_decorator\n",
    "def func_used():\n",
    "    print(\"nice weather we got\")\n",
    "    \n",
    "#hello_decorator is a callable function, that will add some code on top of some other \n",
    "#callable function(func_used function) and return the wrapper function \n",
    "\n",
    "#In decorators, functions are taken as the argument into another function \n",
    "#and then called inside the wrapper function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not all decorators need *args and ***kwargs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This decorator benchmarks time it takes to return the request.\n",
    "\n",
    "def benchmark(func):\n",
    "    import time\n",
    "    \n",
    "    def wrapper():\n",
    "        start = time.time()\n",
    "        func()\n",
    "        end = time.time()\n",
    "        print(f\"[*] Execution time: {end - start} seconds.\")\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[*] Execution time: 0.39233899116516113 seconds.\n"
     ]
    }
   ],
   "source": [
    "@benchmark\n",
    "def fetch_webpage():\n",
    "    import requests\n",
    "    webpage = requests.get(\"https://google.com\")\n",
    "\n",
    "fetch_webpage()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now with with the decorator taking *args and **kwargs\n",
    "\n",
    "def benchmark(func):\n",
    "    import time\n",
    "    \n",
    "    def wrapper(*args, **kwargs):\n",
    "        start = time.time()\n",
    "        return_value = func(*args, **kwargs)\n",
    "        end = time.time()\n",
    "        print(\"[*] Execution time: {end - start} seconds.\")\n",
    "        return return_value\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[*] Execution time: {end - start} seconds.\n"
     ]
    }
   ],
   "source": [
    "@benchmark\n",
    "def fetch_webpage(url):\n",
    "    import requests\n",
    "    webpage = requests.get(url)\n",
    "    return webpage.text\n",
    "\n",
    "webpage = fetch_webpage(\"https://google.com\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hopefully easiest example to understand. If you wanted to take a function that always squares your result regardless of what operations your previous function operates under"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def squarer(func):\n",
    "    \n",
    "    def square_number(*args, **kwargs):\n",
    "        return pow(func(*args, **kwargs), 2)\n",
    "        \n",
    "    return square_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def addition(a, b):\n",
    "    return(a + b)\n",
    "\n",
    "addition(5,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@squarer\n",
    "def addition(a, b):\n",
    "    return(a + b)\n",
    "\n",
    "addition(5,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def multiplication(a, b, c=2):\n",
    "    return a*b*c\n",
    "\n",
    "multiplication(5,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2500"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@squarer # I added the keyword value for c to show that *args and **kwargs will work regardless\n",
    "def multiplication(a, b, c=2):\n",
    "    return a*b*c\n",
    "\n",
    "multiplication(5,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Chaining Decorators</b>\n",
    "\n",
    "Order of execution for decorators: \n",
    "From decorator above the function where the decorator is taken as an argument, then upwards.\n",
    "See example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function num at 0x7f9720103280> func1\n",
      "1\n",
      "<function decorator.<locals>.inner1 at 0x7f97201035e0> func2\n",
      "2\n",
      "<function decorator1.<locals>.inner2 at 0x7f97201039d0> func3\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "300\n"
     ]
    }
   ],
   "source": [
    "def decorator2(func):\n",
    "    print(func, 'func3')\n",
    "    def inner3():\n",
    "        print(4)\n",
    "        x = func() #x = decorator1(decorator(num()))\n",
    "        print(9)\n",
    "        return x * 10 #num is now returning 300\n",
    "    print(3)\n",
    "    return inner3()\n",
    "\n",
    "def decorator1(func):\n",
    "    print(func, 'func2')\n",
    "    def inner2():\n",
    "      print(5)\n",
    "      x = func() #x = decorator(num())\n",
    "      print(8)\n",
    "      return x * 2 #num is now returning 30\n",
    "    print(2)\n",
    "    return inner2\n",
    "\n",
    "def decorator(func): #starts at num returning 10\n",
    "    print(func, 'func1')\n",
    "    def inner1():\n",
    "      print(6)\n",
    "      x = func() #x = num(), which returns 10\n",
    "      print(7)\n",
    "      return x + 5 #num is now returning 15\n",
    "    print(1)\n",
    "    return inner1\n",
    "  \n",
    "@decorator2 #goes third\n",
    "@decorator1 #goes second\n",
    "@decorator #goes first\n",
    "def num():\n",
    "    return 10\n",
    "print(num)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Recursion<a id=\"recursion\"></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "A recursive function is a function which either calls itself or is in a potential cycle of function calls that uses a base case to exit out of the cycle.\n",
    "\n",
    "Using a recursion function to find factorials. Here is a simple diagram I put together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if n < 2: #base case\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "n = 5              5 * factorial(4) ---> FINAL ANSWER 5 * 24 = 120\n",
    "factorial4    =    4 * factorial(3) ---> Return value of 24\n",
    "factorial3    =    3 * factorial(2) ---> Return value of 6\n",
    "factorial2    =    2 * factorial(1) ---> Return value of 2\n",
    "factorial1    =    return 1         ---> Return value of 1\n",
    "\"\"\"\n",
    "\n",
    "factorial(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Another example finding the fibonacci sequence of the nth term.\n",
    "\n",
    "def fib(n):\n",
    "    if n == 1 or n == 2: #base case\n",
    "        return 1\n",
    "    else:\n",
    "        return fib(n-2) + fib(n-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes<a id='classes'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Inheritance<a id='inheritance'></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "<b>Tip:</b> When creating classes `self` is typical convention so please use self, but self can be replaced with anything you'd like.\n",
    "\n",
    "Simple overview of class inheritance. If you want to inherit instance variables from another class following this syntax:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# syntax\n",
    "\n",
    "\"\"\"\n",
    "childclass(parentcall):\n",
    "    def __init__(self, parent_var, new_var):\n",
    "        super().__init__(parent_var)\n",
    "        \n",
    "        OR\n",
    "        \n",
    "childclass(parentcall):\n",
    "    def __init__(self, parent_var, new_var):\n",
    "        super(childclass, self).__init__(parent_var)\n",
    "\"\"\"\n",
    "\n",
    "# Class\n",
    "\n",
    "class Employee:\n",
    "    def __init__(self, name, job):\n",
    "        self.name = name\n",
    "        self.job = job\n",
    "        \n",
    "        \n",
    "# This class inherits name and job from the employee class using super().__init__\n",
    "class Manager(Employee):\n",
    "    def __init__(self, name, job, level):\n",
    "        super().__init__(name, job)\n",
    "        self.level = level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Todd'"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Todd = Employee(\"Todd\", \"Developer\")\n",
    "Todd.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Manager'"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Sharon = Manager(\"Sharon\", \"Senior Developer\", \"Manager\")\n",
    "Sharon.level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Toy:\n",
    "    def __init__(self):\n",
    "        self.price = 10\n",
    "        self.discount = .05\n",
    "\n",
    "        \n",
    "class ToySet(Toy):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "t = ToySet()\n",
    "t.price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Toy:\n",
    "    def __init__(self, extras):\n",
    "        self.price = 10\n",
    "        self.discount = .05\n",
    "        self.extras = extras\n",
    "\n",
    "        \n",
    "class ToySet(Toy):\n",
    "    def __init__(self, extras):\n",
    "        super().__init__(extras)\n",
    "        \n",
    "t = ToySet(9)\n",
    "t.extras"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> Multiple Inheritance </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"This is how you set up your classes to be consumed for multiple inheritance\n",
    "\n",
    "https://stackoverflow.com/questions/34884567/python-multiple-inheritance-passing-arguments-to-constructors-using-super\n",
    "\"\"\"\n",
    "\n",
    "class A:\n",
    "    def __init__(self, a):\n",
    "        self.a = a\n",
    "\n",
    "class B(A):\n",
    "    def __init__(self, b, **kwargs):\n",
    "        self.b = b\n",
    "        super(B ,self).__init__(**kwargs)\n",
    "\n",
    "class C(A):\n",
    "    def __init__(self, c, **kwargs):\n",
    "        self.c = c\n",
    "        super(C, self).__init__(**kwargs)\n",
    "\n",
    "class D(B,C):\n",
    "    def __init__(self,a,b,c,d):\n",
    "        super(D, self).__init__(a=a,b=b,c=c)\n",
    "        self.d = d\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = D(\"a\", \"b\", \"c\", 5)\n",
    "\n",
    "d.a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### \"Private Methods\" <a id=private></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "Python is a consenting adult language, there isn't really a true private method, rather conventions that should be used to avoid naming collision (double underscore) and to signal other programmers the method is used internally (single underscore).\n",
    "\n",
    "- [Stackoverflow answer](https://stackoverflow.com/questions/70528/why-are-pythons-private-methods-not-actually-private)\n",
    "- [Video explanation](https://www.youtube.com/watch?v=ALZmCy2u0jQ)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Single underscore</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:        \n",
    "    def _private(self):  # More of a convention to let other programmers it is used internally.\n",
    "        print(\"bark\")\n",
    "        \n",
    "    def uses_private(self):\n",
    "        return self._private()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "fido = Dog()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bark\n"
     ]
    }
   ],
   "source": [
    "fido._private()  # You can still access it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bark\n"
     ]
    }
   ],
   "source": [
    "fido.uses_private()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Double underscore</b>\n",
    "\n",
    "Double underscores are for making sure subclasses don't accidentally override the private methods and attributes of their superclasses. It's not designed to prevent deliberate access from outside."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'_Spam__var': 42, '_Eggs__var': 21}\n"
     ]
    }
   ],
   "source": [
    "class Spam():\n",
    "    def __init__(self):\n",
    "        self.__var = 42\n",
    "        \n",
    "        \n",
    "    def spam(self):\n",
    "         print(self.__var)\n",
    "     \n",
    "    \n",
    "class Eggs(Spam):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.__var = 21\n",
    "        \n",
    "        \n",
    "    def Egg(self):\n",
    "        print(self.__var)\n",
    "\n",
    "        \n",
    "x = Eggs()\n",
    "print(x.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <b>`__str__` and `__repr__`</b><a id ='strrepr'></a>\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    def __init__(self, name, species):\n",
    "        self.name = name\n",
    "        self.species = species"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Dog object at 0x7f972011f130>\n"
     ]
    }
   ],
   "source": [
    "snoopy = Dog(\"Snoopy\", \"Beagle\")\n",
    "\n",
    "print(snoopy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Dog at 0x7f972011f130>"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "snoopy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"def __str__\n",
    "\n",
    "Adding the function __str__ enables you to give your classes a more readable output.\n",
    "\"\"\"\n",
    "\n",
    "class Dog:\n",
    "    def __init__(self, name, species):\n",
    "        self.name = name\n",
    "        self.species = species\n",
    "        \n",
    "        \n",
    "    def __str__(self):\n",
    "        return f\"I am {self.name}, and I am a {self.species}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am Snoopy, and I am a Beagle\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<__main__.Dog at 0x7f9720117850>"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "snoopy = Dog(\"Snoopy\", \"Beagle\")\n",
    "\n",
    "print(snoopy)  # We now get something useful\n",
    "\n",
    "snoopy # When we inspect we still get the address in memory as well as the object description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Think of __str__ for human consumption and __repr__ for developers.\n",
    "\n",
    "class Dog:\n",
    "    def __init__(self, name, species):\n",
    "        self.name = name\n",
    "        self.species = species\n",
    "\n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f\"{self.__class__.__name__}({self.name}, {self.species})\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dog(Snoopy, Beagle)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Dog(Snoopy, Beagle)"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "snoopy = Dog(\"Snoopy\", \"Beagle\")\n",
    "\n",
    "print(snoopy)  \n",
    "\n",
    "\"\"\"\n",
    "When we inspect we now get both descriptions to match. \n",
    "We get this because the default implementation calls repr internally.\n",
    "\"\"\"\n",
    "snoopy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Now with both.\n",
    "\n",
    "class Dog:\n",
    "    def __init__(self, name, species):\n",
    "        self.name = name\n",
    "        self.species = species\n",
    "        \n",
    "        \n",
    "    def __str__(self):\n",
    "        return f\"I am {self.name}, and I am a {self.species}\"\n",
    "    \n",
    "    \n",
    "    # What you should really use repr for\n",
    "    def __repr__(self):\n",
    "        return f\"{self.__class__.__name__}({self.name}, {self.species})\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am Snoopy, and I am a Beagle\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Dog(Snoopy, Beagle)"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "snoopy = Dog(\"Snoopy\", \"Beagle\")\n",
    "\n",
    "print(snoopy)  # We now get somehthing human readable.\n",
    "\n",
    "snoopy # We get something developer readable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <b>Static and Class Methods</b> <a id=\"scm\"> </a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "[Very helpful video by a python core dev.](https://www.youtube.com/watch?list=PLRVdut2KPAguz3xcd22i_o_onnmDKj3MA&time_continue=370&v=HTLu2DFOdTg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Static Methods</u>\n",
    "\n",
    "The static method decorator allows us to include methods within a class that do not pertain to the class object we are working with. It is essentially a normal function attached to our class.\n",
    "\n",
    "We generally use static methods to create utility functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<u>Class Methods</u>\n",
    "\n",
    "We generally use class method to create factory methods. Factory methods return class object ( similar to a constructor ) for different use cases.\n",
    "\n",
    "Great for alternative constructors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n",
      "26\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# example from https://www.geeksforgeeks.org/class-method-vs-static-method-python/\n",
    "from datetime import date\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, name, age):\n",
    "        self.name = name\n",
    "        self.age = age\n",
    "        \n",
    "        \n",
    "    @classmethod\n",
    "    def from_birth_year(cls, name, year):\n",
    "        \"\"\"\n",
    "        We use classmethod as an alternative constructor.\n",
    "        We use cls to reference the class. \n",
    "        cls could be named anything but cls is standard convention.\n",
    "        \"\"\"\n",
    "        return cls(name, date.today().year - year)\n",
    "    \n",
    "    \n",
    "    @staticmethod\n",
    "    def isAdult(age):\n",
    "        \"\"\"\n",
    "        Here we use a static method as a utility functions as mentioned above.\n",
    "        As you can see we don't need self. \n",
    "        This function doesn't have anything to do with an instance of a person.\n",
    "        \"\"\"\n",
    "        return age > 18\n",
    "    \n",
    "\n",
    "person1 = Person(\"Ty\", 21) \n",
    "person2 = Person.from_birth_year(\"Ty\", 1996) \n",
    "  \n",
    "print(person1.age)\n",
    "print(person2.age)\n",
    "  \n",
    "# print the result \n",
    "print(Person.isAdult(22) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Method Chaining<a id='chaining'></a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "Method/function chaining is calling a class method on another class method.\n",
    "\n",
    "If you've ever used Pandas you have may see a lot of methods being chained together in one call call. To chain mehtods together simply `return self` at the end of each function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Number:\n",
    "    \n",
    "    def __init__(self, number):\n",
    "        self.number = number\n",
    "        \n",
    "    def add(self, number_to_add):\n",
    "        self.number = self.number + number_to_add\n",
    "        return self\n",
    "    \n",
    "    def subtract(self, number_to_subtract):\n",
    "        self.number = self.number - number_to_subtract\n",
    "        return self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "five = Number(5)\n",
    "five.number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "three = five.add(5).subtract(7).number # 5 + 5 - 7 = 3\n",
    "three"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <b>Property Decorators: Getters, Setters and Deleters</b> <a id=\"gsd\"> </a>\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "- [Video that helped me a lot](https://www.youtube.com/watch?v=jCzT9XFZ5bw)\n",
    "- [Great simple explanation, source for some of this code as well](https://sumit-ghosh.com/articles/demystifying-decorators-python/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Property/Getter</b><a id=get></a>\n",
    "\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Property gives classes getter, setter and deleter functionality. \n",
    "@property on its own will give getter funtionality\n",
    "allowing class methods to be called like an attribute.\n",
    "\"\"\"\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, first, last):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "    \n",
    "    \n",
    "    @property  # This will allow me to call fullname as an attribute.\n",
    "    def fullname(self):\n",
    "        return f\"{self.first} {self.last}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Guy Fieri'"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Guy = Person(\"Guy\", \"Fieri\")\n",
    "\n",
    "Guy.fullname\n",
    "\n",
    "# Similar to\n",
    "\n",
    "# Guy.fullname()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Setters</b><a id=set></a>\n",
    "\n",
    "[Return to table of contents](#toc)\n",
    "\n",
    "Why are setters useful?\n",
    "\n",
    "This gives us the ability to alter class attributes used by a certain class\n",
    "method without forcing a method call."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, first, last):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "        self.email = f\"{self.first}.{self.last}@flavortown.com\".lower()\n",
    "    \n",
    "    \n",
    "    def fullname(self):\n",
    "        return f\"{self.first} {self.last}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guy\n",
      "Guy Fieri\n",
      "guy.fieri@flavortown.com\n"
     ]
    }
   ],
   "source": [
    "Guy = Person(\"Guy\", \"Fieri\")\n",
    "\n",
    "# Looks good.\n",
    "print(Guy.first)\n",
    "print(Guy.fullname())\n",
    "print(Guy.email)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Notguy\n",
      "guy.fieri@flavortown.com\n"
     ]
    }
   ],
   "source": [
    "# But what if we change a first or last name?\n",
    "Guy.first = \"Notguy\"\n",
    "print(Guy.first)\n",
    "print(Guy.email) # It doesn't change. So lets make it a method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, first, last):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "        \n",
    "        \n",
    "    def email(self):\n",
    "        return f\"{self.first}.{self.last}@flavortown.com\".lower()\n",
    "    \n",
    "    \n",
    "    def fullname(self):\n",
    "        return f\"{self.first} {self.last}\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Notguy\n",
      "notguy.fieri@flavortown.com\n"
     ]
    }
   ],
   "source": [
    "\"\"\"It worked!\n",
    "\n",
    "But, this would mean I would need to change all \n",
    "instance of email into a method to update them if I \n",
    "changed a first or last name.\n",
    "\n",
    "Now for the setters.\n",
    "\"\"\"\n",
    "\n",
    "Guy = Person(\"Guy\", \"Fieri\")\n",
    "Guy.first = \"Notguy\"\n",
    "\n",
    "print(Guy.first)\n",
    "print(Guy.email()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, first, last):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "        \n",
    "        \n",
    "    @property\n",
    "    def email(self):\n",
    "        return f\"{self.first}.{self.last}@flavortown.com\".lower()\n",
    "    \n",
    "    \n",
    "    @property\n",
    "    def fullname(self):\n",
    "        return f\"{self.first} {self.last}\"\n",
    "    \n",
    "    \n",
    "    @fullname.setter\n",
    "    def fullname(self, new_name):\n",
    "        first, last = new_name.split(' ')\n",
    "        self.first = first\n",
    "        self.last = last"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guy Fieri\n",
      "fieri.notguy@flavortown.com\n",
      "Fieri\n"
     ]
    }
   ],
   "source": [
    "# We can now change attributes though setters from a class method.\n",
    "\n",
    "Guy = Person(\"Guy\", \"Fieri\")\n",
    "print(Guy.fullname)\n",
    "\n",
    "Guy.fullname = \"Fieri Notguy\"\n",
    "print(Guy.email) # can be called as a property not as Guy.email()\n",
    "print(Guy.first)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Deleters</b><a id=del ></a>\n",
    "\n",
    "[Return to table of contents](#toc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Used when we want to delete things or default them to another value.\n",
    "uses del\n",
    "\"\"\"\n",
    "\n",
    "class Person:\n",
    "    def __init__(self, first, last):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "    \n",
    "    \n",
    "    @property\n",
    "    def fullname(self):\n",
    "        return f\"{self.first} {self.last}\"\n",
    "    \n",
    "    \n",
    "    @fullname.deleter\n",
    "    def fullname(self):\n",
    "        print(\"Deleted!\")\n",
    "        self.first = None\n",
    "        self.last = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guy Fieri\n",
      "Deleted!\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "Guy = Person(\"Guy\", \"Fieri\")\n",
    "print(Guy.fullname)\n",
    "\n",
    "del Guy.fullname  # Deletes the values and sets them to None.\n",
    "print(Guy.first)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "    def __init__(self, first, last):\n",
    "        self.first = first\n",
    "        self.last = last\n",
    "        \n",
    "        \n",
    "    @property\n",
    "    def fullname(self):\n",
    "        return f\"{self.first} {self.last}\"\n",
    "    \n",
    "    \n",
    "    @fullname.deleter  # Reset to default\n",
    "    def fullname(self):\n",
    "        print(\"Deleted!\")\n",
    "        self.first = \"Joe\"\n",
    "        self.last = \"Smith\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Guy Fieri\n",
      "Deleted!\n",
      "Joe\n",
      "Smith\n"
     ]
    }
   ],
   "source": [
    "Guy = Person(\"Guy\", \"Fieri\")\n",
    "print(Guy.fullname)\n",
    "\n",
    "del Guy.fullname  # Reset to the defaults we specified.\n",
    "\n",
    "print(Guy.first)\n",
    "print(Guy.last)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}