01_quickstart.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "20f1fd52",
   "metadata": {},
   "source": [
    "# Quickstart: zero to Python\n",
    "\n",
    "Taken and modified from https://foundations.projectpythia.org/foundations/getting-started-python.html"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ec7b89a",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Interactively (demo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e7c51d3",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "To run Python code interactively, one can use the standard Python prompt, which can be launched by typing ``python`` in your standard shell:\n",
    "\n",
    "    $ python\n",
    "    Python 3.4.1 (default, May 21 2014, 21:17:51) \n",
    "    [GCC 4.2.1 Compatible Apple Clang 4.1 ((tags/Apple/clang-421.11.66))] on darwin\n",
    "    Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    "    >>>\n",
    "\n",
    "The ``>>>`` indicates that Python is ready to accept commands. If you type ``a = 1`` then press enter, this will assign the value ``1`` to ``a``. If you then type ``a`` you will see the value of ``a`` (this is equivalent to ``print a``):\n",
    "\n",
    "    >>> a = 1\n",
    "    >>> a\n",
    "    1\n",
    "\n",
    "The Python shell can execute any Python code, even multi-line statements, though it is often more convenient to use Python non-interactively for such cases.\n",
    "\n",
    "The default Python shell is limited, and in practice, you will want instead to use the IPython (or interactive Python) shell. This is an add-on package that adds many features to the default Python shell, including the ability to edit and navigate the history of previous commands, as well as the ability to tab-complete variable and function names. To start up IPython, type:\n",
    "\n",
    "    $ ipython\n",
    "    Python 3.4.1 (default, May 21 2014, 21:17:51) \n",
    "    Type \"copyright\", \"credits\" or \"license\" for more information.\n",
    "\n",
    "    IPython 2.1.0 -- An enhanced Interactive Python.\n",
    "    ?         -> Introduction and overview of IPython's features.\n",
    "    %quickref -> Quick reference.\n",
    "    help      -> Python's own help system.\n",
    "    object?   -> Details about 'object', use 'object??' for extra details.\n",
    "\n",
    "    In [1]:\n",
    "\n",
    "The first time you start up IPython, it will display a message which you can skip over by pressing ``ENTER``. The ``>>>`` symbols are now replaced by ``In [x]``, and output, when present, is prepended with ``Out [x]``. If we now type the same commands as before, we get:\n",
    "\n",
    "    In [1]: a = 1\n",
    "\n",
    "    In [2]: a\n",
    "    Out[2]: 1\n",
    "\n",
    "If you now type the up arrow twice, you will get back to ``a = 1``."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "073b1b72",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Running scripts (demo)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c48cb1ca",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "While the interactive Python mode is very useful to exploring and trying out code, you will eventually want to write a script to record and reproduce what you did, or to do things that are too complex to type in interactively (defining functions, classes, etc.). To write a Python script, just use your favorite code editor to put the code in a file with a ``.py`` extension. For example, we can create a file called ``test.py`` containing:\n",
    "\n",
    "    a = 1\n",
    "    print(a)\n",
    "\n",
    "On Linux computers you can use for example the ``emacs`` editor which you can open by typing:\n",
    "    \n",
    "    emacs &\n",
    "    \n",
    "(ignore the warnings that it prints to the terminal).\n",
    "\n",
    "We can then run the script on the command-line with:\n",
    "\n",
    "    $ python test.py\n",
    "    1\n",
    "\n",
    "Note: The ``print`` statement is necessary, because typing ``a`` on its own will only print out the value in interactive mode. In scripts, the printing has to be explicitly requested with the print command. To print multiple variables, just separate them with a comma after the print command:\n",
    "\n",
    "    print(a, 1.5, \"spam\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c1dce4c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Using the IPython notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3956afa",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The IPython *notebook* is allows you to write notebooks similar to e.g. Mathematica. The advantage of doing this is that you can include text, code, and plots in the same document. This makes it ideal for example to write up a report about a project that uses mostly Python code, in order to share with others. In fact, the notes for this course are written using the IPython notebook!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1db8111",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Click on ``New Notebook`` on the right, which will start a new document. You can change the name of the document by clicking on the **Untitled** name at the top and entering a new name. Make sure you then save the document (make sure that you save regularly as you might lose content if you close the browser window!).\n",
    "\n",
    "At first glance, a notebook looks like a fairly typical application - it has a menubar (File, Edit, View, etc.) and a tool bar with icons. Below this, you will see an empty cell, in which you can type any Python code. You can write several lines of code, and once it is ready to run, you can press shift-enter and it will get executed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3ddc2e15",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "a = 1\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "47b4ca5a-ae8f-401b-87a4-5fbff3e9506a",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "cc0b7f96-2733-4fd7-8e18-71b23b965599",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c6bb48c-8295-43db-995f-ba893329d7c9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e3cf1e1-8915-48db-97a8-9d884a284387",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4b587d7-68e3-4ab2-9c98-261ccebd411f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "da4a31aa-2ecf-40c9-b1a9-8ab201016dee",
   "metadata": {},
   "source": [
    "Andrea"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4af5bb85-48c0-4af5-921d-9cd40ba02cf1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "49ec5550-e26d-4ffc-9ff8-c47e0b5d8b40",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b + 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b9b2f41",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "You can then click on that cell, change the Python code, and press shift-enter again to re-execute the code. Once you have executed a cell once, a new cell will appear below. You can again enter some code, then press shift-enter to execute it."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1920a237",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Text"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "192939c4",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "It is likely that you will want to enter actual text (non-code) in the notebook. To do this, click on a cell, and in the drop-down menu in the toolbar, select 'Markdown'. This is a specific type of syntax for writing text. You can just write text normally and press shift-enter to *render* it:\n",
    "\n",
    "    This is some plain text\n",
    "\n",
    "To edit it, double click on the cell. You can also enter section headings using the following syntax:\n",
    "\n",
    "    This is a title\n",
    "    ===============\n",
    "\n",
    "    This is a sub-title\n",
    "    -------------------\n",
    "\n",
    "which will look like:\n",
    "\n",
    "This is a title\n",
    "===============\n",
    "\n",
    "This is a sub-title\n",
    "-------------------\n",
    "\n",
    "Finally, if you are familiar with LaTeX, you can enter equations using:\n",
    "\n",
    "    $$E = m c^2$$\n",
    "\n",
    "on a separate line, or:\n",
    "\n",
    "    The equation $p=h/\\lambda$ is very important\n",
    "\n",
    "to include it in a sentence. This will look like:\n",
    "\n",
    "$$E = m c^2$$\n",
    "\n",
    "The equation $p=h/\\lambda$ is very important\n",
    "\n",
    "For more information about using LaTeX for equations, see [this guide](http://en.wikibooks.org/wiki/LaTeX/Mathematics)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2db0375",
   "metadata": {},
   "source": [
    "## A very first Python program\n",
    "\n",
    "A Python program can be a single line:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "1d9ed9eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello interweb\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello interweb\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f7d61eac",
   "metadata": {},
   "source": [
    "## Loops in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78861a10",
   "metadata": {},
   "source": [
    "Why not make a `for` loop with some formatted output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "f0a50772",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello interweb, this is iteration number 0\n",
      "Hello interweb, this is iteration number 1\n",
      "Hello interweb, this is iteration number 2\n"
     ]
    }
   ],
   "source": [
    "a = [23, 22, 25]\n",
    "for n in range(3):\n",
    "    print(f\"Hello interweb, this is iteration number {n}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "7370f934-d6ba-4098-a3e3-1fbaffdd8852",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello interweb, this is iteration number 23\n",
      "Hello interweb, this is iteration number 22\n",
      "Hello interweb, this is iteration number 25\n"
     ]
    }
   ],
   "source": [
    "a = [23, 22, 25]\n",
    "for n in a:\n",
    "    print(f\"Hello interweb, this is iteration number {n}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b57b5975",
   "metadata": {},
   "source": [
    "A few things to note:\n",
    "\n",
    "- Python defaults to counting from 0 (like C) rather than from 1 (like Fortran).\n",
    "- Function calls in Python always use parentheses: `print()`\n",
    "- The colon `:` denotes the beginning of a definition (here of the repeated code under the `for` loop.\n",
    "- Code blocks are identified through indentations.\n",
    "\n",
    "To emphasize this last point, here an example with a two-line repeated block:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "87a83424",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello interweb!\n",
      "Hello interweb!\n",
      "Hello interweb!\n",
      "This is iteration number 2.\n",
      "And now we are done.\n"
     ]
    }
   ],
   "source": [
    "for n in range(3):\n",
    "    print(\"Hello interweb!\")\n",
    "print(f\"This is iteration number {n}.\")\n",
    "print('And now we are done.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "e16e99b6",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "n = [2, 3, 5, 7]\n",
    "for e in n:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "938b9601",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> Please avoid Matlab-like for statements with range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "3d555877",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "for e in range(len(n)):\n",
    "    print(n[e]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "d206032e",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hola\n",
      "hola\n",
      "hola\n",
      "hola\n",
      "hola\n"
     ]
    }
   ],
   "source": [
    "m = range(5)  # m = [0, 1, 2, 3, 4]\n",
    "for aa in m:\n",
    "    print(\"hola\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "28597fef",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of index  0  is  2\n",
      "The value of index  1  is  3\n",
      "The value of index  2  is  5\n",
      "The value of index  3  is  7\n"
     ]
    }
   ],
   "source": [
    "# n = [2, 3, 5, 7]\n",
    "for index, value in enumerate(n):\n",
    "# for value in n:\n",
    "# for index in range(len(n)):\n",
    "    print(\"The value of index \", index, \" is \", value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "df322b0e-9514-4241-9034-65f4cee356a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of index  0  is  2\n",
      "The value of index  1  is  3\n",
      "The value of index  2  is  5\n",
      "The value of index  3  is  7\n"
     ]
    }
   ],
   "source": [
    "# n = [2, 3, 5, 7]\n",
    "for index in range(len(n)):\n",
    "# for value in n:\n",
    "# for index in range(len(n)):\n",
    "    print(\"The value of index \", index, \" is \", n[index])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "05212c9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "0\n",
      "3\n",
      "1\n",
      "5\n",
      "2\n",
      "7\n",
      "3\n",
      "2 - 0\n",
      "3 - 1\n",
      "5 - 2\n",
      "7 - 3\n"
     ]
    }
   ],
   "source": [
    "kk = 0\n",
    "for value in n:\n",
    "    print(value)\n",
    "    print(kk)\n",
    "    #print(f'{value} - {kk}')\n",
    "    kk = kk + 1 # kk += 1\n",
    "# BAD\n",
    "\n",
    "\n",
    "for kk, value in enumerate(n):\n",
    "    print(f'{value} - {kk}')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52798674",
   "metadata": {},
   "source": [
    "## Basic flow control\n",
    "\n",
    "Like most languages, Python has an `if` statement for logical decisions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "ff90e230",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n is not greater than 2!\n"
     ]
    }
   ],
   "source": [
    "n = 1\n",
    "if n > 2:\n",
    "    print(\"n is greater than 2!\")\n",
    "else:\n",
    "    print(\"n is not greater than 2!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "9708c0fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 is between 10 and 20\n",
      "Hello world\n"
     ]
    }
   ],
   "source": [
    "x = 15\n",
    "\n",
    "if x == 0:\n",
    "    print(x, \"is zero\")\n",
    "elif (x > 0) and (x < 10):\n",
    "    print(x, \"is between 0 and 10\")\n",
    "elif (x > 10) and (x < 20):\n",
    "    print(x, \"is between 10 and 20\")\n",
    "else:\n",
    "    print(x, \"is negative\")\n",
    "print(\"Hello world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7f9dbbb",
   "metadata": {},
   "source": [
    "Python also defines the `True` and `False` logical constants:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "898eea7e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n > 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "0a9a31e7",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "result = 4 < 5\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de33cd4d",
   "metadata": {},
   "source": [
    "There's also a `while` statement for conditional looping:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "0fc1e74f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is iteration number 0.\n",
      "This is iteration number 1.\n",
      "This is iteration number 2.\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "m = 0\n",
    "while m < 3:\n",
    "    print(f\"This is iteration number {m}.\")\n",
    "    m += 1\n",
    "print(m < 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cafe2905",
   "metadata": {},
   "source": [
    "## Basic Python data types\n",
    "\n",
    "Python is a very flexible language, and many advanced data types are introduced through packages (more on this below). But some of the basic types include: "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7685969",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Built-In Types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86d4eec6",
   "metadata": {},
   "source": [
    "| Type        | Example        | Description                                                  |\n",
    "|-------------|----------------|--------------------------------------------------------------|\n",
    "| ``int``     | ``x = 1``      | integers (i.e., whole numbers)                               |\n",
    "| ``float``   | ``x = 1.0``    | floating-point numbers (i.e., real numbers)                  |\n",
    "| ``complex`` | ``x = 1 + 2j`` | Complex numbers (i.e., numbers with real and imaginary part) |\n",
    "| ``bool``    | ``x = True``   | Boolean: True/False values                                   |\n",
    "| ``str``     | ``x = 'abc'``  | String: characters or text                                   |\n",
    "| ``NoneType``| ``x = None``   | Special object indicating nulls                              |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ff61c09",
   "metadata": {},
   "source": [
    "### Integers (`int`)\n",
    "\n",
    "The number `m` above is a good example. We can use the built-in function `type()` to inspect what we've got in memory:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "48001b12",
   "metadata": {},
   "outputs": [],
   "source": [
    "m = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "bc8a9fe0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7929a869",
   "metadata": {},
   "source": [
    "### Floating point numbers (`float`)\n",
    "\n",
    "Floats can be entered in decimal notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "a24cb406",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "789ad722",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 5 / 2."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "e73dc588",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "4dd396c6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b04fc37",
   "metadata": {},
   "source": [
    "or in scientific notation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "484262dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(4e7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a283e432",
   "metadata": {},
   "source": [
    "where `4e7` is the Pythonic representation of the number $ 4 \\times 10^7 $."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fcec1a58",
   "metadata": {},
   "source": [
    "### Character strings (`str`)\n",
    "\n",
    "You can use either single quotes `''` or double quotes `\" \"` to denote a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "10f14815",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(\"orange\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "cc4daa1c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type('orange')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10fb6d51",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<center> <img src=\"img/list-indexing.png\" width=\"1600\"/> </center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "a4d5d025",
   "metadata": {},
   "outputs": [],
   "source": [
    "p = 'orange'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "32ac5754",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p[5] == p[-1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "4589d494",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "what do_you-like?\n"
     ]
    }
   ],
   "source": [
    "message = \"what do_you-like?\"\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ff72dbd",
   "metadata": {},
   "source": [
    "You can use either single quotes (``'``), double quotes (``\"``), or triple quotes (``'''`` or ``\"\"\"``) to enclose a string (the last one is used for multi-line strings). To include single or double quotes inside a string, you can either use the opposite quote to enclose the string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "b6d38cc9",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Im\n"
     ]
    }
   ],
   "source": [
    "response = 'I''m'\n",
    "print(response)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "713d4300",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLO\n"
     ]
    }
   ],
   "source": [
    "response = 'HELLO'\n",
    "print(response)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "3042b5f5",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# length of string\n",
    "print(len(response))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "64fa6ce4-a1f2-4ffc-a811-8b76f8174a29",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\u001b[0;31mSignature:\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msep\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmaxsplit\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
       "\u001b[0;31mDocstring:\u001b[0m\n",
       "Return a list of the substrings in the string, using sep as the separator string.\n",
       "\n",
       "  sep\n",
       "    The separator used to split the string.\n",
       "\n",
       "    When set to None (the default value), will split on any whitespace\n",
       "    character (including \\\\n \\\\r \\\\t \\\\f and spaces) and will discard\n",
       "    empty strings from the result.\n",
       "  maxsplit\n",
       "    Maximum number of splits (starting from the left).\n",
       "    -1 (the default value) means no limit.\n",
       "\n",
       "Note, str.split() is mainly useful for data that has been intentionally\n",
       "delimited.  With natural text that includes punctuation, consider using\n",
       "the regular expression module.\n",
       "\u001b[0;31mType:\u001b[0m      builtin_function_or_method"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "response.split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "fdbaac5b",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "# Make upper-case. See also str.lower()\n",
    "print(response.lower())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "40784e20",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What do_you-like?\n"
     ]
    }
   ],
   "source": [
    "# Capitalize. See also str.title()\n",
    "print(message.capitalize())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "239c2736",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Spam egg spam spam\"\n",
    "s.index('e')  # An integer giving the position of the sub-string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "de1167c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Spam', 'egg', 'spam', 'spam']"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2 = s.split()\n",
    "s2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "410f14c9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['s', 'am']"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2[2].split('p')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "e30b9ede",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Spam-egg-spam', 'spam']"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s2 = \"Spam-egg-spam_spam\"\n",
    "s2.split('_')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "1bdaa3ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Spam', 'egg', 'spam_spam']"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s3 = s2.split('-')\n",
    "s3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "5fe12e2f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'h_la-adi_s'"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'_'.join(\"-\".join(['hola', 'adios']).split('o'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "e4805c37",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'h_la-adi_s'"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"_\".join(\"-\".join(['hola', 'adios']).split('o'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "41d9ae94",
   "metadata": {},
   "outputs": [],
   "source": [
    "vv = 5.0000045"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "8305763f",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "what do_you-like? HELLO 10.000009\n"
     ]
    }
   ],
   "source": [
    "# concatenation with +\n",
    "print(message + ' ' + response + ' ' + str(2*vv))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "82bc011f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(vv)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d37a7c2",
   "metadata": {},
   "source": [
    "### FORMAT\n",
    "\n",
    "# a = f'{message} {response} {vv}'\n",
    "\n",
    "# a = '{} {} {}'.format(message, response, vv)\n",
    "\n",
    "# a = '{0} {2} {1}'.format(message, response, vv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "cbb06746",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "what do_you-like? HELLO 10.00\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# concatenation with f\n",
    "print(f'{message} {response} {2*vv:.2f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "10a04e39",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'00005'"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f'{5:05d}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "5ab88cf8-732b-4e2b-b44c-85e87936bae6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "2e0136d5-f28e-49a8-a62f-d7cbb6b2f8e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.0"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ppp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "dc5e17b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "what do_you-like? HELLO 5.000\n",
      "HELLO -- what do_you-like? HELLO again HELLO\n",
      " / HELLO\n"
     ]
    }
   ],
   "source": [
    "# concatenation with format\n",
    "print('{} {} {:.3f}'.format(message, response, vv))\n",
    "print('{1} -- {0} {1} again {1}\\n / {1}'.format(message, response))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "acbf5cc3",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HELLOHELLOHELLOHELLOHELLO\n"
     ]
    }
   ],
   "source": [
    "# multiplication is multiple concatenation\n",
    "print(5 * response)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "d024dd71",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'t'"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "message[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "ce0befbd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'what do_you-like?'"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "a64247ce",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "wa o\n"
     ]
    }
   ],
   "source": [
    "# Access individual characters (zero-based indexing)\n",
    "#[first:end:step]\n",
    "print(message[:8:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "39433ce4",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "looc\n"
     ]
    }
   ],
   "source": [
    "cadena1 = \"cool\"\n",
    "print(cadena1[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "723812ba",
   "metadata": {},
   "source": [
    "## Exercise \n",
    "Given a string such as the one below, make a new string that does not contain the word ``this`` and hello and world as joined by \"-\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "1417a837",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"Ciao!, hello this world!\"\n",
    "# Ciao, hello-world!\n",
    "\n",
    "# enter your solution here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "8c553bf4-9245-4da7-a13c-8482a82c7019",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ciao, hello_world!'"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0:11] + \"_\" + a[17:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "7cd7f10d-64d8-43aa-b387-3f113aef61b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ciao!, hello _ world!'"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"_\".join(a.split('this'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "871bfa14-2ed6-4b1d-982c-ea8c676f6c77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ciao!,hello_world!'"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = a.split()\n",
    "\"\".join([b[0], \"_\".join(b[1::2])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edfc2df2-d7f6-4260-9ce7-8dc2f190a56c",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b05b4f4-62e9-4a59-b4ec-1a3bafb36b5e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8f12a0c0",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Built-In Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc93dfea",
   "metadata": {},
   "source": [
    "| Type Name | Example                   |Description                            |\n",
    "|-----------|---------------------------|---------------------------------------|\n",
    "| ``list``  | ``[1, 2, 3]``             | Ordered collection                    |\n",
    "| ``tuple`` | ``(1, 2, 3)``             | Immutable ordered collection          |\n",
    "| ``dict``  | ``{'a': 1, 'b': 2, 'c': 3}`` | (key,value) mapping                |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3fea1f3",
   "metadata": {},
   "source": [
    "### Lists\n",
    "\n",
    "A list is an ordered container of objects denoted by **square brackets**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "d85e09b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [0, 1, 1, 2, 3, 5, 8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4c511573",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0a036c77",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b9040262",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 3]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[0:6:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "639b338f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ppp = list() # empty list\n",
    "for n in range(5):\n",
    "    ppp.append(n+2)\n",
    "ppp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "3362ce49",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "for p in ppp:\n",
    "    print(p + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9bd60a64",
   "metadata": {},
   "source": [
    "Lists are useful for lots of reasons including iteration:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "8934e568",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 - 4.5\n",
      "2 - 5.5\n",
      "3 - 5.5\n",
      "4 - 6.5\n",
      "5 - 7.5\n",
      "6 - 9.5\n",
      "7 - 12.5\n"
     ]
    }
   ],
   "source": [
    "for pos, number in enumerate(mylist):\n",
    "    print(f'{pos + 1} - {number + 4.5}')\n",
    "    \n",
    "# for pos in range(len(mylist)):\n",
    "#    print(mylist[pos])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51d19f0e",
   "metadata": {},
   "source": [
    "Lists do **not** have to contain all identical types:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "07dd945b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 - <class 'int'>\n",
      "1 - <class 'int'>\n",
      "1 - <class 'int'>\n",
      "apple - <class 'str'>\n",
      "40000000.0 - <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "myweirdlist = [0, 1, 1, \"apple\", 4e7]\n",
    "for item in myweirdlist:\n",
    "    print(f'{item} - {type(item)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a2eb01ef",
   "metadata": {},
   "outputs": [],
   "source": [
    "ll = [['a', 'be ready', 'c'], [23, 45]] #### lists do not need to be square \n",
    "# Acces: list[first index][second index]\n",
    "# ll[0][1] -- > 'be ready'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "b1acd822-b402-4730-a40a-25c4dccf6397",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[['a', 'be ready'], ['c_a', 'd']], [23, 45]]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ll = [[['a', 'be ready'], ['c_a', 'd']], [23, 45]]\n",
    "ll"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2b3a74a4-532a-474f-9985-e798d8117cbb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['c', 'a']"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ll[0][1][0].split('_')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "29fec699",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "46"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ll[1][1] +1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "ec8528f6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'d'"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ll[0][1].split()[1][3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "f1bec243",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ll[0][1].split()[1][2:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b1ba550",
   "metadata": {},
   "source": [
    "This list contains a mix of `int`, `float`, and `str` (character string)."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45016df0",
   "metadata": {},
   "source": [
    "Because a list is *ordered*, we can access items by integer index:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "9ea3b0aa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' in ['a', 'be ready', 'c']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8903d2d3",
   "metadata": {},
   "source": [
    "remembering that we start counting from zero!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "929e13ef",
   "metadata": {},
   "source": [
    "Python also allows lists to be created dynamically through *list comprehension* like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "dcfd5b1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squares = [i**2 for i in range(11)]\n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "2141440b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# traditial loop\n",
    "squares = list()\n",
    "for i in range(11):\n",
    "    squares.append(i**2)\n",
    "squares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "543657a4",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false
   },
   "outputs": [],
   "source": [
    "li = [2, 3, 5, 7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "79712caa",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Change value of list\n",
    "li[1] = -2.2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "747250d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, -2.2, 5, 7]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "li"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "93a5b1f8",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, -2.2, 5, 7, 11, 11, 11, 11, 11, 11, 11]\n"
     ]
    }
   ],
   "source": [
    "# Append a value to the end\n",
    "li.append(11)\n",
    "print(li)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "de20c73d",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = li"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "7de1bd64",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, -2.2, 5, 7, 11, 11, 11, 11, 11, 11, 11, 13, 17, 19]\n"
     ]
    }
   ],
   "source": [
    "# Addition concatenates lists\n",
    "print(lst + [13, 17, 19])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "7453fea7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, -2.2, 7, 11, 11, 11, 11, 11, 11, 11]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst.remove(5)\n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "19198522",
   "metadata": {},
   "outputs": [],
   "source": [
    "# lst.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "3ca9b116",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 11, 7, -2.2, 2]"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "cd2c423c",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "# sort() method sorts in-place\n",
    "lst = [2, 5, 1, 6, 3, 4]\n",
    "lst.sort()\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "af4e927a",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 'two', 3.14, [0, 3, 5]]\n"
     ]
    }
   ],
   "source": [
    "lst = [1, \"two\", 3.14, [0, 3, 5]]\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "c1cfb8ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(lst[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4163ba40",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### List indexing and slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "97967f89",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false
   },
   "outputs": [],
   "source": [
    "lst = [2, 3, 5, 7, 11]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "fe3cdc47",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(lst[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "f2fdf72c",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(lst[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "c48a6d1b",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "print(lst[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "id": "1d01280b",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "print(lst[0:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "id": "e2bcc5b4",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "print(lst[:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "678971c4",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 5, 2]\n"
     ]
    }
   ],
   "source": [
    "print(lst[::-2])  # [start:end:step] equivalent to l[0:len(l):2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "c36d02e7",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[100, 3, 5, 7, 11]\n"
     ]
    }
   ],
   "source": [
    "lst[0] = 100\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "672b2d29",
   "metadata": {},
   "source": [
    "### Dictionaries (`dict`)\n",
    "\n",
    "A dictionary is a collection of *labeled objects*. Python uses curly braces `{}` to create dictionaries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "abc8ac9b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 1st order key = 'name', 'species' 'age'\n",
    "# 2nd order key = NAME: male, female\n",
    "\n",
    "mypet1 = {\n",
    "    \"class1\": {'male': [\"Fluffy\", 'Fido'], 'female':'Fida'},\n",
    "    \"class2\": [\"cat\", 'dog', 'parrot', 'iguana'],\n",
    "    \"age\": [4, 5],\n",
    "}\n",
    "type(mypet1)\n",
    "\n",
    "\n",
    "\n",
    "mypet = {\n",
    "    \"weight\": [60, 45, 56, 34],\n",
    "    \"age\": [15, 45, 67, 89],\n",
    "}\n",
    "type(mypet)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "453b915c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'male': ['Fluffy', 'Fido'], 'female': 'Fida'}"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mypet1['class1']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27881993",
   "metadata": {},
   "source": [
    "We can then access items in the dictionary by label using square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "id": "1c104791",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Fida'"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mypet[\"name\"]['female']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7863fa0d",
   "metadata": {},
   "source": [
    "We can iterate through the keys (or labels) of a `dict`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "2d7d619c-c661-447e-8af4-c728e3e62d3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The key is: name\n",
      "The value is: {'male': ['Fluffy', 'Fido'], 'female': 'Fida'}\n",
      "The key is: species\n",
      "The value is: ['cat', 'dog', 'parrot', 'iguana']\n",
      "The key is: age\n",
      "The value is: [4, 5]\n"
     ]
    }
   ],
   "source": [
    "for key in mypet.keys():\n",
    "    print(\"The key is:\", key)\n",
    "    print(\"The value is:\", mypet[key])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "bf42ce6e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The key is: name\n",
      "The value is: {'male': ['Fluffy', 'Fido'], 'female': 'Fida'}\n",
      "The key is: species\n",
      "The value is: ['cat', 'dog', 'parrot', 'iguana']\n",
      "The key is: age\n",
      "The value is: [4, 5]\n"
     ]
    }
   ],
   "source": [
    "for key, values in mypet.items():\n",
    "    print(\"The key is:\", key)\n",
    "    print(\"The value is:\", values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "673dcf67",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': {'male': ['Fluffy', 'Fido'], 'female': 'Fida'}, 'species': ['cat', 'dog', 'parrot', 'iguana'], 'age': [4, 5], 'ninety': 90}\n"
     ]
    }
   ],
   "source": [
    "# Set a new key:value pair\n",
    "mypet[\"ninety\"] = 90\n",
    "print(mypet)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76b80aa3",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9acfa95",
   "metadata": {},
   "source": [
    "- Create a dictionary with the following birthday information:\n",
    "\n",
    "> - Albert Einstein - 03/14/1879\n",
    "> - Benjamin Franklin - 01/17/1706\n",
    "> - Ada Lovelace - 12/10/1815\n",
    "> - Marie Curie - 07/11/1867\n",
    "> - Rowan Atkinson - 01/6/1955\n",
    "> - Rosalind Franklin - 25/07/1920"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "419307ca",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "- Check if Marie Curie is in our dictonary\n",
    "- Get Albert Einstein's birthday"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "3b9f5129-89b7-4a04-9b92-fb581b5fcc7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "info = {'Albert Einstein': '03/14/1879',\n",
    "        'Benjamin Franklin': '01/17/1706',\n",
    "        'Ada Lovelace': '12/10/1815',\n",
    "        'Marie Curie': '07/11/1867',\n",
    "        'Rowan Atkinson': '01/6/1955',\n",
    "        'Rosalind Franklin': '25/07/1920'}\n",
    "\n",
    "info2 = {'name': ['Albert Einstein', 'Benjamin Franklin', 'Ada Lovelace', 'Marie Curie', 'Rowan Atkinson', \n",
    "                  'Rosalind Franklin'],\n",
    "         'birthday': ['03/14/1879', '01/17/1706', '12/10/1815', '07/11/1867', '01/6/1955','25/07/1920']}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "832ac344-3765-40ec-b4c2-01a7af32ea8b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yes, and her birthday is 07/11/1867\n",
      "07/11/1867\n"
     ]
    }
   ],
   "source": [
    "nn = 'Marie Curie'\n",
    "if nn in info:\n",
    "    print(f'Yes, and her birthday is {info.get(nn)}')\n",
    "    print(info.get(nn))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "2bb1a7b4-14ee-4011-b105-338f87b3f029",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'03/14/1879'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "info['Albert Einstein']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "bb0a14e9-2610-4dc9-8845-ecbbdefbff3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nn in info.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "749dbf92-c73c-4e2c-9a1f-e7ab58ee595a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nn in info2['name']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "65215b7b-e819-4255-bafc-42951aafe446",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Albert Einstein\n"
     ]
    }
   ],
   "source": [
    "nn = 'Albert Einstein'\n",
    "for keys, values in info2.items():\n",
    "    if nn in values:\n",
    "        print(nn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "3ae3897b-7413-4555-b5ac-54f505d5b748",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'03/14/1879'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## == --> mask\n",
    "\n",
    "names = info2['name']\n",
    "bds = info2['birthday']\n",
    "\n",
    "pos = names.index('Albert Einstein')\n",
    "bds[pos]\n",
    "\n",
    "\n",
    "info2['birthday'][info2['name'].index('Albert Einstein')]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cec52fb",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e35c083",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "| Operator     | Name           | Description                                            |\n",
    "|--------------|----------------|--------------------------------------------------------|\n",
    "| ``a + b``    | Addition       | Sum of ``a`` and ``b``                                 |\n",
    "| ``a - b``    | Subtraction    | Difference of ``a`` and ``b``                          |\n",
    "| ``a * b``    | Multiplication | Product of ``a`` and ``b``                             |\n",
    "| ``a / b``    | True division  | Quotient of ``a`` and ``b``                            |\n",
    "| ``a // b``   | Floor division | Quotient of ``a`` and ``b``, removing fractional parts |\n",
    "| ``a % b``    | Modulus        | Integer remainder after division of ``a`` by ``b``     |\n",
    "| ``a ** b``   | Exponentiation | ``a`` raised to the power of ``b``                     |\n",
    "| ``-a``       | Negation       | The negative of ``a``                                  |\n",
    "| ``+a``       | Unary plus     | ``a`` unchanged (rarely used)                          |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "fe84f69f",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(22 / 2 == 10 + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "80418361",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# 25 is even\n",
    "print(25 % 2 != 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "801fdce0",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# 66 is odd\n",
    "print(66 % 2 == 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "c032c545",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# check if a is between 15 and 30\n",
    "a = 25\n",
    "print(15 < a < 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "073360bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [2, 3, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "9298b93a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 4, 1]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + [1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6fdc5f5",
   "metadata": {},
   "source": [
    "## Arrays of numbers with `numpy`\n",
    "\n",
    "The vast majority of scientific Python code makes use of *packages* that extend the base language in many useful ways.\n",
    "\n",
    "Almost all scientific computing requires ordered arrays of numbers, and fast methods for manipulating them. That's what numpy does in the Python world.\n",
    "\n",
    "Using any package requires an `import` statement, and (optionally) a nickname to be used locally, denoted by the keyword `as`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "f138cd1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9128a73f-6b2a-4cc5-bb1e-1b3942b2c645",
   "metadata": {},
   "outputs": [],
   "source": [
    "#np."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93654348",
   "metadata": {},
   "source": [
    "Now all our calls to `numpy` functions will be preceeded by `np.`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a5d0eee",
   "metadata": {},
   "source": [
    "Create a linearly space array of numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "0ccbe5ea",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# linspace() takes 3 arguments: start, end, total number of points\n",
    "numbers = np.linspace(0.0, 1.0, 11)\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "255adc0d",
   "metadata": {},
   "source": [
    "We've just created a new type of object defined by numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "16f6ba3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb680a40",
   "metadata": {},
   "source": [
    "Do some arithmetic on that array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "2b33ca32",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1. , 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2. ])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers + [1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "028e9f94",
   "metadata": {},
   "outputs": [],
   "source": [
    "list = [3, 4, 5]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d1f53a88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5, 3, 4, 5]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list + list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70e1fff9",
   "metadata": {},
   "source": [
    "Sum up all the numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82de21e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sum(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b3c8a1f",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Boolean Operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "9fcc9237",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "x = 4\n",
    "print(((x < 6) and (x > 2)) and (x == 5))\n",
    "# and (if, while) -> & (numerical operations in numpy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "b640f313",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print((x > 10) or (x % 2 == 0))\n",
    "# or (if, while) -> | (numerical operation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "be790c58",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "if x != 0:\n",
    "    print('score')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "eb3a0ecd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score\n"
     ]
    }
   ],
   "source": [
    "if not x == 0:\n",
    "    print('score')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "da95c0b6",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(not (x < 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c42946f",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Membership Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98f7c4b6",
   "metadata": {},
   "source": [
    "| Operator      | Description                                       |\n",
    "|---------------|---------------------------------------------------|\n",
    "| ``a in b``    | True if ``a`` is a member of ``b``                |\n",
    "| ``a not in b``| True if ``a`` is not a member of ``b``            |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "abbfc7ac",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "print(1 in [1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "9364f9b2",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "scrolled": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(2 not in [1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14361c43",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "084f80a0",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Defining Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "ecf24ffb",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('This is a function. Copyright 15-03-2024', 'This is a function. Copyright 15-03-2024')\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "# def NAME(input1, input2):\n",
    "#     aaaaa\n",
    "#     bbbbb\n",
    "\n",
    "#     return output1, output2   \n",
    "\n",
    "# out = NAME(inp1, inp2) --- you get a list of 2 variables\n",
    "# out = [out1, out2]\n",
    "# out1, out2 = NAME(inp1, inp2) ----- you get the 2 variables\n",
    "# _, out2 = NAME(inp1, inp2) ----- you get only the 2nd variable\n",
    "\n",
    "def header():\n",
    "    text = \"This is a function\"\n",
    "    text += \". Copyright \" + time.strftime(\"%d-%m-%Y\")\n",
    "\n",
    "    return text, text \n",
    "\n",
    "\n",
    "out1, _ = header()\n",
    "\n",
    "print(header())\n",
    "#print(out1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "4dcc6be5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# aux.py --- plot-functions, aux, read\n",
    "import numpy as np\n",
    "\n",
    "def sine(x):\n",
    "    b = np.sin(x)\n",
    "    \n",
    "    return b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c212314f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# main.py\n",
    "from aux import sine\n",
    "\n",
    "c = sine(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "6cc19ce0",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This function is written by Andrea Lira Loarca. Copyright 15-03-2024\n"
     ]
    }
   ],
   "source": [
    "def header_v2(author):\n",
    "\n",
    "    text = \"This function is written by \"\n",
    "    text += author\n",
    "    text += f\". Copyright {time.strftime('%d-%m-%Y')}\"\n",
    "\n",
    "    return text\n",
    "\n",
    "\n",
    "print(header_v2(\"Andrea Lira Loarca\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "63a3d622",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    l = []\n",
    "    a = 0\n",
    "    b = 1\n",
    "    while len(l) < n:\n",
    "        l.append(a)\n",
    "        c = a + b\n",
    "        a = b\n",
    "        b = c\n",
    "    return l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "aadccefb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3]"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49d90a5a",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Default Argument Values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "ce71929e",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "def fibonacci2(n, start1=0, start2=1):\n",
    "    fib = []\n",
    "    a = 0\n",
    "    b = 1\n",
    "    start = np.min([start1, start2])\n",
    "    print(start)\n",
    "    while len(fib) < n:\n",
    "        if a >= start:\n",
    "            fib.append(a)\n",
    "        c = a + b\n",
    "        a = b\n",
    "        b = c\n",
    "    return fib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "14b00e69",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "[3, 5, 8, 13, 21, 34, 55, 89, 144, 233]\n"
     ]
    }
   ],
   "source": [
    "print(fibonacci2(10, start2=6, start1=3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "270a31a7",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 8, 13, 21, 34, 55, 89, 144, 233, 377]\n"
     ]
    }
   ],
   "source": [
    "print(fibonacci(10, 5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "317fe25d",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "## Keyword arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "e4338aed",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368]\n"
     ]
    }
   ],
   "source": [
    "print(fibonacci(start=5, n=20))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a90b3e21",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Documentation strings (docstrings)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfb29e70",
   "metadata": {},
   "source": [
    "* Python documentation strings (docstrings) provide a convenient **way of associating documentation with Python functions** and modules.\n",
    "* Docstrings can be written following **several styles**. We use [Google Python Style Guide](https://sphinxcontrib-napoleon.readthedocs.io/en/latest/).\n",
    "* An object's docsting is defined by including a **string constant as the first statement in the function's definition**."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5138ab42",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "* Unlike conventional source code comments **the docstring should describe what the function does, not how**.\n",
    "* **All functions should have a docstring**.\n",
    "* This allows to inspect these comments at run time, for instance as an **interactive help system**, or **export them as HTML, LaTeX, PDF** or other formats."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "8a0c1cc3",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def fibonacci(n, start=0):\n",
    "    \"\"\"Build a Fibonacci series with n elements starting at start\n",
    "\n",
    "    Args:\n",
    "        n: number of elements\n",
    "        start: lower limit. Default 0\n",
    "\n",
    "    Returns:\n",
    "        A list with a Fibonacci series with n elements\n",
    "    \"\"\"\n",
    "    fib = []\n",
    "    a = 0\n",
    "    b = 1\n",
    "    while len(fib) < n:\n",
    "        if a >= start:\n",
    "            fib.append(a)\n",
    "        c = a + b\n",
    "        a = b\n",
    "        b = c\n",
    "    return fib"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca878a03",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Modules and Packages"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f7ba4c8",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Loading Modules: the ``import`` Statement"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9473286",
   "metadata": {
    "inputHidden": false,
    "outputHidden": false,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Explicit module import by alias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "b2a3fb79",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from numpy import linspace"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "0242f402",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.55555556, 1.11111111, 1.66666667, 2.22222222,\n",
       "       2.77777778, 3.33333333, 3.88888889, 4.44444444, 5.        ])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "linspace(0, 5, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b79b2743",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Explicit import of module contents"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "406329fb",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import scipy.stats as st\n",
    "from scipy.stats import norm, genpareto"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "326ca303",
   "metadata": {},
   "source": [
    "### Paths\n",
    "\n",
    "## os\n",
    "\n",
    "## pathlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "3e21aab6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "data/columns.txt\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[ 1.99500274e+03,  9.44444000e-01],\n",
       "       [ 1.99500548e+03, -1.61111000e+00],\n",
       "       [ 1.99500821e+03, -3.55556000e+00],\n",
       "       [ 1.99501095e+03, -9.83333000e+00],\n",
       "       [ 1.99501369e+03, -1.02222000e+01],\n",
       "       [ 1.99501643e+03, -9.50000000e+00],\n",
       "       [ 1.99501916e+03, -1.02222000e+01],\n",
       "       [ 1.99502190e+03, -6.61111000e+00],\n",
       "       [ 1.99502464e+03, -2.94444000e+00],\n",
       "       [ 1.99502738e+03,  1.55556000e+00],\n",
       "       [ 1.99503012e+03,  2.77778000e-01],\n",
       "       [ 1.99503285e+03, -1.44444000e+00],\n",
       "       [ 1.99503559e+03, -3.61111000e+00]])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "dir_fn = os.path.join('data', 'columns.txt')\n",
    "print(dir_fn)\n",
    "\n",
    "data = np.loadtxt(dir_fn)\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "6582a472",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.99500274e+03,  9.44444000e-01],\n",
       "       [ 1.99500548e+03, -1.61111000e+00],\n",
       "       [ 1.99500821e+03, -3.55556000e+00],\n",
       "       [ 1.99501095e+03, -9.83333000e+00],\n",
       "       [ 1.99501369e+03, -1.02222000e+01],\n",
       "       [ 1.99501643e+03, -9.50000000e+00],\n",
       "       [ 1.99501916e+03, -1.02222000e+01],\n",
       "       [ 1.99502190e+03, -6.61111000e+00],\n",
       "       [ 1.99502464e+03, -2.94444000e+00],\n",
       "       [ 1.99502738e+03,  1.55556000e+00],\n",
       "       [ 1.99503012e+03,  2.77778000e-01],\n",
       "       [ 1.99503285e+03, -1.44444000e+00],\n",
       "       [ 1.99503559e+03, -3.61111000e+00]])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "dir_data = Path('data')  # --> relative path \n",
    "data = np.loadtxt(dir_data / 'columns.txt')\n",
    "data\n",
    "\n",
    "# src / data / pics\n",
    "p_file = Path('__file__').resolve() # ---> get absolute path of my file.py\n",
    "\n",
    "\n",
    "# PROJECT\n",
    "# -> src / file.py\n",
    "# -> data\n",
    "# -> pics\n",
    "dir_data = p_file.parents[1] / 'data'\n",
    "dir_pics = p_file.parents[1] / 'pics'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "840a3feb",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn = dir_data / 'columns.txt'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "ff6f6d6a-0d7e-491c-a80c-ad08d9a9d981",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "columns_mean.txt\n"
     ]
    }
   ],
   "source": [
    "print(f'{fn.stem}_mean.txt')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}