Python_basics_2076.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.7.4"
    },
    "colab": {
      "name": "Python_basics-2076.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MafikengZ/explore-data-science/blob/main/Python_basics_2076.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rstuDWqlj3Ut"
      },
      "source": [
        "# Python Basics\n",
        "© Explore Data Science Academy\n",
        "\n",
        "## Learning Objectives:\n",
        "By the end of this train, you should be able to:\n",
        "* Perform basic print functions and string manipulation; and\n",
        "* Create basic Python functions.\n",
        "\n",
        "## Outline\n",
        "In this train we will:\n",
        "* Introduce print statements;\n",
        "* Perform basic string manipulation; and\n",
        "* Breakdown the different aspects of Python Functions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8ess357Yj3Uz"
      },
      "source": [
        "## Print Statements and Strings\n",
        "\n",
        "The standard introduction into any programming language is the ''Hello world!'' program. This is a computer program that outputs \"Hello world!\" to your console window. In Python, this program can be implemented using the **print** built-in function as follows: "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2O7Tm2u3j3U0",
        "outputId": "365ab6fd-b46d-4e20-f62a-a7b8f1f21a6d"
      },
      "source": [
        "print(\"Hello world!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello world!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jgQtWizdj3U2"
      },
      "source": [
        "The **print** function \"prints\" the value stored in Python variables/objects as a **string** to the console, or other standard output devices. A **string** is a data type used to represent text, i.e. a sequence of characters. In the Python programming language, strings can be specified by encasing a sequence of characters within single or double-quotes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PC9TFu3-j3U3",
        "outputId": "0b7c0eb6-58c8-478c-897b-f55d664c08a8"
      },
      "source": [
        "String_1 = \"This is a string.\"\n",
        "String_2 = ' This is also a string :)'\n",
        "\n",
        "print(String_1)\n",
        "print(String_2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This is a string.\n",
            " This is also a string :)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pmQ2loJxj3U4"
      },
      "source": [
        "Sometimes, strings will also contain quotation marks or other special characters. To avoid syntax errors in such cases, we need to use the escape character or backslash ```\"\\\"```.  Prefixing a special character with ```\"\\\"``` turns it into an ordinary character. Additionally, the backslash ```\"\\\"``` can be used to specify special characters such as the newline ```\"\\n\"```, tab ```\"\\t\"```, carriage return ```\"\\r\"```, etc. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3FDzlO32j3U5",
        "outputId": "2c44e954-d092-4c81-eab0-9813ca70cf7f"
      },
      "source": [
        "String_3 = 'This shouldn't work.'"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "invalid syntax (<ipython-input-3-76b658394578>, line 1)",
          "traceback": [
            "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-3-76b658394578>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    String_3 = 'This shouldn't work.'\u001b[0m\n\u001b[1;37m                             ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SyYgHW3Aj3U5",
        "outputId": "bff5e7e3-7389-4e65-c543-09ef741bcd7d"
      },
      "source": [
        "String_3 = 'This shouldn\\'t break.'\n",
        "print(String_3)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This shouldn't break.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Wf_rNfDsj3U6"
      },
      "source": [
        "The escape character can also be used to specify characters using unicodes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zonK5B3zj3U7",
        "outputId": "50d81e86-63ff-4c6c-aaba-99de5a832605"
      },
      "source": [
        "print(\"Grinning face: \\U0001f600\")\n",
        "print(\"Squinting face: \\U0001F606\")\n",
        "print(\"ROFL face: \\U0001F923\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Grinning face: 😀\n",
            "Squinting face: 😆\n",
            "ROFL face: 🤣\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PSXmXRl-j3U7"
      },
      "source": [
        "As you might have noticed, the print function appends a newline character ```\"\\n\"``` to its output. This forces consecutive print calls to start on a new line. We can avoid this by assigning the 'end'  argument in the print function to an empty string."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Az7cGlr5j3U8",
        "outputId": "17a31247-27f1-45ec-b2f4-032475df9f44"
      },
      "source": [
        "print(String_1, end='')\n",
        "print(String_2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This is a string. This is also a string :)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7S-I842Pj3U8"
      },
      "source": [
        "We can achieve the same effect by using string concatenation. This operation allows us to combine two or more strings together."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yKY3v8cej3U9",
        "outputId": "07f513d1-3722-45cb-8561-89514b4cf3f3"
      },
      "source": [
        "print(String_1 + String_2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "This is a string. This is also a string :)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Dh9KfoJSj3U9"
      },
      "source": [
        "We can also concatenate strings with other data types by first converting them into strings using the **str()** in-built function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Pv2DBKSdj3U-",
        "outputId": "936d35d9-9183-4c8e-ea09-da9c16bee113"
      },
      "source": [
        "num_chars = len(String_1)\n",
        "print(\"String_1 is \"+str(num_chars)+\" characters long\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "String_1 is 17 characters long\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LQXXaK9Sj3U-"
      },
      "source": [
        "Alternatively, this concatenation can be performed by passing a list of comma-separated inputs into the print function. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9lrnkIjdj3U_",
        "outputId": "4a2f4a7c-8991-4197-86bb-2200c6c37cd1"
      },
      "source": [
        "print(\"String_1 is\",num_chars,\"characters long\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "String_1 is 17 characters long\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qZFVN1x2j3U_"
      },
      "source": [
        "Notice that we didn't need to add extra spacing around the first and last strings and didn't need to convert the num_chars integer into a string.\n",
        "\n",
        "The **print** function can be extremely useful for debugging purposes. For example, printing out the value of the variable before or after mathematical operations to ensure the correct operation occurred."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IduVshSZj3VA",
        "outputId": "c4043b75-07ed-4612-b74f-ac33f940e12f"
      },
      "source": [
        "a = 3\n",
        "b = a%2\n",
        "c = b**2\n",
        "d = a/(c*5) + b\n",
        "\n",
        "print(d)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1.6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YkFjRnmfj3VC"
      },
      "source": [
        "## Functions\n",
        "\n",
        "A function is a block of organised, reusable code that is used to perform an action. \n",
        "\n",
        "![alt_text](https://github.com/Explore-AI/Public-Data/blob/master/function_components.png?raw=true \"Function Components\")\n",
        "\n",
        "The image above points out all the components of a function in Python. \n",
        "\n",
        "### def\n",
        "\n",
        "We can define a function using the `def` keyword. This `def` keyword is then followed by a name for the function and two brackets (we'll get back to this later). It is important to note that everything inside the function must be indented by one tab deeper than `def`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "UJcGs_Lhj3VC"
      },
      "source": [
        "def name_of_your_function(a, b, c):\n",
        "    some_result = do_something_with(a and b and c)\n",
        "    return some_result"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Isuc9wEj3VD"
      },
      "source": [
        "Here is a simple example."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "8qI_0VNRj3VD"
      },
      "source": [
        "def monthly_expenses(rent, food):\n",
        "    total_expenses = rent + food\n",
        "    return total_expenses"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BK4089_rj3VE"
      },
      "source": [
        "Now lets consider the following function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "g9qTrL7ej3VE"
      },
      "source": [
        "def print_something():\n",
        "    print('SoMeThInG')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7-Dg73eLj3VF"
      },
      "source": [
        "We can run this function by writing the name of the function, followed by two brackets:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "238BltlHj3VF",
        "outputId": "b6f14516-30f9-4e24-cb48-54c0b2955031"
      },
      "source": [
        "print_something()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "SoMeThInG\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JYob3Vemj3VG"
      },
      "source": [
        "### return\n",
        "\n",
        "In the above example, we printed something in the function.  But, more often than not, we would want to **return** something from the function. It's useful (at least at the start) to think of **return** as the function passing something back to whoever ran it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "6SiRvbR_j3VH"
      },
      "source": [
        "def return_something():\n",
        "    return 'SoMeThInG'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R1bZVd_rj3VH",
        "outputId": "29c61c97-713a-41b4-8616-d04f685efaf5"
      },
      "source": [
        "return_something()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'SoMeThInG'"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1L_zcG95j3VI"
      },
      "source": [
        "We notice ``return_something`` returns a string. This is different from `print_something` which won't give us any result **out**, but merely *print it*:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "PItdSrVhj3VI",
        "outputId": "143d464f-a472-4273-e34e-02bf8d8674dc"
      },
      "source": [
        "print_something()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "SoMeThInG\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "abLCytk2j3VJ"
      },
      "source": [
        "### Arguments \n",
        "\n",
        "Let's say we want to write a function that returns the result of the future value equation:\n",
        "\n",
        "$(1 + i)^n$\n",
        "\n",
        "where $i$, and $n$ are both numbers. We can pass in the values of i and n into the function, by defining it as follows."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "P13i9V_-j3VJ"
      },
      "source": [
        "def future_value(i, n):\n",
        "    result = (1 + i)**n\n",
        "    return result"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ph71o8zBj3VJ"
      },
      "source": [
        "We can then call our function with any values of i and n."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "X74ocLJTj3VK",
        "outputId": "b1f23a34-1b9f-4a84-8838-e47ceb3b9459"
      },
      "source": [
        "future_value(0.05, 20)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2.653297705144422"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 19
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lO2D_Nbcj3VL"
      },
      "source": [
        "The `i` and the `n` inside `equation(i, n)` are called **arguments** to the function. Function arguments allow us to make generic functions that can be used with infinitely many variations. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "np04uJKPj3VL",
        "outputId": "6c23c113-3581-4ea8-9f07-88d97a4cf039"
      },
      "source": [
        "future_value(0.1, 20)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6.727499949325611"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zO9LCyJPj3VM",
        "outputId": "380fc3d9-f38a-4eac-ba11-ef73936110de"
      },
      "source": [
        "future_value(0.15, 20)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "16.36653739294609"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ffxb-Iv5j3VM"
      },
      "source": [
        "## Scope of Variables\n",
        "\n",
        "Variable scope refers to how accessible a variable is to different parts of the program. The scope of a variable can be **local** or **global**, we illustrate the difference in the example below."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xPEkhfYAj3VN",
        "outputId": "2d08c6d9-b418-4126-a599-10362aeddbe0"
      },
      "source": [
        "y = 10\n",
        "def my_function():\n",
        "    x = 2\n",
        "    print(\"Inside function, x =\",x) \n",
        "    print(\"Inside function, y =\",y) \n",
        "    \n",
        "    return \n",
        "\n",
        "my_function()\n",
        "print(\"Outside function, y =\",y)\n",
        "print(\"Outside function, x =\",x)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Inside function, x = 2\n",
            "Inside function, y = 10\n",
            "Outside function, y = 10\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "name 'x' is not defined",
          "traceback": [
            "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[1;32m<ipython-input-22-0d5f4a43458a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[0mmy_function\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Outside function, y =\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0my\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Outside function, x =\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[1;31mNameError\u001b[0m: name 'x' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aku-d0NCj3VO"
      },
      "source": [
        "**Local variables** only exist within a context, in the above example, this refers to the body of the function. Furthermore, they can only be accessed within this context. On the other hand, **global variables** can be accessed from anywhere in the code. ```x``` is a local variable and only exists within ```my_function``` and attempting to access if outside the function, results in an error. ```y``` however, is a global variable and can be accessed both inside and outside of the function.\n",
        "\n",
        "To declare global variables within a context, we can use the ```global``` keyword as follows:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "E7GOby51j3VO",
        "outputId": "8c1ae7c3-2ad3-40d6-f8ad-4ad6d009bba8"
      },
      "source": [
        "y = 9\n",
        "def my_other_function():\n",
        "    global x\n",
        "    x = 3\n",
        "    print(\"Inside function, x =\",x) \n",
        "    print(\"Inside function, y =\",y) \n",
        "    \n",
        "    return \n",
        "\n",
        "my_other_function()\n",
        "print(\"Outside function, y =\",y)\n",
        "print(\"Outside function, x =\",x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Inside function, x = 3\n",
            "Inside function, y = 9\n",
            "Outside function, y = 9\n",
            "Outside function, x = 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WkOgunCej3VP"
      },
      "source": [
        "## Exercises\n",
        "### Exercise 1: Interest rates\n",
        "\n",
        "You just turned 20 and you want to buy a new pair of shoes to wear at your party. The shoes cost R1000. \n",
        "You're broke right now, but you know that in a year's time - when you turn 21 - you will get a lot of money from your relatives for your 21st birthday.\n",
        "\n",
        "FedBank is willing to lend you R1000, at 20% interest per year.\n",
        "\n",
        "Assuming that you take the loan - how much will you have to pay back in one year?\n",
        "\n",
        "***\n",
        "Loan summary:\n",
        "\n",
        "*   $PV$:     **R1000**\n",
        "*   $n$:      **1 year**\n",
        "*   $i$:      **20% interest** per annum, compounded annually\n",
        "\n",
        "Given a present value loan amount, PV, the formula for a future repayment (FV) is given by:\n",
        "\n",
        "\n",
        "\\begin{equation}\n",
        "FV = PV(1 + i)^n\n",
        "\\end{equation}\n",
        "\n",
        "\n",
        "***\n",
        "\n",
        "In Python we'd calculate this value as follows:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G0tYTG6Pj3VQ",
        "outputId": "5cff1964-5b0f-4fdd-9558-8963bd12f53d"
      },
      "source": [
        "# Present Value of the Loan amount:\n",
        "PV = 1000\n",
        "\n",
        "# Interest rate, i:\n",
        "i = 20 / 100\n",
        "\n",
        "# Term in years, n:\n",
        "n = 1\n",
        "\n",
        "#Calculate the Future Value, FV:\n",
        "PV*(1 + i)**n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1200.0"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "usrkRwNVj3VS"
      },
      "source": [
        "So, if you decide to go ahead with the purchase, you'll need to pay an extra R200 to FedBank after 1 year.\n",
        "\n",
        "### Exercise 2: Future Value Formula\n",
        "\n",
        "Now, perform the exact same calculation, just using a function! Create a function called `future_value`, that takes the following arguments: present value $PV$, interest rate $i$, and a term $n$, and returns the future repayment value ($FV$) of that loan. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "0CaomBkDj3VT"
      },
      "source": [
        "def future_value_of(PV, i, n):\n",
        "    # YOUR CODE HERE:\n",
        "    # FV = some formula\n",
        "    return FV"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "collapsed": true,
        "id": "i8K_MI2Vj3VT"
      },
      "source": [
        "future_value_of(500, 0.15, 10)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_IbUNBg1j3VU"
      },
      "source": [
        "Your code should give the following results:\n",
        "\n",
        "\n",
        "*   `future_value(100, 0.1, 20) = 672.7499949325611`\n",
        "*   `future_value(500, 0.15, 10) = 2022.7788678539534`\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ici531unj3VU"
      },
      "source": [
        "## Conclusion\n",
        "\n",
        "In this train, you learned to perform basic operations using print statements and strings, as well as the basic aspects of Python functions and the scope of variables. The reader is expected to complete the exercises before moving forward to ensure familiarity with these concepts."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6jCQP6fkj3VU"
      },
      "source": [
        "\n",
        "## Appendix\n",
        "\n",
        "- [Print Statement](https://www.w3schools.com/python/ref_func_print.asp)\n",
        "\n",
        "- [Functions](https://www.w3schools.com/python/python_functions.asp)"
      ]
    }
  ]
}