The_Fundamentals_of_Python_Using_Colab.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "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.6.5"
    },
    "colab": {
      "name": "The Fundamentals of Python Using Colab.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Elgendi/Machine-Learning-and-Data-Viz-Workshop/blob/master/The_Fundamentals_of_Python_Using_Colab.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ppJOdBmPDdVl"
      },
      "source": [
        "#### Machine Learning and Visulization for Healthcare Data: Foundtions (Part 1)\n",
        "\n",
        "## Fundamentals of Python using Jupyter Notbook\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MTfmSyOUDdVm"
      },
      "source": [
        "# Copyright (c) Mohamed Elgendi 2020. All rights reserved\n",
        "# Author: Mohamed Elgendi \n",
        "# Version: 1.0 (2020.11.29)\n",
        "# Email: moe.elgendi@gmail.com\n",
        "# Platform: Tested on Windows 10 with Python 3.6"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gak-PsDmDdVm",
        "outputId": "990263d8-1455-4970-a5a9-c6d3c0aea590"
      },
      "source": [
        "print('Hello To The Data Science World')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello To The Data Science World\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XmAilcdZDdVo",
        "outputId": "bf96833f-d64a-42b6-befc-8558296d6d2d"
      },
      "source": [
        "1 + 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 222
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oRYraS8jDdVo"
      },
      "source": [
        "## Cell Types\n",
        "\n",
        "As you can see, each cell can be either code or text. To select between them, choose from the 'Cell Type' dropdown menu on the top left."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cRiZgeciDdVo"
      },
      "source": [
        "## Executing a Command\n",
        "\n",
        "A code cell will be evaluated when you press play, or when you press the shortcut, Shift + Enter. Evaluating a cell evaluates each line of code in sequence, and prints the results of the last line below the cell."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZRq42Yu-DdVo",
        "outputId": "5f637980-7e72-4140-c464-e51438c7cf4c"
      },
      "source": [
        "a = [5,6,7,8,9]\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[5, 6, 7, 8, 9]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 272
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wfUBv2tdDdVp",
        "outputId": "5378f1f7-40be-42ca-e397-e07890e090dc"
      },
      "source": [
        "b = tuple([3, 5, 7])\n",
        "type(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tuple"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 225
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aGdzqjM7DdVp",
        "outputId": "e8d565cb-ec25-47d0-f24f-ab5725c894d0"
      },
      "source": [
        "c = list([3, 5, 7])\n",
        "c"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[3, 5, 7]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 226
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3Fff1QQuDdVp"
      },
      "source": [
        "a = ['University of Manitoba', 'Population', 4000]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_l79obEHDdVp",
        "outputId": "700cdce2-e1a9-40f2-d984-7b24cc399ea1"
      },
      "source": [
        "type(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 220
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "paWxOitxDdVq"
      },
      "source": [
        "c=[0,1,3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GqG5Psp8DdVq",
        "outputId": "63086278-9250-420e-937f-b4d6630f55a9"
      },
      "source": [
        "type(c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 102
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IuYEo7G2DdVq"
      },
      "source": [
        "b = a.copy()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SOMwLl53DdVq",
        "outputId": "c566e2fe-4441-4f2e-98aa-be492ae1af21"
      },
      "source": [
        "a == b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 104
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gZxz-AMqDdVq",
        "outputId": "8f3aad7b-3e03-4750-9954-0dc2a3251fd1"
      },
      "source": [
        "a is b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 105
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ajwLJVyqDdVq",
        "outputId": "cfed53d7-0055-4e0b-d225-7fb647d59dbd"
      },
      "source": [
        "id(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2109190424008"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-WEtJWfSDdVq",
        "outputId": "357d6b92-5144-4f4b-a50b-fb8190a578f1"
      },
      "source": [
        "a[0]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'University of Manitoba'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1wRqHU_FDdVr"
      },
      "source": [
        "a[0] = 'SFU'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FwxyWzf1DdVr",
        "outputId": "89efe35e-8d33-4007-ca95-479e5dfb818e"
      },
      "source": [
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['University of Manitoba', 'Population', 4000]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 106
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5dv73FQHDdVr",
        "outputId": "b214305a-2cdb-4f82-ae03-dae265beaac2"
      },
      "source": [
        "b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['University of Manitoba', 'Population', 4000]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 107
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jvFby1oqDdVr"
      },
      "source": [
        "a = b = c = '??'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8A5SlHg0DdVr",
        "outputId": "1c63ac41-fcdf-452f-87ff-84adb3ba5253"
      },
      "source": [
        "b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'??'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 289
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iZ27eQcIDdVr"
      },
      "source": [
        "a = [5, 25, 'foo', 3.57, None, 'bar']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MnlEEbNfDdVr",
        "outputId": "2adac9c0-a1df-49e3-db75-95dac873266c"
      },
      "source": [
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[5, 25, 'foo', 3.57, None, 'bar']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 114
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nugz0aYHDdVr",
        "outputId": "4de52be9-b618-421c-97da-d86f20eaac4f"
      },
      "source": [
        "a[1] = 1000000000000\n",
        "a.append('AI')\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[5, 1000000000000, 'foo', 3.57, None, 'bar', 'Moe', 'AI/', 'AI']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 117
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JpA3SfoKDdVs"
      },
      "source": [
        "some_other_collection = ['foo', 3.57, 'bar', 'baz', 'hello', 257]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i3agNVDfDdVs",
        "outputId": "a20bd347-922f-43b3-8aec-1068e13cd0d0"
      },
      "source": [
        "type(some_other_collection)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "list"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 120
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ds57j3UTDdVs"
      },
      "source": [
        "b = some_other_collection"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eCqyrNKwDdVs"
      },
      "source": [
        "some_other_collection = 'cool'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-wDOb_b8DdVs",
        "outputId": "5557556f-3ba7-447a-98b0-215fa27bb911"
      },
      "source": [
        "b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['foo', 3.57, 'bar', 'baz', 'hello', 257]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 123
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AfAmEfXIDdVs",
        "outputId": "00b5a569-b8cd-4b5c-db9d-a38fcb88d57b"
      },
      "source": [
        "some_other_collection[1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'o'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TD1IUvE8DdVs",
        "outputId": "cbcf1b68-9fe9-4814-8a96-c144503267ef"
      },
      "source": [
        "some_other_collection.append('CHI')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "'str' object has no attribute 'append'",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[1;32m<ipython-input-124-eab09287477e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msome_other_collection\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'CHI'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[1;31mAttributeError\u001b[0m: 'str' object has no attribute 'append'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aujf09kGDdVs",
        "outputId": "af49defb-29db-459f-f893-4cdad52cd104"
      },
      "source": [
        "some_other_collection[1] = 123"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "'str' object does not support item assignment",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[1;32m<ipython-input-125-9939a99ae942>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0msome_other_collection\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m123\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k7hiVj5hDdVs"
      },
      "source": [
        "some_other_collection = None"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OSCEc4V_DdVs"
      },
      "source": [
        "b = \"Hello\"\n",
        "d = ['aa', 32434, True]\n",
        "d.remove('aa')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RlO3JRtyDdVs",
        "outputId": "65006e62-a7d5-4420-b253-7cb616828608"
      },
      "source": [
        "d"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[32434, True]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q388-dnkDdVs"
      },
      "source": [
        "Sometimes there is no result to be printed, as is the case with assignment."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mIMP4m6SDdVs"
      },
      "source": [
        "Remember that only the result from the last line is printed."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hr1m8DFeDdVs",
        "outputId": "b868feb0-6562-4824-ef65-91df89ff8e12"
      },
      "source": [
        "a = 'hello'\n",
        "a = a + ' world'\n",
        "print(2 + 2)\n",
        "print(3 + 7)\n",
        "(2 + 2, 3 + 7, 3 + 5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n",
            "10\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(4, 10, 8)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XrEDWjZsDdVs",
        "outputId": "91f06b46-d173-4baf-9859-8dd4bb68ff8f"
      },
      "source": [
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'hello world'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u_gXM4cyDdVs",
        "outputId": "f4bb93af-977d-405e-8f3e-26a37b2e8183"
      },
      "source": [
        "2 + 2\n",
        "3 + 7"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q39tBPYYDdVs"
      },
      "source": [
        "However, you can print whichever lines you want using the `print` statement."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NPQjGHmmDdVs",
        "outputId": "9351874a-f01c-44ed-eada-f77aefe2b19b"
      },
      "source": [
        "print(2 + 2)\n",
        "3 + 3"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "4\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F9iVaLzKDdVs"
      },
      "source": [
        "## Knowing When a Cell is Running\n",
        "\n",
        "While a cell is running, a `[*]` will display on the left. When a cell has yet to be executed, `[ ]` will display. When it has been run, a number will display indicating the order in which it was run during the execution of the notebook `[5]`. Try on this cell and note it happening."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qTvrQqNmDdVt"
      },
      "source": [
        "for i in range(5, 10, 3):\n",
        "    print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2ROLw4rKDdVt"
      },
      "source": [
        "#Take some time to run something\n",
        "a = 0\n",
        "for i in range(10000001):\n",
        "    a = a + i\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TDSXah08DdVt"
      },
      "source": [
        "## Importing Libraries\n",
        "\n",
        "The vast majority of the time, you'll want to use functions from pre-built libraries. Here we import `numpy` and `pandas`, the two most common and useful libraries in quant finance and trading. We recommend copying this import statement to every new notebook.\n",
        "\n",
        "Notice that you can rename libraries to whatever you want after importing. The `as` statement allows this. Here we use `np` and `pd` as aliases for `numpy` and `pandas`. This is a very common aliasing and will be found in most code snippets around the web. The point behind this is to allow you to type fewer characters when you are frequently accessing these libraries."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PAZb2c6JDdVt"
      },
      "source": [
        "#!pip list -v | grep numpy # Note the numpy is installed (no need to install it, unless you are looking for a certain version)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_5q-7LuCDdVt"
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ayZKTIbNDdVt",
        "outputId": "851e7927-47e3-4e6d-f585-624770fe596d"
      },
      "source": [
        "a = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "a"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "array([[1, 2, 3],\n",
              "       [4, 5, 6]])"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 273
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u989N0WXDdVt"
      },
      "source": [
        "# important! list vs. array"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UtsiVEtwDdVt",
        "outputId": "57f4cbc4-77dd-46cb-a879-0d1b805e22b0"
      },
      "source": [
        "a[0,1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 275
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AOVjYBM0DdVt"
      },
      "source": [
        "k=a.tolist()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aVOnB3g7DdVt",
        "outputId": "d8a58443-5593-4dbd-9d3a-a3c82c131ad2"
      },
      "source": [
        "k[0][1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 279
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WeDof24bDdVt"
      },
      "source": [
        "## Tab Autocomplete\n",
        "\n",
        "Pressing tab will give you a list of Jupyter's best guesses for what you might want to type next. This is incredibly valuable and will save you a lot of time. If there is only one possible option for what you could type next, Jupyter will fill that in for you. Try pressing tab very frequently, it will seldom fill in anything you don't want, as if there is ambiguity a list will be shown. This is a great way to see what functions are available in a library.\n",
        "\n",
        "Try placing your cursor after the `.` and pressing tab. Further, you can view a method signature by pressing shift + tab."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZZiJ_6_nDdVt",
        "outputId": "2b61ed74-2d87-4b70-c66c-6920a332f9d3"
      },
      "source": [
        "print(np.random.binomial(2,0.5))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-yuaacgLDdVt"
      },
      "source": [
        "np."
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hs9pmOOqDdVt"
      },
      "source": [
        "## Getting Documentation Help\n",
        "\n",
        "Placing a `?` after a function or a module and executing that line of code will give you the documentation Jupyter has has for that function. It's often best to do this in a new cell, as you avoid re-executing other code and running into bugs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RfEcSQSsDdVt"
      },
      "source": [
        "?pd.DataFrame"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uY7EdGzTDdVt"
      },
      "source": [
        "## Introduction to Python\n",
        "\n",
        "This section addresses the main features and functionalities of Python in the domain of Data Science. As data scientists, we care a lot about data structures that let us store large collections of data. Python API has a number of such data structures. Further libraries such as `pandas` define very convinient ways of interacting with data."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Cc5UfqXwDdVt"
      },
      "source": [
        "# Variables\n",
        "\n",
        "The basic variable types that we will cover in this section are `integer`s, `float`s, `boolean`s, and `string`s. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4Cq0At6pDdVt"
      },
      "source": [
        "## Numerics\n",
        "\n",
        "Variables provide names for values in programming. If you want to save a value for later or repeated use, you give the value a name, storing the contents in a variable. Variables in programming work in a fundamentally similar way to variables in algebra, but in Python they can take on various different data types.   \n",
        "\n",
        "An **integer** in programming is the same as in mathematics, a whole number with no values after the decimal point. We use the built-in `print` function here to display the values of our variables as well as their types!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aL9Mn-nEDdVt",
        "outputId": "2cdc62d1-706d-464e-becc-11d159193843"
      },
      "source": [
        "my_int = 42\n",
        "print(my_int, type(my_int))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "42 <class 'int'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kt7Akap-DdVt"
      },
      "source": [
        "Variables assignment is expressed via equals `=` sign, irrespective of the type of the variables that we are assigning. Variables are case sensitive, so make sure that you match the variable names exactly when using them after assignment:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Qfobx814DdVt",
        "outputId": "8d16fc5a-2cb1-4217-f3ad-d5dfd5ee228b"
      },
      "source": [
        "print(my_int)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "42\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7g3nu1PGDdVt"
      },
      "source": [
        "A `float` is a type we prescribe to floating point or, in mathematics, real numbers. `float` number type is used throughout data science to represent and do arithmetic operations on numerical values. To define a float we need to include a decimal point `.` or explicitly force the number the number to be a float by using `float()` function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YNrO6YMNDdVt",
        "outputId": "21fcb51d-cebd-478a-d994-86bd1f74c7b5"
      },
      "source": [
        "my_float = 42.\n",
        "print(my_float, type(my_float))\n",
        "my_float = float(my_int)\n",
        "print(my_float, type(my_float))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "42.0 <class 'float'>\n",
            "42.0 <class 'float'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RxIRq8O5DdVt"
      },
      "source": [
        "We can use `int()` function to coerce a `float` variable back to `int` as follows (note that any digits after decimal point will be truncated): "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0Bo-PVjJDdVu",
        "outputId": "6978be41-a4d2-4778-f4d5-fc2b705167d4"
      },
      "source": [
        "my_int = int(65.73)\n",
        "print(my_int, type(my_int))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "65 <class 'int'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3kjBKxvwDdVu"
      },
      "source": [
        "Let us set the variable `x`, so it also equals 65:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bF2Vuk2fDdVu"
      },
      "source": [
        "x = 65"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rqi-pcFdDdVu",
        "outputId": "fb4d29c4-4dda-46b5-8af8-b62fe038e0b6"
      },
      "source": [
        "type(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 136
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u9v8nyv2DdVu"
      },
      "source": [
        "We could overwrite `x` with a value of a different **type**, such as a decimal fraction:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w_rozCJeDdVu"
      },
      "source": [
        "x = 3.57"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G2kDGbpTDdVu"
      },
      "source": [
        "The type of `x` has now changed:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eZNSeRdZDdVu",
        "outputId": "623667fe-f706-453c-bb0b-8319da2a84ba"
      },
      "source": [
        "type(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 138
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6NWea0BBDdVu"
      },
      "source": [
        "`float` stands for \"floating point\", fractions are expressed in Python as \"floating point\" numbers. This is a particularly important data **type** for data scientists, who deal with floating point numbers most of the time. If you want to *really* understand floating point numbers, have a look at the paper *What Every Computer Scientist Should Know About Floating-Point Arithmetic* by David Goldberg; you can hopefully find it [here](https://www.itu.dk/~sestoft/bachelor/IEEE754_article.pdf).\n",
        "\n",
        "Some programming languages (such as Java, C++, C#, and many others) would not allow overwriting `x` with a value of a different type: once something is an `int`, it is always an `int`. We say that these languages are **statically typed**, whereas Python is **dynamically typed**. Types are important in Python, and Python is still a **strongly typed** language, although the type of a variable may change over the lifetime of the program, hence the expression: \"dynamically typed\".\n",
        "\n",
        "Let us make `x` a float again:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lB0mcwZ4DdVu"
      },
      "source": [
        "x = 3.57"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X9gippLiDdVu",
        "outputId": "e3626515-e025-4163-bad7-7aa489940c2d"
      },
      "source": [
        "type(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 140
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LY1_gQVRDdVu"
      },
      "source": [
        "## Booleans\n",
        "\n",
        "`boolean` is a binary variable type, that can either be `True` or `False`. In later sections we will see how significant `booleans` are in programming. Here is some basic usage:   "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5zsLj13TDdVu",
        "outputId": "3f9bb7da-19be-4f8f-d9c3-5fdf69c14d3e"
      },
      "source": [
        "my_bool = True\n",
        "print(my_bool, type(my_bool))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True <class 'bool'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eP8Va_v1DdVu"
      },
      "source": [
        "## Strings \n",
        "\n",
        "`string` type allows us, programmers, define text variables that we can do various operations on. In order to define a `string`, you will use single `'` or double `\"` quotation marks. In data science `string` type is essential when working with textual data.  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UGyFSu4hDdVu",
        "outputId": "dad0a5b7-32eb-4eea-d9b2-cfa5b25fb62e"
      },
      "source": [
        "my_str = \"foo\"\n",
        "print(my_str, type(my_str))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "foo <class 'str'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KhS4Lp68DdVu"
      },
      "source": [
        "Python API defines a `format()` method that allows us to format strings to our liking:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I7ujUgrwDdVu",
        "outputId": "ab3297e4-7199-40d2-ff29-2f93d8fcc858"
      },
      "source": [
        "sentence = \"Hello. My name is {} and i like {}.\"\n",
        "name = \"Ed\"\n",
        "second = \"bread\"\n",
        "sentence = sentence.format(name, second)\n",
        "print(sentence)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello. My name is Ed and i like bread.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cd1PcttkDdVu",
        "outputId": "9d6c3bc6-84d3-4ba9-b85e-109b45f50a57"
      },
      "source": [
        "'Hello. My name is %s and I have spent %d years in data science' % ('Moe', 100)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Hello. My name is Moe and I have spent 100 years in data science'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 144
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HCFzIbXjDdVv"
      },
      "source": [
        "You can also access individual `string` characters via `[]` indexing, which is, to the most part, identical syntax to that of accessing `list` elements as we shall see in the next sections. A point to remember for now is that indexing in Python starts from `0`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cyj6LJ06DdVv",
        "outputId": "aab73ad4-6715-4280-86d2-7ba0f244c63b"
      },
      "source": [
        "print(sentence[0])\n",
        "print(sentence[16])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "H\n",
            "s\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e6iWoRI2DdVv"
      },
      "source": [
        "We will see more ways to slice and dice strings when we cover `list` type."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "omvFn21bDdVv"
      },
      "source": [
        "## Arithmetic expressions and the `math` library\n",
        "\n",
        "Python supports the standard arithmetic operators:  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ttnWziteDdVv",
        "outputId": "0e58d8e9-6ce3-4df9-fdcd-dd03c866b6ee"
      },
      "source": [
        "print('Addition: ', 5+2)\n",
        "print('Subtraction: ', 5-2)\n",
        "print('Multiplication: ', 5*2)\n",
        "print('Division: ', 5/2)\n",
        "print('Exponentataion: ', 5**3)\n",
        "print('Modulo: ', 5%2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Addition:  7\n",
            "Subtraction:  3\n",
            "Multiplication:  10\n",
            "Division:  2.5\n",
            "Exponentataion:  125\n",
            "Modulo:  1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B9h91H__DdVv",
        "outputId": "da63b64c-0133-4f6c-aeeb-f67b6fddbd93"
      },
      "source": [
        "import math\n",
        "'Square root of 5 is %.010f' % math.sqrt(5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Square root of 5 is 2.2360679775'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 147
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oAmSvXbnDdVv",
        "outputId": "c679f5e0-d7dc-4118-bbfa-a9e7c8a25781"
      },
      "source": [
        "import pandas as pd\n",
        "pd.options.display.float_format = '${:,.2f}'.format\n",
        "df = pd.DataFrame([123.4567, 234.5678, 345.6789, 456.7890],\n",
        "                  index=['foo','bar','baz','quux'],\n",
        "                  columns=['cost'])\n",
        "print(df)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "        cost\n",
            "foo  $123.46\n",
            "bar  $234.57\n",
            "baz  $345.68\n",
            "quux $456.79\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6wVYWFnPDdVv",
        "outputId": "bbb6443f-c183-4dd2-b0b4-d77e4c164a1f"
      },
      "source": [
        "a, b = 'foo', 'bar'\n",
        "print(a)\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "foo\n",
            "bar\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RKOgjGxRDdVv"
      },
      "source": [
        "**Expressions** such as"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AdaHhV3ADdVv",
        "outputId": "d867825a-f123-4912-dbe7-79094219ab09"
      },
      "source": [
        "5/2,5//2, 5%2"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2.5, 2, 1)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 161
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vPOlpN61DdVv",
        "outputId": "b98c0370-c7ed-4251-f7ea-62ccd302b2fc"
      },
      "source": [
        "3 + 5"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 158
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lH2zpjRdDdVv",
        "outputId": "007c059e-ce47-48d1-afcf-1dc70ef9d2e0"
      },
      "source": [
        "x"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.57"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 160
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rFyWWivnDdVv",
        "outputId": "3d48ce71-bb99-4e84-a8fc-97db4bf6ec48"
      },
      "source": [
        "2. * x + 7."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "14.14"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 159
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WuBfaZJ2DdVw"
      },
      "source": [
        "evaluate to numbers (whether integers, or floating point numbers). They are known as **arithmetic** expressions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7nxtVKSmDdVw"
      },
      "source": [
        "In addition, we can perform an array of other common operations on numerics:  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U8CWfhKqDdVw"
      },
      "source": [
        "print('Absolute value: ', abs(-5))\n",
        "print('Rounding: ', round(3.56))\n",
        "print('Maximum value: ', max(3,2,8,10,2,5))\n",
        "print('Minimum value: ', min(3,2,8,10,2,5))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ma3gykXVDdVw"
      },
      "source": [
        "The `math` library provides us with many utilities a data scientist would find handy: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vj9s7DfeDdVw"
      },
      "source": [
        "import math"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e5syqgQUDdVw"
      },
      "source": [
        "We can start make use of these utilities right out of the box:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tOzMRmB8DdVw"
      },
      "source": [
        "print('Euler: ', math.e)\n",
        "print('Pi: ', math.pi)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "87ClgxNdDdVw"
      },
      "source": [
        "# Collections"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sHgYSTq8DdVw"
      },
      "source": [
        "## Lists\n",
        "\n",
        "Lists are arguably the most used data structure in python. Its core function is to allow storage and access of various elements. Financial data in particular is often represented as time-series, which are, at theier core, collections of observed values over time. To define a `list` we use square brackets `[]`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5uKggNfiDdVw",
        "outputId": "f87b365d-8aba-49e2-d59e-b67dcf08507e"
      },
      "source": [
        "my_list = [1,5,6,3]\n",
        "print(my_list, type(my_list))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 5, 6, 3] <class 'list'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LFDTnEDvDdVw"
      },
      "source": [
        "Python allows us to combine elements of different types into the same `list`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XsBl8orMDdVw",
        "outputId": "da08e118-eb49-4225-e31a-08391e8545af"
      },
      "source": [
        "my_list = [1, \"hello world\", True, math.pi]\n",
        "print(my_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 'hello world', True, 3.141592653589793]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZfrGWH4jDdVw"
      },
      "source": [
        "Accessing elements of a `list` is performed using `[]`. Rememeber that index of the first element of the list is `0`, which means that in order to access *n*th element of a `list` you have to pass *n-1* as an index:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VasgAUCNDdVw",
        "outputId": "7c287412-974a-4982-ca77-0825648916a8"
      },
      "source": [
        "print(my_list[0])\n",
        "print(my_list[1])\n",
        "print(my_list[2])\n",
        "print(my_list[3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "hello world\n",
            "True\n",
            "3.141592653589793\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "q3NQyBfbDdVw"
      },
      "source": [
        "You may also access elements from the end of an array by using negative indexing:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IAOcko2pDdVw",
        "outputId": "24c2e733-6d5d-4e0e-9ee4-eadc1edf7843"
      },
      "source": [
        "print(my_list[-1])\n",
        "print(my_list[-2])\n",
        "print(my_list[-3])\n",
        "print(my_list[-4])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3.141592653589793\n",
            "True\n",
            "hello world\n",
            "1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HRyEHwooDdVw"
      },
      "source": [
        "We may set an element in a `list` to a new value:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tx9G8rZYDdVw",
        "outputId": "70571648-836e-4d4d-e956-04425cb95cfa"
      },
      "source": [
        "my_list[-1] = 4\n",
        "print(my_list)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[1, 'hello world', True, 4]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "82v34mHkDdVw"
      },
      "source": [
        "`list`s may also be sliced and diced in many different ways. We can select a range from the list:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eeEuaWBKDdVw",
        "outputId": "16a684db-4d46-4aa3-edfd-b5c0961f2c62"
      },
      "source": [
        "my_list = ['problem','worthy','of','attack','proves','its','worth','by','fighting','back']\n",
        "print(my_list[3:6])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['attack', 'proves', 'its']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vTmp_xhADdVw"
      },
      "source": [
        "We may also select ranges without lower / upper boounds:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RQ47SFPjDdVw",
        "outputId": "a540a141-b337-47bf-cf45-d514423d9b6d"
      },
      "source": [
        "print(my_list[3:])\n",
        "print(my_list[:5])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['attack', 'proves', 'its', 'worth', 'by', 'fighting', 'back']\n",
            "['problem', 'worthy', 'of', 'attack', 'proves']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6EXV3yLbDdVx"
      },
      "source": [
        "You can select a step:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ba8A6xUVDdVx",
        "outputId": "7fa92e26-a74f-469f-ae28-bb1fc1aded47"
      },
      "source": [
        "my_list[::2]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['problem', 'of', 'proves', 'worth', 'fighting']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 169
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XR7QAQZ2DdVx"
      },
      "source": [
        "Reverse the order by setting negative step size:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KX0fZHm8DdVx",
        "outputId": "30735283-bac5-45fa-9558-b231506df73c"
      },
      "source": [
        "my_list[::-1]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['back',\n",
              " 'fighting',\n",
              " 'by',\n",
              " 'worth',\n",
              " 'its',\n",
              " 'proves',\n",
              " 'attack',\n",
              " 'of',\n",
              " 'worthy',\n",
              " 'problem']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 170
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mORCR5usDdVx"
      },
      "source": [
        "And combine these slicers in various ways:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DT3Dy7HcDdVx",
        "outputId": "e78f39a3-66eb-463a-eeeb-e8974e31fcd4"
      },
      "source": [
        "my_list[2:10:3]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['of', 'its', 'fighting']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 171
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G94c3MCoDdVx"
      },
      "source": [
        "Python gives us a few handy funcitons to generate lists of common spec, such as ordered numbers. We utilise `range()` numbers to do just that, just don't forget to wrap with a `list()` coercer to get an actual list back instead of `range`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p00NNINCDdVx",
        "outputId": "c9232ac0-2d59-4993-ac39-9b66bfcc5a22"
      },
      "source": [
        "range(10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "range(0, 10)"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 172
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1lk2CRs-DdVx"
      },
      "source": [
        "list(range(10))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rrNnP5a2DdVy"
      },
      "source": [
        "Conviniently, we can define a step as well:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TgvnnX2PDdVy"
      },
      "source": [
        "list(range(1,10,2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ttY34aJHDdVy"
      },
      "source": [
        "We can add elements to the end of the list via `append()` method:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GC9DHW27DdVy"
      },
      "source": [
        "my_list = list(range(0,10))\n",
        "my_list.append(25)\n",
        "my_list.append(25)\n",
        "print(my_list)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eB6mY8piDdVy"
      },
      "source": [
        "We may remove specific elements by calling `remove()` and supplying it with the value of an element we'd like to remove. Note that only the first instance of an element will be removed: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "029VRZ5wDdVy"
      },
      "source": [
        "my_list.remove(25)\n",
        "my_list.remove(my_list[5])\n",
        "print(my_list)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sOXM2VdiDdVy"
      },
      "source": [
        "Python lists are essential for many aspects of scientific computation; knowing how to manipulate data using Python lists is thus a very important skill to have in your toolbox. For a complete reference on methods available on Python `list`s refer to its documentation page. Common collection operations such as filtering, mapping and sorting are very convinient to execute using anonymous functions (lambdas): "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6vWAzI4wDdVy"
      },
      "source": [
        "list(filter(lambda x: x > 5, my_list))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5oOVkPtRDdVy"
      },
      "source": [
        "list(map(lambda x: x*2, my_list))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_-PE_TCjDdVy"
      },
      "source": [
        "sorted(my_list, reverse=True)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4-BC0iAZDdVy"
      },
      "source": [
        "### Tuples\n",
        "\n",
        "Tuples are conceptually similar to Lists, but they are immutable. This makes them much more efficient in some contexts (python knows they aren't going to be modified) and you'll quite often see functions and methods returning tuples rather than lists. The syntax for creating them is very similar to lists, but with parentheses"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HRdvCkaYDdVy",
        "outputId": "940daa7f-e474-43f6-862b-ec31b70db8a1"
      },
      "source": [
        "mytuple = (1, 3, 'BMI')\n",
        "mytuple"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(1, 3, 'BMI')"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 89
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3OazNNsmDdVy"
      },
      "source": [
        "## Dictionaries\n",
        "Python dictionaries are powerful abstractions that let us define key-value pairs. In other programming languages, such abstractions are also known as maps. We define dictionaries by using `{}` and separating keys and values by `,`. Elements can be accessed via `get()` method or via `[]` notation. Let's see some examples:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vISVQEuqDdVy"
      },
      "source": [
        "book = {\n",
        "    'authors': ['Michael Berthold', 'David J. Hand'],\n",
        "    'title': 'Intelligent Data Analysis',\n",
        "    'publisher': 'Springer',\n",
        "    'year': 2003\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U45JH5PIDdVz",
        "outputId": "b88e52e9-1b91-4b21-a503-ef1d037a5487"
      },
      "source": [
        "book['authors']"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['Michael Berthold', 'David J. Hand']"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 174
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xf-SZVVXDdVz",
        "outputId": "b22b3d56-b28c-42db-98b8-619cb690eef9"
      },
      "source": [
        "my_dict = {1:'one',2:'two',3:'three'}\n",
        "print(my_dict.get(1))\n",
        "print(my_dict[1])\n",
        "my_dict[4] = 'four'\n",
        "print(my_dict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "one\n",
            "one\n",
            "{1: 'one', 2: 'two', 3: 'three', 4: 'four'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_s1FI4BkDdVz"
      },
      "source": [
        "Since python is dynamically typed, we can define very convinient data structures. Let's see how we would define a dummy data-set of financial time-series:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oEcCzJ6jDdVz",
        "outputId": "4a4653ec-2a8c-47cf-9d52-3c30d5a6098c"
      },
      "source": [
        "my_dict = {\n",
        "    'ECG':[200,201,200.1,205],\n",
        "    'HR':[700,750,640,720],\n",
        "    'EMG':[900,850,920,910]\n",
        "}\n",
        "\n",
        "print (my_dict)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "{'ECG': [200, 201, 200.1, 205], 'HR': [700, 750, 640, 720], 'EMG': [900, 850, 920, 910]}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sliuCPm1DdVz"
      },
      "source": [
        "Here, each value corresponds to a list of dummy prices. As we go forth, we will see how powerful such data structures are."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-W9m9rMnDdVz"
      },
      "source": [
        "# Logic"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GECdUufkDdVz"
      },
      "source": [
        "Let us set `x` to the integer 10:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JmQLN1j0DdVz"
      },
      "source": [
        "x = 10"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oJM5y1NoDdVz"
      },
      "source": [
        "## Logical Operators"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ODlGj0IqDdVz",
        "outputId": "0b30f941-b976-4d07-8be5-b5b5a195de04"
      },
      "source": [
        "x < 10"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 181
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "emVLg-kHDdVz",
        "outputId": "35e5a74d-8a46-4c3f-a85d-916c17033333"
      },
      "source": [
        "type(x < 10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "bool"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 182
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jv9GrN3MDdVz"
      },
      "source": [
        "Different **boolean expressions** can be obtained by using different **comparison operators**, such as **less than**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tv2JqmZQDdVz",
        "outputId": "4c5bdeb3-ce61-4d6c-8a1f-ada2a417e917"
      },
      "source": [
        "x < 10"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 183
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qLnpdDjyDdVz"
      },
      "source": [
        "**less than or equals**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vHKu7CeTDdVz",
        "outputId": "ede38a86-6271-43c7-e8b8-22fe35cc738f"
      },
      "source": [
        "x <= 10"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 184
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kKctwtGIDdVz"
      },
      "source": [
        "**equals**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DnBJdHtPDdVz",
        "outputId": "5eea0bd4-fae7-460f-e41c-766a832bfe59"
      },
      "source": [
        "x == 10"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 185
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Edn3y-5_DdV0"
      },
      "source": [
        "**greater than or equals**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a33iiKX_DdV0",
        "outputId": "b90bbd95-b1e8-4d6d-f70e-3f617784b373"
      },
      "source": [
        "x >= 10"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 186
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zNvL1yeaDdV0"
      },
      "source": [
        "**greater than**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6zZcn__-DdV0",
        "outputId": "8387a9d1-5902-4dc0-8891-b7f016865d2d"
      },
      "source": [
        "x > 10"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 187
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wuTASs7MDdV0"
      },
      "source": [
        "And these **comparison operators** can be combined with **logical operators**, such as `not`, `and`, and `or`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n4bnM26nDdV0",
        "outputId": "c2695724-41cb-4a7f-a6ac-b2c56cceec87"
      },
      "source": [
        "(x <= 10) and (x % 2 == 1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 188
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z0hpZ4srDdV0",
        "outputId": "a9d346f7-81dd-4fe1-ed47-ce49cf5da9db"
      },
      "source": [
        "(x <= 10) or (x % 2 == 1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 189
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x0GQA-lWDdV0"
      },
      "source": [
        "We can also use the built-in function `all`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZYHqmbEuDdV0",
        "outputId": "cc850cd4-1a53-4791-f6c6-5e9b1d651890"
      },
      "source": [
        "all([x > 1, 5 <= x, 5 > 3, 7 != 1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 190
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LJcsVGc4DdV1"
      },
      "source": [
        "which is equivalent to"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8WCromRWDdV1",
        "outputId": "c784e41b-d517-422e-95b6-e781f1dc50d9"
      },
      "source": [
        "x > 1 and 5 <= x and 5 > 3 and 7 != 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 191
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nzHtLBroDdV7"
      },
      "source": [
        "Similarly,"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3xKjYaUGDdV7"
      },
      "source": [
        "all([x > 1, 5 <= x, x == 5, 5 > 3, 7 != 1])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3wXFj32RDdV7"
      },
      "source": [
        "is equivalent to"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j9poN8h7DdV7",
        "outputId": "284f0be4-9223-4799-a68c-0c1bd1b71cd2"
      },
      "source": [
        "x > 1 and 5 <= x and x == 5 and 5 > 3 and 7 != 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 192
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gkQ5McDoDdV7"
      },
      "source": [
        "Another builtin function, `any`, enables us to write"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9Q6AqWZMDdV7",
        "outputId": "a992b4e8-84d0-4fda-c388-a063dbb874e7"
      },
      "source": [
        "any([x > 1, 5 <= x, x == 5, 5 > 3, 7 != 1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 193
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9GS24FlmDdV8"
      },
      "source": [
        "which is somewhat more succinct and arguably more readable than the equivalent"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E6IA7eQxDdV8",
        "outputId": "abe84494-aa92-4648-bf51-676d66d00daa"
      },
      "source": [
        "x > 1 or 5 <= x or x == 5 or 5 > 3 or 7 != 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 194
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IxutRtOKDdV9"
      },
      "source": [
        "Each data type can also be evaluated to `True` or `False`. As a general rule, objects like `string` will evaluate to `False` if they do not contain anything and `True` otherwise:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M8t11VKDDdV9",
        "outputId": "f836735a-076c-4e12-9bd9-3c183141935b"
      },
      "source": [
        "print(bool())\n",
        "print(bool(''))\n",
        "print(bool(' '))\n",
        "print(bool(1))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False\n",
            "False\n",
            "True\n",
            "True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RBqRHwIYDdV9"
      },
      "source": [
        "# Functions\n",
        "\n",
        "Funcitons have a huge singinficance for promgrammers and data scientists alike. Functions allow us to describe a piece of logic that we can reuse in future. This lets us leverage power of computation and perform an arbitrary task on large sets of data. Functions are defined using `def` key-word and anonymous functions can be defined via `lambda` key-word. We use `return` to get a value from the function. We use `()` and pass corresponding parameters to run functions. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zW8HgOq6DdV9",
        "outputId": "5a3fcbaa-f0cc-4579-c345-a9acac90ee52"
      },
      "source": [
        "#function that does not return anything:\n",
        "def printer(a):\n",
        "    print(a)\n",
        "\n",
        "printer('hello world')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "hello world\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G6yXXmFoDdV9",
        "outputId": "af134768-e240-48a4-bee9-c88b78bf4d85"
      },
      "source": [
        "def area(length, width):\n",
        "    return length * width\n",
        "\n",
        "print(area(2,5))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "phpJb9RVDdV9",
        "outputId": "57ee2fa6-7bdc-4edc-bb05-27ee9a6168de"
      },
      "source": [
        "double = lambda x: x**2\n",
        "double(10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "100"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 232
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KBOCE9vHDdV9",
        "outputId": "c6398664-26b9-4ef3-9e7c-e19cc0a72a3d"
      },
      "source": [
        "type(area)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "function"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 234
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OVe_fOOsDdV-"
      },
      "source": [
        "type(double)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z7nnFs_MDdV-"
      },
      "source": [
        "# Ex #1: Create a function to add three numbers using def"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8iprvv6Fa7Xa",
        "outputId": "2f27e500-bbb1-4ebf-d864-847bc72b6e63"
      },
      "source": [
        "def sum_1(x, y,z):\n",
        "    return x+y+z\n",
        "\n",
        "print(sum_1(2,3,5))"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0m-o6BTuDdV-"
      },
      "source": [
        "# Ex #2: Create a function to add three numbers using lambda"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "K3MQX4uoa_gF",
        "outputId": "2369369f-75b2-4642-c223-20a3722d1b2c"
      },
      "source": [
        "sum_2 = lambda x,y,z: x+y+z\n",
        "sum_2(2,3,5)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n4uJ5l5uDdV-"
      },
      "source": [
        "## Flow of control\n",
        "\n",
        "We can control the flow of our programs using the basic logic operators and `if` statements. If statment executes if the boolean expression that it evaluates is `True` and `else` block will execute if the block is not `True`. Else-if or `elif` lets us set a specific boolean expression to evaluate if the base case is not `True`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VYi-MJULDdV-",
        "outputId": "bfaa9b8f-8933-421e-d7fb-2d8d83639ed3"
      },
      "source": [
        "#If-else statement skeleton\n",
        "if 'Condition':\n",
        "    #do something if the 'Condition' is True\n",
        "    print('in the if block')\n",
        "else:\n",
        "    #do something otherwise\n",
        "    print('in the else block')\n",
        "#note that 'Condition' will evaluate to True as it is a non-empty string"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "in the if block\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XWerm1bMDdV-",
        "outputId": "537a22b8-da98-499a-dbf6-cf1d1744bc24"
      },
      "source": [
        "a = 6\n",
        "if a == 6:\n",
        "    print('a is equal to 6')\n",
        "else: print ('Error')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a is equal to 6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7wiHFSC6DdV-"
      },
      "source": [
        "We can also have nested `if-else` statements:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BGtHw4XBDdV-",
        "outputId": "30a0d5ca-4cfc-4e08-8085-eabbbe0649be"
      },
      "source": [
        "a = 9\n",
        "\n",
        "if a % 2 == 0:\n",
        "    print('a is divisible by 2')\n",
        "    if a % 3 == 0:\n",
        "        print('a is divisible by 2 and 3')\n",
        "if a % 3 == 0:\n",
        "    print('a is divisible by 3')\n",
        "else:\n",
        "    print('a is devisible by neither 2 or 3')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "a is divisible by 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MbF1zEfUDdV-"
      },
      "source": [
        "We can use Pythonic syntactic sugar constructs such as `in` and `and` to check the membership of element/s in some structure. For example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OdZf8MtpDdV-",
        "outputId": "06ce39be-93a8-4bb7-b8b4-93aecf1fbc43"
      },
      "source": [
        "string = 'I love Python'\n",
        "if 'y' or 'z' in string:\n",
        "    print('This is my string!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This is my string!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WNeMQgKcDdV-"
      },
      "source": [
        "# Iteration\n",
        "It is an essential tool of any programmer to go through a collection of elements and perform operations on each of them. For a data scientist, this skill is ever so important across many stages of the process: data collection, cleaning and analysis.\n",
        "\n",
        "**Loops** allow us to repeat blocks of code multiple times. For example:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-F5QcV64DdV-"
      },
      "source": [
        "## While loop\n",
        "\n",
        "While loop is a basic loop that will execute if some condition is `True` and stops executing when the condition is `False`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wi3V6G4XDdV_",
        "outputId": "d839a989-2543-462d-d094-c5165dbc5245"
      },
      "source": [
        "a = True\n",
        "while a:\n",
        "    print('inside while loop')\n",
        "    a = False"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "inside while loop\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ENnwnQbHDdV_"
      },
      "source": [
        "Here is another example:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p6Lv29hTDdV_",
        "outputId": "803397cc-28ab-4e43-82eb-789d7b973db6"
      },
      "source": [
        "x = 0\n",
        "while x < 10:\n",
        "    print(x)\n",
        "    x = x + 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "awFRbydLDdV_"
      },
      "source": [
        "We start by setting the variable `x` to 0. We then repeat the indented **block**, consisting of the lines `print(x)` and `x = x + 1`, while the condition `x < 10` holds. The second line in this block, `x = x + 1`, keeps incrementing the variable `x` by 1, so eventually the condition `x < 10` will end up being false. Thus we get ten **iterations** of the loop. If we check the value of the variable `x` after we have left the loop, we find that it is"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JVathyAaDdV_",
        "outputId": "31284690-75cd-4bea-9d55-3e37b4ac0a8f"
      },
      "source": [
        "x"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 206
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EJjmFB2uDdV_"
      },
      "source": [
        "We can escape the loop by issuing a `break` command:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FIGuGb_GDdV_",
        "outputId": "401ba12e-49df-44d6-ebeb-5d2c6943db10"
      },
      "source": [
        "a = 0\n",
        "while True:\n",
        "    a += 1\n",
        "    print(a)\n",
        "    if a == 10:\n",
        "        break"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LIhzR5UWDdV_"
      },
      "source": [
        "## For loop\n",
        "\n",
        "For loop is one of the most convinient iteration techniques out there. We use for loops to iterate through lists, dictionaries, ranges and other data structures. Unlike `while` loop, `for` loop will by default go through every element in the list and perform a given task. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RYc3_XgdDdV_",
        "outputId": "e89a1214-240d-4048-edda-198732db468c"
      },
      "source": [
        "a = 0\n",
        "for i in range(10):\n",
        "    a += i\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "45\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UOSST5IqDdV_"
      },
      "source": [
        "There is more than one way to iterate through dictionaries:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7XzS4VVpDdV_"
      },
      "source": [
        "my_dict = {\n",
        "    'Systolic BP':[140,150,100,130],\n",
        "    'Diastolic BP':[90,80,82,80],\n",
        "    'Age':[70,75,64,30],\n",
        "    'BMI':[20,30,25,19]\n",
        "}"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pZAReNyeDdWA",
        "outputId": "d46530e4-b57c-40c9-9ac3-b21afdef6742"
      },
      "source": [
        "for i in my_dict:\n",
        "    print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Systolic BP\n",
            "Diastolic BP\n",
            "Age\n",
            "BMI\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_BcGRFncDdWA",
        "outputId": "9f732d0d-dc28-46b5-ebb3-13557c62d4cb"
      },
      "source": [
        "for (features, values) in my_dict.items():\n",
        "    print(features, values[0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Systolic BP 140\n",
            "Diastolic BP 90\n",
            "Age 70\n",
            "BMI 20\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VD9tnQ1wDdWA"
      },
      "source": [
        "Calling `items()` on dictionary gives access to features/keys and values:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "anvZMcZVDdWA",
        "outputId": "a5ff09cd-4622-458a-e28a-37cce18946ff"
      },
      "source": [
        "for k, v in my_dict.items():\n",
        "    print(k, v[1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Systolic BP 150\n",
            "Diastolic BP 80\n",
            "Age 75\n",
            "BMI 30\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5KuIflChDdWA",
        "outputId": "984a7925-5146-405f-d542-34c69c2ff9cb"
      },
      "source": [
        "my_dict['Age'] # retrieve values from a certain row"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[70, 75, 64, 30]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 244
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gav4WTOYDdWA",
        "outputId": "3717fc8a-b610-4498-8a72-7c4af0ce5020"
      },
      "source": [
        "my_dict['Age'][0] # treat output as a list"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "70"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 243
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "C9JME06DDdWA"
      },
      "source": [
        "# Question: How can we transpose my_dict?\n",
        "Hint: Time to learn about Pandas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XOFmpz_lDdWA"
      },
      "source": [
        "# Summary\n",
        "We are only scratching the surface of functions here and highlighting details of a programming skillset of a data scientist. Python has a wide array of other functionalities that make it useful beyond data science and mathematical computation.  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iutADVPkDdWA"
      },
      "source": [
        "# Recommendation\n",
        "\n",
        "To learn more about Python, you can check the Python documentation via this link: https://docs.python.org/3/\n",
        "\n",
        "If you are looking for a book with some examples:\n",
        "\n",
        "* Wes McKinney. *Python for Data Analysis*, 2nd Edition. O’Reilly Media, Inc., 2017. This book goes through the foundations of the Python programming language, the Jupyter environment, industry-standard Python libraries, especially Pandas, and applications to time series data.\n",
        "\n",
        "\n",
        "When you get error, or if you have a question, a great source is StackOverflow: https://stackoverflow.com/\n",
        "\n",
        "If you are using Python for data science, check out\n",
        "* https://www.kaggle.com/ (great for data science in general)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FS5vRFz4DdWA"
      },
      "source": [
        "# End \n",
        "This concludes the lecture / tutorial on Python programming for data science. Please be sure to ask any questions!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wLDXGxKVDdWA"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}