Week_1_Python_Class.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Copy of Week 1 Python Class.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/FrancisBilla/DSci/blob/master/Week_1_Python_Class.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GTdL0pn10nh_"
      },
      "source": [
        "# Week 1 Python Class \n",
        "\n",
        "Proprietary material - Under Creative Commons 4.0 licence CC-BY-NC https://creativecommons.org/licenses/by-nc/4.0/legalcode\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dODyBDgn8GeM"
      },
      "source": [
        "Previous knowledge needed for this material:\n",
        "\n",
        "\n",
        "\n",
        "1.   Python Syntax\n",
        "2.   Variables\n",
        "3.   Data structures\n",
        "4.   Flow control\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ULzwDPrkxop4"
      },
      "source": [
        "## Quick review"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jgWg6EaJdUOF"
      },
      "source": [
        "Lists in loops:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rHZtupKCdwy4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ceccf3a1-ff72-40e8-e5cc-6ff467037d8f"
      },
      "source": [
        "test_list = [x**2 for x in range(5)]\n",
        "test_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[0, 1, 4, 9, 16]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BmFhCTOFd_uk",
        "outputId": "7a474b50-18ba-4aec-d439-4834443fcfc7"
      },
      "source": [
        "loop_list = []\n",
        "\n",
        "for i, x in enumerate(test_list):\n",
        "    loop_list.append((i,x))\n",
        "\n",
        "loop_list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16)]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_39dq4YSfaeU"
      },
      "source": [
        "Dictionaries in loops"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zb9g5KotffEE",
        "outputId": "6f4577cc-c1a0-4fb2-87c0-cb11841ea99c"
      },
      "source": [
        "test_dict = {key:value for key, value in enumerate(['a', 'b', 'c'])}\n",
        "test_dict"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{0: 'a', 1: 'b', 2: 'c'}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "buJR5-qRhUI9",
        "outputId": "64cb3ea7-3a7c-4325-bc19-f5c630f0d34f"
      },
      "source": [
        "loop_dict = {}\n",
        "\n",
        "for i in test_dict:\n",
        "    value = test_dict[i]\n",
        "    loop_dict[value] = i # Inverting the keys and values\n",
        "\n",
        "loop_dict"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'a': 0, 'b': 1, 'c': 2}"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 8
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Rs7G1yiisZg"
      },
      "source": [
        "## Help "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZC3RdR64iu6s"
      },
      "source": [
        "Python comes by default with a **help** function that provides the documentation of libraries, modules, classes, functions, etc.\n",
        "\n",
        "The **help** function is used with the following syntaxis:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "help(something)\n",
        "```\n",
        "\n",
        "Let's see an example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "drW4BH5Aj_V7",
        "outputId": "e6bc3816-f93e-4878-8b17-faaebc1e8609"
      },
      "source": [
        "help(print)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Help on built-in function print in module builtins:\n",
            "\n",
            "print(...)\n",
            "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
            "    \n",
            "    Prints the values to a stream, or to sys.stdout by default.\n",
            "    Optional keyword arguments:\n",
            "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
            "    sep:   string inserted between values, default a space.\n",
            "    end:   string appended after the last value, default a newline.\n",
            "    flush: whether to forcibly flush the stream.\n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1PAOd715fmVV"
      },
      "source": [
        "You can also build your own help functions!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FDZy1n09fmGf"
      },
      "source": [
        "def square_function(x): \n",
        "    \"\"\" Takes x and returns the square value of x. \"\"\" \n",
        "    return x**2\n",
        "\n",
        "square_function?"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-N7biIrEd_ep"
      },
      "source": [
        "Another way to get help is the ? simbol that can be used to get information from a variable"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3ITyBlsAInbG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "8f462346-81cd-4890-f503-658ef86a1387"
      },
      "source": [
        "test_list = [x**2 for x in range(5)]\n",
        "print(test_list)\n",
        "test_list?"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[0, 1, 4, 9, 16]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZuNBIbNteQNz"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GBJlerhovqBz"
      },
      "source": [
        "# Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r00ycNuNxbTr"
      },
      "source": [
        "> Programers are lazy...  &nbsp; &nbsp; &nbsp; &nbsp; And thats a good thing.\n",
        "\n",
        "\n",
        "\n",
        "When programing, it is important to keep the code clean, readable and concise.\n",
        "This helps others (and yourself) to expand, edit and use your code.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r_CgZPJSl_ZA"
      },
      "source": [
        "So, imagine you have a code like this"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vESLHohkuPw0",
        "outputId": "2db862fa-be99-46f0-f956-4f8d6031af76"
      },
      "source": [
        "print(\"Working\")\n",
        "\n",
        "\"\"\"\n",
        "\n",
        "Some long and/or complicated process\n",
        "\n",
        "\"\"\"\n",
        "\n",
        "print(\"Finished!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Working\n",
            "Finished!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FtDzfzOBsF6d"
      },
      "source": [
        "What happens if we want to repeatedly run this code?\n",
        "\n",
        "One option could be to copy and paste this code several times, but that would take a lot of space and make the code dificult to read. <br /> <br />\n",
        "\n",
        "Instead, let's write this code inside a function! <br /> <br />\n",
        "\n",
        "Python functions are defined using the syntax **def** and execute the code inside the body of the function each time they are called. \n",
        "\n",
        "So, let's put the previous code inside a function that we'll call **worker_function**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nE6qqRsfxG8w"
      },
      "source": [
        "def worker_function():\n",
        "    print(\"Working\")\n",
        "\n",
        "    \"\"\"\n",
        "\n",
        "    Some long and/or complicated process\n",
        "\n",
        "    \"\"\"\n",
        "\n",
        "    print(\"Finished!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5FT6amL50Zfg"
      },
      "source": [
        "And let's call it a couple of times"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b3HtDOAm0gfB",
        "outputId": "a642493b-b2b9-47e5-bf6f-5c382d1182fb"
      },
      "source": [
        "print(\"Work once\")\n",
        "worker_function()\n",
        "\n",
        "print(\"Work again\")\n",
        "worker_function()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Work once\n",
            "Working\n",
            "Finished!\n",
            "Work twice\n",
            "Working\n",
            "Finished!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GgbOAp2c3ZCh"
      },
      "source": [
        "Great! \n",
        "\n",
        "A function its a first class object, so it can also be assigned to a variable using **=**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xGIT2Uf204-V",
        "outputId": "1d92b2e2-20d1-4126-a980-b00f3567c55e"
      },
      "source": [
        "w = worker_function\n",
        "\n",
        "print(type(w))\n",
        "\n",
        "w()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "<class 'function'>\n",
            "Working\n",
            "Finished!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y3pXccoy5WiS"
      },
      "source": [
        "The () allow to pass arguments or inputs to the function. In this case of our worker_function takes no arguments, but you can pass any type of variable including data structures or even other functions by using this syntax.\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "my_function(arg_1, arg_2, ..., arg_n)\n",
        "```\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YI0APyawE__n"
      },
      "source": [
        "But how do we access the values inside the function? <br /><br />\n",
        "\n",
        "For this we can use the syntax: \n",
        "\n",
        "```\n",
        "return output_1, output_2\n",
        "```\n",
        "\n",
        "At the end of the function. <br /><br />\n",
        "\n",
        "> Note: &nbsp; Functions can even return other functions\n",
        "\n",
        "So lets define the general syntax for a function as:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "def function(arg_1, arg_2):\n",
        "    process # Whatever your function is doing \n",
        "    return output_1, output_2\n",
        "```\n",
        "\n",
        "This function grabs the arguments arg_1 and arg_2, then runs trough the code in process and returns the variables output_1 and output_2 <br /><br />\n",
        "\n",
        "Notice that the indents define what is inside the function, so: \n",
        "\n",
        "```\n",
        "def function():\n",
        "    this_is_inside_the_function\n",
        "and_this_is_not\n",
        "```\n",
        "\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Twg1CZ0YE82i"
      },
      "source": [
        "Some examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QvQbs9fC44aY",
        "outputId": "3d3262f4-53d5-4dd7-a516-5a52965b5e4e"
      },
      "source": [
        "# Returns the square of x\n",
        "\n",
        "def square(x):\n",
        "    \n",
        "    sqr = x**2\n",
        "\n",
        "    return sqr\n",
        "\n",
        "# Returns the cube of x\n",
        "\n",
        "def cube(x):\n",
        "\n",
        "    qbe = x**3\n",
        "\n",
        "    return qbe\n",
        "\n",
        "# Returns the sum of two functions aplied to x\n",
        "\n",
        "def func_sum(x, func1, func2):\n",
        "\n",
        "    return func1(x) + func2(x)\n",
        "\n",
        "func_sum(2, square, cube)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e8-gAIXLUdTw"
      },
      "source": [
        "Default values can also be asigned to any function argument. \n",
        "\n",
        "\n",
        "\n",
        "> Note: All default values have to be declared on the right side\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pWsRAo6fOB3a",
        "outputId": "cb67e88d-e5d0-4bf4-9f2a-4ccf7081d8da"
      },
      "source": [
        "# Returns the nth exponential of x\n",
        "\n",
        "def exponential(x, n=0): # If not declared, n will take de value 0\n",
        "\n",
        "    return x**n\n",
        "\n",
        "exponential(2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UyhwJSl-YiTp"
      },
      "source": [
        "Exercises:\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QS3s8zytYpuK"
      },
      "source": [
        "## Scope\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TCVETZoCPZ88"
      },
      "source": [
        "What would be the result of the following cell?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lz1bLU3BPiMu",
        "outputId": "8edcf422-b3bc-4a87-ef2e-a013f4f06495"
      },
      "source": [
        "x = 0\n",
        "\n",
        "def x_10():\n",
        "    x = 10\n",
        "    return x\n",
        "\n",
        "print(x_10())\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n",
            "0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AJ9XSHRfYu4o"
      },
      "source": [
        "The variables declared inside a function are defined inside an environment called *namespace* that is assigned to that function when it is called. All the variables inside a *namespace* are called the local variables.\n",
        "\n",
        "This means that local variables have no relation with variables outside the function that have the same name. \n",
        "\n",
        "The concept of where these variables are defined is called **Scope**, and is an inportant concept to keep in mind while working with functions.\n",
        "\n",
        "In python there are three levels of scope:\n",
        "\n",
        "\n",
        "\n",
        "1.   **Global**: Defined on the code body\n",
        "2.   **Local**: Defided inside a function\n",
        "3.   **Built-in**: Default variables and functions\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ocKmjgCqYdVE"
      },
      "source": [
        "When calling a variable inside a function, Python will search for it's name in the local variables and then in the global variables.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eIof9icpY2Z5",
        "outputId": "3620cc28-5c42-40e4-c4cc-9ca2f2933dc3"
      },
      "source": [
        "e = 2.71828\n",
        "\n",
        "def e_exp(x):\n",
        "    return e**x\n",
        "\n",
        "e_exp(2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7.3890461584"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LdNqbg14nRXR"
      },
      "source": [
        "To modify a global variable from a function it's necessary to declare it as global.\n",
        "\n",
        "Let's fix the previous function x_10"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tcuhLwwPWg-c",
        "outputId": "40f94b42-b7f8-4f6a-8d3f-e23ae83a4490"
      },
      "source": [
        "x = 0\n",
        "\n",
        "def x_10():\n",
        "    global x\n",
        "    x = 10\n",
        "    return x\n",
        "\n",
        "print(x_10())\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n",
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VbChI8t-PQwH"
      },
      "source": [
        "## Arguments of variable lenght\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qeexFNnLrvNh"
      },
      "source": [
        "Sometimes, a function needs to be able to receive a variable number of arguments. This property can be used by defining an ***args** argument to the function.\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "def function(*args):\n",
        "    proccess\n",
        "    return\n",
        "```\n",
        "\n",
        "Similarly, ****kwargs** defines labeled arguments of variable lenght.\n",
        "\n",
        "```\n",
        "def function(**kwargs):\n",
        "    proccess\n",
        "    return\n",
        "```\n",
        "\n",
        "Inside the function **kwargs** its a dictionary.\n",
        "\n",
        "Some examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XgNKGUts__KL",
        "outputId": "1fcbc6fb-b0cc-4fce-b5da-c4749ed138d5"
      },
      "source": [
        "def mult(*args):\n",
        "    x = 1\n",
        "    for arg in args:\n",
        "        x *= arg\n",
        "    return x\n",
        "\n",
        "mult(1,2,3,4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "24"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1In64iIyERw9",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9e0f8465-3d30-4ff5-fb51-fd2faa1527df"
      },
      "source": [
        "def print_info(**kwargs):\n",
        "    print(kwargs.keys())\n",
        "    print(kwargs.values())\n",
        "\n",
        "\n",
        "print_info(a=1, b=2, c=3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "dict_keys(['a', 'b', 'c'])\n",
            "dict_values([1, 2, 3])\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bd9_rZ0P7eH6"
      },
      "source": [
        "## Lambdas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cpqOTKFi7rSG"
      },
      "source": [
        "Lambdas are similar to functions, but their syntax is shorter and less cumbersome. Also, they can only have one expression.\n",
        "\n",
        "For example the function\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "def square(x):\n",
        "    return x**2\n",
        "```\n",
        "\n",
        "Can be replaced by the lambda \n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "square = lambda x: x**2\n",
        "```\n",
        "\n",
        "The general sintaxis for lambdas is:\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "lambda_name = lambda arg_1, arg_2 : process\n",
        "```\n",
        "\n",
        "Lambdas are often used as anonymous functions or arguments for other functions. Lets see some examples to clarify its usefullness. \n",
        "   \n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aAO0hRT35OtU",
        "outputId": "507ed5d0-7fa0-4c77-e2e9-b93272209a85"
      },
      "source": [
        "def exp_factory(n):\n",
        "    return lambda x: x**n\n",
        "\n",
        "square = exp_factory(2)\n",
        "\n",
        "cube = exp_factory(3)\n",
        "\n",
        "print(square(4), cube(4))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "16 64\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BnOEGoVMNo17"
      },
      "source": [
        "\n",
        "Note:\n",
        "\n",
        "*   **map()**: Applies a function (or lambda) over the items inside a container.\n",
        "*   **filter()**: Filters the items inside a container by a boolean function.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7-j4jsTWMJfZ",
        "outputId": "071031b5-1acb-400d-969b-db70cb7c36fa"
      },
      "source": [
        "m = map(lambda x: x**2, [1, 2, 3, 4, 5])\n",
        "\n",
        "f = filter(lambda x: x>2, [1, 2, 3, 4, 5])\n",
        "\n",
        "print(list(m), list(f))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 4, 9, 16, 25] [3, 4, 5]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gdp9Eot6go7N"
      },
      "source": [
        "## Extra Material: Decorators"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zbUeEb05hVr2"
      },
      "source": [
        "Let's remember that functions in Python are first class objects. This means that: \n",
        "\n",
        "\n",
        "\n",
        "*   Functions are objects, so they can be treated as any variable\n",
        "*   Functions can be passed as an argument to another function\n",
        "\n",
        "\n",
        "Decorators are functions of *superior order*. This means that they receive other functions as an argument.\n",
        "\n",
        "\n",
        "In other words, decorators are a syntax to pass functions to another function. \n",
        "Their syntax is the following\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "@decorator\n",
        "def function(args):\n",
        "    process\n",
        "    return output\n",
        "```\n",
        "\n",
        "This is equivalent to calling \n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "decorator(function)\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "They might seem a bit confusing at first, so let's explore a couple of examples to see how simple they are."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zq3P_Hu8Jh-d"
      },
      "source": [
        "First, let's define a decorator that calls a function n times"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s8Hda9DmM9LF"
      },
      "source": [
        "def eco(f, n=2):\n",
        "\n",
        "    f()\n",
        "    if n>1:\n",
        "        eco(f, n-1)\n",
        "    \n",
        "    return f\n",
        "    "
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xNeRUOOUQFPH",
        "outputId": "aeadcf24-14c2-4085-8b16-a60daeebb6ca"
      },
      "source": [
        "@eco\n",
        "def hello():\n",
        "    print('Hello World!')\n"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello World!\n",
            "Hello World!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gZLt8LWBgRnS"
      },
      "source": [
        "That looks great, but what happens if we want to pass an argument to the decorator like n=4?\n",
        "\n",
        "Python will return a TypeError because eco is defined to receive a function and an integer. \n",
        "\n",
        "To be able to pass arguments, its necesary to create a function that process those arguments and returns a decorator "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KEo7gniwfXG-"
      },
      "source": [
        "def eco_n(n):\n",
        "\n",
        "    def eco(f, n=n):\n",
        "        f()\n",
        "        if n>1:\n",
        "            eco(f, n-1)\n",
        "\n",
        "    return eco"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "grYvSSOSlOEb",
        "outputId": "96b1e37a-714e-4921-a184-ea2a2aad0694"
      },
      "source": [
        "@eco_n(5)\n",
        "def hello():\n",
        "    print('Hello World!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello World!\n",
            "Hello World!\n",
            "Hello World!\n",
            "Hello World!\n",
            "Hello World!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nbo9N9AERIRq"
      },
      "source": [
        "This is the exent to which we are going to touch decorators on this material, but they can be a powerfull tool in a data scientist arsenal so try to keep them in mind. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1yoNd8F__mo8"
      },
      "source": [
        "# OOP"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4yBKgNys0USC"
      },
      "source": [
        "Object oriented programing (OOP), is one of many programing paradigms for structured programming, where each behavior is associated to an object actions and properties.\n",
        "\n",
        "\n",
        "\n",
        "In this material we won't dwelve too deep into OOP, but instead we will build and/or reinforce the base for data science aplications and allow you to research more if you are interested.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CKWLU4xElBvJ"
      },
      "source": [
        "## Classes \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5wI8V06pueXF"
      },
      "source": [
        "Data structures, like integers and strings, allow us to store, manipulate and represent data. But they might be a bit too simple to represent more complex structures. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kj_7X1a0ujRQ"
      },
      "source": [
        "A class helps by allowing to organize this data while defining its behavior and interactions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9ec6LqLWorKa"
      },
      "source": [
        "It's important to clarify that in Python, an object is an instance of a class that determines its structure and properties. \n",
        "An example is that a class is similar to a recipe and the objects are the food made following that recipe, so you cannot interact directly with a class, but you can with its instances.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PHnuvyrutXyS"
      },
      "source": [
        "A class in Python can be defined by the following sintaxis:\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "class MyClass:\n",
        "\n",
        "    process\n",
        "    ...\n",
        "\n",
        "```\n",
        "\n",
        "And to instantiate (or build) an object is:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "object = MyClass()\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "Classes are extremely versatile, so it's hard to write a general structure for them. But still, it can be seen that they follow a similar structure to the functions seen previously. \n",
        "\n",
        "Classes also have a *namespace* just like functions and the same scope rules still aply.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3kdj9cbZxBgD"
      },
      "source": [
        "> Obs: A class is defined without parenthesis but is instantiated with them"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NBh-JEST4_mE"
      },
      "source": [
        "Let's check with the most simple class possible"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "atWZ_90vQNJL",
        "outputId": "7f87559c-8af5-4820-bc67-f086fb10c4d2"
      },
      "source": [
        "class NullClass:\n",
        "    pass    # Does nothing\n",
        "\n",
        "obj = NullClass()\n",
        "\n",
        "type(obj)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "__main__.NullClass"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dsOuX4-85vby"
      },
      "source": [
        "### Methods"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H3f_6BML61VB"
      },
      "source": [
        "Methods are functions that are associated to a class and can be called by its instances with the syntax\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "TheClass.the_method(args)\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "They are defined inside the class with the syntax **def** just like functions.\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "class TheClass:\n",
        "\n",
        "    def the_method(args):\n",
        "        process\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "Let's see some examples:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4caA5Xzy0PJ8"
      },
      "source": [
        "Let's make a simple class called **Duck** that has to behave like a normal digital duck."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Q5SDxlwJ0N8D",
        "outputId": "0cb4e54f-0c81-456b-a313-55453ec861a8"
      },
      "source": [
        "class Duck:\n",
        "    \n",
        "    def quack(self, n_quacks=1):\n",
        "        for _ in range(n_quacks):\n",
        "            print('quack')\n",
        "\n",
        "ducky = Duck()\n",
        "\n",
        "ducky.quack(3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "quack\n",
            "quack\n",
            "quack\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HLXkpZN_VNju"
      },
      "source": [
        "#### Self\n",
        "\n",
        "You might have notice the use of **self** as the first argument in the method quack. For a class, **self** represents its instance, so by using **self** you are telling Python that you are accessing the methods and variables of that instance. \n",
        "\n",
        "> Obs: A Python *quirk* is that the parameter **self** is passed automatically in a method, but not received. This means that when defining a method, **the first parameter has to be self**, but its not needed when building it."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RXAiIIuzoQOk"
      },
      "source": [
        "To store a variable inside an instance, we can do the following:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "MyInstance.class_variable = 'Some values'\n",
        "```\n",
        "Here we are storing 'Some values' in the variable *class_variable* for the instance MyInstance of some unknown class.\n",
        "\n",
        "But how do we store these values from inside the class?\n",
        "\n",
        "For this, we can use **self** inside the class definition to indicate Python that we want to save them inside the class instance.\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m8EFeY9Zq2IR"
      },
      "source": [
        "As an example:\n",
        "\n",
        "Let's make a smarter duck, that can remember how many times it last quacked."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7D-huSlcrhIn",
        "outputId": "615cb602-556e-413b-9087-03f2298030e4"
      },
      "source": [
        "class SmartDuck:\n",
        "\n",
        "    def quack(self, n_quacks=1):\n",
        "        self.n_quacks = n_quacks\n",
        "        for _ in range(n_quacks):\n",
        "            print('quack')\n",
        "\n",
        "    def count_quacks(self):\n",
        "        print('I last quacked {} times'.format(self.n_quacks) )\n",
        "\n",
        "smart_ducky = SmartDuck()\n",
        "\n",
        "smart_ducky.quack(1)\n",
        "smart_ducky.quack(2)\n",
        "\n",
        "smart_ducky.count_quacks()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "quack\n",
            "quack\n",
            "quack\n",
            "I last quacked 2 times\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sCjLpvJv7XQD"
      },
      "source": [
        "#### Special Methods"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cJCqGsBR0r1G"
      },
      "source": [
        "Special methods are functions with a fixed name (usually with a double underscore) that have some special properties. \n",
        "\n",
        "Perhaps the most important is the method **\\_\\_init\\_\\_**, that initializes an instance. \n",
        "\n",
        "Lets make an example with the special methods **\\_\\_init\\_\\_** and **\\_\\_add\\_\\_**. There are a lot more  of this, but please check them out on your own. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-CyWfIRC57c-"
      },
      "source": [
        "Lets further improve the digital duck so that each duck has a name, a weight, can remember all the times it has cuacked and can add itself to other ducks to make a new super duck."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bok-Mmee56_E",
        "outputId": "32390b73-80d7-464c-e006-d03c0143bbfc"
      },
      "source": [
        "class SuperDuck:\n",
        "\n",
        "    def __init__(self, name, weight):\n",
        "        self.name = name\n",
        "        self.weight = weight \n",
        "        self.cuacks = 0\n",
        "\n",
        "    def cuack(self, n_cuacks=1):\n",
        "        for _ in range(n_cuacks):\n",
        "            print('quack')\n",
        "            self.cuacks += 1\n",
        "\n",
        "    def count_cuacks(self):\n",
        "        print('I have quacked {} times'.format(self.cuacks))\n",
        "\n",
        "    def greet(self):\n",
        "        print('Hi! my name is {} and I weight {} kg.'.format(self.name, self.weight))\n",
        "\n",
        "    def __add__(self, other):\n",
        "        new_name = 'Super {}{}'.format(self.name, other.name)\n",
        "        new_weight = self.weight + other.weight\n",
        "\n",
        "        return SuperDuck(new_name, new_weight)\n",
        "\n",
        "tomy = SuperDuck('tomy', 5)\n",
        "samy = SuperDuck('samy', 4)\n",
        "\n",
        "tomy.greet()\n",
        "\n",
        "super_duck = tomy + samy \n",
        "\n",
        "super_duck.greet()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hi! my name is tomy and I weight 5 kg.\n",
            "Hi! my name is Super tomysamy and I weight 9 kg.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lGO6Re1QKpUG"
      },
      "source": [
        "## Inheritance"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I1gD_MQrLh_Z"
      },
      "source": [
        "Inheritance is a property of classes that allow us to make new classes with the properties and methods of another class. This creates a hierarchy between the classes, so the class being inherited from is called the **Parent Class** and the class that inherits it is the **Child Class**.\n",
        "\n",
        "This allows to save a lot of code, and can help in organizing the classes functionalities.\n",
        "\n",
        "The syntax for inheritance is:\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "class ChildClass(ParentClass):\n",
        "    do_stuff()\n",
        "```\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hUb5vVH-0LyB"
      },
      "source": [
        "> Note: To assert that an instance is the same class as another, its heavily recommended to use **isinstance()** instead of the previously used **type()**."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FZ91HC9qXCpx"
      },
      "source": [
        "Lets see some examples:\n",
        "\n",
        "We define the class Dinosaur that will be the Parent of all dinosaur classes"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tHEODEpAa422"
      },
      "source": [
        "class Dinosaur:\n",
        "\n",
        "    def __init__(self, name, weight):\n",
        "        self.name = name\n",
        "        self.weight = weight\n",
        "\n",
        "    def walk(self):\n",
        "        print('walking')\n",
        "\n",
        "    def roar(self):\n",
        "        print('roar')\n",
        "\n",
        "    def greet(self):\n",
        "        print('My name is {} and I am a generic dinosaur'.format(self.name))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k8imYpjilpd8"
      },
      "source": [
        "Now lets define the Child classes"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rt5t_1eDsBC-"
      },
      "source": [
        "class TRex(Dinosaur):\n",
        "\n",
        "    def attack(self):\n",
        "        print('bite')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IGP3aJ-Tv7sZ",
        "outputId": "b5825299-aab3-41c4-c88c-acc5c1807140"
      },
      "source": [
        "terry = TRex('terry', 14000)\n",
        "\n",
        "terry.greet()\n",
        "\n",
        "terry.attack()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "My name is terry and I am a generic dinosaur\n",
            "bite\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5u-U1FzFjr7H"
      },
      "source": [
        "Mmmhhh, that looks fine, but perhaps it would be better if the T-Rex didn't introduce himself as a generic dinosaur.\n",
        "\n",
        "To fix this, lets introduce the concept of method overriding."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pta66xnTzEHv"
      },
      "source": [
        "#### Method Override"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pn7t5jEnzetT"
      },
      "source": [
        "In the inheritance, a Child can override the Parent methods and properties. \n",
        "\n",
        "To do this, it's necessary to redefine the method in the Child with the same name. When overriding, the original Parent method can still be accessed with **super()**\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DyIuF6TSHoaV"
      },
      "source": [
        "Lets fix the TRex class using override and super()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fJ6whQpCJ7a9"
      },
      "source": [
        "class TRex(Dinosaur):\n",
        "\n",
        "    def __init__(self, name, weight, theeth):\n",
        "\n",
        "        super().__init__(name, weight)\n",
        "\n",
        "        self.theeth = theeth\n",
        "\n",
        "    def attack(self):\n",
        "        print('bite')\n",
        "\n",
        "    def greet(self):\n",
        "        print('My name is {} and I am a T-Rex'.format(self.name))\n",
        "\n",
        "    def old_greet(self):\n",
        "        super().greet()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JBCLUCkniWy_",
        "outputId": "de295b3e-a6d2-42b1-a531-df73f01ed8c1"
      },
      "source": [
        "terry = TRex('terry', 14000, 100)\n",
        "\n",
        "terry.greet()\n",
        "\n",
        "terry.walk()\n",
        "\n",
        "terry.old_greet()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "My name is terry and I am a T-Rex\n",
            "walking\n",
            "My name is terry and I am a generic dinosaur\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wwzhp4ZTrA7e"
      },
      "source": [
        "Now that looks a lot better.\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0ORj6nXP5Zi1"
      },
      "source": [
        "### Extra Material: Privacy"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qQgG5mmd7Cru"
      },
      "source": [
        "When definig variables and methods inside a class, they can be accessed and modified from outside their own *namespace* by using the syntax **.** as seen previously.\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "outside_var = MyClass.inside_var\n",
        "\n",
        "MyClass,inside_var = 'something else'\n",
        "```\n",
        "\n",
        "But how can we limit the access to these variables and methods?\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r8WSDQ49PqyE"
      },
      "source": [
        "In Python, we can restrict the acces to the data by using **private** and **protected** attributes. \n",
        "\n",
        "\n",
        "\n",
        "*   **Private attributes**: Can only by accessed by their own instance. To define them, the syntax **__attribute** (two underscore) is used.\n",
        "*   **Protected attributes**: Can be accessed from outside the class scope, but unless they are a Child of the class, they cannot be accessed from other classes. To define them, the syntax **_attribute** (one underscore) is used. \n",
        "\n",
        "\n",
        "All attributes that are not defined as either private or protected are public by default, an therefore not encapsulated.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Tcuoky4xWLOr"
      },
      "source": [
        "Let's test this concept with an example"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GEk3TwxVW1qn"
      },
      "source": [
        "class PrivacyTest:\n",
        "\n",
        "    def __init__(self, public, protected, private):\n",
        "        self.public = public\n",
        "        self._protected = protected \n",
        "        self.__private = private "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kst8l0R0W0zw",
        "outputId": "74820387-42b4-4fc4-f80e-af00353f7b8a"
      },
      "source": [
        "privacy_test = PrivacyTest('public', 'protected', 'private')\n",
        "\n",
        "print(privacy_test.public)\n",
        "print(privacy_test._protected)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "public\n",
            "protected\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        },
        "id": "0QTRiZmtuYBS",
        "outputId": "0dc8dbf6-386a-4537-ba89-1c89fb1a5590"
      },
      "source": [
        "print(privacy_test.__private)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-3-a48070c2ef82>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprivacy_test\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__private\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'privacy_test' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ypuj-Z9ntUr-"
      },
      "source": [
        "#### Setters and Getters\n",
        "\n",
        "Sometimes, its a good practice to define some getter and setter methods in a class. \n",
        "\n",
        "The **getter** methods allow to access the attributes withouth risking modification, while the **setter** methods allows to modify them. \n",
        "\n",
        "\n",
        "These methods allow us to access private attributes like this:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hNnDb1cJnFY3",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "07aaa469-a676-4d12-fd1c-59d7cb1b8c0d"
      },
      "source": [
        "class GetSetTest:\n",
        "\n",
        "    def __init__(self, private):\n",
        "        self.__private = private \n",
        "\n",
        "    def get_private(self):\n",
        "        return self.__private\n",
        "\n",
        "    def set_private(self, value):\n",
        "        self.__private = value\n",
        "\n",
        "test = GetSetTest('private')\n",
        "\n",
        "test.set_private('set')\n",
        "\n",
        "print(test.get_private())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "set\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o1S3XnwPJWXP"
      },
      "source": [
        "These methods can help  protect the program from an user or external software, but it's recommended to use them with discretion as they can also make the code less readable. \n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zFu32ZGRKpU3"
      },
      "source": [
        "# Exercices\n",
        "\n",
        "1. Make a decorator that allows to measure the mean and variance of the execution time of a function.\n",
        "\n",
        "2. Design a game of tick-tack-toe using Python classes and functions. The only requisites are:\n",
        "\n",
        "\n",
        "    *   Can't use external libraries\n",
        "    *   Must implement at least one Parent and Child class\n",
        "    *   Can be played by two people\n",
        "    *   At the end of the game announce the winner or if the game is a draw\n",
        "    *   Follows all normal rules of tick-tck-toe (can't use the same space twice, no out of borders, it ends with the firts three in line)\n",
        "\n"
      ]
    }
  ]
}