05_python/python_rest.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python standard libraries and scripts"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "More details: [The Python standard library](https://docs.python.org/3/library/index.html)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exceptions"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Observe several exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are [many exceptions](https://docs.python.org/3/library/exceptions.html#exception-hierarchy) defined in Python.  \n",
    "Here are a few examples of code raising exceptions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1/0                   # ZeroDivisionError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# dct = { \"a\":1 }\n",
    "# dct[\"b\"]              # KeyError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print( wrongVarName ) # ValueError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# int( \"a\" )            # ValueError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# personAge = 199\n",
    "# if personAge >= 120:\n",
    "#    raise ValueError( f\"Value of personAge must be below 120, not {personAge}.\" )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Flow control of exceptions"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `try`/`except`/`except`/`finally` blocks it is possible to write code which can react to exceptions.  \n",
    "The `try` statement declares a block of code in which exceptions are monitored.  \n",
    "The `except` clauses specify how to react to provided types of exceptions.  \n",
    "The `final` clause allows to provide a block of code which is always executed (even if an exception has happened in the `try` block)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's define a function `fun` which may generate an exception depending on the value of `div` argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun(div):\n",
    "    print( f\"fun({div}) start\" )\n",
    "\n",
    "    try:\n",
    "        print( f\"fun({div}) try start\" )\n",
    "        1/div\n",
    "        print( f\"fun({div}) try done\" )\n",
    "    except ZeroDivisionError:            # if ZeroDivisionError-exception-happened:\n",
    "        print( f\"fun({div}) except ZeroDivisionError\" )\n",
    "    finally:\n",
    "        print( f\"fun({div}) finally\" )\n",
    "\n",
    "    print(f\"fun({div}) end\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To understand `try`/`expect`/`finally` study the differences between outputs of the following code cells:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"main start\")\n",
    "fun(1)\n",
    "print(\"main end\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"main start\")\n",
    "fun(0)\n",
    "print(\"main end\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"main start\")\n",
    "fun(\"A\")\n",
    "print(\"main end\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another example which forces a user to enter a positive number.  \n",
    "This code does not crash when the user enters some text instead of a number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while True:\n",
    "    try:\n",
    "        val = float( input( \"Please enter a positive number\" ) )\n",
    "        if val > 0:\n",
    "            break\n",
    "        print( \"Not a positive number. Try again...\" )\n",
    "    except ValueError:\n",
    "        print( \"Not a number. Try again...\" )\n",
    "\n",
    "print( f\"You entered {val}. Thanks.\" )\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Files"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A *file* can be thought of as a (large) vector of bytes.  \n",
    "Due to technical limitations of *(physical) devices* which preserve the files, access to the content might be slow\n",
    "(this is an old device keeping files: [tape device](https://en.wikipedia.org/wiki/Tape_drive)).  \n",
    "Usually, the most optimal way of accessing the full content of a file is to read or write it progressively without any seeking (jumping).  "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A *file system* is a standard which defines how to organize files stored on a device and how to access them.  \n",
    "Typically, files are identified by (short) file names. These names are further organized in a hierarchical *directory* structures.  \n",
    "When a *full path* (i.e. a file name in a directory) is provided the file system can provide access to the file."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It depends on the program which uses the file how the file content is interpreted:\n",
    "- A *text file* is intended to be processed line-by-line and usually can be opened in simple text editors.  \n",
    "    (often there might be some extra characters added or removed to make the file transferrable between different operating systems and character encoding environments):\n",
    "    - A *simple text file* (popular ending of the file name, called *extension*: `.txt`).\n",
    "    - A *markdown file* (extension: `.md`).\n",
    "    - A *python script file* (extension: `.py`).\n",
    "    - A *[json](https://www.json.org/json-en.html)* file (extension: `.json`): good for storing nested collections.\n",
    "    - A *python notebook file* (extension: `.ipynb`): a collection of data describing python jupyter notebook cells.\n",
    "- A *binary file* is usually processed in blocks of unmodified file bytes:\n",
    "    - A *gzip* file (extension: `.gz`): another file compressed\n",
    "    - A *zip* file (extension: `.zip`): multiple other files compressed"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Example:"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```text\n",
    ".                                                # The top-level (root) directory\n",
    "├── 01_python\n",
    "│   ├── git_github_intro.md\n",
    "│   ├── git_simple_cmds.jpg                      # Binary file, an image in \"jpg\" format\n",
    "│   ├── memory_organization.md\n",
    "│   ├── memory_pointers.jpg\n",
    "│   ├── memory_units.jpg\n",
    "│   ├── python_basic.ipynb\n",
    "│   └── python_lists_tuples.ipynb\n",
    "├── 02_python\n",
    "│   ├── git_practice.md\n",
    "│   ├── python_sets_dicts.ipynb\n",
    "│   └── set_operations.png                       # Binary file, an image in \"png\" format\n",
    "├── 03_python                                    # A directory\n",
    "│   └── python_flow_control.ipynb                # A file named \"python_flow_control.ipynb\" in directory \"03_python\"\n",
    "├── 04_python\n",
    "│   ├── food_classes.png                         # File extension: .png\n",
    "│   ├── git_assignment.md\n",
    "│   ├── python_oop.ipynb                         # Full path from the root: 04_python/python_oop.ipynb\n",
    "│   └── two_tables.png\n",
    "├── 05_python                                    # THIS IS THE CURRENT DIRECTORY (see below)\n",
    "│   └── python_rest.ipynb                        # THIS IS THIS FILE (when opened in an editor, it defines the current directory)\n",
    "├── LICENSE\n",
    "└── README.md                                    # A markdown file, by convention README.md describes what is in this directory\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing text files"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's start with writing some texts from the list `ls` to the console:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls = [ \"oat flakes\", \"sugar\", \"half milk\", \"water\", \"banana\", \"blueberries\" ]\n",
    "\n",
    "for l in ls:\n",
    "    print( l )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Several small adjustments of the code redirect the `print` output to a file.  \n",
    "The name of the file is provided in the `fileName` variable.  \n",
    "(*Note:* this code will be improved in the next cells)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls = [ \"oat flakes\", \"sugar\", \"half milk\", \"water\", \"banana\", \"blueberries\" ]\n",
    "\n",
    "fileName = \"testfile.txt\"                    # This is the path where the file will be written.\n",
    "f = open(file=fileName, mode=\"w\")            # 1. Creates (or re-creates) an empty file with the provided fileName (path);\n",
    "                                             #    mode=\"w\" requests \"write\" access.\n",
    "                                             # 2. Provides an object (f) allowing access to the file.\n",
    "                                             # 3. Reserves memory buffers for quick access.\n",
    "for l in ls:\n",
    "    print( l, file=f )                       # This (usually) writes to the buffers, not directly to the file.\n",
    "\n",
    "f.close()                                    # Forces the buffers to be written; closes access to the file."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `with` command surrounds its code block by a *context manager*.  \n",
    "The manager guarantees that the file `f` will always be closed, even if the code block raises an exception:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls = [ \"oat flakes\", \"sugar\", \"half milk\", \"water\", \"banana\", \"blueberries\" ]\n",
    "\n",
    "fileName = \"testfile.txt\"                    # This is the path where the file will be written.\n",
    "with open(file=fileName, mode=\"w\") as f:     # f is the result of open(...) but now with auto-close after the block\n",
    "    for l in ls:\n",
    "        print( l, file=f )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In some situations you may prefer to use the `write` method.  \n",
    "Then, ends of lines will need to be added."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls = [ \"oat flakes\", \"sugar\", \"half milk\", \"water\", \"banana\", \"blueberries\" ]\n",
    "\n",
    "fileName = \"testfile.txt\"\n",
    "with open(file=fileName, mode=\"w\") as f:\n",
    "    for l in ls:\n",
    "        f.write( l )                         # Let's use the write method of f, instead of the print command\n",
    "        f.write( \"\\n\" )                      # The write method does not add new lines"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reading text files"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `mode=\"r\"` in `open(...)` to get reading access to a file.  \n",
    "The `readlines()` method reads all lines from a file into a list of `str` texts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fileName = \"testfile.txt\"                    # Note: write this file first with one of the writing examples\n",
    "with open(file=fileName, mode=\"r\") as f:     # Note: now mode=\"r\" for reading access!!!\n",
    "    lines = f.readlines()                    # Texts from all lines of the file will be read and returned as a list\n",
    "\n",
    "lines                                        # Note: each text has end-of-line characters at the end"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to process a file line-by-line without full reading into memory.  \n",
    "Here, single lines are iterated over in a comprehension:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fileName = \"testfile.txt\"                    # Note: write this file first with one of the writing examples\n",
    "with open(file=fileName, mode=\"r\") as f:     \n",
    "    lineLens = [len(l) for l in f]\n",
    "\n",
    "lineLens"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And here, single lines are iterated over in a `for` loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lineLens = []\n",
    "\n",
    "fileName = \"testfile.txt\"                    # Note: write this file first with one of the writing examples\n",
    "with open(file=fileName, mode=\"r\") as f:\n",
    "    for l in f:\n",
    "        lineLens.append( len(l) )\n",
    "\n",
    "lineLens"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing/reading JSON files"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simple/nested lists, dictionaries of texts and numbers can be easily written in the [JSON format](https://en.wikipedia.org/wiki/JSON):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "assignmentsInfo = {\n",
    "    \"firstName\": \"John\",\n",
    "    \"lastName\": \"Smith\",\n",
    "    \"studentId\": \"s12345678\",\n",
    "    \"sshGitHub\": \"git@github.com:LUMC/EfDS.git\"\n",
    "}\n",
    "\n",
    "fileName = \"assignments.json\"\n",
    "with open( fileName, \"w\" ) as f:\n",
    "    json.dump( obj = assignmentsInfo, fp = f )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also reading `.json` files is straightforward:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "fileName = \"assignments.json\"\n",
    "with open( fileName, \"r\" ) as f:\n",
    "    ai = json.load( fp = f )\n",
    "ai"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scripts (not Python notebooks) and the command line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python script vs. Python notebook"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python scripts are simple text files (usually with extension `.py`) containing only Python statements.  \n",
    "Simple pure-text editors may be used to write Python scripts, although dedicated code editors are recommended.\n",
    "\n",
    "Python jupiter notebooks are JSON documents describing cells which contain Python code, free user text written in Markdown, calculation output, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Start a Python script in the console/terminal/cmd"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Operating systems usually have a shell program which allows to type commands for the system.  \n",
    "Here are some options:\n",
    "- `cmd` on Windows, `Cygwin`\n",
    "- `Terminal.app` on Mac\n",
    "- `xterm` on Linux\n",
    "- (if you use Visual Studio Code): `Terminal` in the `View` menu\n",
    "\n",
    "The following command typed in the system console should start Python interactive mode:\n",
    "```text\n",
    "> python                                                                  # system console\n",
    "Python 3.8.5 (default, Sep  4 2020, 02:22:02) \n",
    "[Clang 10.0.0 ] :: Anaconda, Inc. on darwin\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>> sum([1,2,3])                                                          # python console\n",
    "6\n",
    ">>> exit()                                                                # close python console\n",
    ">                                                                         # back to system console\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assume that in the current directory you have a Python script `my_script.py` with the following content:\n",
    "```python\n",
    "print( \"Hello, world!\" )\n",
    "```\n",
    "\n",
    "Then, in the system console you may start your script as follows:\n",
    "```text\n",
    "> python my_script.py\n",
    "Hello, world!\n",
    ">\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A Python script with command line arguments"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to pass text arguments from the system console to the Python script.  \n",
    "Assume that `my_script.py` has the following code:\n",
    "\n",
    "```python\n",
    "import sys\n",
    "\n",
    "if __name__ == \"__main__\":                  # a suggested way to define the main part of a script\n",
    "    print( \"Hello, world!\" )\n",
    "    for a in sys.argv:                      # sys.argv contains the script name\n",
    "        print(a)                            # and additional arguments\n",
    "```\n",
    "\n",
    "Here is how you can pass some arguments:\n",
    "```text\n",
    "> python my_script.py A BB CCC 1234          \n",
    "Hello, world!                               \n",
    "my_script.py                                # the script name (my_script.py)\n",
    "A                                           #      and 4 arguments are passed to Python\n",
    "BB                                          #      in the sys.argv variable\n",
    "CCC                                         #      as strings\n",
    "1234\n",
    ">\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Math"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scan quickly [the reference page of the `math` (mathematical functions) module](https://docs.python.org/3/library/math.html).  \n",
    "(It is important to get an overview of available functionality...)  \n",
    "Some examples are shown below (import first the module):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import *                                                 # import all functions from the module"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sums, products"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs = [1,2,3,4]\n",
    "sum(vs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs = [1,2,3,4]\n",
    "prod(vs)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Powers, exponents, logs"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some examples to study:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[ log10(1), log10(10), log10(0.1) ]\n",
    "[ log2(2), log2(1024), log2(0.5) ]\n",
    "exp(1)\n",
    "e                                                                    # math.e\n",
    "[ log(exp(1)), exp(log(12345)) ]\n",
    "[ sqrt(4), pow(4,0.5), 4**0.5 ]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trigonometry"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some examples to study:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pi                                                                  # math.pi\n",
    "degrees(pi)\n",
    "[ sin(0), sin(pi) ]\n",
    "[ cos(0), cos(pi) ]\n",
    "[ atan2(0,1), atan2(1,0), atan2(0,-1), atan2(-1,0) ]                # nearly anticlockwise\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rounding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[ floor( 2.2 ), floor( 2.99999 ), floor( -2.99999 ) ]              # rounding in lower direction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[ ceil( 2.2 ), ceil( 2.99999 ), ceil( -2.99999 ) ]                 # rounding in upper direction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[ trunc( 2.2 ), trunc( 2.99999 ), trunc( -2.99999 ) ]              # rounding towards zero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[ round( 2.2 ), round( 2.99999 ), round( -2.99999 ) ]              # not in math package\n",
    "{ x:round(x) for x in [-2.5,-1.5,-0.5,0.5,1.5,2.5] }               # \"halfs\" are rounded to the closest even number"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combinatorics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "comb(4, 2)                                                         # number of 2-element subsets out of a 4-element set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "perm(4, 2)                                                         # number of 2-element lists out of a 4-element set"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Missing or infinite values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs = ( 0, 1, nan, inf, -inf )                                      # math.nan, math.inf\n",
    "{v:isnan(v) for v in vs}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs = ( 0, 1, nan, inf, -inf )\n",
    "{v:isinf(v) for v in vs}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs = ( 0, 1, nan, inf, -inf )\n",
    "{v:isfinite(v) for v in vs}"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## (Pseudo-) random numbers"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scan quickly [the reference page of the `random` (generate pseudo-random numbers) module](https://docs.python.org/3/library/random.html).  \n",
    "(It is important to get an overview of available functionality...)  \n",
    "*Note:* do not use these functions for security purposes.  \n",
    "Some examples are shown below (import first the module):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import *                                               # import all functions from the module"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integers, seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[randint(10, 20) for i in range(10)]                               # random integers, both ends inclusive"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The generated numbers are only pseudo-random. They are based on an internally generated sequence of numbers.  \n",
    "The `seed(num)` function allows to move the internal sequence to points defined by an integer `num`.  \n",
    "The following code will always generate the same pseudorandom sequence.  \n",
    "*Note:* `seed` works with all random numbers/choices (not only with integers)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed( 123 )                                                        # change 123 to another integer to get different random nums\n",
    "[randint(10, 20) for i in range(10)]                               # random integers, both ends inclusive"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Real numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[uniform(0, 1) for i in range(10)]                                 # from a uniform distribution on [0,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[gauss(mu=0, sigma=1) for i in range(10)]                          # from the normal distribution mu=0, sd=1"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Collections"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a standard French `deck` representing 52 playing cards.  \n",
    "It is possible to represent the cards by their [Unicode symbols](https://en.wikipedia.org/wiki/Playing_cards_in_Unicode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "suits = [ \"\\u2660\", \"\\u2665\", \"\\u2666\", \"\\u2663\" ]\n",
    "nums = [ \"A\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", \"8\", \"9\", \"10\", \"J\", \"Q\", \"K\" ]\n",
    "deck = [n+s for n in nums for s in suits]\n",
    "print( \" \".join( deck ) )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is how a list can be shuffled (order of the elements gets randomly changed):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "copiedDeck = deck.copy()                                           # let's make a copy, so deck stays unchanged\n",
    "for i in range(3):\n",
    "    shuffle( copiedDeck )                                          # permute the elements of copiedDeck in place\n",
    "    print( \" \".join( copiedDeck ) )"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `sample` to randomly select without returning elements of a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(3):\n",
    "    d = sample(deck, k=5)                                         # randomly picked 5 cards (without returning back to the deck)\n",
    "    print( str.join( \" \", d ) )\n",
    "\n",
    "# sample(deck, 100)                                               # ValueError, no returns, so can't pick 100 elements from 52"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use `choice` for choosing with returning:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = choices(deck, k=100)\n",
    "d.sort()\n",
    "print( str.join( \" \", d ) )                                      # note repetitions"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Statistics"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scan quickly [the reference page of the `statistics` (mathematical statistics functions) module](https://docs.python.org/3/library/statistics.html).  \n",
    "(It is important to get an overview of available functionality...)  \n",
    "Some examples are shown below (import first the module):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from statistics import *                                         # import all functions from the module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's generate some normally distributed numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs = [gauss(mu=0, sigma=1) for i in range(100)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{ \"min\":min(vs), \"max\":max(vs), \"mean\":mean(vs), \"median\":median(vs) }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "{ \"sd\":stdev(vs), \"var\":variance(vs) }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Self-study tasks"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python script to generate normally distributed random numbers (random, statistics, file write, script)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a Python script `gen_norm_nums.py` which generates normally distributed random numbers and writes them to a text file.  \n",
    "The script should accept four parameters: \n",
    "- `fileName`: name of the file to be written\n",
    "- `size`: number of numbers to generate\n",
    "- `mu`: the mean for the `gauss` generator\n",
    "- `sd`: the `sigma` for the `gauss` generator\n",
    "The script should also report on the console what are the actual mean and standard deviation of the generated numbers.\n",
    "\n",
    "You may add code to generate exceptions when parameters have nonsense values.  \n",
    "The following command line should work in a console:\n",
    "\n",
    "```text\n",
    "> python ./gen_norm_nums.py nums.txt 10 0 1         # 10 numbers, mean 0, sd 1, write to nums.txt\n",
    "Size:   10\n",
    "Mean:   requested=0.0, generated=0.11592080981585763\n",
    "Stddev: requested=1.0, generated=0.9322987440171838\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Unidirected graph (class, writing to file/console, exceptions)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Wikipedia page [Graph (discrete mathematics)](https://en.wikipedia.org/wiki/Graph_(discrete_mathematics)) provides an example illustration of *a (undirected) graph with six vertices and seven edges*.  \n",
    "Implement a class `Graph` allowing to memorize a graph. Use the following names:\n",
    "- `vs` and `_vs` should represent vertices\n",
    "- `es` and `_es` should represent edges\n",
    "- `addV` and `addE` should be the methods to add a vertex/edge\n",
    "- it should be an error to add an edge before adding its vertices first"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find below the code how the `Graph` class is expected to be used (and proposed phases of the class Graph implementation)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ----- phase 1: create an empty graph -----\n",
    "g = Graph()\n",
    "\n",
    "# ----- phase 2: make adding vertices possible -----\n",
    "g.addV(\"a\")\n",
    "g.addV(\"b\")\n",
    "# g.addV(\"b\")                        # ValueError: Vertex b is already in the graph.\n",
    "\n",
    "# ----- phase 3: make adding edges possible -----\n",
    "g.addE(\"a\",\"b\")\n",
    "# g.addE(\"a\",\"b\")                    # ValueError: Edge a<->b is already in the graph.\n",
    "# g.addE(\"b\",\"a\")                    # ValueError: Edge a<->b is already in the graph.\n",
    "# g.addE(\"a\",\"x\")                    # ValueError: Add x first as a vertex.\n",
    "\n",
    "# ----- phase 4: allow chaining (return self) -----\n",
    "g.addV(\"c\").addV(\"d\")\n",
    "g.addE(\"c\",\"c\").addE(\"c\",\"d\")\n",
    "\n",
    "# ----- phase 5: provide getters of the graph data -----\n",
    "print( g.vs() )                      # Sorted list of node names: ['a', 'b', 'c', 'd']\n",
    "print( g.es() )                      # List of tuples (return a copy so it does not get modified)\n",
    "                                     # {('c', 'd'), ('c', 'c'), ('a', 'b')}\n",
    "\n",
    "# ----- phase 6: provide checker of an edge -----\n",
    "print( g.hasE( \"a\", \"b\" ) )          # True\n",
    "print( g.hasE( \"a\", \"c\" ) )          # False\n",
    "print( g.hasE( \"???\", \"???\" ) )      # False; too costly to always check vertices\n",
    "\n",
    "# ----- phase 7: implement writer of adjacency matrix -----\n",
    "g.writeAdjacencyMatrix()             # Write adjacency matrix to console (f=sys.stdout)\n",
    "with open(file=\"g.mx\", mode=\"w\") as f:\n",
    "    g.writeAdjacencyMatrix(f=f)      # Write dot graphViz to the file\n",
    "\n",
    "# Here is the adjacency matrix:\n",
    "#    \ta\tb\tc\td\n",
    "#   a\t0\t0\t1\t0\n",
    "#   b\t0\t1\t0\t0\n",
    "#   c\t1\t0\t0\t1\n",
    "#   d\t1\t0\t0\t0"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Shuffling lines of a file (random, statistics, file read/write, script)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a Python script `shuffle_lines.py` which reads a text file, shuffles its lines and writes them back to another text file.  \n",
    "The script should accept two parameters: \n",
    "- `inFileName`: text file to be read\n",
    "- `outFileName`: text file to be written\n",
    "\n",
    "You may add code to generate exceptions when parameters have nonsense values.  \n",
    "The following command line should work in a console:\n",
    "\n",
    "```text\n",
    "> python shuffle_lines.py nums.txt nums_sh.txt       # read lines from nums.txt, shuffle, write to nums_sh.txt\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fibonacci numbers (functions)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Write a function `fib(pos)` which calculates [Fibonacci number](https://en.wikipedia.org/wiki/Fibonacci_number) at position `pos` in the sequence.  \n",
    "The expected output for the first 19 elements:\n",
    "```python\n",
    "fib(pos) for pos in range(19)]\n",
    "# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584]\n",
    "```"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "jupyter",
   "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.12.0"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "0fadeaac72bf3c14f9665939c662a31c8aa4e36681a8cd408ae34884627e6cff"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}