01.My_own_decks/Programming_languages/Python/Python 3 Cheat Sheet 2-2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Cheat Sheet 2-2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a summary of the most important key features and syntax of the language. It was made in order to create an anki deck for memorizing the below examples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "A function is a block of code which only runs when it is called. You can pass data, known as parameters, into a function. A function can return data as a result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A function prototype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function_name(parameters ):\n",
    "   \"\"\"function_docstring\n",
    "   on multiple lines\"\"\"\n",
    "   #function_suite\n",
    "   return [expression]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a simple example of a print_me function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "def print_me(str):\n",
    "    \"\"\"print the input str\"\"\"\n",
    "    print(str)\n",
    "    \n",
    "\n",
    "print_me(\"Hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How parameters (arguments) in Python are passed ?  \n",
    "\n",
    "by reference: if you change what a parameter refers to within a function, the change also reflects back in the calling function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 'a', 2.3, 'b']"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def append_lst(lst, param):\n",
    "    # reference passed\n",
    "    lst.append(param)\n",
    "\n",
    "my_lst = [1, 'a', 2.3]\n",
    "append_lst(my_lst, 'b')\n",
    "my_lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def change_lst(lst):\n",
    "    # assign a new reference\n",
    "    lst = ['a', 'b', 'c']\n",
    "    \n",
    "\n",
    "my_lst = [1, 2, 3]\n",
    "change_lst(my_lst)\n",
    "my_lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Explanation of what is namespace separation  \n",
    "\n",
    "A namespace is a region of a program in which identifiers have meaning. When a Python function is called, a new namespace is created for that function, one that is distinct from all other namespaces that already exist.\n",
    "\n",
    "In practice, this is that variables can be defined and used within a Python function even if they have the same name as variables defined in other functions or in the main program. In these cases, there will be no confusion or interference because they’re kept in separate namespaces.\n",
    "\n",
    "This means that when you write code within a function, you can use variable names and identifiers without worrying about whether they’re already used elsewhere outside the function. This helps minimize errors in code considerably."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "example of positional arguments  \n",
    "The most straightforward way to pass arguments is with positional arguments (also called required arguments). Order is important:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loic is 20 yrs old\n"
     ]
    }
   ],
   "source": [
    "def you(name, age):\n",
    "    print(f'{name} is {age} yrs old')\n",
    "    \n",
    "    \n",
    "you(\"Loic\", 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "you(\"Loic\")\n",
    "# TypeError: you() missing 1 required\n",
    "# positional argument: 'age'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "you(\"Loic\", 20, ['t', '1'])\n",
    "# TypeError: you() takes 2 positional \n",
    "# arguments but 3 were given"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "example with global vs. local variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 10\n",
    "def sum(x):\n",
    "    return x+y\n",
    "\n",
    "sum(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x\n",
    "# NameError: name 'x' \n",
    "# is not defined"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example of keyword arguments  \n",
    "\n",
    "you specify arguments in the form \\<keyword\\>=\\<value\\>. Each \\<keyword\\> must match a parameter in the function definition. The number of arguments and parameters must still match."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Abdel is 30 yrs old\n"
     ]
    }
   ],
   "source": [
    "def you(name=\"Loic\", age=20):\n",
    "    print(f'{name} is {age} yrs old')\n",
    "    \n",
    "    \n",
    "you(\"Abdel\", 30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "lifts the restriction on argument order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Louis is 10 yrs old\n"
     ]
    }
   ],
   "source": [
    "you(age=10, name=\"Louis\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "you(name=\"Louis\", cost=10)\n",
    "# TypeError: you() got an unexpected \n",
    "# keyword argument 'cost'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "call a function using both positional and keyword arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30 is Abdel yrs old\n"
     ]
    }
   ],
   "source": [
    "def you(name=\"Loic\", age=20):\n",
    "    print(f'{name} is {age} yrs old')\n",
    "    \n",
    "\n",
    "you(30, \"Abdel\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ali is 5 yrs old\n"
     ]
    }
   ],
   "source": [
    "you(\"Ali\", age=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "you(name=\"Marc\", 0)\n",
    "# SyntaxError: positional argument \n",
    "# follows keyword argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example of default parameters  \n",
    "\n",
    "If a parameter specified in a function definition has the form \\<name\\>=\\<value\\>, then \\<value\\> becomes a default value for that parameter. They are referred to as default or optional parameters. Any argument that’s left out assumes its default value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Max is 20 yrs old\n"
     ]
    }
   ],
   "source": [
    "def you(name, age=20):\n",
    "    print(f'{name} is {age} yrs old')\n",
    "    \n",
    "\n",
    "you(\"Max\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def you(name=\"Mo\", age):\n",
    "    print(f'{name} is {age} yrs old')\n",
    "    \n",
    "you(20)\n",
    "# SyntaxError: non-default argument \n",
    "# follows default argument"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "summary of arguments / parameters:\n",
    "\n",
    "- __Positional arguments__ must agree in order and number with the parameters declared in the function definition.\n",
    "- __Keyword argument__s must agree with declared parameters in number, but they may be specified in arbitrary order.\n",
    "- __Default parameters__ allow some arguments to be omitted when the function is called."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Mutable default parameter values__\n",
    "\n",
    "default parameter values are defined only once when the function is defined"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1789862290432\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, '##']"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(my_list=[]):\n",
    "    print(id(my_list))\n",
    "    my_list.append('##')\n",
    "    return my_list\n",
    "\n",
    "f([1, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1789862258560\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, '##']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1789862291584\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['##']"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1789862291584\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['##', '##']"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# workaround\n",
    "def f(my_list=None):\n",
    "    if my_list is None:\n",
    "        my_list = []\n",
    "    my_list.append('##')\n",
    "    return my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Argument passing summary\n",
    "- Passing __an immutable object__ (an int, str, tuple, or frozenset) acts like pass-by-value: the function can’t modify the object in the calling environment.\n",
    "\n",
    "- Passing __a mutable object__ (a list, dict, or set) acts somewhat—but not exactly—like pass-by-reference: the function can’t reassign the object wholesale, but it can change items in place within the object & these changes will be reflected in the calling environment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the return statement purposes\n",
    "\n",
    "1.It immediately terminates the function and passes execution control back to the caller.  \n",
    "2.It provides a mechanism by which the function can pass data back to the caller."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    print('foo')\n",
    "    return\n",
    "    print('bar')\n",
    "\n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This sort of paradigm can be useful for error checking in a function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    if error_cond1:\n",
    "        return\n",
    "    if error_cond2:\n",
    "        return\n",
    "\n",
    "    <normal processing>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example of returning data to the caller  \n",
    "\n",
    "a function can return any type of object. In the calling environment, the function call can be used syntactically in any way that makes sense for the type of object the function returns."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'foo': 1, 'bar': 2}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f():\n",
    "    return dict(foo=1, bar=2)\n",
    "\n",
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f()['bar']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ob'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f():\n",
    "    return 'foobar'\n",
    "\n",
    "f()[2:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'raboof'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f()[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of a function that returns multiple elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'b'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f():\n",
    "    return 'a', 1, 'b', 2\n",
    "\n",
    "f()[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(f())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('a', 2)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, *_, z = f()\n",
    "x, z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of a function that returns nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    return\n",
    "\n",
    "print(f())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def g():\n",
    "    pass\n",
    "\n",
    "print(g())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of a function that doubles an int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    x *= 2\n",
    "\n",
    "x = 5\n",
    "f(x)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "this won’t work because integers are immutable,   \n",
    "so a function can’t change an integer argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def g(x):\n",
    "    return x * 2\n",
    "\n",
    "x = 5\n",
    "x = g(x)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of a function that doubles values of a list (by side effect or not)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def double_list(x):\n",
    "    i = 0\n",
    "    while i < len(x):\n",
    "        x[i] *= 2\n",
    "        i += 1\n",
    " \n",
    "a = [1, 2, 3, 4, 5]\n",
    "double_list(a)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8, 10]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def double_list(x):\n",
    "    return [e*2 for e in x ]\n",
    "\n",
    "a = [1, 2, 3, 4, 5]\n",
    "a = double_list(a)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Argument Tuple Packing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "when the nb of arguments is not defined and a tuple is probably not something the user of the function would expect.\n",
    "To pass a function a variable nb of arguments use the asterisk (*) operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_avg(*args):\n",
    "    return sum(args) / len(args)\n",
    "\n",
    "my_avg(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_avg(1, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Argument Dictionary Packing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the double asterisk (**) can be used to specify dictionary packing and unpacking : the corresponding arguments is expected to be key=value pairs and should be packed into a dictionary (and not considered as a dict):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'foo': 1, 'bar': 2, 'baz': 3}\n"
     ]
    }
   ],
   "source": [
    "def dict_arg(**kwargs):\n",
    "    print(kwargs)\n",
    "\n",
    "dict_arg(foo=1, bar=2, baz=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_arg({\"foo\":1, \"bar\":2, \"baz\":3})\n",
    "# TypeError: dict_arg() takes 0 \n",
    "# positional arguments but 1 was given"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Credits: [Real Python dot com](https://realpython.com/python-kwargs-and-args/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of a function with standard positional parameters, args, and kwargs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2\n",
      "['foofoo', 'barbar']\n",
      "{'x': 101, 'y': 201, 'z': 301}\n"
     ]
    }
   ],
   "source": [
    "def f(a, b, *args, **kwargs):\n",
    "    print(a, b)\n",
    "    print([x*2 for x in args])\n",
    "    print({k:v+1 for k, v in kwargs.items()})\n",
    "    \n",
    "f(1,2, 'foo', 'bar', x=100, y=200, z=300)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple Unpackings args in a Python Function Call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "def f(*args):\n",
    "    for i in args:\n",
    "        print(i)\n",
    "        \n",
    "a, b = [1, 2, 3], ['a', 'b', 'c']\n",
    "f(*a, *b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiple Unpackings kwargs in a Python Function Call"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a --> 1\n",
      "b --> 2\n",
      "x --> 100\n",
      "y --> 200\n"
     ]
    }
   ],
   "source": [
    "def f(**kwargs):\n",
    "    for (k, v) in kwargs.items():\n",
    "        print(k, \"-->\", v)\n",
    "        \n",
    "a, b = {'a': 1, 'b': 2}, {'x': 100, 'y': 200}\n",
    "f(**a, **b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keyword-Only Arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keyword-only arguments allow a Python function to take a variable number of arguments, followed by one or more additional __options__ as keyword arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-> a.b.c\n"
     ]
    }
   ],
   "source": [
    "def concat(*args, prefix='-> ', sep='.'):\n",
    "    print(f'{prefix}{sep.join(args)}')\n",
    "\n",
    "concat('a', 'b', 'c')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "//a.b.c\n"
     ]
    }
   ],
   "source": [
    "concat('a', 'b', 'c', prefix='//')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "//a-b-c\n"
     ]
    }
   ],
   "source": [
    "concat('a', 'b', 'c', prefix='//', sep='-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Docstrings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Perform a foo transfo.\n",
      "    \n",
      "    Keyword arguments:\n",
      "    bar -- blabla (default=1)\n",
      "    baz -- blabla (default=1)\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "def foo(bar=0, baz=1):\n",
    "    \"\"\"Perform a foo transfo.\n",
    "    \n",
    "    Keyword arguments:\n",
    "    bar -- blabla (default=1)\n",
    "    baz -- blabla (default=1)\n",
    "    \"\"\"\n",
    "    #<function_body>\n",
    "    \n",
    "print(foo.__doc__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the interactive Python interpreter,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function foo in module __main__:\n",
      "\n",
      "foo(bar=0, baz=1)\n",
      "    Perform a foo transfo.\n",
      "    \n",
      "    Keyword arguments:\n",
      "    bar -- blabla (default=1)\n",
      "    baz -- blabla (default=1)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(foo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Function Annotations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Annotations provide a way to attach metadata to a function’s parameters & return value.   \n",
    "- They don’t impose any semantic restrictions on the code\n",
    "- They make good documentation (add clarity to docstring)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': int, 'b': str, 'return': float}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(a: int = 12, b: str = 'baz') -> float:\n",
    "    print(a, b)\n",
    "    return(3.5)\n",
    "\n",
    "f.__annotations__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12 baz\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo 2.5\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f('foo', 2.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enforcing Type-Checking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "cf. PEP 484 and use mypy, a free static type checker for Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "when passing a mutable value as a default argument in a function, the default argument is mutated anytime that value is mutated"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['zzz', 'aaa']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def append_lst(lst=[]):\n",
    "    lst.append(\"aaa\")\n",
    "    return [\"zzz\"] + lst\n",
    "\n",
    "append_lst()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['zzz', 'aaa', 'aaa']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "append_lst()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1}\n",
      "{'a': 1, 'b': 2}\n"
     ]
    }
   ],
   "source": [
    "def f(value, key, hash={}):\n",
    "    hash[value] = key\n",
    "    return hash\n",
    "\n",
    "print(f('a', 1))\n",
    "print(f('b', 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and not as expected   \n",
    "{'a': 1}  \n",
    "{'b': 2}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "solution to mutable value as a default argument in a function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use None as a default and assign the mutable value inside the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def append(element, seq=None):\n",
    "    if seq is None:\n",
    "        seq = []\n",
    "    seq.append(element)\n",
    "    return seq\n",
    "\n",
    "append(1)  # `seq` is assigned to []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "append(2)  # `seq` is assigned to [] again!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sorting with lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['N. Bohr', 'M. Curie', 'C. Darwin', 'A. Einstein']"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scientists = [ 'M. Curie', 'A. Einstein', \n",
    "              'N. Bohr', 'C. Darwin']\n",
    "\n",
    "sorted(scientists, key=lambda name: name.split()[-1])\n",
    "#sorted(iterable, key(callable))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of a lambda with a tuple as input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x, y: x + y)(2, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Detecting Callable Objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def is_even(x):\n",
    "    return x % 2 == 0\n",
    "\n",
    "callable(is_even)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "is_odd = lambda x: x % 2 == 1\n",
    "callable(is_odd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "callable(list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "callable(list.append)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class CallMe:\n",
    "    def __call__(self):\n",
    "        print(\"Called!\")\n",
    "        \n",
    "callable(CallMe())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Object Oriented Programming\n",
    "\n",
    "This part is based on the examples provided in the excellent course by [Joe Marini @LinkedinLearning](https://www.linkedin.com/learning/python-object-oriented-programming)\n",
    "\n",
    "Why OOP ?\n",
    "- not required to code in Python\n",
    "- but complex programs are hard to keep organized\n",
    "- OOP can structure code\n",
    "    * group together data & behavior into one place\n",
    "    * promotes modularization of programs\n",
    "    * isolates parts of the code"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Concepts / key terms  \n",
    " - Class = a blueprint for creating objects of a particular type\n",
    " - Methods = regular functions that are part of a class\n",
    " - Attributes = variables that hold data that are part of a class\n",
    " - Object = a specific instance of a class\n",
    " - Inheritance = means by which class can inherit capabilitites from another\n",
    " - Composition = means of buiding complex objects out of other objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic class definition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "create a basic class, an instance & print the class proerty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Brave New World'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Book():\n",
    "    # the \"init\" function is called when\n",
    "    # the instance is created & ready to\n",
    "    # be initialized\n",
    "    def __init__(self, title):\n",
    "        self.title = title\n",
    " \n",
    "b1 = Book(\"Brave New World\")\n",
    "b1.title"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instance methods and attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39.95\n",
      "29.95\n",
      "22.4625\n"
     ]
    }
   ],
   "source": [
    "class Book():\n",
    "    def __init__(self, title, author, pages, price):\n",
    "        self.title = title\n",
    "        self.author = author\n",
    "        self.pages = pages\n",
    "        self.price = price\n",
    "        \n",
    "    def get_price(self):\n",
    "        if hasattr(self, \"_discount\"):\n",
    "            return self.price * (1 - self._discount) \n",
    "        else:\n",
    "            return self.price \n",
    "    \n",
    "    def set_discount(self, amount):\n",
    "        self._discount = amount\n",
    "\n",
    "b1 = Book(\"Brave New World\", \"L. Tolstoy\", 1225, 39.95)\n",
    "b2 = Book(\"War and Piece\", \"JD Salinger\", 234, 29.95)\n",
    "\n",
    "print(b1.get_price())\n",
    "print(b2.get_price())\n",
    "b2.set_discount(0.25)\n",
    "print(b2.get_price())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What \\_ & \\__ are used for ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- The \\_ indicates that an attribute or a method is intended to only be used by the class.  \n",
    "- With \\__ the interpreter will change the name of that attribute or method so that other classes will get an error.   \n",
    "- This prevent subclasses from inadvertently overriding the attribute but other classes can subvert this simply by using the class name.  \n",
    "- You can use this to make sure that subclasses don't use the same name for an attribute or don't have the right to overwrite it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'SecreT'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Book():\n",
    "    def __init__(self, title):\n",
    "        self.title = title\n",
    "        self.__secret = \"SecreT\"\n",
    " \n",
    "b1 = Book(\"Brave New World\")\n",
    "b1._Book__secret"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b1.__secret\n",
    "# AttributeError: 'Book' object\n",
    "# has no attribute '__secret'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checking instance types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Book"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Book():\n",
    "    def __init__(self, title):\n",
    "        self.title = title\n",
    "        \n",
    "class Newspaper():\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        \n",
    "b1 = Book(\"The Grapes of Wrath\")\n",
    "b2 = Book(\"The Catcher In the Rye\")\n",
    "n1 = Newspaper(\"The NY Times\")\n",
    "\n",
    "type(b1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Newspaper"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(n1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b1) == type(b2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b1) == type(n1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(b1, Book)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(n1, Book)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(n1, object)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Class methods and members"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "attribute at the Class level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Book types:  ('Hardcover', 'Paperback', 'Ebook')\n"
     ]
    }
   ],
   "source": [
    "class Book():\n",
    "    # class attribute shared by all instances\n",
    "    BOOK_TYPES = (\"Hardcover\", \"Paperback\", \"Ebook\")\n",
    "    \n",
    "    # a class method\n",
    "    @classmethod\n",
    "    def get_book_types(cls):\n",
    "        return cls.BOOK_TYPES\n",
    "    \n",
    "    \n",
    "    def set_title(self, new_title):\n",
    "        self.title = new_title\n",
    "    \n",
    "    def __init__(self, title, booktype):\n",
    "        self.title = title\n",
    "        if (not booktype in Book.BOOK_TYPES):\n",
    "            raise ValueError(f\"{booktype} is not valid\")\n",
    "        else:\n",
    "            self.booktype = booktype\n",
    "\n",
    "            \n",
    "print(\"Book types: \", Book.get_book_types())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "b1 = Book(\"Title 1\", \"Hardcover\")\n",
    "# \"Comics\" instead of \"Hardcover\" will raise an error"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Static method example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Static methods don't modify the state of either the class or a specific object instance. Not so many use case : when you don't need to access any properties of a particular object or the class itself, but it makes sense for the method to belong to the class.  \n",
    "The are global functions in the class namespace.  \n",
    "Example : singleton"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance & Composition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Understanding inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example to show how to create multiples classes inherited to an other"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Publication():\n",
    "    def __init__(self, title, price):\n",
    "        self.title = title\n",
    "        self.price = price\n",
    "\n",
    "class Periodical(Publication):\n",
    "    def __init__(self, title, price, period, publisher):\n",
    "        super().__init__(title, price)\n",
    "        self.period = period\n",
    "        self.publisher = publisher\n",
    "\n",
    "class Book(Publication):\n",
    "    def __init__(self, title, author, pages, price):\n",
    "        super().__init__(title, price)\n",
    "        self.author = author\n",
    "        self.pages = pages\n",
    "\n",
    "class Magazine(Periodical):\n",
    "    def __init__(self, title, publisher, price, period):\n",
    "        super().__init__(title, price, period, publisher)\n",
    "\n",
    "class Newspaper(Periodical):\n",
    "    def __init__(self, title, publisher, price, period):\n",
    "        super().__init__(title, price, period, publisher)\n",
    "        \n",
    "b1 = Book('bbb', \"me\", 211, 19.5)\n",
    "n1 = Newspaper('NY Times', 'my company', 6.0, 'Daily')\n",
    "m1 = Magazine('Time', 'all', 5.5, 'Monthly')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "me\n",
      "my company\n",
      "5.5 6.0\n"
     ]
    }
   ],
   "source": [
    "print(b1.author)\n",
    "print(n1.publisher)\n",
    "print(m1.price, n1.price)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Abstract base classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You don't want consumers of your base class to be able to create instances of the base class itself. Because it's just intended to be a blueprint. Subclasses provide concrete implementations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "class GraphicShape:\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "     \n",
    "    @abstractmethod\n",
    "    def calcArea(self):\n",
    "        pass\n",
    "    \n",
    "class Circle(GraphicShape):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "        \n",
    "    def calcArea(self):\n",
    "        return 3.14 * (self.radius ** 2)\n",
    "    \n",
    "        \n",
    "class Square(GraphicShape):\n",
    "    def __init__(self, side):\n",
    "        self.side = side\n",
    "        \n",
    "    def calcArea(self):\n",
    "        return self.side ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "314.0\n",
      "144\n"
     ]
    }
   ],
   "source": [
    "# g = GraphicShape()\n",
    "# cannot be instantiate\n",
    "c = Circle(10)\n",
    "print(c.calcArea())\n",
    "s = Square(12)\n",
    "print(s.calcArea())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using multiple inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "working example of a class C inherited from both A & B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo bar\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.foo = \"foo\"\n",
    "        \n",
    "class B:\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.bar = \"bar\"\n",
    "        \n",
    "class C(A, B):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "    def showprops(self):\n",
    "        print(self.foo, self.bar)\n",
    "\n",
    "c = C()\n",
    "c.showprops()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "an other working example of a class C inherited from both A & B, but when both superclasses have the same property with different values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python looks in the superclasses in the order in which they are defined from left to right"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo Class A\n",
      "(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>)\n"
     ]
    }
   ],
   "source": [
    "class A:\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.foo = \"foo\"\n",
    "        self.name = \"Class A\"\n",
    "        \n",
    "class B:\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.bar = \"bar\"\n",
    "        self.name = \"Class B\"\n",
    "        \n",
    "class C(A, B):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "    def showprops(self):\n",
    "        print(self.foo, self.name)\n",
    "\n",
    "c = C()\n",
    "c.showprops() \n",
    "print(C.__mro__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interfaces"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is an interface ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "an interface is a kind of promise for a program behavior / capacity. It's a programming feature. Unlike Java or C#, Python does not have explicit language support for this. But it is easy to implement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When to use an interface ?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we want to create a very smal, focused class, that we can use whenever we want another class to be able to indicate. It gives the flexibility to apply this new class which is serving the function of an interface anywhere it is needed. Interfaces are really usefull for declaring that a class has a capability that it knows how to provide"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An example of an interface"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "314.0\n",
      "{ \"square\": 314.0 }\n"
     ]
    }
   ],
   "source": [
    "from abc import ABC, abstractmethod\n",
    "\n",
    "\n",
    "class GraphicShape(ABC):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "    @abstractmethod\n",
    "    def calcArea(self):\n",
    "        pass\n",
    "\n",
    "\n",
    "class JSONify(ABC):\n",
    "    @abstractmethod\n",
    "    def toJSON(self):\n",
    "        pass\n",
    "\n",
    "\n",
    "class Circle(GraphicShape, JSONify):\n",
    "    def __init__(self, radius):\n",
    "        self.radius = radius\n",
    "\n",
    "    def calcArea(self):\n",
    "        return 3.14 * (self.radius ** 2)\n",
    "\n",
    "    def toJSON(self):\n",
    "        return f\"{{ \\\"square\\\": {str(self.calcArea())} }}\"\n",
    "\n",
    "\n",
    "c = Circle(10)\n",
    "print(c.calcArea())\n",
    "print(c.toJSON())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Understanding composition\n",
    "\n",
    "a concept that allows to create complex objects out of simpler ones. It is different than inheritance but both two are not exclusive. For instance, a monolithic class definition can be made more extensible & flexible by composiing it with simpler class objects, each of which is responsible for its own features & data. See screenshot.\n",
    "\n",
    "![title](./composition_.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Leo Toltstoy War & Piece 219\n"
     ]
    }
   ],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, price, author=None):\n",
    "        self.title, self.price = title, price\n",
    "        self.author = author\n",
    "        self.chapters = []\n",
    "        \n",
    "    def add_chapter(self, chapter):\n",
    "        self.chapters.append(chapter)\n",
    "    \n",
    "    def get_page_count(self):\n",
    "        result = 0\n",
    "        for ch in self.chapters:\n",
    "            result += ch.page_count\n",
    "        return result\n",
    "        \n",
    "class Author:\n",
    "    def __init__(self, f_name, l_name):\n",
    "        self.f_name, self.l_name = f_name, l_name\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'{self.f_name} {self.l_name}'\n",
    "    \n",
    "class Chapter:\n",
    "    def __init__(self, name, page_count):\n",
    "        self.name, self.page_count = name, page_count\n",
    "\n",
    "\n",
    "auth = Author(\"Leo\", \"Toltstoy\")\n",
    "b1 = Book(\"War & Piece\", 39., auth)\n",
    " \n",
    "b1.add_chapter(Chapter(\"Ch. 1\", 123))\n",
    "b1.add_chapter(Chapter(\"Ch. 2\", 96))\n",
    "print(b1.author, b1.title, b1.get_page_count())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Magic Object Methods\n",
    "\n",
    "A set of methods that Python automatically associates with every class definition. Your class can override these methods to customize a variety of behavior and make them act just like Python's built-in classes.\n",
    "\n",
    "- customize object behavior & integrate with the language\n",
    "- define how objects are represented as strings (for user or debugging purpose) \n",
    "- control access to attribute values, both for get and set\n",
    "- built in comparison and equality testing capabilities\n",
    "- allow objects to be called like functions (make code more concise & readable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String representation  \n",
    "\n",
    "The str function is used to provide a user-friendly string description of the object, and is usually intended to be displayed to the user.   \n",
    "The repr function is used to generate a more developer-facing string that ideally can be used to recreate the object in tis current state (used for debugging purpose)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Catcher in the Rye by JD Salinger\n",
      "title=The Catcher in the Rye, auth=JD Salinger\n"
     ]
    }
   ],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, author, price):\n",
    "        super().__init__()\n",
    "        self.title, self.author = title, author\n",
    "    \n",
    "    def __str__(self):\n",
    "        return f'{self.title} by {self.author}' \n",
    "    \n",
    "    def __repr__(self):\n",
    "        return f'title={self.title}, auth={self.author}'\n",
    "        \n",
    "b1 = Book(\"The Catcher in the Rye\", \"JD Salinger\", 29.95)\n",
    "print(str(b1))\n",
    "print(repr(b1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Equality and comparison\n",
    "\n",
    "Why : plain objects in Python, by default, don't know how to compare themselves to each other. It can be achieved with the equality & comparison magic methods. Python doesn't compare objects attributes by attributes : it just compares 2 different instances to each other (same object in memory ?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, author, price):\n",
    "        super().__init__()\n",
    "        self.title = title\n",
    "        self.author = author\n",
    "        self.price = price\n",
    "        \n",
    "    def __eq__(self, value):\n",
    "        if not isinstance(value, Book):\n",
    "            raise ValueError(\"Not a book\")\n",
    "        return (self.title == value.title and \n",
    "                self.author == value.author)\n",
    "        \n",
    "b1 = Book(\"My Book\", \"Me\", 20)\n",
    "b2 = Book(\"My Book\", \"Me\", 20)\n",
    "b3 = Book(\"Your Book\", \"You\", 30)\n",
    "print(b1 == b2)\n",
    "print(b1 == b3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "examples of greater and lesser magic methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "['Other Book', 'Your Book', 'My Book']\n"
     ]
    }
   ],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, price):\n",
    "        super().__init__()\n",
    "        self.title = title\n",
    "        self.price = price\n",
    "        \n",
    "    def __ge__(self, value):\n",
    "        if not isinstance(value, Book):\n",
    "            raise ValueError(\"Not a book\")\n",
    "        return self.price >= value.price\n",
    "    \n",
    "    def __lt__(self, value):\n",
    "        if not isinstance(value, Book):\n",
    "            raise ValueError(\"Not a book\")\n",
    "        return self.price < value.price\n",
    "    \n",
    "        \n",
    "b1 = Book(\"My Book\", 40)\n",
    "b2 = Book(\"Your Book\", 30)\n",
    "b3 = Book(\"Other Book\", 20)\n",
    "print(b1 >= b2)\n",
    "\n",
    "books = [b1, b2, b3]\n",
    "books.sort()\n",
    "print([b.title for b in books])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Attribute access\n",
    "\n",
    "Your class can define methods that intercept the process any time an attribute is set or retrieved. It gives you a great amount of flexibility and control over hwo attributes are retrieved and set in your classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\\_\\_getattribute__ is similar to \\_\\_getattr__, with the important difference that \\_\\_getattribute__ will intercept EVERY attribute lookup, doesn’t matter if the attribute exists or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27.0\n",
      "36.0\n",
      "NEW_ATTR\n"
     ]
    }
   ],
   "source": [
    "class Book:\n",
    "    def __init__(self, author, price):\n",
    "        super().__init__()\n",
    "        self.author = author\n",
    "        self.price = price\n",
    "        self._discount = 0.1\n",
    "\n",
    "    # Don't directly access the attr name \n",
    "    # otherwise a recursive loop is created\n",
    "    def __getattribute__(self, name):\n",
    "        if name == \"price\":\n",
    "            p = super().__getattribute__(\"price\")\n",
    "            d = super().__getattribute__(\"_discount\")\n",
    "            return p - (p * d)\n",
    "        return super().__getattribute__(name)\n",
    "\n",
    "    # Don't set the attr directly here otherwise\n",
    "    # a recursive loop causes a crash\n",
    "    def __setattr__(self, name, value):\n",
    "        if name == \"price\" and type(value) is not float:\n",
    "            raise ValueError(\"Not a float\")\n",
    "        return super().__setattr__(name, value)\n",
    "\n",
    "    # pretty much generate attr on the fly\n",
    "    def __getattr__(self, name):\n",
    "        return name.upper()\n",
    "\n",
    "\n",
    "b1 = Book(\"My book\", 30.0)\n",
    "print(b1.price)\n",
    "\n",
    "b1.price = float(40)\n",
    "print(b1.price)\n",
    "\n",
    "print(b1.new_attr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Callable objects\n",
    "\n",
    "Callable like any other function. This features is interesting when you have objects whose attributes change frequently or are often modified together (more compact code & easier to read)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "War & Piece $39.95\n",
      "My Book $100.0\n"
     ]
    }
   ],
   "source": [
    "class Book:\n",
    "    def __init__(self, title, price):\n",
    "        super().__init__()\n",
    "        self.title = title\n",
    "        self.price = price\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f'{self.title} ${self.price}'\n",
    "    \n",
    "    def __call__(self, title, price):\n",
    "        self.title = title\n",
    "        self.price = price\n",
    "\n",
    "b1 = Book('War & Piece', 39.95)\n",
    "print(b1)\n",
    "b1('My Book', 100.)\n",
    "print(b1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Classes\n",
    "\n",
    "In 3.7 Python introduced a new feature called Data Class which helps to automate the creation and managing of classes that mostly exist just to hold data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining a data class\n",
    "\n",
    "Dataclasses have more benefits than concise code : they also automatically implement init, repr and eq magic methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Book(title='My Book', author='Meh', pages=120, price=2.5)\n"
     ]
    }
   ],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass\n",
    "class Book:\n",
    "    title : str\n",
    "    author : str\n",
    "    pages : int\n",
    "    price : float\n",
    "    \n",
    "    def book_infos(self):\n",
    "        return f'{self.title} ${self.price}'\n",
    "\n",
    "b1 = Book(\"My Book\", \"Meh\", 120, 2.5)\n",
    "b2 = Book(\"My Book\", \"Meh\", 120, 2.5)\n",
    "\n",
    "print(b1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b1 == b2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Meh'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b1.author"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'My Book $2.5'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b1.book_infos()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Book(title='My Book', author='YOU!', pages=120, price=2.5)\n"
     ]
    }
   ],
   "source": [
    "b1.author = \"YOU!\"\n",
    "print(b1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using post initialization\n",
    "\n",
    "for example, we might want to create attributes that depends on the values of other attributes, but we can't write init (the dataclass do it for us). The post_init is where you can add additionnal attr that might depend on other ones in your object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "War & Piece $13.5\n"
     ]
    }
   ],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass\n",
    "class Book:\n",
    "    title : str\n",
    "    price : float\n",
    "    \n",
    "    def __post_init__(self):\n",
    "        self.infos = f'{self.title} ${self.price}'\n",
    "\n",
    "b1 = Book(\"War & Piece\", 13.5)\n",
    "print(b1.infos)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using default values\n",
    "\n",
    "Dataclasses provide the ability to define values for their attributes subject to some rules."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Book(title='No title', author='No author', pages=0, price=0.0)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass\n",
    "class Book:\n",
    "    title : str = \"No title\"\n",
    "    author : str = \"No author\"\n",
    "    pages : int = 0\n",
    "    price : float = 0.0\n",
    "\n",
    "\n",
    "b1 = Book()\n",
    "b1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Be aware that attributes without default values have to come first"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Book(price=123.5, title='No title', author='No author', pages=0)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass\n",
    "class Book:\n",
    "    price : float\n",
    "    title : str = \"No title\"\n",
    "    author : str = \"No author\"\n",
    "    pages : int = 0\n",
    "\n",
    "b1 = Book(123.5)\n",
    "b1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if price is not declared first : TypeError: non-default argument 'price' follows default argument   \n",
    "\n",
    "An other solution is to use \"field\" :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Book(title=123.5, author='No author', pages=0, price=10.0)"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from dataclasses import dataclass, field\n",
    "\n",
    "@dataclass\n",
    "class Book:\n",
    "    title : str = \"No title\"\n",
    "    author : str = \"No author\"\n",
    "    pages : int = 0\n",
    "    price : float = field(default=10.0)\n",
    "\n",
    "b1 = Book(123.5)\n",
    "b1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "instead of the default values, you can also use a function outside the object definition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Immutable data classes\n",
    "\n",
    "Occasionally you'll want to create classes whose data can't be changed : the data in them should be immutable. This is possible by specifiing an argument to the data class decorator.  \n",
    "\n",
    "The \"frozen\" parameter makes the class immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value 1\n"
     ]
    }
   ],
   "source": [
    "from dataclasses import dataclass\n",
    "\n",
    "@dataclass(frozen=True)\n",
    "class ImmutableClass:\n",
    "    value1: str = \"Value 1\"\n",
    "    value2: int = 0\n",
    "        \n",
    "    def some_meth(self, new_val):\n",
    "        self.value2 = new_val\n",
    "        \n",
    "obj = ImmutableClass()\n",
    "print(obj.value1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obj.some_meth(100)\n",
    "# FrozenInstanceError: \n",
    "# cannot assign to field 'value2'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Various links and sources / credits:  \n",
    "- Real Python: [defining your own python function](https://realpython.com/defining-your-own-python-function/)\n",
    "- [W3Schools](https://www.w3schools.com/python/python_functions.asp)\n",
    "- [Programiz](https://www.programiz.com/python-programming/function)\n",
    "- [Python OOP by by Joe Marini @LinkedinLearning](https://www.linkedin.com/learning/python-object-oriented-programming)"
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}