WSQ_Python_Programming_for_Finance_22_Oct_2022.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Topic 1 Introduction to Python Programming\n"
      ],
      "metadata": {
        "id": "oyATxq5q9Kae"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. You can run the notebook document sequentially (one cell at a time) by pressing **shift + enter**. \n",
        "2. While a cell is running, a [*] is shown on the left. After the cell is run, the output will appear on the next line."
      ],
      "metadata": {
        "id": "cKyqBKR38BRk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### What is programming?\n",
        "\n",
        "Programming is the way of telling a machine what to do. This machine might be your computer, smartphone, or tablet. The task might be something as simple as noting down today’s date or capturing information about the Earth’s atmosphere on a satellite. \n",
        "\n",
        "Programming has a lot of alias names and they’re used interchangeably. It goes by programming, developing, or coding all of which involves creating software that gets a machine to do what you want it to do."
      ],
      "metadata": {
        "id": "EXLwsExoUOeM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Introduction to Python programming\n",
        "Python places more weight on coding productivity and code readability. \n",
        "\n",
        "Python makes use of simple syntax which looks like written English. It talks with words andsentences, rather than characters. \n",
        "\n",
        "Python is a portable language. Python can be installed and run on any computer.\n",
        "\n",
        "The characteristics of Python programming are:"
      ],
      "metadata": {
        "id": "xnGgoc4PUtcD"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- Python is an interpretive language and Python codes run sequentially \n",
        "- Python syntax is case sensitive\n",
        "- There is no semicolon to indicate an end of the statement and therefore Python interprets the end of the line as the end of the statement.\n",
        "- Python is very sensitive to spacing in front\n",
        "- One more thing to keep in mind, the equal '=' sign used while assigning a value to a variable. It should not be read as 'equal to'. It should be read or interpreted as \"is set to\". "
      ],
      "metadata": {
        "id": "2xxkjPhsd80m"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Hello World program\n",
        "How would you make Python print \"Hello World\" for you? Well, it's never been this easy, just use the <b> print </b> command."
      ],
      "metadata": {
        "id": "pRrW9LSUTgHO"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N3DJ-DyMrkIl"
      },
      "source": [
        "print(\"Hello World!\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# You may try other variations\n",
        "print(\"I am new to programming!\")\n",
        "print(\"Python is cool!\")"
      ],
      "metadata": {
        "id": "TWRIvolLUaks"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Comment"
      ],
      "metadata": {
        "id": "Tq_2L2s3VfTj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# This is a single line comment\n",
        "print(\"Hello, World!\")"
      ],
      "metadata": {
        "id": "IzZ4Z0EgVlC2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "This is a comment\n",
        "written in\n",
        "more than just one line\n",
        "\"\"\"\n",
        "print(\"Hello, World!\")"
      ],
      "metadata": {
        "id": "EsbSrJvFVdfQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Acitivty\n",
        "\n",
        "Python coding is a lot of fun and is easy. Take this Python code for an example:"
      ],
      "metadata": {
        "id": "sgfwibEgXRTf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 2\n",
        "y = 3\n",
        "sum = x + y\n",
        "print(sum)"
      ],
      "metadata": {
        "id": "0-xz9Q2MXSgh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OEmvlnboxSSW"
      },
      "source": [
        "# Topic 2: Data Types and Operators"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Numbers"
      ],
      "metadata": {
        "id": "CETbY36XZ5uD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = 1\n",
        "print(x)      # This will print the new value of 'x' variable\n",
        "type(x)        # This will print the most updated data type of 'x'"
      ],
      "metadata": {
        "id": "s8bSgVWbZ88H"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = x + 1.11\n",
        "print(x)      # This will print the new value of 'x' variable\n",
        "type(x)        # This will print the most updated data type of 'x'"
      ],
      "metadata": {
        "id": "nRxCElP7Z4vY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Indentation"
      ],
      "metadata": {
        "id": "-0_ZXKMKaaCw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Python forces you to follow proper indentation. The number of spaces in indentation can be different, but all lines of code within the same block should have the same number of spaces in the indentation.\n",
        "\n",
        "For example, the 3rd line of the code in the cell below shows incorrect indentation. Try running the code to see the error that it throws."
      ],
      "metadata": {
        "id": "IjikTjx9fGGU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Python Program to calculate the square of number\n",
        "num = 8\n",
        "   num_sq = num ** 2\n",
        "print (num_sq)"
      ],
      "metadata": {
        "id": "bhOQskP7fIx5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# On removing the indent\n",
        "num = 8\n",
        "num_sq = num ** 2\n",
        "print(num_sq)"
      ],
      "metadata": {
        "id": "i7G03JPRfLl3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q5lHdI5arvKl"
      },
      "source": [
        "a = 1\n",
        "b = 2\n",
        "#     print(a+b)  \n",
        "print(a+b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "etQse5It4ycS"
      },
      "source": [
        "#### Multiple Assignment"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9ZFm4ooUwG_L"
      },
      "source": [
        "a,b=1,2\n",
        "a,b = b,a+b\n",
        "print('a = ',a)\n",
        "print('b = ',b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a,b = 1,2\n",
        "a = b\n",
        "b = a +b\n",
        "print('a = ',a)\n",
        "print('b = ',b)"
      ],
      "metadata": {
        "id": "EyS2MEMwBqG8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dvYPFeIS5Ec6"
      },
      "source": [
        "#### Formatting Numbers using \"format\""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TgzmToLqu-Bs"
      },
      "source": [
        "# To print in a formatted way\n",
        "a = 1\n",
        "b = 2\n",
        "print(\"{}+{}={}\".format(a,b,a+b))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VdtXOK6Bz7kt"
      },
      "source": [
        "# To format the decimal places\n",
        "a = 1.222\n",
        "b = 2.333\n",
        "print(\"{:0.1f}+{:0.1f}={:0.1f}\".format(a,b,a+b))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5mXehutK5JqK"
      },
      "source": [
        "# To arrange the location\n",
        "\n",
        "a = 1.222\n",
        "b = 2.333\n",
        "print(\"{1:0.1f}+{0:0.1f}={2:0.1f}\".format(a,b,a+b))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Formatting Numbers Using String Literals"
      ],
      "metadata": {
        "id": "kZdeDZBFbVnb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# To print in a formatted way\n",
        "a = 1\n",
        "b = 2\n",
        "print(f\"{a}+{b}={a+b}\")"
      ],
      "metadata": {
        "id": "7QahJthEbd8B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# To format the decimal places\n",
        "a = 1.222\n",
        "b = 2.333\n",
        "print(f\"{a:0.1f}+{b:0.1f}={a+b:0.1f}\")"
      ],
      "metadata": {
        "id": "YTy4wx0pcQ9l"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# To arrange the location\n",
        "a = 1.222\n",
        "b = 2.333\n",
        "print(f\"{b:0.1f}+{a:0.1f}={a+b:0.1f}\")"
      ],
      "metadata": {
        "id": "hLZsKpHncwJo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Format Numbers\n",
        "\n",
        "a = 4.444\n",
        "\n",
        "b = 5.555\n",
        "\n",
        "c = 6.6666\n",
        "\n",
        "d = a + b +c\n",
        "\n",
        "Use string literals method to format the output as shown below\n",
        "5.55 + 6.67 + 4.4 = 17\n"
      ],
      "metadata": {
        "id": "R50d8uJMdIOc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 4.444\n",
        "b = 5.555\n",
        "c = 6.6666\n",
        "d = a + b +c\n",
        "\n",
        "print(________________)"
      ],
      "metadata": {
        "id": "uSvYLgIzdXy3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Format Numbers"
      ],
      "metadata": {
        "id": "LQArZVDvdclV"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "08q59OEQ0gMO"
      },
      "source": [
        "a = 4.444\n",
        "b = 5.555\n",
        "c = 6.6666\n",
        "d = a + b +c\n",
        "\n",
        "print(f\"{b:0.2f}+{c:0.2f}+{a:0.1f}={a+b+c:0.0f}\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Multiline Statements"
      ],
      "metadata": {
        "id": "vGgCxJdIe0tf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "biology_marks = 82\n",
        "physics_marks = 91\n",
        "maths_marks = 96\n",
        "chemistry_marks = 88\n",
        "total_marks = biology_marks + physics_marks + maths_marks + chemistry_marks\n",
        "print (total_marks)"
      ],
      "metadata": {
        "id": "qwa8W5oOeRoV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If a line is too long, the code can be made readable by adding a split, to a single line of code and convert them into multiple lines. In such scenarios, use backward slash as line continuation character to specify that the line should continue."
      ],
      "metadata": {
        "id": "T3kqGaCbeY1R"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "total_marks = biology_marks + \\\n",
        "    physics_marks + \\\n",
        "    maths_marks + \\\n",
        "    chemistry_marks\n",
        "\n",
        "print(total_marks)"
      ],
      "metadata": {
        "id": "yhr5aWfeeU0m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vDxFXHUP6Lyz"
      },
      "source": [
        "**bold text**### Strings"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Python support single and double quotes. But the quotation has to be consistent."
      ],
      "metadata": {
        "id": "24ReSDjzgFB6"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NZOU8r8_2AGQ"
      },
      "source": [
        "# Concatenate two strings\n",
        "\n",
        "a = 'Hello'\n",
        "b = \" World\"\n",
        "print(a+b)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5gT_42iA25IM"
      },
      "source": [
        "# Change the casing in string\n",
        "\n",
        "a = \"Hello\".upper()\n",
        "print(a)\n",
        "b = \" World\".lower()\n",
        "print(b)\n",
        "print(a+b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Strings"
      ],
      "metadata": {
        "id": "APT3RKVHg-w8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 'Hello'\n",
        "b = \" World\"\n",
        "print(a+b)"
      ],
      "metadata": {
        "id": "d8jLtxhKHrPc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### String Methods"
      ],
      "metadata": {
        "id": "9SJdHF_DH5Eq"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gGUdjxWQ3OdK"
      },
      "source": [
        "a = \"The GST is 7%\" \n",
        "b = a.replace(\"GST\",\"Good and Service Tax\")\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Formatting Strings"
      ],
      "metadata": {
        "id": "HASZLn6ShCI1"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1WOWaSfm3ina"
      },
      "source": [
        "# Method 1: format\n",
        "b =\"budget\"\n",
        "print(\"A {} is a quantitative plan for acquiring and using resources over a specified period\".format(b))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Method 2: String literals\n",
        "b =\"budget\"\n",
        "print(f\"A {b} is a quantitative plan for acquiring and using resources over a specified period\")"
      ],
      "metadata": {
        "id": "U1vH32izhJqE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Format String\n",
        "\n",
        "bs =\"balance sheet\"\n",
        "income =\"income statement\"\n",
        "\n",
        "Print the following output using string literals method\n",
        "\n",
        "\"The finance statements typically require Balance sheet and INCOME STATEMENT.\"\n"
      ],
      "metadata": {
        "id": "xLJGuv-Lhr_B"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZfDCRQqH4Ayk"
      },
      "source": [
        "bs =\"balance sheet\"\n",
        "income =\"income statement\"\n",
        "\n",
        "print(__________________)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Format String"
      ],
      "metadata": {
        "id": "tWa6yWAFid5L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "bs =\"balance sheet\"\n",
        "income =\"income statement\"\n",
        "\n",
        "print(f\"The finance statements typically require {bs.capitalize()} and {income.upper()}.\")"
      ],
      "metadata": {
        "id": "m7sY9927h1tr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Strip Whitespace"
      ],
      "metadata": {
        "id": "OZss5Z1_ikcd"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J5EzOvKm5jvm"
      },
      "source": [
        "# Remove the spacing in string\n",
        "\n",
        "a = \"         Hello\".strip()\n",
        "b = \" World\"\n",
        "print(a+b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Split and Join Strings "
      ],
      "metadata": {
        "id": "XOU83roHipVO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 'Asset is the sum of Liability and Equity. '\n",
        "b = a.split()\n",
        "print(b)\n",
        "\n",
        "a = 'Asset = Liability + Equity '\n",
        "b = a.split(\"=\")\n",
        "print(b)\n",
        "\n",
        "c = \" = \".join(b)\n",
        "print(c)\n"
      ],
      "metadata": {
        "id": "o77nF-liiwS4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Split and Join String\n",
        "\n",
        "Given email = 'finance@company.com'\n",
        "\n",
        "- separate the user name and domain name\n",
        "- join back the username and domain name with a '/'\n"
      ],
      "metadata": {
        "id": "n2wwQAXdjStn"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T0GJJDsz7wP9"
      },
      "source": [
        "email = 'finance@company.com'\n",
        "\n",
        "b = email.__________\n",
        "print(b)\n",
        "c = \"/\".__________\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Split and Join String"
      ],
      "metadata": {
        "id": "xf0-k2B-jxg5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "email = 'finance@company.com'\n",
        "\n",
        "b = email.split(\"@\")\n",
        "print(b)\n",
        "c = \"/\".join(b)\n",
        "print(c)"
      ],
      "metadata": {
        "id": "mWpuVxv3jkIN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_qyZdCtQEo37"
      },
      "source": [
        "### Lists\n",
        "\n",
        "Lists in Python, are used to store heterogeneous types of data. Lists are mutable i.e. one can change the content within a list, without changing its identity.\n",
        "\n",
        "\n",
        "List is enclosed by square brackets and elements should be separated by a comma."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Creating lists"
      ],
      "metadata": {
        "id": "oHQVPZo0PN51"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hiMCUdZP8R5o"
      },
      "source": [
        "new_list = []  # Empty List\n",
        "print(new_list)\n",
        "type(new_list)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "new_list = [10, 20, 30, 40]  # A list of integers\n",
        "print(new_list)\n",
        "type(new_list)"
      ],
      "metadata": {
        "id": "07hkec4RlHP5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "new_list = [10, 20.2, \"thirty\", 40]  # A list of mixed data types\n",
        "print(new_list)\n",
        "type(new_list)"
      ],
      "metadata": {
        "id": "cp-lb2pQlJqr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "new_list = [[10, 20, 30], [10.1, 20.2, 30.3], [\n",
        "    \"ten\", \"twenty\", \"thirty\"]]  # A nested list\n",
        "print(new_list)\n",
        "type(new_list)"
      ],
      "metadata": {
        "id": "5OL1dZ1glLJx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "new_list = [10, [20.2, [\"thirty\", [40]]]]  # A deeply nested list\n",
        "print(new_list)\n",
        "type(new_list)"
      ],
      "metadata": {
        "id": "0JNOFvLFlMnp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Slicing List"
      ],
      "metadata": {
        "id": "20xoLCFUlaZp"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VIW7Dx1S9Rm3"
      },
      "source": [
        "a = [7,8,9,10,11] \n",
        "a[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t23bRsO79YZ7"
      },
      "source": [
        "a = [7,8,9,10,11] \n",
        "a[2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P7WLjY1e9aZ-"
      },
      "source": [
        "a = [7,8,9,10,11] \n",
        "a[0:3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "twjcEeie9pXq"
      },
      "source": [
        "a = [7,8,9,10,11] \n",
        "a[2:4]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XOLWx-pu9sw1"
      },
      "source": [
        "a = [7,8,9,10,11] \n",
        "a[-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h3DWXUCi90cz"
      },
      "source": [
        "a = [7,8,9,10,11] \n",
        "a[-2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [7,8,9,10,11] \n",
        "a[:]"
      ],
      "metadata": {
        "id": "V_eHCySzlsfN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [7,8,9,10,11] \n",
        "a[0:4:2]"
      ],
      "metadata": {
        "id": "ajRb33PIlu_z"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### List Methods\n",
        "Let us have a look at few of the methods, with which we can manipulate lists.\n",
        "\n",
        "Please Note: A function or a method is a block of code which is used to perform a single task or a set of tasks repeatedly."
      ],
      "metadata": {
        "id": "Iqla4cm5mp33"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "list.<b>index</b> (x) <br>\n",
        "It returns a zero-based index in the list of the first item whose value is x. Raises an error of there is no such item as 'x'."
      ],
      "metadata": {
        "id": "GNa577kcmXis"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MRYZ4_-U9243"
      },
      "source": [
        "a = ['equity','liability','asset','expense','income']\n",
        "\n",
        "a.index('expense')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "list.<b>append</b> (x) <br>\n",
        "Add an item to the end of the list"
      ],
      "metadata": {
        "id": "te8dc_MxmwNt"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LPcuEu0r99Vp"
      },
      "source": [
        "a = ['equity','liability','asset','expense','income']\n",
        "a.append('revenue')\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "list.<b>extend</b> (x) <br>\n",
        "Extend the list by appending all the items at the end of the list."
      ],
      "metadata": {
        "id": "77k_yymdnPkv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = ['equity','liability','asset','expense','income']\n",
        "b = ['cash flow', 'budget']\n",
        "b.extend(a)\n",
        "b"
      ],
      "metadata": {
        "id": "cHKrO5fnnSZV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "list.<b>insert</b> (i,x) <br>\n",
        "Insert an item at any given position within the list. The first argument 'i', is the index of the item before which you want to insert something. "
      ],
      "metadata": {
        "id": "vjFn__ShoaMb"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dGPj0R8T-Cfn"
      },
      "source": [
        "# To insert something at the beginning of the list, you may type list.insert (0,x)\n",
        "a = ['equity','liability','asset','expense','income']\n",
        "a.insert(0,'budget')\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Inserting an item at the 2th position in a list\n",
        "\n",
        "a = ['equity','liability','asset','expense','income']\n",
        "a.insert(2,'budget')\n",
        "a\n"
      ],
      "metadata": {
        "id": "clzPfrVapbqx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "list.<b>remove</b> (x)<br>\n",
        "Remove the first item from the list whose value is 'x'. It is an error if there is no such item."
      ],
      "metadata": {
        "id": "GpviUAbQpuw5"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RRtnt1LQ-SuG"
      },
      "source": [
        "a = ['budget','equity','liability','asset','expense','income']\n",
        "a.remove('budget')\n",
        "a\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = ['budget','equity','liability','asset','expense','income']\n",
        "a.remove('asset')\n",
        "a"
      ],
      "metadata": {
        "id": "d3qbbPjFp7dX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "list.<b>pop</b> (i) <br>\n",
        "Remove any item from any given position (index) in the list. If no index is specified, it removes and returns the last element from the list."
      ],
      "metadata": {
        "id": "H4REC21NqVDM"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OTlBEes2-Xwz"
      },
      "source": [
        "a = ['budget','equity','liability','asset','expense','income']\n",
        "a.pop()\n",
        "a\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bAECnvVQ-Y7P"
      },
      "source": [
        "a = ['budget','equity','liability','asset','expense','income']\n",
        "a.pop(2)\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "list.<b>count</b> (x) <br>\n",
        "Returns the number of times 'x' appears in the list"
      ],
      "metadata": {
        "id": "KuliSaxzrO8d"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = ['equity','budget','equity','liability','asset','equity','expense','income']\n",
        "a.count('equity')"
      ],
      "metadata": {
        "id": "dV28o3xwylbs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "list.<b>reverse</b> () <br>\n",
        "It reverses the items of the list."
      ],
      "metadata": {
        "id": "EGAE7q1DrvaS"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n-1xkskr-hej"
      },
      "source": [
        "a = ['budget','equity','liability','asset','expense','income']\n",
        "a.reverse()\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "list.<b>sort</b> () <br>\n",
        "It sorts the items in the list."
      ],
      "metadata": {
        "id": "zwQAwWNfsH61"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = ['budget','equity','liability','asset','expense','income']\n",
        "a.sort()\n",
        "a"
      ],
      "metadata": {
        "id": "4lzGjQvSsLcy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "list.<b>copy</b> () <br>\n",
        "It duplicate another list."
      ],
      "metadata": {
        "id": "T8bm83HYs_ND"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A-LMFkcC-tmt"
      },
      "source": [
        "a = ['equity','liability','asset','expense','income']\n",
        "b = a.copy()\n",
        "b.pop()\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SMsPXOmb-wyY"
      },
      "source": [
        "c = a \n",
        "c.pop()\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: List\n",
        "\n",
        "years =['2017,'2018','2020','2021']\n",
        "\n",
        "- copy from original years to years2\n",
        "- remove 2021 in years2\n",
        "- insert '2019' in location 2 in years2\n",
        "- reverse the order of years2\n"
      ],
      "metadata": {
        "id": "9DqneCTmuIZg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "y1 =['2017','2018','2020','2021']\n",
        "\n",
        "y2 = ___________\n",
        "y2._____________\n",
        "y2.______________________\n",
        "y2"
      ],
      "metadata": {
        "id": "eshLLS6QuNIg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: List"
      ],
      "metadata": {
        "id": "cbZ7zoFFuNwf"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TjQgGNUm_Tgy"
      },
      "source": [
        "y1 =['2017','2018','2020','2021']\n",
        "\n",
        "y2 = y1.copy()\n",
        "y2.remove('2021')\n",
        "y2.insert(2,'2019')\n",
        "y2.revers()\n",
        "y2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UKAO7EvLC88s"
      },
      "source": [
        "### Tuple\n",
        "\n",
        "Tuple is an immutable list. Similar to lists a tuple can contain a heterogeneous sequence of elements but it is not possible to append, edit or remove any individual elements within a tuple."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Creating Tuple"
      ],
      "metadata": {
        "id": "ZFBgprPPTo6Z"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "new_tup = ()  # Empty Tuple\n",
        "print(new_tup)\n",
        "type(new_tup)"
      ],
      "metadata": {
        "id": "Y4QS8EGpu9rg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "new_tup = (10, 20, 30, 40)  # A tuple of integers\n",
        "print(new_tup)\n",
        "type(new_tup)"
      ],
      "metadata": {
        "id": "57gKvCrEvAD7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "new_tup = (10, 20.2, 'thirty', 40)  # A tuple of mixed data type\n",
        "print(new_tup)\n",
        "type(new_tup)"
      ],
      "metadata": {
        "id": "2as_Ka5rvBqo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "new_tup = ((10, 20, 30), (10.1, 20.2, 30.3),\n",
        "           (\"ten\", \"twenty\", \"thirty\"))  # A nested tuple\n",
        "type(new_tup)"
      ],
      "metadata": {
        "id": "1fy4Z004vDq7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "new_tup = (10, (20.2, (\"thirty\", (40))))  # A deeply nested tuple\n",
        "print(new_tup)\n",
        "type(new_tup)"
      ],
      "metadata": {
        "id": "bSyVnIrNvFev"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Slicing Tuples"
      ],
      "metadata": {
        "id": "dzESCme1utHW"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bEsfonrsDFj3"
      },
      "source": [
        "a = ('equity','liability','asset','expense','income')\n",
        "a[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "chGMeYTWDG1P"
      },
      "source": [
        "a = ('equity','liability','asset','expense','income')\n",
        "a[1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QifhJaM2DIBK"
      },
      "source": [
        "a = ('equity','liability','asset','expense','income')\n",
        "a[-1]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = ('equity','liability','asset','expense','income')\n",
        "a[0:2]"
      ],
      "metadata": {
        "id": "46JVosOevZlW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Tuple vs List"
      ],
      "metadata": {
        "id": "W4MnYgbKPxp2"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qsQOHoh5SP33"
      },
      "source": [
        "b = ['equity','liability','asset','expense','income']\n",
        "b.append('budget')\n",
        "print(f\"The list is {b}\")\n",
        "a = ('equity','liability','asset','expense','income')\n",
        "a.append('budget')\n",
        "print(f\"The tuple is {a}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f_8W2mUCEEUa"
      },
      "source": [
        "### Dictionary\n",
        "\n",
        "A dictionary is generally used for mapping. Similarly, a dictionary in Python also has a mapping between its “Key” and “Value” pairs. You can access the dictionary using ‘keys’ to get the information or ‘value’ stored within these ‘keys’."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Creating dictionaries\n",
        "\n",
        "Dictionaries are enclosed in brace brackets and the key: value pair should be separated by a comma."
      ],
      "metadata": {
        "id": "rdLJUjXXxZH2"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5xH4p4NgDJDF"
      },
      "source": [
        "new_dict = {}  # Empty Dictionary\n",
        "print(new_dict)\n",
        "type(new_dict)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a new dictionary\n",
        "\n",
        "revenue = {'2017': '1.3M', '2018': '2.2M', '2019': '3.5M'}\n",
        "print(revenue)\n",
        "type(revenue)"
      ],
      "metadata": {
        "id": "x64VhjwaxfFE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Accessing Dictionary Value"
      ],
      "metadata": {
        "id": "VPyTb4cjSNzD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Printing multiple values of various keys\n",
        "\n",
        "revenue = {'2017': '1.3M', '2018': '2.2M', '2019': '3.5M'}\n",
        "revenue['2017'], revenue['2019']"
      ],
      "metadata": {
        "id": "bloKUjPGyE7c"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Dictionary Methods\n",
        "\n",
        "Let us have a look at the few functions for accessing or manipulating dictionaries."
      ],
      "metadata": {
        "id": "UJywqAYtx5Ag"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<b>len (x_dict)</b> <br>\n",
        "To know the number of key: value pairs in the dictionary."
      ],
      "metadata": {
        "id": "QS5hSK5jx91j"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fJJik_moEReQ"
      },
      "source": [
        "revenue = {'2017': '1.3M', '2018': '2.2M', '2019': '3.5M'}\n",
        "len(revenue)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<b>x_dict.keys ( )</b> <br>\n",
        "Returns all the 'keys' of dictionaries"
      ],
      "metadata": {
        "id": "BkVC7v3gzC6r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "revenue = {'2017': '1.3M', '2018': '2.2M', '2019': '3.5M'}\n",
        "revenue.keys()"
      ],
      "metadata": {
        "id": "tTwqbaWezERF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<b>x_dict.values ( )</b> <br>\n",
        "Returns all the 'values' of dictionaries"
      ],
      "metadata": {
        "id": "xFIVZVEIzWVV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "revenue = {'2017': '1.3M', '2018': '2.2M', '2019': '3.5M'}\n",
        "revenue.values()"
      ],
      "metadata": {
        "id": "I1ZLOMwazYIG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The <b>del</b> statement <br>\n",
        "It is used for deleting any keys from the dictionary."
      ],
      "metadata": {
        "id": "LWF1XhJBzpqb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "revenue = {'2017': '1.3M', '2018': '2.2M', '2019': '3.5M'}\n",
        "del revenue['2017']\n",
        "revenue"
      ],
      "metadata": {
        "id": "I9_o2ASJzxiW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "x_dict.<b>pop (key) </b> <br>\n",
        "It will pop a 'value' of the reqired key and remove the key\n"
      ],
      "metadata": {
        "id": "baNBOfkY0Gfn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "revenue = {'2017': '1.3M', '2018': '2.2M', '2019': '3.5M'}\n",
        "print(revenue.pop('2018'))\n",
        "revenue"
      ],
      "metadata": {
        "id": "22KR0D8Y0Led"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g6g6fh8fEjjG"
      },
      "source": [
        "### Set\n",
        "\n",
        "A set is an unordered collection with no duplicate elements. They are useful to create lists that hold only unique values and are also mutable. The elements of a set can be anything like numbers, strings or characters."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Creating Sets"
      ],
      "metadata": {
        "id": "J22SQb9oT2dg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "new_set = {}  # Empty Set ---> An empty set cannot be created\n",
        "print(new_set)\n",
        "type(new_set)"
      ],
      "metadata": {
        "id": "Wiz96Swe06wL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "new_set = {'equity','liability','asset','expense','income'} # A new set\n",
        "print(new_set)\n",
        "type(new_set)"
      ],
      "metadata": {
        "id": "r9_Z7O0o0_gP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Now there are 2 'equity' in our set. What will happen if we print this set?\n",
        "\n",
        "new_set = {'equity','liability','easset','expense','income','equity'} \n",
        "\n",
        "print(new_set)  # The set will only print unique values"
      ],
      "metadata": {
        "id": "exv-Uy_S1Nws"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Set Methods\n",
        "\n",
        "You can even perform mathematical operations like set union, set intersection, set difference and symmetric difference amongst different datasets."
      ],
      "metadata": {
        "id": "fE__9U111xhx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "<b> x.union(y) </b> <br>\n",
        "This method returns all the unique items that are present in the two sets, as a new set."
      ],
      "metadata": {
        "id": "TOzwZ32y15BB"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gQq_3eo-ET5T"
      },
      "source": [
        "a = {'equity','liability','asset'}\n",
        "b = {'asset','expense','income'}\n",
        "a.union(b)\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<b> x.intersection(y) </b> <br>\n",
        "This method returns the common items that are present in two sets, as a new set."
      ],
      "metadata": {
        "id": "dge6DmbT2Vx1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = {'equity','liability','asset'}\n",
        "b = {'asset','expense','income'}\n",
        "a.intersection(b)"
      ],
      "metadata": {
        "id": "ZspSJJ-12eGf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<b> x.difference(y) </b> <br>\n",
        "This method returns the items of 'set 1' which are not common (repetitive) to the 'set 2', as a new set. "
      ],
      "metadata": {
        "id": "5IDl8hxW2yWx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = {'equity','liability','asset'}\n",
        "b = {'asset','expense','income'}\n",
        "a.difference(b)"
      ],
      "metadata": {
        "id": "F5rp8VVX2shb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<b>y.issubset(x)</b> <br>\n",
        "This method returns True for 'Set 2', if all the elements of 'Set 2' are present in 'Set 1'"
      ],
      "metadata": {
        "id": "Hgh9tYhV2rF3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = {'equity','liability','asset'}\n",
        "b = {'asset'}\n",
        "b.issubset(a)"
      ],
      "metadata": {
        "id": "2CJ9yr6D3JsR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "<b>x.issuperset(y)</b><br>\n",
        "This method returns True for 'Set 1' if all the elements of Set 2 are present in 'Set 1'. "
      ],
      "metadata": {
        "id": "EfVjfsEh3b_B"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = {'equity','liability','asset'}\n",
        "b = {'equity','liability','asset','expense','income','equity'} \n",
        "b.issuperset(a)"
      ],
      "metadata": {
        "id": "wiJ54C-13eOt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Set\n",
        "\n",
        "sent = \"A budget is a quantitative plan for acquiring and using resources over a specified period.\"\n",
        "\n",
        "Find out the number of unique vocabulary in this sentence\n"
      ],
      "metadata": {
        "id": "17sSPk1e33JK"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U12NnuF0E9sH"
      },
      "source": [
        "sent = \"A budget is a quantitative plan for acquiring and using resources over a specified period.\"\n",
        "\n",
        "words = ____________\n",
        "vocab = ______________\n",
        "len(vocab)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Set"
      ],
      "metadata": {
        "id": "qqzsv9IU4MzN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "sent = \"A budget is a quantitative plan for acquiring and using resources over a specified period.\"\n",
        "\n",
        "words = sent.split()\n",
        "vocab = set(words)\n",
        "len(vocab)"
      ],
      "metadata": {
        "id": "q8qSJN2m4Idl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jQrXptZkRcfP"
      },
      "source": [
        "### Operators\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jgIAr5NiF_VO"
      },
      "source": [
        "# Arithmetic Operators\n",
        "\n",
        "7%3"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iQHQz6sDRiQk"
      },
      "source": [
        "# Compound Operators\n",
        "\n",
        "a = 1\n",
        "#a = a + 2\n",
        "a += 2\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FpV67dCNR8Nr"
      },
      "source": [
        "# Comparison Operators\n",
        "3>2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sLs1uR3pSMDO"
      },
      "source": [
        "3==2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uqQt2iCpSPbZ"
      },
      "source": [
        "3!=2"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wn7cUuHoSWrv"
      },
      "source": [
        "# Membership Operators\n",
        "\n",
        "a = ['equity','liability','asset','expense','income']\n",
        "'asset' in a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Z1bsWkiSgN8"
      },
      "source": [
        "'property' in a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YRJRZH3uSjAQ"
      },
      "source": [
        "# Logical Operators\n",
        "\n",
        "True or False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CoymIqjoSr_s"
      },
      "source": [
        "True and False"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Activity: Operator\n",
        "\n",
        "a = 1; b = 2;\n",
        "\n",
        "What is  (a == 1) and not(b > 3) ?\n"
      ],
      "metadata": {
        "id": "EVrgSyea4gKy"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ns83RqGaSvai"
      },
      "source": [
        "a = 1; b = 2;\n",
        "(_________) and not(______)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Solution: Operator"
      ],
      "metadata": {
        "id": "MVrryjLZ4s7Q"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 1; b = 2;\n",
        "(a == 1) and not(b > 3)"
      ],
      "metadata": {
        "id": "625ushFz4nxM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vOmj5r0XU4uu"
      },
      "source": [
        "# Topic 3 Problem Solving with Control Structures"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "98b0URw3V-Uz"
      },
      "source": [
        "### If and elif\n",
        "\n",
        "In python, the syntax for an ‘if' conditional statement is as follows:\n",
        "\n",
        "<pre>if (condition_1):<br>\n",
        "    statement_block_1<br>\n",
        "elif (condition_2):<br>\n",
        "    statement_block_2<br>\n",
        "elif (condition_3):<br>\n",
        "    statement_block_3<br></pre>\n",
        "<br>\n",
        "Let us consider an example to understand the working of an 'if' statement.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eE9WZsbQUlMa"
      },
      "source": [
        "stock_price_ABC = 299  # Variable value\n",
        "\n",
        "if (stock_price_ABC < 300):  # if condition_1 is true then...\n",
        "    # statement_block_1 will get executed\n",
        "    print(\"We will buy 500 shares of ABC\")\n",
        "\n",
        "elif (stock_price_ABC == 300):\n",
        "    print(\"We will buy 200 shares of ABC\")\n",
        "\n",
        "elif (stock_price_ABC > 300):\n",
        "    print(\"We will buy 150 shares of ABC\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you change the value of the variable 'stock_price_ABC' to..."
      ],
      "metadata": {
        "id": "ejuBDF2r5jro"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock_price_ABC = 300  # then...\n",
        "\n",
        "if (stock_price_ABC < 300):\n",
        "    print(\"We will buy 500 shares of ABC\")\n",
        "\n",
        "elif (stock_price_ABC == 300):  # if condition_2 is true then...\n",
        "    # statement_block_2 will get executed\n",
        "    print(\"We will buy 200 shares of ABC\")\n",
        "\n",
        "elif (stock_price_ABC > 300):\n",
        "    print(\"We will buy 150 shares of ABC\")"
      ],
      "metadata": {
        "id": "_eFUxgDb5mE0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you change the value of the variable 'stock_price_ABC' to..."
      ],
      "metadata": {
        "id": "_k3YiN866J_e"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock_price_ABC = 301  # then...\n",
        "\n",
        "if (stock_price_ABC < 300):\n",
        "    print(\"We will buy 500 shares of ABC\")\n",
        "\n",
        "elif (stock_price_ABC == 300):\n",
        "    print(\"We will buy 200 shares of ABC\")\n",
        "\n",
        "elif (stock_price_ABC > 300):  # if condition_3 is true then...\n",
        "    # statement_block_3 will get executed\n",
        "    print(\"We will buy 150 shares of ABC\")"
      ],
      "metadata": {
        "id": "xy5aFLYD6IJt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### If and else \n",
        "\n",
        "If - else block of conditional statements is similar to the working of 'if' statements. If the 'if' condition is <b>true</b>, then the statements inside the 'if' block will be executed. If the 'if' condition is <b> false</b>, then the statements inside the 'else' block will be executed. \n",
        "\n",
        "In Python, the syntax for an ‘if else' conditional statement is as follows:\n",
        "\n",
        "<pre>if (condition_1):<br>\n",
        "    statement_block_1<br>\n",
        "else:<br>\n",
        "    statement_block_2<br></pre>\n",
        "<br>\n",
        "Let us consider an example to understand the working of an 'if else' statement."
      ],
      "metadata": {
        "id": "dL_ERqxr7AEx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock_price_ABC = 300\n",
        "\n",
        "if (stock_price_ABC > 250):  # if condition 1 is true then....\n",
        "    # this block of code will be executed\n",
        "    print(\"We will sell the stock and book the profit\")\n",
        "\n",
        "else:\n",
        "    print(\"We will keep buying the stock\")"
      ],
      "metadata": {
        "id": "pEOY95iy7IHJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "If you change the value of the variable 'stock_price_ABC' to..."
      ],
      "metadata": {
        "id": "wnrxrLm57daG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock_price_ABC = 200  # then...\n",
        "\n",
        "if (stock_price_ABC > 250):  # if condition 1 is false then....\n",
        "    print(\"We will sell the stock and book the profit\")\n",
        "\n",
        "else:\n",
        "    # this block of code will be executed\n",
        "    print(\" We will keep buying the stock\")"
      ],
      "metadata": {
        "id": "IyfjjwGN7fR_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Activity: Conditional\n",
        "\n",
        "income = input('What is your income?' )\n",
        "\n",
        "income = int(income)\n",
        "\n",
        "- if income is more than  8000, then print \"High income\"\n",
        "- if income is is between 4000 to 8000, then print \"Medium high income\"\n",
        "- if income is between 2000 to 4000, then print \"Medium income\"\n",
        "- if income is between 1000 to 2000, then print \"Medium low income\"\n",
        "otherwise, print \"Low income\"\n"
      ],
      "metadata": {
        "id": "87YKGYYF71WJ"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1Ddfgr-yVpse"
      },
      "source": [
        "# Exercise\n",
        "income = input('What is your income?' )\n",
        "income = int(income)\n",
        "if ________:\n",
        "    print('High income')\n",
        "elif ___________:\n",
        "    print('Medium high income')\n",
        "elif ______________:\n",
        "    print('Medium income')\n",
        "elif _____________:\n",
        "    print('Medium low income')\n",
        "else:\n",
        "    print(\"Low income\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Solution: Conditional"
      ],
      "metadata": {
        "id": "NhrfFhPS8gKg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Exercise\n",
        "income = input('What is your income?' )\n",
        "income = int(income)\n",
        "if income > 8000:\n",
        "    print('High income')\n",
        "elif income > 4000:\n",
        "    print('Medium high income')\n",
        "elif income > 2000:\n",
        "    print('Medium income')\n",
        "elif income > 1000:\n",
        "    print('Medium low income')\n",
        "else:\n",
        "    print(\"Low income\")"
      ],
      "metadata": {
        "id": "bN8rSenz8ijt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-vL5s19wa7Fy"
      },
      "source": [
        "### Ternary Operator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hn059abcYkLM"
      },
      "source": [
        "# Ternary Operator\n",
        "\n",
        "order = 10\n",
        "discount = 25 if order>100 else 0\n",
        "discount"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F4usVvO8cp4S"
      },
      "source": [
        "### While Loop\n",
        "\n",
        "The while construct consists of a condition and block of code. \n",
        "\n",
        "The general syntax for a ‘while’ loop is as follows: \n",
        "\n",
        "<pre>\n",
        "<b> while condition/expression:\n",
        "    block of statements</b>\n",
        "</pre>\n",
        "\n",
        "To begin, the condition is evaluated.<br>\n",
        "\n",
        "If the condition is true, the 'block of statements' is executed. Every time, the condition is checked before executing the block of statements. <br>\n",
        "\n",
        "This keeps on repeating until the condition becomes false. Once the condition is false, it comes out of the loop to execute the other statements."
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Simple Example of While Loop"
      ],
      "metadata": {
        "id": "i70LVoPqYjZg"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kBBJHUyBcfSh"
      },
      "source": [
        "a = 0  # Variable\n",
        "\n",
        "while a <= 10:  # This is the condition. The loop will execute until the condition becomes 'false'\n",
        "    a = a + 1\n",
        "    print(a)\n",
        "print(\"We are now out of the loop\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Compute Fibonacci Seq and Golden Ratio Using While Loop\n",
        "\n",
        "Generate a python list of 10 square numbers using for loop and the range\n",
        "\n",
        "[1,4,9,16,25,36,49,64,81,100]\n"
      ],
      "metadata": {
        "id": "46iGUlyY-1jr"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5QpEG7vqdA8X"
      },
      "source": [
        "a,b=0,1\n",
        "fib = []\n",
        "golden_ratio = []\n",
        "while (_____________):\n",
        "    ___________\n",
        "print(fib)\n",
        "print(golden_ratio)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Compute Fibonacci Seq and Golden Ratio Using While Loop"
      ],
      "metadata": {
        "id": "odSlMkVdYZ3x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a,b=0,1\n",
        "fib = []\n",
        "golden_ratio = []\n",
        "while (b<100):\n",
        "    a,b = b,a+b\n",
        "    fib.append(b)\n",
        "    golden_ratio.append(round(b/a,3))\n",
        "print(fib)\n",
        "print(golden_ratio)"
      ],
      "metadata": {
        "id": "7NHqHlJpYPE0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Why Multiiple Assignment"
      ],
      "metadata": {
        "id": "jQmccwnOZXPO"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_rXD7MNtfrwS"
      },
      "source": [
        "a,b=0,1\n",
        "fib = []\n",
        "golden_ratio = []\n",
        "while (b<100):\n",
        "    a = b\n",
        "    b = a+b\n",
        "    fib.append(b)\n",
        "    golden_ratio.append(round(b/a,3))\n",
        "print(fib)\n",
        "print(golden_ratio)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Compute Golden Ratio\n",
        "a,b=0,1\n",
        "while (b<5000):\n",
        "    a,b = b,a+b\n",
        "    r = b/a\n",
        "    print(r)"
      ],
      "metadata": {
        "id": "QEWNTehoICcu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "12PaTj4EhyMN"
      },
      "source": [
        "### For Loop\n",
        "\n",
        "In the programming languages, there are many situations when you need to execute a block of code several numbers of times. A loop statement allows us to execute a statement or group of statements multiple times.\n",
        "\n",
        "The general syntax for a ‘for’ loop is as follows: \n",
        "\n",
        "<pre>\n",
        "<b>for (variable) in <b>sequence:\n",
        "    block of statements</b>\n",
        "</pre>\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### For Loop Example\n",
        "\n",
        "Here, the block of statements within the loop will get executed, until all ‘sequence’ elements get exhausted. Once all sequence elements are exhausted, the program will come out of the loop."
      ],
      "metadata": {
        "id": "89GaBx885jsJ"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6X2Y6L-Zg4rV"
      },
      "source": [
        "# Closing prices of the ABC stock over 10 days\n",
        "\n",
        "Close_Price_ABC = [300, 305, 287, 298, 335,\n",
        "                   300, 297, 300, 295, 310]  # Our sequence\n",
        "\n",
        "for i in Close_Price_ABC:\n",
        "\n",
        "    if i < 300:\n",
        "        print(\"We Buy\")\n",
        "\n",
        "    if i == 300:\n",
        "        print(\"No new positions\")\n",
        "\n",
        "    if i > 300:\n",
        "        print(\"We Sell\")\n",
        "\n",
        "print(\"We are now out of the loop\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Range"
      ],
      "metadata": {
        "id": "8UgibcKsA3jY"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QDDzr3Klh-os"
      },
      "source": [
        "for i in range(1,20,2):\n",
        "    print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity : For Loop\n",
        "\n",
        "Generate a python list of 10 square numbers using for loop and the range\n",
        "\n",
        "[1,4,9,16,25,36,49,64,81,100]\n"
      ],
      "metadata": {
        "id": "jeoI5UySBDX4"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oxJjT4w4jRAo"
      },
      "source": [
        "a = []\n",
        "\n",
        "______________:\n",
        "    a.append(i*i)\n",
        "a"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution : For Loop"
      ],
      "metadata": {
        "id": "O3uOi2zmBUaz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = []\n",
        "\n",
        "for i in range(1,11):\n",
        "    a.append(i*i)\n",
        "a"
      ],
      "metadata": {
        "id": "5-J5OS3bBOJM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8qkUBXU_t2Zk"
      },
      "source": [
        "#### Enumerate"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yISTQSWkl5Hc"
      },
      "source": [
        "year = ['2017','2018','2019']\n",
        "revenue = [150000,200000,500000]\n",
        "\n",
        "for i,y in enumerate(year):\n",
        "    r = revenue[i]\n",
        "    print(f\"{y}'s revenue is ${r}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1gD3UdC5tx3c"
      },
      "source": [
        "#### Zip"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qhitU0smpwgw"
      },
      "source": [
        "year = ['2017','2018','2019']\n",
        "revenue = [150000,200000,500000]\n",
        "\n",
        "data = zip(year,revenue)\n",
        "for y,r in data:\n",
        "    print(f\"{y}'s revenue is ${r}\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Loop Multiple Sequences\n",
        "\n",
        "year = ['2017','2018','2019']\n",
        "\n",
        "revenue = [150000,200000,500000]\n",
        "\n",
        "expense = [90000,100000,250000]\n",
        "\n",
        "data = ___________________\n",
        "\n",
        "<pre>\n",
        "for y,r,e in data:\n",
        "    print(f\"{y}'s revenue is ${r} and expense is ${e}\")\n",
        "</pre>\n",
        "\n"
      ],
      "metadata": {
        "id": "T_rlkTJ_Cg2C"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NQscqBRSqp8a"
      },
      "source": [
        "year = ['2017','2018','2019']\n",
        "revenue = [150000,200000,500000]\n",
        "expense = [90000,100000,250000]\n",
        "\n",
        "data = ___________________\n",
        "for y,r,e in data:\n",
        "    print(f\"{y}'s revenue is ${r} and expense is ${e}\")\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Loop Multiple Sequences"
      ],
      "metadata": {
        "id": "GAqjmt7bC5yo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "year = ['2017','2018','2019']\n",
        "revenue = [150000,200000,500000]\n",
        "expense = [90000,100000,250000]\n",
        "\n",
        "data = zip(year,revenue,expense)\n",
        "for y,r,e in data:\n",
        "    print(f\"{y}'s revenue is ${r} and expense is ${e}\")\n"
      ],
      "metadata": {
        "id": "CWAjpNxaC4y3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZDsco65MuO7U"
      },
      "source": [
        "#### Break"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Closing prices of the ABC stock over 10 days\n",
        "\n",
        "Close_Price_ABC = [300, 305, 287, 298, 335,\n",
        "                   300, 297, 300, 295, 310]  # Our sequence\n",
        "\n",
        "for i in Close_Price_ABC:\n",
        "\n",
        "    if i < 300:\n",
        "        break\n",
        "\n",
        "    if i == 300:\n",
        "        print(\"No new positions\")\n",
        "\n",
        "    if i > 300:\n",
        "        print(\"We Sell\")\n",
        "\n",
        "print(\"We are now out of the loop\")"
      ],
      "metadata": {
        "id": "vKGlEuJ2D58c"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "3### Continue"
      ],
      "metadata": {
        "id": "zoZRoMXmEuUO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Closing prices of the ABC stock over 10 days\n",
        "\n",
        "Close_Price_ABC = [300, 305, 287, 298, 335,\n",
        "                   300, 297, 300, 295, 310]  # Our sequence\n",
        "\n",
        "for i in Close_Price_ABC:\n",
        "\n",
        "    if i < 300:\n",
        "        continue\n",
        "\n",
        "    if i == 300:\n",
        "        print(\"No new positions\")\n",
        "\n",
        "    if i > 300:\n",
        "        print(\"We Sell\")\n",
        "\n",
        "print(\"We are now out of the loop\")"
      ],
      "metadata": {
        "id": "xWamGm_JEiZ_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### List Comprehension"
      ],
      "metadata": {
        "id": "ynmzD74pFYW1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = [i*i for i in range(1,11)]\n",
        "a\n"
      ],
      "metadata": {
        "id": "sRyedC9iFjCe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = [i*i for i in range(1,11) if i%2==0]\n",
        "a"
      ],
      "metadata": {
        "id": "TjU7GSH9Fmvf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Set Comprehension"
      ],
      "metadata": {
        "id": "LkdeefcU6sED"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = {i*i for i in range(1,11)}\n",
        "a"
      ],
      "metadata": {
        "id": "_FyxYoba6vRA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Dict Comprehension"
      ],
      "metadata": {
        "id": "9Mer_S027DuL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = {i:i*i for i in range(1,11)}\n",
        "a"
      ],
      "metadata": {
        "id": "ZZODMujI6zxS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Generator"
      ],
      "metadata": {
        "id": "BrWerAZBF_MP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = (i*i for i in range(1,11))\n",
        "print(next(a))\n",
        "print(next(a))\n",
        "print(next(a))"
      ],
      "metadata": {
        "id": "Q8BBE4Xp7JBu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: List Comprehension\n",
        "\n",
        "Create a comprehensive list of 10 square numbers that are not divisible by 3 and 5\n",
        "\n",
        "[1, 4, 16, 49, 64, 121, 169, 196, 256, 289]\n",
        "\n"
      ],
      "metadata": {
        "id": "Oa-Qe1QeFuf5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = [i*i for i in range(1,20) if ___________ and not i%5==0]\n",
        "a"
      ],
      "metadata": {
        "id": "WyiFBLAtGIOn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution : List Comprehension"
      ],
      "metadata": {
        "id": "_v5XpzPAGJcV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = [i*i for i in range(1,20) if not i%3==0 and not i%5==0]\n",
        "a"
      ],
      "metadata": {
        "id": "YsXUtNv7F041"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZzAiN7P93Xs4"
      },
      "source": [
        "# Topic 4 Scripting with Function and Lambda\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "The syntax for constructing a function is:\n",
        "<pre>\n",
        "def function_name (parameter-list):\n",
        "\tStatements, i.e function body\n",
        "    return a value, if required\n",
        "</pre>\n",
        "Let us create ‘my_function’.\n",
        "\n",
        "This is a simple function which we have created to calculate the exponential of any number. Now, whenever we need to perform this particular calculation, all we need to do is <b>call</b> this function and insert the values for <b>‘x’</b> and <b>‘n’</b>. You may have a look at it."
      ],
      "metadata": {
        "id": "-tVZps3UUxny"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VMjjCcCg1yUp"
      },
      "source": [
        "def my_function(x, n):\n",
        "    output = x ** n\n",
        "    return output"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GJWg5yHN57m6"
      },
      "source": [
        "my_function(10, 2)  # 10 raise to 2 = 100"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_5FMoE6y59sS"
      },
      "source": [
        "my_function(5, 3)  # 5 raise to 3 = 125"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Function\n",
        "\n",
        "\n",
        "The FV calculation allows investors to predict, with varying degrees of accuracy, the amount of profit that can be generated by different investments\n",
        "\n",
        "Create a function for compute the future value given by:\n",
        "\n",
        "FV = PV * ((1+r) ** n)\n",
        "\n",
        "where\n",
        "- FV: Future value\n",
        "- PV: Present value\n",
        "- r: annual interest rate\n",
        "- n: number of years\n"
      ],
      "metadata": {
        "id": "QQ_HAjguHwX8"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "afJj1oBD6AOm"
      },
      "source": [
        "def FV(PV,r,n):\n",
        "    FV = ____________\n",
        "    return FV"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Function"
      ],
      "metadata": {
        "id": "WZkJjdvXH5l3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def FV(PV,r,n):\n",
        "    FV = PV * ((1+r) ** n)\n",
        "    return FV"
      ],
      "metadata": {
        "id": "QGQrayprNF_w"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "PV = 1000\n",
        "r = 0.05\n",
        "n = 1\n",
        "\n",
        "fv = FV(PV,r,n)\n",
        "\n",
        "print(fv)"
      ],
      "metadata": {
        "id": "vKgGO5k4NLOM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Another Example"
      ],
      "metadata": {
        "id": "CFlM5JtTi9qR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def fare(d):\n",
        "    book=2.0\n",
        "    start=3.0\n",
        "    cost=1.0\n",
        "    fare=book+start+d*cost\n",
        "    return fare"
      ],
      "metadata": {
        "id": "wseopujYH13T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WJjzjSdU7pDC"
      },
      "source": [
        "fare(10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mCeWZftpVFH5"
      },
      "source": [
        "#### Mutlple Outputs"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VEuGt6eF7r0m"
      },
      "source": [
        "def f(x):\n",
        "    return x*x,2*x"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JoknEzbg75xh"
      },
      "source": [
        "f(5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Multiple Return\n",
        "\n",
        "Prompt the user for the order \n",
        "Create a function to return the discount amount and the tax for grocery purchase\n",
        "\n",
        "- discount = 25 if order > 200 else 0\n",
        "- disc_amt = discount*order/100\n",
        "- tax = 0.07*(order - disc_amt)\n"
      ],
      "metadata": {
        "id": "sCVVXHmMIEMV"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "i5EB4gvV-Urs"
      },
      "source": [
        "def grocery(order):\n",
        "    discount = ________________\n",
        "    disc_amt = discount*order/100\n",
        "    tax = 0.07*(order - disc_amt)\n",
        "    return ____________\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "order = input('How much is your. order')\n",
        "order = float(order)\n",
        "discount,tax = grocery(order)\n",
        "print('The discount is ${}'.format(discount))\n",
        "print('The tax is ${}'.format(round(tax,2)))"
      ],
      "metadata": {
        "id": "MMu6N9-6jSo4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Multiple Return"
      ],
      "metadata": {
        "id": "-9BlPaDeIKrr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def grocery(order):\n",
        "    discount = 25 if order > 200 else 0\n",
        "    disc_amt = discount*order/100\n",
        "    tax = 0.07*(order - disc_amt)\n",
        "    return disc_amt,tax"
      ],
      "metadata": {
        "id": "eb6JKjN2IJZv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3y4ja-K9Ban5"
      },
      "source": [
        "order = input('How much is your. order')\n",
        "order = float(order)\n",
        "discount,tax = grocery(order)\n",
        "print('The discount is ${}'.format(discount))\n",
        "print('The tax is ${}'.format(round(tax,2)))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xVsgS0exV8CG"
      },
      "source": [
        "#### Multiple Arguments"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a3EhxW9rBmjZ"
      },
      "source": [
        "def f(x,y):\n",
        "    return x*y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tn5zzRqCEam5"
      },
      "source": [
        "f(2,3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GF9yN_gEEdQ9"
      },
      "source": [
        "f(2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8d_R1QEiWEdA"
      },
      "source": [
        "#### Default Argument"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w_6RLxgSEmCp"
      },
      "source": [
        "def f(x,y=3):\n",
        "    return x*y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qXCSf5rYEtvN"
      },
      "source": [
        "f(2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gwLloVffExZx"
      },
      "source": [
        "def f(x=3,y=3):\n",
        "    return x*y"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pMR_OsBsE8rF"
      },
      "source": [
        "f()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H8cnwItpFATi"
      },
      "source": [
        "f(y=5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GF6XlLwIWNNN"
      },
      "source": [
        "#### Variable Argument"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R2pWIop9FEjP"
      },
      "source": [
        "def sum(*b):\n",
        "    sum = 0\n",
        "    for i in b:\n",
        "        sum = sum + i\n",
        "    return sum"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nK3BDxUvFdZ9"
      },
      "source": [
        "sum(1,2,3,4,5,6,7,8,9,10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Variable Arguments\n",
        "\n",
        "Give a sequence of variable number of elements, create a function to determine the minimum value\n",
        "\n",
        "Eg a =[5,4,7] then function will return 4\n",
        "\n"
      ],
      "metadata": {
        "id": "TbTZwUBjIceX"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "s9cmTvnxFff6"
      },
      "source": [
        "def min(*b):\n",
        "    m = ________\n",
        "    for i in b:\n",
        "        _______\n",
        "    return m"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Variable Arguments"
      ],
      "metadata": {
        "id": "yvClrdHwIfbH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def min(*b):\n",
        "    m = b[0]\n",
        "    for i in b[1:]:\n",
        "        if i<m: m=i\n",
        "    return m"
      ],
      "metadata": {
        "id": "XOPu6FT9IiDO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qZKPDuX4IbCF"
      },
      "source": [
        "min(7,4,8,9,10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SxBroH_N4l7Q"
      },
      "source": [
        "#### Lambda Function\n",
        "\n",
        "The lambda operator is a way to create small <b>anonymous functions</b> i.e. functions without a name.<br>\n",
        "<br>\n",
        "They are temporary functions i.e. they are needed only where they have been created.<br>\n",
        "<br>\n",
        "The lambda feature was added in Python due to high demand from the Lisp programmers (Lisp is a programming language).\n",
        "\n",
        "The general syntax for Lambda is as follows:<br>\n",
        "<pre><b>lambda</b> argument_list: expression</pre>\n",
        "Let us have a look at some of the examples.\n",
        "\n",
        "It is similar to defining a function where x and y are the parameters and x + y is the operation performed in the block of codes.<br>\n",
        "\n",
        "You can even observe, that the usage of lambda is the same as the function call. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ocEHK7xWIebs"
      },
      "source": [
        "sum = lambda x, y: x + y\n",
        "sum(2, 3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "product = lambda x, y: x * y\n",
        "product(2, 3)"
      ],
      "metadata": {
        "id": "yCK_4iZPJHkc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_operation = lambda x, y, z:  x + y - z\n",
        "my_operation(10, 20, 30)"
      ],
      "metadata": {
        "id": "NGMSx15aJNO1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Activity: Lambda\n",
        "<pre>\n",
        "f = lambda x,y: 10*x+y \n",
        "\n",
        "def g(f,x,y=0):\n",
        "  return f(x,y); \n",
        "\n",
        "What is g(f,4)?\n",
        "\n",
        "</pre>\n"
      ],
      "metadata": {
        "id": "-jVP3c8KKZoI"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mwiq-ugZzSSD"
      },
      "source": [
        "f = lambda x,y: 10*x+y\n",
        "\n",
        "def g(f,x,y=0):\n",
        "  return f(x,y); "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LhsEWo9S0uFr"
      },
      "source": [
        "g(f,4)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LAH9rbHtWVf3"
      },
      "source": [
        "#### Map\n",
        "\n",
        "One of the advantages of using a lambda is the map() function.<br>\n",
        "<pre> map (<b>lambda</b>, sequence of lists)</pre>\n",
        "map() applies the lambda function to all elements within the sequence. These elements are generally lists."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "list_1 = [1, 2, 3, 4]\n",
        "list_2 = [10, 20, 30, 40]\n",
        "list(map(lambda x, y: x + y, list_1, list_2))"
      ],
      "metadata": {
        "id": "Ah9LAfJVK_Ag"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "list_1 = [1, 2, 3, 4]\n",
        "list_2 = [10, 20, 30, 40]\n",
        "list_3 = [100, 200, 300, 400]\n",
        "list(map(lambda x, y, z: x + y + z, list_1, list_2, list_3))"
      ],
      "metadata": {
        "id": "NwEUbrSgLK_R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "list_2 = [10, 20, 30, 40]\n",
        "list_3 = [100, 200, 300, 400]\n",
        "list(map(lambda y, z: y + z, list_2, list_3))"
      ],
      "metadata": {
        "id": "DNUSTYyqLNuQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Map\n",
        "\n",
        "Using map to compute the answer for \n",
        "f = lambda x,y:10*x+y\n",
        "\n",
        "x = [0,1,2,3]\n",
        "\n",
        "y = [2,4,6,8]\n"
      ],
      "metadata": {
        "id": "PM4U_2Y3LT1O"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EPHqJ3Z11Ye7"
      },
      "source": [
        "f = lambda x,y:10*x+y\n",
        "x = [0,1,2,3]\n",
        "y = [2,4,6,8]\n",
        "\n",
        "b = map(____________)\n",
        "list(b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Map"
      ],
      "metadata": {
        "id": "_MDATYFTLft_"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8QzyCygu4H9x"
      },
      "source": [
        "f = lambda x,y:10*x+y\n",
        "x = [0,1,2,3]\n",
        "y = [2,4,6,8]\n",
        "\n",
        "b = map(f,x,y)\n",
        "list(b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6HnBRerQ6p_-"
      },
      "source": [
        "### Filter\n",
        "\n",
        "Another advantage of using a lambda is the filter() function.<br>\n",
        "<pre> filter (<b>lambda</b>, list)</pre>\n",
        "It is an elegant way to filter out the required elements from a list"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "fib = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55] \n",
        "list(filter(lambda x: x > 8, fib))"
      ],
      "metadata": {
        "id": "9tvudgASL19_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "fib = [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55] \n",
        "list(filter(lambda x: x < 8, fib))"
      ],
      "metadata": {
        "id": "lUSCSVBnL3mn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "signals = ['Buy', 'Sell', 'Sell', 'Buy', 'Buy', 'Sell', 'Buy'] \n",
        "list(filter(lambda x: x == 'Buy', signals))"
      ],
      "metadata": {
        "id": "GngQWkP7L5xN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Activity: Filter\n",
        "\n",
        "Using filter to remove all the negative values in  \n",
        "x = [0,1,-4, 2,-6,3]\n"
      ],
      "metadata": {
        "id": "_YNZfcKWMPeh"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3_pkTkKd4-_E"
      },
      "source": [
        "x = [0,1,-4, 2,-6,3]\n",
        "\n",
        "b = filter(___________)\n",
        "list(b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Solution: Filter"
      ],
      "metadata": {
        "id": "xsaLMm5JMSrT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x = [0,1,-4, 2,-6,3]\n",
        "\n",
        "b = filter(lambda x:x>=0,x)\n",
        "list(b)"
      ],
      "metadata": {
        "id": "M5ETIDCcMR9m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cNMFXRHl7bou"
      },
      "source": [
        "### Modules and Packages\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Any file in Python which has a .py extension can be a module. A module can consist of arbitrary objects, classes, attributes or functions which can be imported by users."
      ],
      "metadata": {
        "id": "xUA8LNbHU1Pc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Importing Modules\n",
        "\n",
        "There are different ways to import modules. Let us begin by importing the 'math' module."
      ],
      "metadata": {
        "id": "3Wq8vMtyOszV"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EViZ78gG6enc"
      },
      "source": [
        "import math\n",
        "\n",
        "print(math.sin(0.5))\n",
        "print(math.pi)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sYrneig47yE-"
      },
      "source": [
        "import math as mt\n",
        "m.sin(0.5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "55mStyaN8Jra"
      },
      "source": [
        "from math import *\n",
        "sin(0.5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fnboycpy8Rd9"
      },
      "source": [
        "from math import sin,pi\n",
        "sin(pi/2)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gOjMlCeD8cjU"
      },
      "source": [
        "import time\n",
        "\n",
        "print(sin(pi/2))\n",
        "time.sleep(10)\n",
        "print(cos(pi/2))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PU0xvjTc9zjj"
      },
      "source": [
        "import random\n",
        "die = random.choice([1,2,3,4,5,6])\n",
        "die"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hIZtxtlH92Pb"
      },
      "source": [
        "import urllib.request\n",
        "with urllib.request.urlopen('http://python.org/') as f:\n",
        "   html = f.read()\n",
        "print(html)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Installing Python Packages\n",
        "In the previous units, you have learned and practised how to import a python package. Built-in packages such as Pandas, NumPy are available by default in Python. \n",
        "\n",
        "But there are a lot more other packages publically available you might want to use. If you try to import such packages without installing them first you would get an error called 'ModuleNotFoundError'."
      ],
      "metadata": {
        "id": "CqLCdJ8CPCQw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Install package using pip\n",
        "\n",
        "Pip, a package installer, is used to install and manage packages that are available in Python Package Index (PyPi) which is a repository for Python packages.\n",
        "\n",
        "It is a recommended tool as most of the python packages are made available through PyPi. Pip is installed along when you install Python in your system. You need not worry about downloading or installing pip exclusively."
      ],
      "metadata": {
        "id": "NutpH3lZPPgM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "To install the package in a Jupyter notebook, you can use the following command.\n",
        "\n",
        "`!pip install package_name`\n",
        "\n",
        "To install the package in a command prompt or Spyder, you can use the below command.\n",
        "\n",
        "`pip install package_name`"
      ],
      "metadata": {
        "id": "QIMA_Gd4PTwJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install numpy\n",
        "!pip install matplotlib\n",
        "!pip install pandas\n",
        "!pip install yfinance"
      ],
      "metadata": {
        "id": "cN3xsCjCPJz1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hxuq2dzNN0u1"
      },
      "source": [
        "#### Pandas Demo: Import Stock Data from CSV File"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "stock = pd.read_csv('https://raw.githubusercontent.com/tertiarycourses/datasets/master/Singtel.csv')\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "8iWQlgPUQCfR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Preparing Data to visualise\n",
        "\n",
        "stock_close =stock[['Date'tr, 'Close']]  # The columns which we require\n",
        "stock_close.set_index('Date', inplace=True)  # Setting index as date\n",
        "\n",
        "# More on this in the upcoming section on 'Pandas'\n",
        "stock_close"
      ],
      "metadata": {
        "id": "q0KcOCLjQk02"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CLpTBrw_Npvf"
      },
      "source": [
        "#### Matplotlib Demo: Visualize Stock Price History"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J9IdbhHxEVYw"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# This customizes the size of the plot as per the inputs. Here 14,5 represents the breadth and length of the plot.\n",
        "plt.figure(figsize=(14, 5))\n",
        "\n",
        "# This helps in plotting the blue color of the ‘infy_close’ series line graph.\n",
        "plt.plot(stock_close, 'b')\n",
        "# plt.plot (infy_close, 'g') # to plot green color\n",
        "\n",
        "# This helps in plotting the discrete red data points of the closing prices of ‘infy_close’ series.\n",
        "plt.plot(stock_close, 'ro')\n",
        "# Here ‘r’ stands for ‘red’ and ‘o’ stands for circles while plotting our discrete data points.\n",
        "# That is why the points are colored red and the default line color is blue.\n",
        "\n",
        "# This gives a grid layout to the plot.\n",
        "plt.grid(True)\n",
        "\n",
        "# This gives the title to the plot.\n",
        "plt.title('Singtel Close Price Representation')\n",
        "\n",
        "# This labels the x-axis\n",
        "plt.xlabel('Trading Days')\n",
        "\n",
        "# This labels the y-axis\n",
        "plt.ylabel('Singtel Close Price')\n",
        "\n",
        "\n",
        "# To plot and visualise the data\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Yahoo Finance Demo"
      ],
      "metadata": {
        "id": "UTA-XAE8oRy0"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C-M1lVjFKXs3"
      },
      "source": [
        "import yfinance as yf\n",
        "stock = yf.download('Z74.SI', start=\"2017-01-01\", end=\"2021-11-30\")\n",
        "stock.tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Preparing Data to visualise\n",
        "\n",
        "stock_close =stock[['Close']]  # The columns which we require\n",
        "\n",
        "stock_close.tail()"
      ],
      "metadata": {
        "id": "YzSrvpJcSmY5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8zoxIJw9Lf8C"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "# This customizes the size of the plot as per the inputs. Here 14,5 represents the breadth and length of the plot.\n",
        "plt.figure(figsize=(14, 5))\n",
        "\n",
        "# This helps in plotting the blue color of the ‘infy_close’ series line graph.\n",
        "plt.plot(stock_close, 'b')\n",
        "# plt.plot (infy_close, 'g') # to plot green color\n",
        "\n",
        "# This helps in plotting the discrete red data points of the closing prices of ‘infy_close’ series.\n",
        "plt.plot(stock_close, 'ro')\n",
        "# Here ‘r’ stands for ‘red’ and ‘o’ stands for circles while plotting our discrete data points.\n",
        "# That is why the points are colored red and the default line color is blue.\n",
        "\n",
        "# This gives a grid layout to the plot.\n",
        "plt.grid(True)\n",
        "\n",
        "# This gives the title to the plot.\n",
        "plt.title('Singtel Close Price Representation')\n",
        "\n",
        "# This labels the x-axis\n",
        "plt.xlabel('Trading Days')\n",
        "\n",
        "# This labels the y-axis\n",
        "plt.ylabel('Close Price')\n",
        "\n",
        "\n",
        "# To plot and visualise the data\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mg_6tPBVZUeq"
      },
      "source": [],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7ezBm7D7gEZc"
      },
      "source": [
        "#Topic 5 Import and Process Finance Data\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "`pandas` like `NumPy` is a key constituent of the scientific computing framework in Python.\n",
        "It's a powerful tool which can perform data manipulation and other excel like operations at high speed. \n",
        "\n",
        "To give you a sense of how comprehensive it is, the [official documentation](https://pandas.pydata.org/pandas-docs/stable/) of `pandas` is over 3000 pages!\n",
        "\n",
        "**`pandas` is built on top of NumPy.** Many of the more sophisticated statistical libraries such as `statsmodels` and `scikit-learn` in turn are built on top of `pandas`. Thus there is a **high degree of compatibility** among these libraries.<br><br>\n",
        "Two of the most important data structures in `pandas` that we will extensively use are `Series` and `DataFrame`."
      ],
      "metadata": {
        "id": "B0DwjkY2fgwY"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zhIjWR40gVcA"
      },
      "source": [
        "### Install Python Data Analysis Packages"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hzBEFiJ6gEZd"
      },
      "source": [
        "# These packagss have been pre-installed on Google Colab\n",
        "!pip install numpy\n",
        "!pip install matplotlib\n",
        "!pip install seaborn\n",
        "!pip install pandas\n",
        "!pip install scipy\n",
        "!pip install sklearn\n",
        "!pip install yfinance"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H5rpHv_FjI70"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sb\n",
        "import pandas as pd\n",
        "import sklearn\n",
        "import yfinance as yf"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7V8iF4swgZzg"
      },
      "source": [
        "### Series\n",
        "\n",
        "In Python, understanding Series is a natural predecessor to understanding dataframes.\n",
        "\n",
        "Series are indexed data frame with only one data column. It is easier to understand them first before moving to study complex data frames.\n",
        "\n",
        "A series is a one-dimensional labelled 'array-like' object. The labels are nothing but the index of the data. \n",
        "\n",
        "A series is a special case of a two-dimensional array, which has only 2 columns- one column is for the index and the other column is for data. "
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "mkt_cap =[82.54,2.52,8.39,51.24,10.11,40.29,11.80,16.70,45.14,5.49,26.76,5.20]\n",
        "\n",
        "s = pd.Series(mkt_cap, index=stock_list)\n",
        "print(s)\n",
        "type(s)"
      ],
      "metadata": {
        "id": "Vw0mBcFp6sVn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "s.plot.barh()"
      ],
      "metadata": {
        "id": "QJHOhdIRDsPY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### <span style=\"color:black\">Series.index</span>\n",
        "\n",
        "It is useful to know the range of the index when the series is large.\n",
        "\n",
        "In fact, **`Series` are like Python dictionaries**, with the index being analogous to the `keys`  and the actual data equivalent to `values`. Even the syntax is similar to Python dictionaries."
      ],
      "metadata": {
        "id": "Qap73duOIuAG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s.index"
      ],
      "metadata": {
        "id": "TGW7RZb8Is4b"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "##### <span style=\"color:black\">Series.values</span>\n",
        "It returns the values of the series."
      ],
      "metadata": {
        "id": "5WrxGLiZJPNg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "s.values"
      ],
      "metadata": {
        "id": "9NIjuSVZJUvV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Series\n",
        "\n",
        "- Create a Pandas Series for the average buy price with stocks as index\n",
        "- Plot the stock price vs stock list\n"
      ],
      "metadata": {
        "id": "NxqejdyTdad0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "sector = ['Finance','Healthcare','Transport','Finance','Finance','Technology','Technology',\\\n",
        "              'Food','Finance','Finance','Food','Transport']\n",
        "stock_qty = [300,100,200,800,300,3000,1000,1000,300,100,1000,1000]\n",
        "avg_price=[31.23,11.50,20.95,11.39,9.07,2.38,3.78,0.66,26.61,18.68,4.15,1.30]\n",
        "mkt_cap =[82.54,2.52,8.39,51.24,10.11,40.29,11.80,16.70,45.14,5.49,26.76,5.20]\n",
        "\n",
        "s = _____________\n",
        "s.plot.barh()\n",
        "plt.xlabel('stock price')\n"
      ],
      "metadata": {
        "id": "bVWKefkmdZFj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Series"
      ],
      "metadata": {
        "id": "HzOIYoiGeAXs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "sector = ['Finance','Healthcare','Transport','Finance','Finance','Technology','Technology',\\\n",
        "              'Food','Finance','Finance','Food','Transport']\n",
        "stock_qty = [300,100,200,800,300,3000,1000,1000,300,100,1000,1000]\n",
        "avg_price=[31.23,11.50,20.95,11.39,9.07,2.38,3.78,0.66,26.61,18.68,4.15,1.30]\n",
        "mkt_cap =[82.54,2.52,8.39,51.24,10.11,40.29,11.80,16.70,45.14,5.49,26.76,5.20]\n",
        "\n",
        "s = pd.Series(avg_price, index=stock_list)\n",
        "s.plot.barh()\n",
        "plt.xlabel('stock price')"
      ],
      "metadata": {
        "id": "n-wP0lZid-9U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6VI4s6KugEa1"
      },
      "source": [
        "### DataFrame\n",
        "\n",
        "The underlying idea of a dataframe is based on 'spreadsheets'. In other words, dataframes store data in discrete rows and columns, where each column can be named (something that is not possible in Arrays but is possible in Series). There are also multiple columns in a dataframe (as opposed to Series, where there can be only one discrete indexed column).\n",
        "\n",
        "We can think of `DataFrame` like an Excel sheet with **multiple columns of data along with its index**, where each column is capable of handling different data types. In other words, it is a **two-dimensional labelled data container.**"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "stock_qty = [300,100,200,800,300,3000,1000,1000,300,100,1000,1000]\n",
        "avg_price=[31.23,11.50,20.95,11.39,9.07,2.38,3.78,0.66,26.61,18.68,4.15,1.30]\n",
        "\n",
        "my_portfolio = {\n",
        "    \"stock_name\": stock_list,\n",
        "    \"quantity_owned\": stock_qty,\n",
        "    \"average_buy_price\": avg_price\n",
        "}\n",
        "\n",
        "my_portfolio_df = pd.DataFrame(my_portfolio)\n",
        "my_portfolio_df"
      ],
      "metadata": {
        "id": "v0TnVNuzSgiS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Customize index of the dataframe \n",
        "\n",
        "In the above output, you can see that the 'index' is the default one which starts from 0. One can customize this index."
      ],
      "metadata": {
        "id": "S_YlcOhzeler"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "stock_qty = [300,100,200,800,300,3000,1000,1000,300,100,1000,1000]\n",
        "avg_price=[31.23,11.50,20.95,11.39,9.07,2.38,3.78,0.66,26.61,18.68,4.15,1.30]\n",
        "\n",
        "my_portfolio = {\n",
        "    \"quantity_owned\": stock_qty,\n",
        "    \"average_buy_price\": avg_price\n",
        "}\n",
        "\n",
        "my_portfolio_df = pd.DataFrame(my_portfolio,index=stock_list)\n",
        "\n",
        "my_portfolio_df\n"
      ],
      "metadata": {
        "id": "qTcBknGmezIo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Reset Index"
      ],
      "metadata": {
        "id": "1vfisA4C0JsY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Use inplace=True to replace the original DataFrame. \n",
        "# If inplace=False, then a new Dataframe is created\n",
        "\n",
        "my_portfolio_df.reset_index(inplace=True)\n",
        "my_portfolio_df\n",
        "\n",
        "# This is same a  \n",
        "# my_portfolio_df = my_portfolio_df.reset_index()"
      ],
      "metadata": {
        "id": "j1-IBQKhyF-W"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Set Index"
      ],
      "metadata": {
        "id": "_sfnQ4Qx0IPL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_portfolio_df.set_index('index',inplace=True)\n",
        "my_portfolio_df\n"
      ],
      "metadata": {
        "id": "oP5rLxQx0KUe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Rename columns\n",
        " \n",
        "If we want to rename the column names, while dealing with the dataframe we need to use the rename function"
      ],
      "metadata": {
        "id": "dO7DGFENnyPo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "stock_qty = [300,100,200,800,300,3000,1000,1000,300,100,1000,1000]\n",
        "avg_price=[31.23,11.50,20.95,11.39,9.07,2.38,3.78,0.66,26.61,18.68,4.15,1.30]\n",
        "\n",
        "my_portfolio = {\n",
        "    \"quantity_owned\": stock_qty,\n",
        "    \"average_buy_price\": avg_price\n",
        "}\n",
        "\n",
        "my_portfolio_df = pd.DataFrame(my_portfolio,index=stock_list)\n",
        "\n",
        "my_portfolio_df"
      ],
      "metadata": {
        "id": "sNNrm1pj0TGC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_portfolio_df = my_portfolio_df.rename(columns={'quantity_owned':'qty','average_buy_price':'buy_price'})\n",
        "my_portfolio_df"
      ],
      "metadata": {
        "id": "84-OZRQgnvr2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Rearrange the columns in a dataframe \n",
        "\n",
        "We can also define or change the order of columns."
      ],
      "metadata": {
        "id": "LMiiuRXshXKu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "stock_qty = [300,100,200,800,300,3000,1000,1000,300,100,1000,1000]\n",
        "avg_price=[31.23,11.50,20.95,11.39,9.07,2.38,3.78,0.66,26.61,18.68,4.15,1.30]\n",
        "\n",
        "my_portfolio = {\n",
        "    \"quantity_owned\": stock_qty,\n",
        "    \"average_buy_price\": avg_price\n",
        "}\n",
        "\n",
        "my_portfolio_df = pd.DataFrame(my_portfolio,columns=[\"average_buy_price\",\"quantity_owned\"],index=stock_list)\n",
        "\n",
        "my_portfolio_df"
      ],
      "metadata": {
        "id": "dxktuWcwhdi9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "krqD-p7dgEa8"
      },
      "source": [
        "#### Dataframe Attributes\n",
        "\n",
        "A DataFrame consists of three parts viz.\n",
        "1. `index`\n",
        "2. `columns`\n",
        "3. `values`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L2qOLrdELSa0"
      },
      "source": [
        "my_portfolio_df.info()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zdcvpThcqwmn"
      },
      "source": [
        "my_portfolio_df.shape"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bMPIfw_Pq5eX"
      },
      "source": [
        "my_portfolio_df.columns"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IN7zf4lIsXwP"
      },
      "source": [
        "my_portfolio_df.index"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IvcD2AFjgEa8"
      },
      "source": [
        "my_portfolio_df['average_buy_price'].values"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tbM-3JwHgEa5"
      },
      "source": [
        "### Import CSV Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "d6n0myPugEa5"
      },
      "source": [
        "# Import CSV file\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "stock = pd.read_csv('https://raw.githubusercontent.com/tertiarycourses/datasets/master/DBS.csv')\n",
        "stock.tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EIEw3MzzrCtk"
      },
      "source": [
        "stock.set_index('Date', inplace=True) \n",
        "stock.tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Import CSV file\n",
        "\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "stock = pd.read_csv('https://raw.githubusercontent.com/tertiarycourses/datasets/master/DBS.csv', index_col=\"Date\")\n",
        "stock.tail()"
      ],
      "metadata": {
        "id": "-Fp8FfXohA_L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "One of the great features about `pandas` is how it works so symbiotically with some of the other popular Python packages such as `NumPy` and `Matplotlib`. Under the hood, the `values` of the `pandas Series` and the `pandas Dataframe` objects are `NumPy ndarrays`. \n",
        "\n",
        "We will use `matplotlib` in conjunction with `pandas` to plot and visualize our data. You can read and learn more about it [here](https://matplotlib.org/api/pyplot_summary.html)."
      ],
      "metadata": {
        "id": "15zGGwy42iwC"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tHpotVaX9p0y"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "stock[['Adj Close','Close']].plot(figsize=(15,7)) \n",
        "plt.xlabel('Days')\n",
        "plt.ylabel('Close Price')\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Import Yahoo Finance Data"
      ],
      "metadata": {
        "id": "NemUNqMRwzrQ"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zZZ3obNlH9fa"
      },
      "source": [
        "# Import Yahoo Finance file\n",
        "\n",
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "stock = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock.tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "stock[['Adj Close','Close']].plot(figsize=(15,7))\n",
        "plt.xlabel('Days')\n",
        "plt.ylabel('Close and Adj Close Price')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "0PBh8w1pbv4s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YSLwqC1QgEa-"
      },
      "source": [
        "#### Activity: Import Finance Data\n",
        "\n",
        "- Import Singtel stock data from the Yahoo Finance\n",
        "- Plot the Singtel open and close date from 2017-01-01 to 2021-11-31\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = _______________\n",
        "end_date = _______________\n",
        "ticker = ___________________\n",
        "stock = _____________________\n",
        "stock.tail()"
      ],
      "metadata": {
        "id": "1SvUHk05dld1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock_close = _________________ \n",
        "stock_close.tail()"
      ],
      "metadata": {
        "id": "TXGk2CRFdtDx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "stock[['Adj Close','Close']].plot(figsize=(15,7))\n",
        "plt.xlabel('Days')\n",
        "plt.ylabel('Close and Adj Close Price')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "PzK17Umkdgw5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Import Finance Data"
      ],
      "metadata": {
        "id": "lN1etIuneI4f"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import yfinance as yf\n",
        "\n",
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'Z74.SI'\n",
        "stock = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock.tail()"
      ],
      "metadata": {
        "id": "slM07ZZtePGc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "plt.figure(figsize=(14, 5))\n",
        "plt.plot(stock[['Adj Close','Close']])\n",
        "plt.xlabel('Days')\n",
        "plt.ylabel('Close and Adj Close Price')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "nzAoFpu9eUSk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PyQthkxrgEbE"
      },
      "source": [
        "### Access Row and Column in a dataframe \n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Selecting Column - You can access or retrieve a single or multiple columns by their names or by their location. "
      ],
      "metadata": {
        "id": "-ZKsG5Ns1ghb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_portfolio_df"
      ],
      "metadata": {
        "id": "9yVtBz7blPiY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WZdePh6lMb-G"
      },
      "source": [
        "my_portfolio_df[\"quantity_owned\"]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EGiaSo1cgEbG"
      },
      "source": [
        "my_portfolio_df.quantity_owned"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sa0IRnuGgEbF"
      },
      "source": [
        "my_portfolio_df[[\"quantity_owned\",\"average_buy_price\"]]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7E1s525XgEbL"
      },
      "source": [
        "#### Selecting Row\n",
        "\n",
        "There are two  key ways by which we select rows of our dataset for further analysis.\n",
        "* Using the label based indexing operator `.loc[]` \n",
        "* Using the integer based indexing operator`.iloc[]`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BouqI6IUgEbN"
      },
      "source": [
        "# loc method - It selects data based on the **'label'** of the rows and columns. Also, it can simultaneously select subsets of rows and columns.\n",
        "my_portfolio_df.loc['OCBC']"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "thAsYbKDgEbL"
      },
      "source": [
        "# iloc method - It selects data based on the integer locations of the rows and columns. Very similar to the .loc[] operator. \n",
        "# One difference is that .loc includes the last value of index when slicing, whereas .iloc excludes it like the rest of Python.\n",
        "\n",
        "my_portfolio_df.iloc[3]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RW8axahyD2K3"
      },
      "source": [
        "my_portfolio_df.loc[['DBS','OCBC','UOB']]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dydlYm0iEEbc"
      },
      "source": [
        "my_portfolio_df.iloc[[3,5,7]]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_portfolio_df.iloc[3:7]"
      ],
      "metadata": {
        "id": "BeDqOmP_q754"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Selecting Row and Column\n",
        "\n",
        "- Import the Singtel stock data from Yahoo FInance from 2017 to 2021\n",
        "- Select the Close and Open price from 2021-11-15 to 2021-11-30\n"
      ],
      "metadata": {
        "id": "qGhiwCRgxdpT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'Z74.SI'\n",
        "stock = yf.download(ticker,start=start_date, end=end_date)\n",
        "\n",
        "stock.loc[___________________]"
      ],
      "metadata": {
        "id": "PbwmnR5YweXE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Selecting Row and Column"
      ],
      "metadata": {
        "id": "XaL1ETptxs2v"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'Z74.SI'\n",
        "stock = yf.download(ticker,start=start_date, end=end_date)\n",
        "\n",
        "stock[['Close','Open']].loc['2021-11-15':'2021-11-30']\n",
        "# Alternative solution\n",
        "# stock.loc['2021-11-15':'2021-11-30'][['Close','Open']]\n",
        "\n"
      ],
      "metadata": {
        "id": "TiqW__k7xmiC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Sort Column\n",
        "\n",
        "Sometimes it becomes necessary to sort a stock price dataframe, based on the 'Closing Price'."
      ],
      "metadata": {
        "id": "Pa3mJxonpIvP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "stock_qty = [300,100,200,800,300,3000,1000,1000,300,100,1000,1000]\n",
        "avg_price=[31.23,11.50,20.95,11.39,9.07,2.38,3.78,0.66,26.61,18.68,4.15,1.30]\n",
        "\n",
        "my_portfolio = {\n",
        "    \"quantity_owned\": stock_qty,\n",
        "    \"average_buy_price\": avg_price\n",
        "}\n",
        "\n",
        "my_portfolio_df = pd.DataFrame(my_portfolio,columns=[\"average_buy_price\",\"quantity_owned\"],index=stock_list)"
      ],
      "metadata": {
        "id": "AFkEYSQ-qP3m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_portfolio_df = my_portfolio_df.sort_values(by=\"quantity_owned\", ascending=False)\n",
        "my_portfolio_df"
      ],
      "metadata": {
        "id": "w6UMJfMrpOjB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Sort Data\n",
        "\n",
        "- Sort the data by market cap \n",
        "- List the top five stocks with highest market cap\n"
      ],
      "metadata": {
        "id": "mEZiiIEgtQlg"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uKzLvpGYOiS2"
      },
      "source": [
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "stock_qty = [300,100,200,800,300,3000,1000,1000,300,100,1000,1000]\n",
        "avg_price=[31.23,11.50,20.95,11.39,9.07,2.38,3.78,0.66,26.61,18.68,4.15,1.30]\n",
        "mkt_cap =[82.54,2.52,8.39,51.24,10.11,40.29,11.80,16.70,45.14,5.49,26.76,5.20]\n",
        "\n",
        "my_portfolio = {\n",
        "    \"quantity_owned\": stock_qty,\n",
        "    \"average_buy_price\": avg_price,\n",
        "    'market_cap':mkt_cap\n",
        "}\n",
        "\n",
        "my_portfolio_df = pd.DataFrame(my_portfolio,columns=_______________________,index=stock_list)\n",
        "my_portfolio_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WGfo4H5GCS_J"
      },
      "source": [
        "my_portfolio_df = my_portfolio_df.sort_values(___________________)\n",
        "my_portfolio_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N4NJjk3vC-z7"
      },
      "source": [
        "my_portfolio_df.iloc[_____________]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ktUTspoOgEbR"
      },
      "source": [
        "#### Solution: Sort Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TaiPid8ogEbR"
      },
      "source": [
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "stock_qty = [300,100,200,800,300,3000,1000,1000,300,100,1000,1000]\n",
        "avg_price=[31.23,11.50,20.95,11.39,9.07,2.38,3.78,0.66,26.61,18.68,4.15,1.30]\n",
        "mkt_cap =[82.54,2.52,8.39,51.24,10.11,40.29,11.80,16.70,45.14,5.49,26.76,5.20]\n",
        "\n",
        "my_portfolio = {\n",
        "    \"quantity_owned\": stock_qty,\n",
        "    \"average_buy_price\": avg_price,\n",
        "    'market_cap':mkt_cap\n",
        "}\n",
        "\n",
        "my_portfolio_df = pd.DataFrame(my_portfolio,columns=[\"average_buy_price\",\"quantity_owned\",\"market_cap\"],index=stock_list)\n",
        "my_portfolio_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_portfolio_df = my_portfolio_df.sort_values(by=\"market_cap\", ascending=False)\n",
        "my_portfolio_df"
      ],
      "metadata": {
        "id": "52cGUTwTs5yr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eL5jssLACoKe"
      },
      "source": [
        "my_portfolio_df.iloc[:5]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QPtyo6FwgEbf"
      },
      "source": [
        "### Filter Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q-VD2kuPgEbg"
      },
      "source": [
        "my_portfolio_df[my_portfolio_df['market_cap']>20]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Another way is to use df.query\n",
        "my_portfolio_df.query('market_cap<100 and market_cap>20')"
      ],
      "metadata": {
        "id": "aihAAr0Y4Pu8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v3eUxvoDahFJ"
      },
      "source": [
        "my_portfolio_df[(my_portfolio_df[\"market_cap\"] > 20) & (my_portfolio_df[\"quantity_owned\"] < 1000)]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rX5fxXOia5Ye"
      },
      "source": [
        "my_portfolio_df[my_portfolio_df[\"quantity_owned\"] == 1000]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UV95VleWbG37"
      },
      "source": [
        "my_portfolio_df.loc[[\"DBS\", \"UOB\"], :]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8f8Ms-FxgEbh"
      },
      "source": [
        "#### Activity: Filtering Data\n",
        "\n",
        "Filter the stock data with the following criteria:\n",
        "market capitalization more than 10\n",
        "stock quantity less than 500\n",
        "stock price is below $10\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VHoW5H6lgEbi"
      },
      "source": [
        "my_portfolio_df[(my_portfolio_df[_________________________]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Filtering Data"
      ],
      "metadata": {
        "id": "4knsJRH5vcdz"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "byhZzaRFgEbj"
      },
      "source": [
        "my_portfolio_df[(my_portfolio_df[\"market_cap\"] > 10) & (my_portfolio_df[\"quantity_owned\"] < 500) & (my_portfolio_df[\"average_buy_price\"] < 10)]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9ZdSa2HugEbk"
      },
      "source": [
        "### Clean Data"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FJZ3Z8_OgEbk"
      },
      "source": [
        "#### Check Missing Data\n",
        "\n",
        "This method returns a Boolean result.<br>\n",
        "<br>\n",
        "It will return 'True' if the data point has a 'NaN' (Not a Number) value. Missing data is represented by a NaN value. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y2Dh8Y4rgEbk"
      },
      "source": [
        "import numpy as np\n",
        "NaN = np.nan\n",
        "\n",
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "stock_qty = [300,NaN,200,800,300,3000,1000,NaN,300,100,1000,1000]\n",
        "avg_price=[31.23,11.50,20.95,11.39,9.07,2.38,NaN,0.66,26.61,18.68,NaN,1.30]\n",
        "mkt_cap =[82.54,2.52,8.39,51.24,10.11,40.29,11.80,16.70,45.14,5.49,26.76,5.20]\n",
        "\n",
        "my_portfolio = {\n",
        "    \"quantity_owned\": stock_qty,\n",
        "    \"average_buy_price\": avg_price,\n",
        "    'market_cap':mkt_cap\n",
        "}\n",
        "\n",
        "my_portfolio_df = pd.DataFrame(my_portfolio,columns=[\"average_buy_price\",\"quantity_owned\",\"market_cap\"],index=stock_list)\n",
        "my_portfolio_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_portfolio_df.isnull()"
      ],
      "metadata": {
        "id": "jTQfOWAN-KzC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Remove Missing Data\n",
        "\n",
        "This method remove the missing data"
      ],
      "metadata": {
        "id": "CaPB06Jf1tn0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "my_portfolio_df.dropna()"
      ],
      "metadata": {
        "id": "o3ZhxnnK1zJs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Impute Missing Sata\n",
        "\n",
        "The .fillna() method will fill all the 'NaN' values of the entire dataframe or of the requested columns with a scalar value of your choice. "
      ],
      "metadata": {
        "id": "Q3bqy6zay-37"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "NaN = np.nan\n",
        "\n",
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "stock_qty = [300,NaN,200,800,300,3000,1000,NaN,300,100,1000,1000]\n",
        "avg_price=[31.23,11.50,20.95,11.39,9.07,2.38,NaN,0.66,26.61,18.68,NaN,1.30]\n",
        "mkt_cap =[82.54,2.52,8.39,51.24,10.11,40.29,11.80,16.70,45.14,5.49,26.76,5.20]\n",
        "\n",
        "my_portfolio = {\n",
        "    \"quantity_owned\": stock_qty,\n",
        "    \"average_buy_price\": avg_price,\n",
        "    'market_cap':mkt_cap\n",
        "}\n",
        "\n",
        "my_portfolio_df = pd.DataFrame(my_portfolio,columns=[\"average_buy_price\",\"quantity_owned\",\"market_cap\"],index=stock_list)\n",
        "my_portfolio_df"
      ],
      "metadata": {
        "id": "9sewVbgT-pvZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_portfolio_df.fillna(0)"
      ],
      "metadata": {
        "id": "qI5hWDxXzMHM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AqoJ4N9UYDAE"
      },
      "source": [
        "my_portfolio_df.fillna(method='pad')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_W74ecfugEbp"
      },
      "source": [
        "my_portfolio_df.fillna(method='backfill')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VKfI8-4G50wi"
      },
      "source": [
        "#### Activity: Clean Data\n",
        "\n",
        "- Check for dataframe for missing data \n",
        "- Impute the missing data with 'pad' or 'backfill'\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "NaN = np.nan\n",
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "stock_qty = [300,100,200,800,300,3000,1000,1000,300,100,1000,1000]\n",
        "avg_price=[31.23,NaN,20.95,11.39,9.07,2.38,NaN,0.66,26.61,18.68,4.15,1.30]\n",
        "mkt_cap =[82.54,2.52,8.39,51.24,NaN,40.29,11.80,16.70,45.14,5.49,NaN,5.20]\n",
        "\n",
        "my_portfolio = {\n",
        "    \"quantity_owned\": stock_qty,\n",
        "    \"average_buy_price\": avg_price,\n",
        "    'market_cap':mkt_cap\n",
        "}\n",
        "\n",
        "my_portfolio_df = pd.DataFrame(my_portfolio,columns=[\"average_buy_price\",\"quantity_owned\",\"market_cap\"],index=stock_list)\n",
        "my_portfolio_df"
      ],
      "metadata": {
        "id": "mPzF0l1i00K8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_portfolio_df._________________"
      ],
      "metadata": {
        "id": "FLcrsBjZ01wP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_portfolio_df.________________________"
      ],
      "metadata": {
        "id": "zwcLepJt07HE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Clean Data"
      ],
      "metadata": {
        "id": "s22buHE2088K"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vVYwauI_1rg1"
      },
      "source": [
        "NaN = np.nan\n",
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "stock_qty = [300,100,200,800,300,3000,1000,1000,300,100,1000,1000]\n",
        "avg_price=[31.23,NaN,20.95,11.39,9.07,2.38,NaN,0.66,26.61,18.68,4.15,1.30]\n",
        "mkt_cap =[82.54,2.52,8.39,51.24,NaN,40.29,11.80,16.70,45.14,5.49,NaN,5.20]\n",
        "\n",
        "my_portfolio = {\n",
        "    \"quantity_owned\": stock_qty,\n",
        "    \"average_buy_price\": avg_price,\n",
        "    'market_cap':mkt_cap\n",
        "}\n",
        "\n",
        "my_portfolio_df = pd.DataFrame(my_portfolio,columns=[\"average_buy_price\",\"quantity_owned\",\"market_cap\"],index=stock_list)\n",
        "my_portfolio_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kho24nHc2v0g"
      },
      "source": [
        "my_portfolio_df.isnull()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gLC5Wgts2O_y"
      },
      "source": [
        "my_portfolio_df.fillna(method='backfill')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wY6zdzqxZ1vh"
      },
      "source": [
        "#Topic 6 Aggregate and Visualize Finance Data"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Add New Computed Column"
      ],
      "metadata": {
        "id": "B6QooxQF6tLR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import Yahoo Finance file\n",
        "\n",
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "stock = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "s0jMrTODEZN3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Computing the percentage change between today's Close and Open\n",
        "\n",
        "stock['intraday_return'] = 100 * (stock['Close'] / stock['Open'] - 1) \n",
        "stock.head()"
      ],
      "metadata": {
        "id": "MPl6V2ZsFNeG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Percentage change calculations"
      ],
      "metadata": {
        "id": "pFgw06rIFhRk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Computing the percentage change between today's Close and previous day's Close using the method pct_change()\n",
        "\n",
        "stock['Close_Pct_Change'] = 100 * stock['Close'].pct_change()\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "2681FO_kEK7E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### The shift operator\n",
        "\n",
        "The shift operator **time-shifts the specified columns either forward or backward by the # of steps specified.** \n",
        "Here shift(1) brings the Close price column down by one step. The shift operator is helpful in making \n",
        "vectorized operations possible in certain cases."
      ],
      "metadata": {
        "id": "FkGx8_-zFmFT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a new column called 'Previous_Close' by using the shift operator on Close column.\n",
        "\n",
        "stock['Previous_Close'] =  stock['Close'].shift()\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "OQ2yxIBvFCwt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculating the percentage return between previous close and today's open\n",
        "\n",
        "stock['simple_return'] = 100*(stock['Close']/stock['Close'].shift(1)-1)\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "ZEM2FtzaSXpj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock['log_return'] = np.log(stock['Close'] / stock['Close'].shift(1))\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "h4qK-TqaRo9-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculating the percentage return between previous close and today's open\n",
        "\n",
        "stock['overnight_return'] = 100*(stock['Open']/stock['Previous_Close']-1)\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "WSyQLjmkGFDy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Moving Average calculations using .rolling()"
      ],
      "metadata": {
        "id": "v_r2yjVnHJQf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import Yahoo Finance file\n",
        "\n",
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "stock = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "5H78UEF1KA2p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Creting a new column called 'MA' containing 5 day Moving Average of Close prices.\n",
        "\n",
        "stock['MA_5'] = stock['Close'].rolling(window=5).mean()\n",
        "stock.head(10)"
      ],
      "metadata": {
        "id": "5lbF44-UHMQ_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Working with missing/NaN values"
      ],
      "metadata": {
        "id": "0AAGeNq0Hu25"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock.dropna(inplace=True)\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "gcuYTjZ4HwfL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Joining Data"
      ],
      "metadata": {
        "id": "toLdZq2WCDpH"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qrR8YxldgEb0"
      },
      "source": [
        "#### Concat Data"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2018-12-31'\n",
        "ticker = 'Z74.SI'\n",
        "stock1 = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock1.tail()"
      ],
      "metadata": {
        "id": "i8iJG2z226lP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2019-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'Z74.SI'\n",
        "stock2 = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock2.tail()"
      ],
      "metadata": {
        "id": "F-sG5bkS3Bwk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0ZJK443QsjFx"
      },
      "source": [
        "stock3 = pd.concat([stock1,stock2],axis=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock3.head()"
      ],
      "metadata": {
        "id": "Gm6Mq7PZ3aCa"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock3.tail()"
      ],
      "metadata": {
        "id": "lmrB3IWW3cY_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jz0HugqlgEb0"
      },
      "source": [
        "#### Append Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e0jr3wVpgEb9"
      },
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2018-12-31'\n",
        "ticker = 'Z74.SI'\n",
        "stock1 = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock1.tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2020-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "stock2 = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock2.tail()"
      ],
      "metadata": {
        "id": "-CmJyvWB5eTm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock3 = stock1.append(stock2)"
      ],
      "metadata": {
        "id": "7KDBvvRF5iBM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock3.head()"
      ],
      "metadata": {
        "id": "8uWogWFO5pFO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock3.tail()"
      ],
      "metadata": {
        "id": "9CJakRYw5r-F"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rp5jbizT1qjW"
      },
      "source": [
        "#### Activity: Joining Data\n",
        "\n",
        "- Import the DBS stock data from 2017-01-01 to 2019-12-31\n",
        "- Import another DBS stock data from 2020-01-01 to 2021-11-30\n",
        "- Join the two data sets from 2017-01-01 to 2021-11-30\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = __________\n",
        "end_date = ________\n",
        "ticker = ___________'\n",
        "stock1 = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock1.tail()"
      ],
      "metadata": {
        "id": "AOFZW5_z4ZXS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = __________\n",
        "end_date = ________\n",
        "ticker = ___________'\n",
        "stock2 = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock2.tail()"
      ],
      "metadata": {
        "id": "8_8t0AGX4a8G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock3 = _______________________"
      ],
      "metadata": {
        "id": "tRVUJ4eB4epq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock3.tail()"
      ],
      "metadata": {
        "id": "gUU8gs5n4gcV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock3.head()"
      ],
      "metadata": {
        "id": "ojfT1Gu34iJf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Joining Data"
      ],
      "metadata": {
        "id": "HJrEHXUl4is7"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wlrIGwcDaRmU"
      },
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2019-12-31'\n",
        "ticker = 'D05.SI'\n",
        "stock1 = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock1.tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rd828ic8aoJF"
      },
      "source": [
        "start_date = '2020-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "stock2 = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock2.tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mkSioRJzcKYD"
      },
      "source": [
        "stock3 = pd.concat([stock1,stock2],axis=0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VTPdBSFfc1eh"
      },
      "source": [
        "stock3.tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock3.head()"
      ],
      "metadata": {
        "id": "WIJsh2Jz4Wnx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Qk0-GRygEcA"
      },
      "source": [
        "#### Merging Data"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5xEp6QeJgEcB"
      },
      "source": [
        "left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],\n",
        "                     'A': ['A0', 'A1', 'A2', 'A3'],\n",
        "                     'B': ['B0', 'B1', 'B2', 'B3']})\n",
        "left"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OzGGgFa96UDw"
      },
      "source": [
        "right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K4'],\n",
        "                      'C': ['C0', 'C1', 'C2', 'C4'],\n",
        "                      'D': ['D0', 'D1', 'D2', 'D4']})\n",
        "right"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bWJefyWs6evU"
      },
      "source": [
        "result = pd.merge(left, right, on='key')\n",
        "result"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Aqto-er66klo"
      },
      "source": [
        "inner = pd.merge(left, right, on='key',how='inner')\n",
        "inner"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Krzonfx96omW"
      },
      "source": [
        "outer = pd.merge(left, right, on='key',how='outer')\n",
        "outer"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tEKbui0M643F"
      },
      "source": [
        "left = pd.merge(left, right, on='key',how='left')\n",
        "left"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iKPAD2Tj6_Rr"
      },
      "source": [
        "right  = pd.merge(left, right, on='key',how='right')\n",
        "right"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U0VtE3NrgEcD"
      },
      "source": [
        "#### Activiity: Merging Data\n",
        "\n",
        "- Import the DBS stock data from 2017-01-01 to 2019-12-31\n",
        "- Import another DBS stock data from 2019-01-01' to 2021-11-30\n",
        "- Merge the two data sets on Date using inner join\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2019-12-31'\n",
        "ticker = 'D05.SI'\n",
        "stock1 = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock1.tail()"
      ],
      "metadata": {
        "id": "bYbr0HPM737L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2019-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "stock2 = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock2.tail()"
      ],
      "metadata": {
        "id": "C_f8R-5975H1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock3 = pd.merge(stock1, stock2, on='Date',how='inner')\n",
        "stock3.head()"
      ],
      "metadata": {
        "id": "2vusbSYs7747"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Merging Data"
      ],
      "metadata": {
        "id": "UhN-bGoy79MN"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kK8TMhXrgEcD"
      },
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2019-12-31'\n",
        "ticker = 'D05.SI'\n",
        "stock1 = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock1.tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yyxVS2dkgEcE"
      },
      "source": [
        "start_date = '2019-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "stock2 = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock2.tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock3 = pd.merge(stock1, stock2, on='Date',how='inner')\n",
        "stock3.head()"
      ],
      "metadata": {
        "id": "6upwPFbm65Ra"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WNDTF_GDgEcF"
      },
      "source": [
        "### Grouping Data and Aggregation\n",
        "\n",
        "Any groupby operation involves one of the following operations on the original dataframe/object. They are:\n",
        "<br>\n",
        "1. <b>Splitting</b> the data into groups based on some criteria.<br>\n",
        "<br>\n",
        "2. <b>Applying</b> a function to each group separately.<br>\n",
        "<br>\n",
        "3. <b>Combining</b> the results into a single dataframe.<br>\n",
        "<br>\n",
        "Splitting the data is pretty straight forward. What adds value to this split is the 'Apply' step. This makes 'Groupby' function interesting. In the apply step, you may wish to do one of the following: <br>\n",
        "<br>\n",
        "a. Aggregation − Computing a summary statistic. Eg: Compute group sums or means.<br>\n",
        "<br>\n",
        "b. Transformation − performs some group-specific operation. Eg: Standardizing data (computing z-score) within the group.<br> \n",
        "<br>\n",
        "c. Filtration − discarding the data with some condition.<br> \n",
        "<br>\n",
        "Let us now create a DataFrame object and perform all the operations on it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4uoSPWMkAvO2"
      },
      "source": [
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "sector = ['Finance','Healthcare','Transport','Finance','Finance','Technology','Technology',\\\n",
        "              'Food','Finance','Finance','Food','Transport']\n",
        "stock_qty = [300,100,200,800,300,3000,1000,1000,300,100,1000,1000]\n",
        "avg_price=[31.23,11.50,20.95,11.39,9.07,2.38,3.78,0.66,26.61,18.68,4.15,1.30]\n",
        "mkt_cap =[82.54,2.52,8.39,51.24,10.11,40.29,11.80,16.70,45.14,5.49,26.76,5.20]\n",
        "position =[\"Buy\",\"Sell\",\"Sell\",\"Sell\",\"Buy\",\"Buy\",\"Buy\",\"Sell\",\"Buy\",\"Sell\",\"Buy\",\"Sell\"]\n",
        "\n",
        "my_portfolio = {\n",
        "    \"quantity_owned\": stock_qty,\n",
        "    \"average_buy_price\": avg_price,\n",
        "    'market_cap':mkt_cap,\n",
        "    'sector':sector,\n",
        "    'position': position\n",
        "}\n",
        "\n",
        "my_portfolio_df = pd.DataFrame(my_portfolio,columns=[\"average_buy_price\",\"quantity_owned\",\"market_cap\",\"sector\",\"position\"],index=stock_list)\n",
        "my_portfolio_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "my_portfolio_df.groupby('sector').count()"
      ],
      "metadata": {
        "id": "kGr4sS0A8RCu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OSP0-2Wsc7IW"
      },
      "source": [
        "my_portfolio_df.groupby('sector').market_cap.mean()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rnDXLTzPA0pj"
      },
      "source": [
        "my_portfolio_df.groupby(['sector','quantity_owned']).mean()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OEcoFLbfCMUo"
      },
      "source": [
        "my_portfolio_df.groupby('sector').sum()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LmfbBIZBj3Ww"
      },
      "source": [
        "my_portfolio_df.groupby('sector').agg(['count', 'mean','sum'])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Epe1nDikjen3"
      },
      "source": [
        "my_portfolio_df.groupby('sector').agg(lambda x:max(x)-min(x))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I4EUqUAZK9kl"
      },
      "source": [
        "### Activitiy: Groupby\n",
        "\n",
        "Compute the total number of stocks purchased for each sector."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "my_portfolio_df.groupby(____________)[____________]._____________)"
      ],
      "metadata": {
        "id": "cRpzgLSP_spS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Solution: Groupby"
      ],
      "metadata": {
        "id": "WeeiyWtu_xVP"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L2LIQrGveBxp"
      },
      "source": [
        "my_portfolio_df.groupby('sector')['quantity_owned'].sum()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QsuSAJvUIh6k"
      },
      "source": [
        "#### Pivoting Data"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "my_portfolio_df.pivot(values=\"quantity_owned\", columns=\"position\")"
      ],
      "metadata": {
        "id": "lV2nZT2Aj3t9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IknTVeXtMLtS"
      },
      "source": [
        "pd.pivot_table(my_portfolio_df, values=\"quantity_owned\", \\\n",
        "               aggfunc=\"sum\",index=[\"sector\"], columns=[\"position\"])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FCCuTYPwTRWj"
      },
      "source": [
        "#### Activity: Pivot Table\n",
        "\n",
        "Create a pivot table and compute the average buy price for each sector"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pd.pivot_table(_______________________)"
      ],
      "metadata": {
        "id": "VD2nyS74BYVj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Pivot Table"
      ],
      "metadata": {
        "id": "SBwZxu1EBbPh"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "H99uCIMpFhCS"
      },
      "source": [
        "pd.pivot_table(my_portfolio_df, values=\"average_buy_price\", \\\n",
        "               aggfunc=\"mean\",index=[\"sector\"], columns=[\"position\"])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G1dOkMVjgEcR"
      },
      "source": [
        "## Visualization"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oo5-hh9wndTS"
      },
      "source": [
        "#### Line Plot"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "dbs = yf.download(ticker,start=start_date, end=end_date)"
      ],
      "metadata": {
        "id": "PVXnPkDwCDm1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xPNmPhoVnCjq"
      },
      "source": [
        "dbs['Close'].plot()\n",
        "plt.ylabel('Close Price')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2uCvKWxPoGSL"
      },
      "source": [
        "#### Activity: Scatter Plot\n",
        "\n",
        "- Download the Singtel and DBS historical stock market price\n",
        "- Create a scatter plot between Singtel and DBS closing stock price.\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "dbs = yf.download(ticker,start=start_date, end=end_date)\n",
        "dbs = dbs['Close']\n",
        "\n",
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'Z74.SI'\n",
        "singtel = yf.download(ticker,start=start_date, end=end_date)\n",
        "singtel = singtel['Close']\n",
        "\n",
        "df = pd.DataFrame(_______________)\n",
        "df.plot.____________________________"
      ],
      "metadata": {
        "id": "JYj-5W5pCo6j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Scatter Plot"
      ],
      "metadata": {
        "id": "iJUlfl4Fpar4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "dbs = yf.download(ticker,start=start_date, end=end_date)\n",
        "dbs = dbs['Close']\n",
        "\n",
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'Z74.SI'\n",
        "singtel = yf.download(ticker,start=start_date, end=end_date)\n",
        "singtel = singtel['Close']\n",
        "\n",
        "df = pd.DataFrame({'dbs_stock':dbs,'singtel_stock':singtel})\n",
        "df.plot.scatter(x=\"dbs_stock\", y=\"singtel_stock\",alpha=0.5)"
      ],
      "metadata": {
        "id": "taRNW360pYnK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "dbs = yf.download(ticker,start=start_date, end=end_date)\n",
        "dbs = dbs['Close']\n",
        "\n",
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'U11.SI'\n",
        "uob = yf.download(ticker,start=start_date, end=end_date)\n",
        "uob = uob['Close']\n",
        "\n",
        "df = pd.DataFrame({'dbs_stock':dbs,'uob_stock':uob})\n",
        "df.plot.scatter(x=\"dbs_stock\", y=\"uob_stock\",alpha=0.5)"
      ],
      "metadata": {
        "id": "2nLPsrd7pGsu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "35dULZLRpJrP"
      },
      "source": [
        "#### Bar Plot"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# data = pd.read_csv('https://raw.githubusercontent.com/tertiarycourses/datasets/master/gst-by-economic-sector.csv')\n",
        "# data\n",
        "my_portfolio_df.pivot(values=\"quantity_owned\", columns=\"sector\").plot.bar()"
      ],
      "metadata": {
        "id": "7U4qd409VgM5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "data.groupby('economic_sector')['no_of_businesses'].sum().plot.barh()\n",
        "plt.xlabel('No of Business')"
      ],
      "metadata": {
        "id": "8LHWs494V0MA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Bar Plot\n",
        "\n",
        "- Import the economic data from https://raw.githubusercontent.com/tertiarycourses/datasets/master/gst-by-economic-sector.csv\n",
        "- Create a bar plot of # of businesses for each year\n"
      ],
      "metadata": {
        "id": "3geB1dZ1Zkec"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = pd.read_csv('https://raw.githubusercontent.com/tertiarycourses/datasets/master/gst-by-economic-sector.csv')\n",
        "data.groupby(___________________)\n",
        "plt.xlabel('No of Business')"
      ],
      "metadata": {
        "id": "JlDvZHHGDNit"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Bar Plot"
      ],
      "metadata": {
        "id": "cZcSRLfBZpAH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = pd.read_csv('https://raw.githubusercontent.com/tertiarycourses/datasets/master/gst-by-economic-sector.csv')\n",
        "data.groupby(['financial_year'])['no_of_businesses'].sum().plot.barh()\n",
        "plt.xlabel('No of Business')"
      ],
      "metadata": {
        "id": "iaTwRKUeZtfW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Stacked Bar Plot"
      ],
      "metadata": {
        "id": "pzCMhBMie7ac"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "sector = ['Finance','Healthcare','Transport','Finance','Finance','Technology','Technology',\\\n",
        "              'Food','Finance','Finance','Food','Transport']\n",
        "stock_qty = [300,100,200,800,300,3000,1000,1000,300,100,1000,1000]\n",
        "avg_price=[31.23,11.50,20.95,11.39,9.07,2.38,3.78,0.66,26.61,18.68,4.15,1.30]\n",
        "mkt_cap =[82.54,2.52,8.39,51.24,10.11,40.29,11.80,16.70,45.14,5.49,26.76,5.20]\n",
        "position =[\"Buy\",\"Sell\",\"Sell\",\"Sell\",\"Buy\",\"Buy\",\"Buy\",\"Sell\",\"Buy\",\"Sell\",\"Buy\",\"Sell\"]\n",
        "\n",
        "my_portfolio = {\n",
        "    \"quantity_owned\": stock_qty,\n",
        "    \"average_buy_price\": avg_price,\n",
        "    'market_cap':mkt_cap,\n",
        "    'sector':sector,\n",
        "    'position': position\n",
        "}\n",
        "\n",
        "my_portfolio_df = pd.DataFrame(my_portfolio,columns=[\"average_buy_price\",\"quantity_owned\",\"market_cap\",\"sector\",\"position\"],index=stock_list)\n",
        "my_portfolio_df"
      ],
      "metadata": {
        "id": "N01kx2-3clsq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pd.pivot_table(my_portfolio_df, values=\"quantity_owned\", \\\n",
        "               aggfunc=\"sum\",index=\"position\",columns=\"sector\").plot.bar()\n",
        "\n",
        "plt.ylabel('stock quality')"
      ],
      "metadata": {
        "id": "5VCxuXkSexbo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pd.pivot_table(my_portfolio_df, values=\"quantity_owned\", \\\n",
        "               aggfunc=\"sum\",index=\"position\",columns=\"sector\").plot.bar(stacked=True)\n",
        "\n",
        "plt.ylabel('stock quality')"
      ],
      "metadata": {
        "id": "tiRy40J-cpfw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KXrmndH-AXVm"
      },
      "source": [
        "### Pie Plot"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YbKPBpubAKXr"
      },
      "source": [
        "data = pd.read_csv('https://raw.githubusercontent.com/tertiarycourses/datasets/master/gst-by-economic-sector.csv')\n",
        "\n",
        "plt.figure(figsize=(10,10))\n",
        "data.groupby(['economic_sector'])['no_of_businesses'].sum().plot.pie()\n",
        "plt.ylabel('')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wi8T2GV-8YJ1"
      },
      "source": [
        "### Boxplot"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZSHONUAzgEcX"
      },
      "source": [
        "my_portfolio_df.pivot(columns='sector',values='average_buy_price').plot.box()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8LqNNWR8_3DJ"
      },
      "source": [
        "### Area Plot"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mniu6MsH_sf9"
      },
      "source": [
        "pd.pivot_table(my_portfolio_df, values=\"average_buy_price\", \\\n",
        "               aggfunc=\"mean\",index=\"sector\",columns=\"position\").plot.area()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VH1TUqLC8boj"
      },
      "source": [
        "### Histogram"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "croK8jpc4z0Y"
      },
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "dbs = yf.download(ticker,start=start_date, end=end_date)\n",
        "dbs.Close.plot.hist(bins=25)\n",
        "plt.xlabel('Stock Price')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-WNvXsgO6Eva"
      },
      "source": [
        "### Activity: Histogram\n",
        "\n",
        "- Download the Singtel historical stock price from Yahoo Finance.\n",
        "- Plot a histogram of Singtel Close stock price\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2XCEhmlv5yzh"
      },
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'Z74.SI'\n",
        "singtel = yf.download(ticker,start=start_date, end=end_date)\n",
        "singtel.____________________________\n",
        "plt.xlabel('Stock Price')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Solution: Histogram"
      ],
      "metadata": {
        "id": "yrx8DwvdqXok"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'Z74.SI'\n",
        "singtel = yf.download(ticker,start=start_date, end=end_date)\n",
        "singtel.Close.plot.hist(bins=25)\n",
        "plt.xlabel('Stock Price')"
      ],
      "metadata": {
        "id": "3VXDkefUqV3U"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L2TpPaOmgEcY"
      },
      "source": [
        "## Topic 2.4 Data Analysis \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P73Xquh-Fg4u"
      },
      "source": [
        "#### Descriptive Statistics"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'Z74.SI'\n",
        "stock = yf.download(ticker,start=start_date, end=end_date)\n",
        "\n",
        "stock.Close.describe()"
      ],
      "metadata": {
        "id": "XIMybfhaIff0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.count()\n",
        "\n",
        "This method returns the number of non-null observations over the requested observations."
      ],
      "metadata": {
        "id": "E_-hKUzkI1TY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock.count()"
      ],
      "metadata": {
        "id": "J-SvH6TDIkMD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.min()\n",
        "\n",
        "This method returns the minimum value over the requested observations"
      ],
      "metadata": {
        "id": "bUCPBnUEJFkt"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uvqm6j8zCSgD"
      },
      "source": [
        "stock.min()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.max()\n",
        "\n",
        "This method returns the maximum value over the requested observations."
      ],
      "metadata": {
        "id": "GIYRrh4aJZ81"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ie8PE1CoDC1o"
      },
      "source": [
        "stock.max()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.mean()\n",
        "\n",
        "The mean of a set of observations is the arithmetic average of the values. \n",
        "\n",
        "This method returns the mean of the requested observations."
      ],
      "metadata": {
        "id": "z5UlMjwLJpMd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock.mean()"
      ],
      "metadata": {
        "id": "r7zaa4NrJqU_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.median()\n",
        "\n",
        "The median is a statistical measure that determines the middle value of a dataset listed in ascending order.\n",
        "\n",
        "This method returns the median of the requested observations."
      ],
      "metadata": {
        "id": "_MuB-2baJ1uW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock.median()"
      ],
      "metadata": {
        "id": "AmWk1KvsJ2nc"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.mode()\n",
        "\n",
        "The mode is the value that appears most frequently in a data set. \n",
        "\n",
        "This method returns the mode of the requested observations."
      ],
      "metadata": {
        "id": "hPJ4uldTKB8C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock.mode()"
      ],
      "metadata": {
        "id": "PjiDa87tKDjR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.sum()\n",
        "\n",
        "This method returns the sum of all the values of the requested observations."
      ],
      "metadata": {
        "id": "3nzNVf3xKNF5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock.sum()"
      ],
      "metadata": {
        "id": "Kfc6dn71KOZY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.diff()\n",
        "\n",
        "This method returns the 'difference' between the current observation and the previous observation."
      ],
      "metadata": {
        "id": "5P0Imo6BKapL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock.diff()"
      ],
      "metadata": {
        "id": "GLI-ehD-KbkB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.pct_change()]\n",
        "\n",
        "This method returns the percentage change of the current observation with the previous observation."
      ],
      "metadata": {
        "id": "Z94pK1K9Kg3E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock.pct_change()"
      ],
      "metadata": {
        "id": "FFExQy3aKhyb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.var()\n",
        "\n",
        "Variance is a statistical measurement of the spread between numbers in a data set.\n",
        "\n",
        "This method returns the variance of the requested observations."
      ],
      "metadata": {
        "id": "WiWkP1OaKpVk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock.var()"
      ],
      "metadata": {
        "id": "Cyn2zjWXKqiP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.std()\n",
        "\n",
        "Standard deviation is a statistical measure that measures the dispersion of a dataset relative to its mean.\n",
        "\n",
        "\n",
        "This method returns the standard deviation of the requested observations."
      ],
      "metadata": {
        "id": "DftRYv8nKvMQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "stock.std()"
      ],
      "metadata": {
        "id": "mRtD9gd4KwCm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.rolling(window=).mean()\n",
        "\n",
        "A moving average(also known as rolling average) is a calculation used to analyze data points by creating a series of averages of different subsets of the full data set. It is commonly used as a technical indicator.\n",
        "\n",
        "This method helps us to calculate the moving average of the observations."
      ],
      "metadata": {
        "id": "A_zOk6ZdK0jS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "stock['Close'].plot(figsize=(17,8))\n",
        "stock[\"Close\"].rolling(window=10).mean().plot(figsize=(17,8))\n",
        "stock[\"Close\"].rolling(window=100).mean().plot(figsize=(17,8))\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "In6-Y11xK21T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.ewm(span=).mean()\n",
        "Exponential Moving Average\n"
      ],
      "metadata": {
        "id": "tY7jUjafLh6I"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "97jOK_x5DjP9"
      },
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "stock['Close'].plot(figsize=(17,8))\n",
        "stock[\"Close\"].ewm(span=10,).mean().plot(figsize=(17,8))\n",
        "stock[\"Close\"].ewm(span=100).mean().plot(figsize=(17,8))\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-B9V_ginGSC8"
      },
      "source": [
        "#### Activitiy: Rolling Window Average\n",
        "\n",
        "- Import the Singtel stock close data from Yahoo from 2017 to 2021\n",
        "- Overlay the raw data, rolling window, expanding window\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "dbs = yf.download(ticker,start=start_date, end=end_date)"
      ],
      "metadata": {
        "id": "KuF6B83px3QD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a-hemZw3FfeM"
      },
      "source": [
        "plt.figure(figsize=(10,5))\n",
        "dbs['Close'].plot()\n",
        "dbs['Close']._____________________________\n",
        "dbs['Close'].________________________\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Rolling Window Average"
      ],
      "metadata": {
        "id": "Eqw9yb4MyH5v"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "dbs = yf.download(ticker,start=start_date, end=end_date)"
      ],
      "metadata": {
        "id": "eXDD9CIlyBZV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plt.figure(figsize=(10,5))\n",
        "dbs['Close'].plot()\n",
        "dbs['Close'].rolling(window=20).mean().plot()\n",
        "dbs['Close'].expanding(min_periods=10).mean().plot()\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "upDGSVneyFqp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MEt4jzoeA_Rf"
      },
      "source": [
        "#### DataFrame.cov()\n",
        "\n",
        "Covariance is a statistical measure that is used to determine the relationship between the movement of two asset prices.\n",
        "\n",
        "This method returns the covariance between the closing price of the DBS stock with the closing price of the UOB stock."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mBFHvjNKA3KH"
      },
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "dbs = yf.download(ticker,start=start_date, end=end_date)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xB6udGwrA6dF"
      },
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'U11.SI'\n",
        "uob = yf.download(ticker,start=start_date, end=end_date)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dbs[\"Close\"].cov(uob[\"Close\"])"
      ],
      "metadata": {
        "id": "Q_DsR7ZYMpUI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.corr()\n",
        "\n",
        "Correlation is a statistical measure that expresses the extent to which two variables are linearly related.\n",
        "\n",
        "This method returns the correlation between the closing price of the DBS stock with the closing price of the UOB stock."
      ],
      "metadata": {
        "id": "G9lOx_jZNG4J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dbs[\"Close\"].corr(uob[\"Close\"])"
      ],
      "metadata": {
        "id": "FJdBTeu5NJuo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Activity: Covariance and Correlation\n",
        "\n",
        "- Import the DBS and Singtel stock close data from Yahoo from 2017 to 2021\n",
        "- Compute the covariance and correlation between DBS and Singtel stock closing price"
      ],
      "metadata": {
        "id": "0nCcQEKuzo8x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "dbs = yf.download(ticker,start=start_date, end=end_date)"
      ],
      "metadata": {
        "id": "L-8vQbuyzZg5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'Z74.SI'\n",
        "singtel = yf.download(ticker,start=start_date, end=end_date)"
      ],
      "metadata": {
        "id": "B43ShdW_zuAY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dbs[\"Close\"]._______________________"
      ],
      "metadata": {
        "id": "8WyDdsILz3y5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dbs[\"Close\"].____________________"
      ],
      "metadata": {
        "id": "XGN9do5az59R"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Covariance and Correlation"
      ],
      "metadata": {
        "id": "BdaHiDyA0GHp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dbs[\"Close\"].cov(singtel[\"Close\"])"
      ],
      "metadata": {
        "id": "sMA1dHT1z_bZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dbs[\"Close\"].corr(singtel[\"Close\"])"
      ],
      "metadata": {
        "id": "s6K1HJHS0DEO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.kurt()\n",
        "\n",
        "Kurtosis is a statistical measure that defines how heavily the tails of a distribution differ from the tails of a normal distribution.\n",
        "\n",
        "This method returns unbiased kurtosis over the requested data set using Fisher's definition of kurtosis (where kurtosis of normal distribution = 0)"
      ],
      "metadata": {
        "id": "TAJ-8rY2Nxi5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A negative kurtosis value indicates a platykurtic distribution. Such a distribution will have thinner tails, resulting in fewer extreme positive or negative events."
      ],
      "metadata": {
        "id": "LgN-flq4N7sU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dbs[\"Close\"].kurt()"
      ],
      "metadata": {
        "id": "o-iztmWFNzIh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### DataFrame.skew()\n",
        "\n",
        "In statistics, skewness is a measure of the asymmetry of the distribution of a variable about its mean.\n",
        "\n",
        "This method unbiased skew over the requested data set."
      ],
      "metadata": {
        "id": "O8K7yxUTN-Tr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dbs[\"Close\"].skew()"
      ],
      "metadata": {
        "id": "ELE3IPxcOAjv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WpK7XPfuZJs-"
      },
      "source": [
        "# Topic 7 Analyze Finance Data"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Apply"
      ],
      "metadata": {
        "id": "YFO741CdW-zV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import Yahoo Finance file\n",
        "\n",
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "stock = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "72iQkhd8XNzb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a function to calculate the intraday range\n",
        "def daily_range(x):\n",
        "    return x['Close']-x['Open']"
      ],
      "metadata": {
        "id": "xW4aqVWSXF4D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a new column by applying the function we defined above to the DataFrame df\n",
        "stock['daily_range'] = stock.apply(daily_range, axis=1)\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "wnwNBbhDYfJH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pM576cf-f8vC"
      },
      "source": [
        "stock_list = ['DBS','Haw Par','Jardine C&C','OCBC','SGX','Singtel','ST Engineering',\\\n",
        "              'Thai Beverage','UOB','Venture','Wilmar','YZJ Shipbldg']\n",
        "sector = ['Finance','Healthcare','Transport','Finance','Finance','Technology','Technology',\\\n",
        "              'Food','Finance','Finance','Food','Transport']\n",
        "dividend = ['Yes','No','No','Yes','No','Yes','No',\\\n",
        "              'Yes','No','No','No','Yes']            \n",
        "stock_qty = [300,100,200,800,300,3000,1000,1000,300,100,1000,1000]\n",
        "avg_price=[31.23,11.50,20.95,11.39,9.07,2.38,3.78,0.66,26.61,18.68,4.15,1.30]\n",
        "mkt_cap =[82.54,2.52,8.39,51.24,10.11,40.29,11.80,16.70,45.14,5.49,26.76,5.20]\n",
        "\n",
        "my_portfolio = {\n",
        "    \"quantity_owned\": stock_qty,\n",
        "    \"average_buy_price\": avg_price,\n",
        "    'market_cap':mkt_cap,\n",
        "    'sector':sector,\n",
        "    'dividend':dividend\n",
        "}\n",
        "\n",
        "my_portfolio_df = pd.DataFrame(my_portfolio,columns=[\"average_buy_price\",\"quantity_owned\",\"market_cap\",\"sector\",\"dividend\"],index=stock_list)\n",
        "my_portfolio_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n1YhVsaDf-YV"
      },
      "source": [
        "SGD2USD = 1.4\n",
        "my_portfolio_df['average_buy_price'] = my_portfolio_df['average_buy_price'].apply(lambda x:x/SGD2USD)\n",
        "my_portfolio_df"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "viSiaJyLnzQ3"
      },
      "source": [
        "#### Activity: Apply"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Import Yahoo Finance file\n",
        "\n",
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "stock = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "iCOoa9XyyDMI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U3MVhK0tmm48"
      },
      "source": [
        "def Direction(x):\n",
        "    ______"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock['Direction'] = stock.__________\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "U1nhLSruyUVr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solution: Apply"
      ],
      "metadata": {
        "id": "ysAGLWrd4VKe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import Yahoo Finance file\n",
        "\n",
        "start_date = '2017-01-01'\n",
        "end_date = '2021-11-30'\n",
        "ticker = 'D05.SI'\n",
        "stock = yf.download(ticker,start=start_date, end=end_date)\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "maMqZck-ZkY5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def Direction(x):\n",
        "    if x['Close']>x['Open']:\n",
        "        return 'Up'\n",
        "    else:\n",
        "      return 'Down'"
      ],
      "metadata": {
        "id": "A3sxYNBgqY3X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "stock['Direction'] = stock.apply(Direction,axis=1)\n",
        "stock.head()"
      ],
      "metadata": {
        "id": "Z-VM5GFqlokf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DdggqdNXIp0x"
      },
      "source": [
        "### Pipe"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "start_date = '2017-01-01'\n",
        "end_date = '2019-12-31'\n",
        "ticker = 'D05.SI'\n",
        "dbs = yf.download(ticker,start=start_date, end=end_date)\n",
        "dbs"
      ],
      "metadata": {
        "id": "FpUnwiN9P_Ma"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dbs.loc['2019-01-01':'2019-12-30']"
      ],
      "metadata": {
        "id": "mwNXx2trQB9i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def load_data(ticker, start_date,end_date):\n",
        "    return yf.download(ticker,start=start_date, end=end_date)\n",
        "    "
      ],
      "metadata": {
        "id": "i5yk6a7BN1di"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dbs = load_data('D05.SI','2021-01-01','2021-11-30')\n",
        "dbs"
      ],
      "metadata": {
        "id": "XYjveuWIRppl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def filter_data(df):\n",
        "    start = '2021-01-01'\n",
        "    end = '2021-06-01'\n",
        "    return df.loc[start:end]"
      ],
      "metadata": {
        "id": "mHP0gmC0O3g4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dbs_filtered = filter_data(dbs)\n",
        "dbs_filtered"
      ],
      "metadata": {
        "id": "rWFobc76SWxH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def plotbar(df):\n",
        "    df['Close'].plot()\n",
        "    plt.xlabel('Days')\n",
        "    plt.ylabel('Price')"
      ],
      "metadata": {
        "id": "PCVVmPHoObFj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plotbar(dbs_filtered)"
      ],
      "metadata": {
        "id": "Bl5-1qlmSkE7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "dbs_pipe =(\n",
        "    load_data('D05.SI','2021-01-01','2021-11-30')\n",
        "    .pipe(filter_data)\n",
        "    .pipe(plotbar)\n",
        ")\n"
      ],
      "metadata": {
        "id": "aSWhCMQZOjLY"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RQbQYM3-LBXi"
      },
      "source": [
        "#### Activity: Pipe\n",
        "\n",
        "- Create a pipe to load the UOB stock data from Yahoo Finance\n",
        "- Filter only the Open and Close data\n",
        "- Plot the Open and Close data\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def load_data(ticker, start_date,end_date):\n",
        "    _____________________\n",
        "    return stock"
      ],
      "metadata": {
        "id": "WvLV5fRUXI4d"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def plotbar(df):\n",
        "    __________________"
      ],
      "metadata": {
        "id": "XXDJb--jXPCW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "uob_pipe =(\n",
        "    ____________________\n",
        ")"
      ],
      "metadata": {
        "id": "297R-IB7XS-P"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Solutoin: Pipe"
      ],
      "metadata": {
        "id": "JPas0fgMXKQo"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UyD7LWyPJ-J2"
      },
      "source": [
        "def load_data(ticker, start_date,end_date):\n",
        "    stock = yf.download(ticker,start=start_date, end=end_date)\n",
        "    stock = stock[['Open','Close']]\n",
        "    return stock\n",
        "    "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MtPATB8JKFg8"
      },
      "source": [
        "def plotbar(df):\n",
        "    df.plot()\n",
        "    plt.xlabel('Days')\n",
        "    plt.ylabel('Price')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o1kWNSu-K1nJ"
      },
      "source": [
        "uob_pipe =(\n",
        "    load_data('U11.SI','2019-01-01','2021-11-30')\n",
        "    .pipe(plotbar)\n",
        ")"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}