Lab01.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python and Jupyter Notebooks\n",
    "\n",
    "This lab session entails a very brief introduction to python and Jupyter notebooks. It is assumed that you are already comfortable with the theory material for the MSPH306 course. Some of the content covered during this session was covered briefly during the preceding theory classes.\n",
    "\n",
    "Jupyter notebook is an HTML-based notebook environment for Python, similar to Mathematica or Maple. It provides a cell-based environment with great interactivity, where calculations can be organized and documented in a structured way. Jupyter is a loose acronym meaning \"Julia, Python, and R\", three programming languages that are supported by the platform. \n",
    "\n",
    "You can access Jupyter notebooks from the Anaconda Navigator, or directly open the Jupyter Notebook application itself. It should automatically open up in your web browser. \n",
    "\n",
    "## Starting Jupyter \n",
    "\n",
    "If you have not already done so, then begin this lab session by starting the Jupyter notebook server as follows:\n",
    "\n",
    "1. On the keyboard, **press and hold** the 3 keys “CTRL” + “ALT” + “T” together as indicated below\"\n",
    "\n",
    "\n",
    "   <img src=\"images/terminal_shortcut.png\" alt=\"Terminal Shortcut\" width=\"600\"/>\n",
    "\n",
    "\n",
    "2. This will launch the Terminal, looking like this:\n",
    "\n",
    "   <img src=\"images/terminal.png\" alt=\"Terminal\" width=\"600\"/>\n",
    "\n",
    "   Once you see this terminal window, you can release the keys that you're pressing.\n",
    "\n",
    "\n",
    "3. Click inside the terminal window, then **type in the following command** using your keyboard, and **press \"ENTER\"**\n",
    "\n",
    "\n",
    "   ```bash\n",
    "   conda activate && jupyter notebook\n",
    "   ```\n",
    "\n",
    "\n",
    "   **Note** that there are TWO '&' symbols in the command above. Also **note** that \"jup**y**ter\" is spelled with a 'y'.\n",
    "\n",
    "\n",
    "4. Executing this command will start the Firefox browser and load the Jupyter notebook server inside, looking like this:\n",
    "\n",
    "\n",
    "   ![Jupyter Start](images/jupyter_start.png \"Jupyter Start\")\n",
    "\n",
    "\n",
    "5. Navigate to the folder named 'msph306' by clicking the link circled above.\n",
    "   \n",
    "6. You will see a list of files. The files ending in '.ipynb' are lab notebooks. \n",
    "\n",
    "7. Click on the notebook named 'Lab01.ipynb' to load this notebook into Jupyter. \n",
    "\n",
    "8. Continue this exercise over there.\n",
    "\n",
    "## Python programming in Jupyter: A simple Hello World Program\n",
    "\n",
    "Python code is usually stored in text files with the file ending \".py\". Jupyter notebooks are stored in files with the file ending \".ipynb\".\n",
    "\n",
    "In Jupyter notebooks, content is divided into 'cells'. Each cell can be of two types: \n",
    "\n",
    "1. Markdown Cells: These cells contain text, links and images formatted with the **markdown** language. These are for humans to read, and do not contain executable code. The text that you are reading right now is in a markdown cell.\n",
    "   \n",
    "2. Code cells: These cells contain codes that can be executed. The cell below this one is a python code cell.\n",
    "   \n",
    "\n",
    "### Exercise 01\n",
    "Click inside the code cell below and write down a simple 'hello world' program. This should be just a one-line print command. \n",
    "\n",
    "Execute the code cell by clicking \"Run\" on the toolbar at the top. See screenshot below:\n",
    "\n",
    "   ![Jupyter Run](images/jupyter_run.png \"Jupyter Run\")\n",
    "\n",
    "\n",
    "The output should be displayed just below the code cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This is a code cell. Type your program below this comment\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple math in Python\n",
    "\n",
    "\n",
    "Every line in a Python program file is assumed to be a Python statement, or part thereof.\n",
    "\n",
    "The only exception is comment lines, which start with the character # (optionally preceded by an arbitrary number of white-space characters, i.e., tabs or spaces). Comment lines are usually ignored by the Python interpreter.\n",
    "\n",
    "### Exercise 02\n",
    "You can use python just like a programmable calculator. Click inside the code cell below, type in a simple one-line arithmetic expression like '2+3' and execute the code cell as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can create a code cell just below any active cell by clicking on the \"+\" icon in the toolbar (see below). \n",
    "\n",
    "The cell that you have just used your mouse to click on or inside is an 'active cell'\n",
    "\n",
    "![Jupyter New Cell](images/jupyter_newcell.png \"Jupyter New Cell\")\n",
    "\n",
    "\n",
    "\n",
    "### Exercise 03:\n",
    "1. Click anywhere on **this cell**. Now, this cell becomes \"active\". \n",
    "2. Now, click on the '+' icon on the top menu to create a code cell below this blank cell. \n",
    "3. Then, enter a simple one-line math expression and execute it to display the evaluated result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can **delete** any active cell by clicking on the scissors icon (see below)\n",
    "\n",
    "![scissors](images/jupyter_scissors.png)  \n",
    "\n",
    "The icon is next to the \"+\" icon in the toolbar above. \n",
    "Test this by selecting the cell that you just created and deleting it. \n",
    "Make sure that you don't accidentally delete any other cell. \n",
    "\n",
    "### More arithmetic with Python\n",
    "Expression syntax is straightforward: the operators +, -, * and / can be used to perform arithmetic; parentheses (()) can be used for grouping. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(50 - 5*6) / 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.6"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 / 5 # division always returns a floating-point number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The integer numbers (e.g. 2, 4, 20) have type 'int', the ones with a fractional part (e.g. 5.0, 1.6) have type 'float'. \n",
    "\n",
    "Division (/) always returns a float. To do floor division and get an integer result you can use the // operator; to calculate the remainder you can use %:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.666666666666667"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "17 / 3  # classic division returns a float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "17 // 3  # floor division discards the fractional part"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "17 % 3  # the % operator returns the remainder of the division"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 * 3 + 2  # floored quotient * divisor + remainder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With Python, it is possible to use the ** operator to calculate powers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "128"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2**7 # 2 to the power of 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The equal sign (=) is used to assign a value to a variable. Always, the result of the last computation in the cell is displayed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "width = 20\n",
    "height = 77\n",
    "width * height"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 04:\n",
    "Create a code cell just below. In that cell, enter code that takes a width of $20$, height of $5\\times 9$, then displays the width, height, and area."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The type() function in Python\n",
    "\n",
    "The 'type()' function in python yields the type of data stored in any object, whether a variable, value or an expression. For instance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 <class 'int'>\n",
      "2 <class 'int'>\n",
      "4.5 <class 'float'>\n",
      "3.45 <class 'float'>\n",
      "7.45 <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(6, type(6))\n",
    "\n",
    "x = 2\n",
    "print(x, type(x))\n",
    "\n",
    "print(4.5, type(4.5))\n",
    "\n",
    "y=3.45\n",
    "print(y, type(y))\n",
    "\n",
    "z = 2 * x + y\n",
    "print(z,type(z))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 05: \n",
    "\n",
    "In the code cell below, use the following formula,\n",
    "\\begin{equation}\n",
    "e^x = 1+x + \\frac{x^2}{2!} + \\frac{x^3}{3!} + \\dots,\n",
    "\\end{equation}\n",
    "to estimate the value of $e$ accurate to the first place of decimal. The value of $e=2.7182 \\dots$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python variables\n",
    "\n",
    "Now that you've had an introduction to Jupyter Notebooks, let’s delve deeper into programming concepts.\n",
    "\n",
    "**Note: Python is a case-sensitive language. This means that ‘var’, ‘Var’, and ‘vaR’ are considered different identifiers.**\n",
    "\n",
    "## Variables and Keywords\n",
    "\n",
    "The most fundamental named entity in Python is an **identifier**, which is essentially a name for something. A Python identifier is used to name a variable, function, class, module, or any other Python object.\n",
    "\n",
    "There are two types of identifiers: Variables and Keywords.\n",
    "\n",
    "Keywords are predefined identifiers in Python. There are 33 keywords in Python, each with a specific meaning.\n",
    "\n",
    "| Keyword     | Description                           |\n",
    "|-------------|---------------------------------------|\n",
    "| `False`     | Boolean value, result of comparison  |\n",
    "| `None`      | Represents the absence of a value    |\n",
    "| `True`      | Boolean value, result of comparison  |\n",
    "| `and`       | Logical AND operator                 |\n",
    "| `as`        | Alias for modules                    |\n",
    "| `assert`    | Assert statement for debugging       |\n",
    "| `async`     | Asynchronous function declaration    |\n",
    "| `await`     | Wait for an async function           |\n",
    "| `break`     | Exit a loop                          |\n",
    "| `class`     | Define a class                       |\n",
    "| `continue`  | Skip the rest of the loop iteration  |\n",
    "| `def`       | Define a function                    |\n",
    "| `del`       | Delete an object                     |\n",
    "| `elif`      | Else if condition                    |\n",
    "| `else`      | Else condition                       |\n",
    "| `except`    | Exception handling                   |\n",
    "| `finally`   | Execute code regardless of exceptions|\n",
    "| `for`       | For loop                             |\n",
    "| `from`      | Import specific parts of a module    |\n",
    "| `global`    | Declare a global variable            |\n",
    "| `if`        | If condition                         |\n",
    "| `import`    | Import a module                      |\n",
    "| `in`        | Check if a value is in a sequence    |\n",
    "| `is`        | Test object identity                 |\n",
    "| `lambda`    | Anonymous function                   |\n",
    "| `nonlocal`  | Declare a non-local variable         |\n",
    "| `not`       | Logical NOT operator                 |\n",
    "| `or`        | Logical OR operator                  |\n",
    "| `pass`      | Null statement, does nothing         |\n",
    "| `raise`     | Raise an exception                   |\n",
    "| `return`    | Return a value from a function       |\n",
    "| `try`       | Try block for exception handling     |\n",
    "| `while`     | While loop                           |\n",
    "| `with`      | Simplify exception handling          |\n",
    "| `yield`     | Return a generator                   |\n",
    "\n",
    "For example,\n",
    "\n",
    "```python\n",
    "True, False\n",
    "```\n",
    "are keywords for Boolean expressions. `True` corresponds to the logic bit 1 and `False` to the bit 0. Similarly,\n",
    "```\n",
    "and, or, not\n",
    "```\n",
    "are logical operator keywords. Additionally, `None` represents a null Python object, similar to the null set in set theory. We will explore the usage of some of these keywords throughout this course. The key point is that **these keywords are reserved**, meaning you cannot use them as variable names.\n",
    "\n",
    "Next, let’s discuss variables. Variables are names that refer to data. Essentially, they are a way to reference data created by your program in memory. For instance, a Python statement like\n",
    "```python\n",
    "log_one = 0\n",
    "```\n",
    "when executed, causes Python to perform the following actions:\n",
    "1. Create the data, which is an integer with value `0`, and store it in computer memory. \n",
    "2. Create a variable named `log_one` and associate it with the previously created data. \n",
    "\n",
    "Thus, this data is **referenced** by the variable log_one. This reference allows you to access and manipulate the data using the variable name.\n",
    "\n",
    "This reference and its associated data will remain preserved throughout the execution of the program, unless you change the reference, the data that was referenced, or delete the variable.\n",
    "\n",
    "Data can also be **unreferenced**, that is to say, not be associated with any variable. For instance, the python statement\n",
    "```python\n",
    "print(23.5)\n",
    "```\n",
    "when executed, causes Python to perform the following actions:\n",
    "1. Create the data, which is an integer with value `23.5`, and store it in computer memory.\n",
    "2. Pass that data to the `print()` function and display the output\n",
    "\n",
    "Note, however, that no variable was involved. This means that the created data is unreferenced. Python has a **garbage collector** that deletes unreferenced data from memory as it runs through the program. \n",
    "\n",
    "You can delete a variable or re-reference it, for instance\n",
    "```python\n",
    "a = 5\n",
    "b = 10\n",
    "\n",
    "...\n",
    "...\n",
    "\n",
    "del(a)\n",
    "b = 25\n",
    "\n",
    "```\n",
    "Let us look at this piece of code carefully.\n",
    "\n",
    "1. In the first line, the integer `5` was prepared in memory and referenced by the variable named `a`.\n",
    "    * Therefore, this data is in a referenced state.\n",
    "2. In the penultimate line, the variable `a` is **deleted** with the `del()` function. \n",
    "    * Note that this `del` is a keyword from the table above! \n",
    "    * This is a built-in function that, when executed, deletes the variable in its argument. In this case, that is `a`.\n",
    "    * Now, the associated data (the integer `5`) has been ***de-referenced*** to an unreferenced state.\n",
    "    * This unreferenced data will be erased from computer memory later. \n",
    "3. In the second line, the integer `10` was prepared in memory and referenced by the variable named `b`. \n",
    "    * Therefore, this data is also in a referenced state.\n",
    "4. However, in the last line, `b` was ***re-referenced*** to newly created data , namely, the integer `25`.\n",
    "    * So the old data (the integer `10`) is now in an unreferenced state.\n",
    "    * This data will **also** be erased from computer memory later. \n",
    "\n",
    "\n",
    "### Rules for creating variables:\n",
    "\n",
    "* Must start with alphabet or an underscore.\n",
    "* Followed by zero or more letters, _ , and digits.\n",
    "* A keyword cannot be used as identifier.\n",
    "\n",
    "\n",
    "### Usage of variables\n",
    "\n",
    "Variables can be used in two ways:\n",
    "\n",
    "1. As arguments to functions or declarations. For instance, the example above:\n",
    "   ```python\n",
    "    del(a)\n",
    "    ```\n",
    "   where we supplied the variable `a` as an argument to the `del()` function.\n",
    "2. As **operands** to **operators** in an expression. For instance, the expression \n",
    "    ```python\n",
    "        a = b + c\n",
    "    ```\n",
    "    where the `+` operator is executed with the variables `b` and `c` as operands. The evaluated value (assuming that `b` and `c` are referenced to numbers, then the value is simply their sum) is referenced by the variable `a`. \n",
    "  \n",
    "\n",
    "When naming variables it’s good to keep in mind that “shorter is better”. For example, a variable named `therm` is better than `thermodynamic_property`. On the other hand, also keep in mind that “meaningful is good”: for example, `therm` is typically a better name than `t` etc. That being said, if you are dealing with the time parameter, it’s probably wiser to name it t rather than time.\n",
    "\n",
    "\n",
    "Let us now try an example code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "# A variable\n",
    "a = 5\n",
    "\n",
    "print(a) # This prints the value of variable a\n",
    "\n",
    "b = 10\n",
    "\n",
    "print(b) # This prints the value of variable a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "b = 20 #This re-references b to the value 20\n",
    "\n",
    "#Now, the new value will be printed\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'a' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[9], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;66;03m# If we delete a variable and try to print it, there will be an error, since it is no longer defined\u001b[39;00m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m(a)\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43ma\u001b[49m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'a' is not defined"
     ]
    }
   ],
   "source": [
    "# If we delete a variable and try to print it, there will be an error, since it is no longer defined\n",
    "del(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n",
      "I am a literal string\n",
      "11.4\n"
     ]
    }
   ],
   "source": [
    "b = 25\n",
    "\n",
    "c = 30\n",
    "\n",
    "# You can use variables as operands, as long as the operator makes sense\n",
    "a = b + c\n",
    "print(a)\n",
    "\n",
    "#You can also use literal values (numbers or strings), together with variables, as both arguments and operands\n",
    "\n",
    "print(\"I am a literal string\")\n",
    "\n",
    "a = 3.4\n",
    "\n",
    "print(a+8) #Here, '8' is a \"literal integer\", whereas 'a' is a variable referenced to an integer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that, If, however, any one of `b` and `c` are **not** numbers, then the value is unpredictable, and could result in an error message."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[10], line 7\u001b[0m\n\u001b[1;32m      4\u001b[0m c \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m3\u001b[39m\n\u001b[1;32m      6\u001b[0m \u001b[38;5;66;03m# This operation does not make sense\u001b[39;00m\n\u001b[0;32m----> 7\u001b[0m a \u001b[38;5;241m=\u001b[39m \u001b[43mb\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mc\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "# This won't work\n",
    "\n",
    "b = \"Frogs\" #b is now referenced to a string\n",
    "c = 3\n",
    "\n",
    "# This operation does not make sense\n",
    "a = b + c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'NoneType' and 'int'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[11], line 6\u001b[0m\n\u001b[1;32m      3\u001b[0m b \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m  \u001b[38;5;66;03m#'b' is a variable referenced to the null object\u001b[39;00m\n\u001b[1;32m      4\u001b[0m c \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m3\u001b[39m\n\u001b[0;32m----> 6\u001b[0m a \u001b[38;5;241m=\u001b[39m \u001b[43mb\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mc\u001b[49m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'NoneType' and 'int'"
     ]
    }
   ],
   "source": [
    "# Nor does this make any sense\n",
    "\n",
    "b = None  #'b' is a variable referenced to the null object\n",
    "c = 3\n",
    "\n",
    "a = b + c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variable Types\n",
    "\n",
    "Variables come in different types.  Different types serve distinct purposes and are associated with different costs (e.g., in terms of memory storage). Here are some examples of built-in types:\n",
    "\n",
    "* Integer: For example, `ival = 17`.\n",
    "* Float (decimals): For example, `therm = 12.6`.\n",
    "* Complex: For example, `z = 1.2 + 2.3j`. (Note that this does not say 2.3*j. Also note that python used `j` instead of `i` to identify $\\sqrt{-1}$).\n",
    " * Boolean (a single bit signifying truth or falsehood): For example, `myflag = True`. (The other option is False).\n",
    "* String: For example, `phrase = \"My string\"`. (Note that we could have used single quotes instead, ‘My string’).\n",
    "\n",
    "\n",
    "You can find the type of a variable using the built-in `type()` function. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(int, float, float)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 3\n",
    "b = 4.5\n",
    "\n",
    "c = a + b\n",
    "\n",
    "type(a), type(b), type(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the types of `a, b, c` are automatically set by python. \n",
    "\n",
    "Python is an intelligent interpreter, and can figure out which values are of which type. \n",
    "\n",
    "This is important, because `int` and `float` data need different amounts of computer memory, so the interpreter needs to determine how much memory to allocate before creating the data. \n",
    "\n",
    "Other programming languages, like `C/C++`, cannot do this on their own. You have to tell them which type of data a particular variable references to.\n",
    "\n",
    "**Note for C/C++ Programmers:** In the standard CPython, every object begins with a reference count and a pointer to the type for that object. That requires `16` bytes of memory. A python `float` stores its data as a C `double`, that's `8` bytes. So a total of `16 + 8 = 24` bytes for float objects. Integers in python are very different from those in C, and require variable amounts of memory depending on how big their values are.\n",
    "\n",
    "The type of a variable can change automatically with new references. Python is smart enough to do this on its own."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 - <class 'int'>\n",
      "9.6 - <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 10\n",
    "\n",
    "c = a+b\n",
    "\n",
    "print(c, '-', type(c))\n",
    "\n",
    "a = 3.4\n",
    "b = 6.2\n",
    "\n",
    "\n",
    "c = a+b\n",
    "\n",
    "print(c, '-', type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also force a change in the type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.0 - <class 'float'>\n",
      "5.0 - <class 'float'>\n",
      "5 - <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "x = (50 - 5*6) / 4\n",
    "print(x, '-', type(x))\n",
    "\n",
    "y = x\n",
    "print(y, '-', type(y))\n",
    "\n",
    "y = int(x)\n",
    "print(y, '-', type(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, however, that this kind of **retyping** could result in information loss."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.878048780487806 - <class 'float'>\n",
      "4.878048780487806 - <class 'float'>\n",
      "4 - <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "x = (50 - 5*6) / 4.1\n",
    "print(x, '-', type(x))\n",
    "\n",
    "y = x\n",
    "print(y, '-', type(y))\n",
    "\n",
    "y = int(x)\n",
    "print(y, '-', type(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The re-typing of `y` to `int` caused the decimal part to be discarded, as there was no memory allocated for it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 06:\n",
    "\n",
    "1. Create a variable named `distance` and reference it to a `float` that is an estimate of the distance to your home from this lab in kilometres. Then, create another variable named `mileToKm` that referenced to a `float` that is an estimate of one mile in kilometres (about `1.60934`). Now, use these variables to convert your distance to miles and display the output.\n",
    "2. Write a program that takes a number as input and splits it into integer part and decimal part."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions in python\n",
    "\n",
    "In python, a function is an **indented** block of code that performs a specific task. It helps in organizing code, making it reusable and easier to understand.\n",
    "\n",
    "**Indentation** refers to the spaces at the beginning of a code line. The default indentation in python is $0$ spaces or tabs, as you have seen until now:\n",
    "```python\n",
    "v = 78.2 #No indentation\n",
    "```\n",
    "Python indentation refers to adding a tab before a statement to a particular block of code. In other words, all the statements with the same space to the left, belong to the same code block:\n",
    "```python\n",
    "if v == 78.2:\n",
    "    u = 1 #These statements are indented by 4 spaces\n",
    "    u = u + 2\n",
    "    for v in range(100):\n",
    "        print(v) #These statements are indented by 8 spaces.\n",
    "else:\n",
    "    u = 0 #These statements are indented by 4 spaces\n",
    "```\n",
    "\n",
    "### Creating a function:\n",
    "\n",
    "* You define a function using the def keyword followed by the function name and parentheses (), then a colon (:). \n",
    "\n",
    "* The body of the function **must be indented** by four spaces.\n",
    "\n",
    "* In jupyter code cells, if you correctly define the function name (ending with the colon), then pressing <Enter> to go to the next line automatically creates indentation.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hasjhdksh(dajsdjaskl):\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet():\n",
    "    print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the `print()` statement inside the body of the function is **indented** with respect to the definition. The indented block of code is the only part that will be executed when the function is called later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n",
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "greet()\n",
    "greet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am not inside the function.\n",
      "Hello, World!\n",
      "Hi there from me!\n",
      "Hello, World!\n",
      "Hi there from me!\n"
     ]
    }
   ],
   "source": [
    "def new_greet():\n",
    "    print(\"Hello, World!\")\n",
    "    print(\"Hi there from me!\")\n",
    "    \n",
    "print(\"I am not inside the function.\")\n",
    "\n",
    "new_greet()\n",
    "\n",
    "new_greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, the statement \"I am not inside the function\" is executed after `new_greet()` is *silently* defined (*i.e.* with no output of its own). Every subsequent call of `new_greet()`  only executes the statements in the indented block that constitutes the body of the function 'new_greet()'.\n",
    "\n",
    "Functions can take parameters (arguments) to process data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Alice !\n",
      "Hello Bob !\n",
      "Hello Rahul !\n"
     ]
    }
   ],
   "source": [
    "def greet(name):\n",
    "    print(\"Hello\", name, \"!\")\n",
    "\n",
    "greet(\"Alice\")  # Output: Hello, Alice!\n",
    "greet(\"Bob\")\n",
    "greet(\"Rahul\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Functions can return values using the return statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n",
      "31\n"
     ]
    }
   ],
   "source": [
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "result = add(5, 3)\n",
    "print(result)  # Output: 8\n",
    "print(add(23, 8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** Unlike other programming languages like C/C++, python can return **multiple values** with no limit."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8, -2)\n",
      "(3551.1670000000004, -3542.567)\n",
      "(8, -2)\n",
      "(3551.1670000000004, -3542.567)\n",
      "(102.60000000000001, 96.2, 318.08000000000004, 31.0625)\n"
     ]
    }
   ],
   "source": [
    "def add_subtract(x, y):\n",
    "    added = x + y\n",
    "    subtracted = x - y\n",
    "    return added, subtracted\n",
    "\n",
    "print(add_subtract(3,5))\n",
    "print(add_subtract(4.3,3546.867))\n",
    "\n",
    "\n",
    "def four_ops(x, y):\n",
    "    add = x + y\n",
    "    sub = x - y\n",
    "    mult = x * y\n",
    "    div = x/y\n",
    "    return add, sub, mult, div\n",
    "\n",
    "print(add_subtract(3,5))\n",
    "print(add_subtract(4.3,3546.867))\n",
    "\n",
    "\n",
    "print(four_ops(99.4, 3.2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can provide default values for parameters. These are done with **keyword arguments**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice !\n",
      "Hello, Bob !\n",
      "Hello, World !\n"
     ]
    }
   ],
   "source": [
    "def greet(name=\"World\"):\n",
    "    print(\"Hello,\", name, \"!\")\n",
    "\n",
    "greet(\"Alice\")  # Output: Hello, Alice!\n",
    "greet(\"Bob\")\n",
    "greet()         # Output: Hello, World!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can call functions using keyword arguments to make the code more readable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Alice Smith !\n",
      "Hello, Bob (no last name given) !\n",
      "Hello, Analabha Roy !\n"
     ]
    }
   ],
   "source": [
    "def greet(first_name, last_name=\"(no last name given)\"):\n",
    "    print(\"Hello,\", first_name, last_name, \"!\")\n",
    "\n",
    "greet(\"Alice\", last_name=\"Smith\")  # Output: Hello, Alice Smith!\n",
    "greet(\"Bob\")\n",
    "greet(\"Analabha\", last_name=\"Roy\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scope rule \n",
    "\n",
    "A immutable variable that is defined inside the function is local to that function. This means that when you change your variables’ values inside the function, you do not impact the value of the variables outside. Thus, the **scope** of an immutable variable defined inside a function is restricted to the execution context of that function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "outside 1 2\n",
      "inside 8 42\n",
      "outside 1 2\n"
     ]
    }
   ],
   "source": [
    "def f(a):\n",
    "    a += 1\n",
    "    b = 42\n",
    "    print('inside', a, b)\n",
    "\n",
    "a = 1\n",
    "b = 2\n",
    "print('outside', a, b)\n",
    "\n",
    "f(7)\n",
    "\n",
    "print('outside', a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notabene:** You **have** to keep in mind that even though the function `f()` was defined first, that does not mean that it was executed first. The actual lines of code are executed in sequence, starting from the first line after the function definition, namely `a = 1`. When `f(7)` was called, the block indented under the definition of `f()` was executed in an independent context. This will happen every time `f()` is called."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exercise 07: \n",
    "\n",
    "1. Write a python function that takes a temperature value in degrees Celsius as input and outputs the conversion to Fahrenheit. The working formula is\n",
    "   \\begin{equation*}\n",
    " C = \\frac{5}{9}\\left(F-32\\right)\n",
    "\\end{equation*}\n",
    "\n",
    "2. Write a program that takes in as input the name as a string and age as an integer and prints \"Hello, my name is <name>, and my age is <age value>\". For instance, providing an input \"Rahul\" for name and `43` for age should print \"Hello, my name is Rahul, and my age is 43.\""
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "hpc",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}