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.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules in Python\n",
    "\n",
    "A module is a file containing python function definitions and executable statements, even python classes. If you save your python code to a file with a `.py` extension, it can be run as an executable or **imported** into any other python execution context as a module.\n",
    "\n",
    "\n",
    "A Python package is simply a structured arrangement of modules installed in your computer. Packages are the natural way to organize and distribute larger Python projects. \n",
    "\n",
    "You can thus use projects prepared by other people in your python program by installing it in your computer and importing the python files therein as modules.\n",
    "\n",
    "Here are examples of two standard modules included with python\n",
    "\n",
    "### math module\n",
    "\n",
    "The `math` module is part of Python’s standard library and provides basic mathematical functions and constants.\n",
    "\n",
    "#### Key Functions:\n",
    "\n",
    "1. Basic Operations: `math.sqrt(x), math.pow(x, y), math.exp(x)`\n",
    "2. Trigonometry: `math.sin(x), math.cos(x), math.tan(x)`\n",
    "3. Constants: `math.pi, math.e`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n",
      "8.0\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# Calculate square root\n",
    "print(math.sqrt(16))  # Output: 4.0\n",
    "\n",
    "# Calculate power\n",
    "print(math.pow(2, 3))  # Output: 8.0\n",
    "\n",
    "# Trigonometric functions\n",
    "print(math.sin(math.pi / 2))  # Output: 1.0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can, if you wish, import the math module into a customized name of your choice. This can be used to shorten the name so you won't have to type in modules with long names."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4.0\n",
      "8.0\n",
      "1.0\n"
     ]
    }
   ],
   "source": [
    "import math as m\n",
    "\n",
    "# Calculate square root\n",
    "print(m.sqrt(16))  # Output: 4.0\n",
    "\n",
    "# Calculate power\n",
    "print(m.pow(2, 3))  # Output: 8.0\n",
    "\n",
    "# Trigonometric functions\n",
    "print(m.sin(math.pi / 2))  # Output: 1.0\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you're only going to use a few functions or variables from a particular module, you can simply import them into your program, instead of the whole module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793 2.718281828459045\n",
      "20.085536923187664\n"
     ]
    }
   ],
   "source": [
    "from math import pi, e\n",
    "\n",
    "print(pi, e)\n",
    "print(e**3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.2246467991473532e-16, 1.0, 2.0000000000000004)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sin\n",
    "\n",
    "sin(pi), sin(pi/2), 1/(sin(pi/4)**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The os module\n",
    "\n",
    "Finally, let us look at another standard module. The `os` module provides functions for interacting with the operating system, such as file and directory manipulation, environment variable access, and process management.\n",
    "\n",
    "\n",
    "#### Key Functions:\n",
    "\n",
    "1. Current Working Directory: `os.getcwd(), os.chdir(path)`\n",
    "2. File and Directory Operations: `os.mkdir(path), os.rmdir(path), os.remove(path)`\n",
    "3. Environment Variables: `os.getenv(key), os.putenv(key, value)`\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/daneel/gitrepos/msph306\n",
      "/home/daneel/gitrepos\n",
      "['hariseldon99.github.io', 'QE-SSP', 'scientific-python-lectures', 'papers', 'telegrambot-scripts', 'signal_processing', 'i_just_made_this', 'git-filter-repo', 'qutip-lectures', 'cuda-samples', 'DTC-kitaev', 'MMP2-9-Rolipram-manuscript', 'biobb_wf_protein-complex_md_setup', 'dtwa_bbgky_fermions', 'johansson', 'periodic_lipkin', 'StatMechCodes', 'curie_weiss_periodic', 'Flat_band', 'Autodock_sims', 'archives', 'slurm_showq', 'python_workshop', 'msph306', 'ising_exact', 'Quantum-Harmonic-Numpy', 'zenodo-upload', 'fermion_rand_pdrive', '.ipynb_checkpoints', '.metadata', 'cuda-python-magma-examples', 'dtwa_quantum_spins', 'gromacs-2022-cp2k-tutorial', 'buparamshavak', 'ginSODA', 'Hands-On-GPU-Programming-with-Python-and-CUDA', 'Publications', 'ftwa', 'CDTC_review_response_etc', 'qutip_codes', 'gromacs_sims', 'thesis_Mahbub', 'mdanalysis', '66e7123deb374f0ac6e850c5', 'cuda-samples.tar.gz', 'msph402b']\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "# Get current working directory\n",
    "print(os.getcwd())  # Output: Current working directory path\n",
    "\n",
    "# Change current working directory\n",
    "os.chdir('../')\n",
    "print(os.getcwd())  # Output: Get current working directory path\n",
    "\n",
    "# Create a new directory\n",
    "os.mkdir('i_just_made_this')\n",
    "\n",
    "# List files and directories\n",
    "print(os.listdir('.'))  # Output: List of files and directories in the current directory\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exploring a module\n",
    "Exploring a Python module using built-in functions like `help()` and `dir()` is a great way to understand its capabilities. Let’s use the math module as an example.\n",
    "\n",
    "#### Using dir()\n",
    "The `dir()` function lists all the attributes and methods of a module. This is useful for getting an overview of what the module offers.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'isqrt', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc', 'ulp']\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# List all attributes and methods in the math module\n",
    "print(dir(math))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This will output a list of all functions and constants available in the math module, such as `sqrt, pi, sin`, etc.\n",
    "\n",
    "\n",
    "#### Using help()\n",
    "The `help()` function provides detailed documentation about a module, function, class, or method. It’s very useful for understanding how to use a specific function or what parameters it accepts.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module math:\n",
      "\n",
      "NAME\n",
      "    math\n",
      "\n",
      "MODULE REFERENCE\n",
      "    https://docs.python.org/3.11/library/math.html\n",
      "    \n",
      "    The following documentation is automatically generated from the Python\n",
      "    source files.  It may be incomplete, incorrect or include features that\n",
      "    are considered implementation detail and may vary between Python\n",
      "    implementations.  When in doubt, consult the module reference at the\n",
      "    location listed above.\n",
      "\n",
      "DESCRIPTION\n",
      "    This module provides access to the mathematical functions\n",
      "    defined by the C standard.\n",
      "\n",
      "FUNCTIONS\n",
      "    acos(x, /)\n",
      "        Return the arc cosine (measured in radians) of x.\n",
      "        \n",
      "        The result is between 0 and pi.\n",
      "    \n",
      "    acosh(x, /)\n",
      "        Return the inverse hyperbolic cosine of x.\n",
      "    \n",
      "    asin(x, /)\n",
      "        Return the arc sine (measured in radians) of x.\n",
      "        \n",
      "        The result is between -pi/2 and pi/2.\n",
      "    \n",
      "    asinh(x, /)\n",
      "        Return the inverse hyperbolic sine of x.\n",
      "    \n",
      "    atan(x, /)\n",
      "        Return the arc tangent (measured in radians) of x.\n",
      "        \n",
      "        The result is between -pi/2 and pi/2.\n",
      "    \n",
      "    atan2(y, x, /)\n",
      "        Return the arc tangent (measured in radians) of y/x.\n",
      "        \n",
      "        Unlike atan(y/x), the signs of both x and y are considered.\n",
      "    \n",
      "    atanh(x, /)\n",
      "        Return the inverse hyperbolic tangent of x.\n",
      "    \n",
      "    cbrt(x, /)\n",
      "        Return the cube root of x.\n",
      "    \n",
      "    ceil(x, /)\n",
      "        Return the ceiling of x as an Integral.\n",
      "        \n",
      "        This is the smallest integer >= x.\n",
      "    \n",
      "    comb(n, k, /)\n",
      "        Number of ways to choose k items from n items without repetition and without order.\n",
      "        \n",
      "        Evaluates to n! / (k! * (n - k)!) when k <= n and evaluates\n",
      "        to zero when k > n.\n",
      "        \n",
      "        Also called the binomial coefficient because it is equivalent\n",
      "        to the coefficient of k-th term in polynomial expansion of the\n",
      "        expression (1 + x)**n.\n",
      "        \n",
      "        Raises TypeError if either of the arguments are not integers.\n",
      "        Raises ValueError if either of the arguments are negative.\n",
      "    \n",
      "    copysign(x, y, /)\n",
      "        Return a float with the magnitude (absolute value) of x but the sign of y.\n",
      "        \n",
      "        On platforms that support signed zeros, copysign(1.0, -0.0)\n",
      "        returns -1.0.\n",
      "    \n",
      "    cos(x, /)\n",
      "        Return the cosine of x (measured in radians).\n",
      "    \n",
      "    cosh(x, /)\n",
      "        Return the hyperbolic cosine of x.\n",
      "    \n",
      "    degrees(x, /)\n",
      "        Convert angle x from radians to degrees.\n",
      "    \n",
      "    dist(p, q, /)\n",
      "        Return the Euclidean distance between two points p and q.\n",
      "        \n",
      "        The points should be specified as sequences (or iterables) of\n",
      "        coordinates.  Both inputs must have the same dimension.\n",
      "        \n",
      "        Roughly equivalent to:\n",
      "            sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))\n",
      "    \n",
      "    erf(x, /)\n",
      "        Error function at x.\n",
      "    \n",
      "    erfc(x, /)\n",
      "        Complementary error function at x.\n",
      "    \n",
      "    exp(x, /)\n",
      "        Return e raised to the power of x.\n",
      "    \n",
      "    exp2(x, /)\n",
      "        Return 2 raised to the power of x.\n",
      "    \n",
      "    expm1(x, /)\n",
      "        Return exp(x)-1.\n",
      "        \n",
      "        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.\n",
      "    \n",
      "    fabs(x, /)\n",
      "        Return the absolute value of the float x.\n",
      "    \n",
      "    factorial(n, /)\n",
      "        Find n!.\n",
      "        \n",
      "        Raise a ValueError if x is negative or non-integral.\n",
      "    \n",
      "    floor(x, /)\n",
      "        Return the floor of x as an Integral.\n",
      "        \n",
      "        This is the largest integer <= x.\n",
      "    \n",
      "    fmod(x, y, /)\n",
      "        Return fmod(x, y), according to platform C.\n",
      "        \n",
      "        x % y may differ.\n",
      "    \n",
      "    frexp(x, /)\n",
      "        Return the mantissa and exponent of x, as pair (m, e).\n",
      "        \n",
      "        m is a float and e is an int, such that x = m * 2.**e.\n",
      "        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.\n",
      "    \n",
      "    fsum(seq, /)\n",
      "        Return an accurate floating point sum of values in the iterable seq.\n",
      "        \n",
      "        Assumes IEEE-754 floating point arithmetic.\n",
      "    \n",
      "    gamma(x, /)\n",
      "        Gamma function at x.\n",
      "    \n",
      "    gcd(*integers)\n",
      "        Greatest Common Divisor.\n",
      "    \n",
      "    hypot(...)\n",
      "        hypot(*coordinates) -> value\n",
      "        \n",
      "        Multidimensional Euclidean distance from the origin to a point.\n",
      "        \n",
      "        Roughly equivalent to:\n",
      "            sqrt(sum(x**2 for x in coordinates))\n",
      "        \n",
      "        For a two dimensional point (x, y), gives the hypotenuse\n",
      "        using the Pythagorean theorem:  sqrt(x*x + y*y).\n",
      "        \n",
      "        For example, the hypotenuse of a 3/4/5 right triangle is:\n",
      "        \n",
      "            >>> hypot(3.0, 4.0)\n",
      "            5.0\n",
      "    \n",
      "    isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)\n",
      "        Determine whether two floating point numbers are close in value.\n",
      "        \n",
      "          rel_tol\n",
      "            maximum difference for being considered \"close\", relative to the\n",
      "            magnitude of the input values\n",
      "          abs_tol\n",
      "            maximum difference for being considered \"close\", regardless of the\n",
      "            magnitude of the input values\n",
      "        \n",
      "        Return True if a is close in value to b, and False otherwise.\n",
      "        \n",
      "        For the values to be considered close, the difference between them\n",
      "        must be smaller than at least one of the tolerances.\n",
      "        \n",
      "        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That\n",
      "        is, NaN is not close to anything, even itself.  inf and -inf are\n",
      "        only close to themselves.\n",
      "    \n",
      "    isfinite(x, /)\n",
      "        Return True if x is neither an infinity nor a NaN, and False otherwise.\n",
      "    \n",
      "    isinf(x, /)\n",
      "        Return True if x is a positive or negative infinity, and False otherwise.\n",
      "    \n",
      "    isnan(x, /)\n",
      "        Return True if x is a NaN (not a number), and False otherwise.\n",
      "    \n",
      "    isqrt(n, /)\n",
      "        Return the integer part of the square root of the input.\n",
      "    \n",
      "    lcm(*integers)\n",
      "        Least Common Multiple.\n",
      "    \n",
      "    ldexp(x, i, /)\n",
      "        Return x * (2**i).\n",
      "        \n",
      "        This is essentially the inverse of frexp().\n",
      "    \n",
      "    lgamma(x, /)\n",
      "        Natural logarithm of absolute value of Gamma function at x.\n",
      "    \n",
      "    log(...)\n",
      "        log(x, [base=math.e])\n",
      "        Return the logarithm of x to the given base.\n",
      "        \n",
      "        If the base not specified, returns the natural logarithm (base e) of x.\n",
      "    \n",
      "    log10(x, /)\n",
      "        Return the base 10 logarithm of x.\n",
      "    \n",
      "    log1p(x, /)\n",
      "        Return the natural logarithm of 1+x (base e).\n",
      "        \n",
      "        The result is computed in a way which is accurate for x near zero.\n",
      "    \n",
      "    log2(x, /)\n",
      "        Return the base 2 logarithm of x.\n",
      "    \n",
      "    modf(x, /)\n",
      "        Return the fractional and integer parts of x.\n",
      "        \n",
      "        Both results carry the sign of x and are floats.\n",
      "    \n",
      "    nextafter(x, y, /)\n",
      "        Return the next floating-point value after x towards y.\n",
      "    \n",
      "    perm(n, k=None, /)\n",
      "        Number of ways to choose k items from n items without repetition and with order.\n",
      "        \n",
      "        Evaluates to n! / (n - k)! when k <= n and evaluates\n",
      "        to zero when k > n.\n",
      "        \n",
      "        If k is not specified or is None, then k defaults to n\n",
      "        and the function returns n!.\n",
      "        \n",
      "        Raises TypeError if either of the arguments are not integers.\n",
      "        Raises ValueError if either of the arguments are negative.\n",
      "    \n",
      "    pow(x, y, /)\n",
      "        Return x**y (x to the power of y).\n",
      "    \n",
      "    prod(iterable, /, *, start=1)\n",
      "        Calculate the product of all the elements in the input iterable.\n",
      "        \n",
      "        The default start value for the product is 1.\n",
      "        \n",
      "        When the iterable is empty, return the start value.  This function is\n",
      "        intended specifically for use with numeric values and may reject\n",
      "        non-numeric types.\n",
      "    \n",
      "    radians(x, /)\n",
      "        Convert angle x from degrees to radians.\n",
      "    \n",
      "    remainder(x, y, /)\n",
      "        Difference between x and the closest integer multiple of y.\n",
      "        \n",
      "        Return x - n*y where n*y is the closest integer multiple of y.\n",
      "        In the case where x is exactly halfway between two multiples of\n",
      "        y, the nearest even value of n is used. The result is always exact.\n",
      "    \n",
      "    sin(x, /)\n",
      "        Return the sine of x (measured in radians).\n",
      "    \n",
      "    sinh(x, /)\n",
      "        Return the hyperbolic sine of x.\n",
      "    \n",
      "    sqrt(x, /)\n",
      "        Return the square root of x.\n",
      "    \n",
      "    tan(x, /)\n",
      "        Return the tangent of x (measured in radians).\n",
      "    \n",
      "    tanh(x, /)\n",
      "        Return the hyperbolic tangent of x.\n",
      "    \n",
      "    trunc(x, /)\n",
      "        Truncates the Real x to the nearest Integral toward 0.\n",
      "        \n",
      "        Uses the __trunc__ magic method.\n",
      "    \n",
      "    ulp(x, /)\n",
      "        Return the value of the least significant bit of the float x.\n",
      "\n",
      "DATA\n",
      "    e = 2.718281828459045\n",
      "    inf = inf\n",
      "    nan = nan\n",
      "    pi = 3.141592653589793\n",
      "    tau = 6.283185307179586\n",
      "\n",
      "FILE\n",
      "    /usr/local/miniforge3/envs/hpc/lib/python3.11/lib-dynload/math.cpython-311-x86_64-linux-gnu.so\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# Get detailed information about the math module\n",
    "help(math)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exploring Specific Functions\n",
    "\n",
    "You can also use `help()` to get information about specific functions within a module.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function tanh in module math:\n",
      "\n",
      "tanh(x, /)\n",
      "    Return the hyperbolic tangent of x.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# Get detailed information about the sqrt function\n",
    "help(math.tanh)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jupyter Notebooks provide enhanced introspection capabilities. \n",
    "\n",
    "They allow you to explore modules interactively with features like tab completion and inline documentation.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "# In IPython or Jupyter Notebook\n",
    "import math\n",
    "\n",
    "\n",
    "# Type math.sqrt? and execute to see the documentation for the sqrt function\n",
    "math.sqrt?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4051.5420254925943"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# In this code cell type math. and press Tab after the dot to see all available functions and attributes\n",
    "math.cosh(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercise 08:\n",
    "\n",
    "1. Copy-paste the code from exercise 05 into a code cell below and rerun it. Add code to test the accuracy of the calculate value of $e$ with the value from the `math` module. \n",
    "\n",
    "2. Prepare a table of values of the sine and cosine of some standard angles, like `0`, `pi/6` ,`pi/4`, `pi/2`.\n",
    "\n",
    "3. Use the `os` module to delete the new directory created in the above example. Search the available functions in this module to find the suitable one."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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
}