Notebooks/Basics_I___Data_Types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Basics I - Data Types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Author**: [Gabriele Pompa](https://www.linkedin.com/in/gabrielepompa/): gabriele.pompa@unisi.com"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Table of contents\n",
    "\n",
    "[Executive Summary](#summary)\n",
    "1. [Integers](#int)\n",
    "2. [Floats](#float)\n",
    "3. [Booleans](#bool)\\\n",
    "    3.1. [`while` loop](#while)\\\n",
    "    3.2. [`if` statement](#if)\n",
    "4. [Strings](#str)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### **Resources**: \n",
    "\n",
    "- [_Python for Finance (2nd ed.)_](http://shop.oreilly.com/product/0636920117728.do): Sec. 3.Basic Data Types (Section 3.Excursus: Regular Expression is optional)\n",
    "- [_The Python Tutorial_](https://docs.python.org/3.7/tutorial/): Sec. [3.1.1](https://docs.python.org/3.7/tutorial/introduction.html#numbers) (Numbers), [3.1.2](https://docs.python.org/3.7/tutorial/introduction.html#strings) (Strings), [3.2](https://docs.python.org/3.7/tutorial/introduction.html#first-steps-towards-programming) (First Steps Toward Programming), [4.1](https://docs.python.org/3.7/tutorial/controlflow.html#if-statements) (if Statements)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Executive Summary <a name=\"summary\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Informally, the _type_ of a variable is related to the amount of bits that are reserved in memory to store it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Python interpreter infers at run-time the type of a variable. Thus we say that Python is a _dynamically typed_ language. This to contrast it with other - compiled - languages, like C or C++, where the type of a variable has to be declared when the variable identifier (that is, its name in our code) is introduced for the first time in the code. The latter kind of languages are told _statically typed_ languages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function `type()` can be called over any defined variable and returns its type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The following sections are organized as follows: \n",
    "- In Sec. [1](#int) we introduce integer numbers (or `int`), which are the Python data type to represent integers like 1, 2, 3,...\n",
    "- In Sec. [2](#float) we introduce float numbers (or `float`), which are the Python data type to represent fractions like 1/2, 0.25 or real numbers like $e$, $\\pi$,...\n",
    "- In Sec. [3](#bool) we introduce booleans (or `bool`), which are the Python data type to represent the logical values `True` or `False`. In this context `while` loops (in Sec. [3.1](#while)) and `if` statements (in Sec. [3.2](#if)) are introduced.\n",
    "- In Sec. [4](#str) we introduce strings (or `str`), which are the Python data type to represent text like `\"this one\"`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Integers <a name=\"int\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Integers like 1, 2, 3,... are represented in Python as `int` data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n = 10\n",
    "type(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The amount of bits (i.e. memory) reserved to an `int` depends on its value. For `n=10`, 4 bits are reserved. We can check this using the `.bit_length()` method of `int` variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n.bit_length()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indeed, it's simple to see that (check this [decimal-to-binary converter](https://www.rapidtables.com/convert/number/decimal-to-binary.html))\n",
    "\n",
    "$$\n",
    "10 = (1 \\times 2^3) + (0 \\times 2^2) + (1 \\times 2^1) + (0 \\times 2^0) = 8 + 0 + 2 + 0\n",
    "$$\n",
    "\n",
    "therefore the 4 binary numbers (i.e. 0/1 bits) `1010` are sufficient to represent the integer number 10."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is very efficient in its internal representation of integer numbers as it can represent integers arbitrarily big, like $10^{100}$ (named [Googol](https://en.wikipedia.org/wiki/Googol))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n"
     ]
    }
   ],
   "source": [
    "googol = 10**100\n",
    "print(googol)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "333"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "googol.bit_length()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Floats <a name=\"float\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Non-integers numbers are represented in Python as `float` data type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.25\n"
     ]
    }
   ],
   "source": [
    "q = 1/4\n",
    "print(q)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(q)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The fraction $\\frac{1}{4}$ is represented _exactly_ as the `float` 0.25. This is because 0.25 has an exact (and obvious) binary representation (in terms of negative powers of the base 2)\n",
    "\n",
    "$$\n",
    "\\frac{1}{4} = (0 \\times 2^{0}) + (0 \\times 2^{-1}) + (1 \\times 2^{-2}) = \\left(0 \\times 1 \\right) + \\left(0 \\times \\frac{1}{2} \\right) + \\left(1 \\times \\frac{1}{4} \\right) = 0.25\n",
    "$$\n",
    "\n",
    "where the 0/1 bits associated to smaller powers of 2: $ 2^{-3}, 2^{-4}, ...$ are all zero."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Therefore, in a [_fixed-point_](https://en.wikipedia.org/wiki/Fixed-point_arithmetic) binary representation (that is a binary representation using a fixed number of bits after the decimal point '.', as the one above), the decimal number 0.25 can be represented as the binary number `0.01` (check this [decimal-to-binary converter](https://www.rapidtables.com/convert/number/decimal-to-binary.html)), that is using only the first two left-most bits after the '.' (which are the most significant)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Binary representation of `float` numbers is not always _perfect_. That is, it's not alway true that a decimal number $0 < q < 1$ can be represented exactly as the series\n",
    "\n",
    "$$\n",
    "q = \\sum_{i=1}^{k} b_i \\times 2^{-i}\n",
    "$$\n",
    "\n",
    "where $b_i = 0/1$ is the $i$-th bit. In particular it can be that:\n",
    "\n",
    "- the series is infinite ($k = \\infty$);\n",
    "\n",
    "- the series requires more bits than those at disposal. That is, given a finite number of bits at disposal - say $k_{MAX}$ - it can be that $k > k_{MAX}$.\n",
    "\n",
    "In this last case, the best we can do is a _truncation_ of the series. That is, $q$ can will be approximately represented as \n",
    "\n",
    "$$\n",
    "q \\approx \\sum_{i=1}^{k_{MAX}} b_i \\times 2^{-i}\n",
    "$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In real life things are more complicated. In particular, The IEEE 754 [double-precision](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) standard - currently adopted by modern 64-bits machines - reserves 64 bits to represent a decimal number, but bits are not simply associated to negative and decreasing powers of the base 2: $2^{-1}, 2^{-2}, ...$ as in the [fixed-point](https://en.wikipedia.org/wiki/Fixed-point_arithmetic) binary representation that we considered before. The IEEE 754 standard prescribes a [_floating-point_](https://en.wikipedia.org/wiki/Double-precision_floating-point_format) format, where the meaning and role of the bits in the binary representation changes depending on their position. In particular, for your knowledge (more informations in [Wikipedia](https://en.wikipedia.org/wiki/Double-precision_floating-point_format)):\n",
    "- 1 bit (the $1$st one) represents the _sign;_ \n",
    "- 11 bits (from the $2$nd to the $12$th) represent an _exponent;_ \n",
    "- 52 bits (from the $13$th to the last one) represet the _fractional part_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This representation allows to represent a greater range of decimal numbers, given the same amount of bits at disposal (64). This increase in the range of number representable comes at the cost of precision. In the IEEE 754 double-precision standards, the relative accuracy is of 15-digits."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The _finite-precision_ in the binary representation of decimal numbers leads to expected results like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.35"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q = 0.25 + 0.1\n",
    "q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but also to unexpected ones like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.44999999999999996"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q = 0.35 + 0.1  #should be 0.45\n",
    "q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nevertheless, module [`decimal`](https://docs.python.org/2/library/decimal.html) allows us to set an arbitrary precision (we won't use it, but it's good for you to know):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "import decimal \n",
    "from decimal import Decimal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, flags=[], traps=[InvalidOperation, DivisionByZero, Overflow])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decimal.getcontext()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the precision is of 28 significant (non-zero) digits by default (`prec=28`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('0.05882352941176470588235294118')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q = Decimal(1) / Decimal(17)\n",
    "q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "the precision can be changed arbitrarily to set the number of significant (non-zero) digits after the '.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('0.0588')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decimal.getcontext().prec = 3  # here we se the precision to 3 significant digits after the '.'\n",
    "\n",
    "q = Decimal(1) / Decimal(17)\n",
    "q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Bool <a name=\"bool\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Logical states like `True` and `False` are represented in Python as `bool` data type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output of a _comparison_ operator\n",
    "\n",
    "- `<` (smaller than), \n",
    "- `>` (greater than), \n",
    "- `<=` (smaller or equal than), \n",
    "- `>=` (greater or equal than), \n",
    "- `==` (equal to), \n",
    "- `!=` (not equal to)\n",
    "\n",
    "is a boolean value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 17\n",
    "b = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flag = (a < b)\n",
    "flag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flag = (a > b)\n",
    "flag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flag = (a <= b)\n",
    "flag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flag = (a >= b)\n",
    "flag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flag = (a == b)\n",
    "flag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flag = (a != b)\n",
    "flag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Logical operators_ \n",
    "- `and` (logic and), \n",
    "- `or` (logic or), \n",
    "- `not` (logic not)\n",
    "\n",
    "apply to boolean values and return boolean values as output. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "bool_1 = (a < b)\n",
    "bool_2 = (a > b)\n",
    "\n",
    "print(bool_1)\n",
    "print(bool_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flag = (bool_1 and bool_2)\n",
    "flag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flag = (bool_1 or bool_2)\n",
    "flag"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "flag = (not bool_1)\n",
    "flag"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a one-to-one correspondence between `bool` and `int`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "where we have used the _casting_ functions `int()` and `bool()` which cast a variable to `int` and `bool`, respectively (there are many more, `float()`, `str()`,...). More examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i = int(1.15)\n",
    "print(i)\n",
    "type(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = float(10)\n",
    "print(f)\n",
    "type(f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "90\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = str(90) # strings data types introduced below\n",
    "print(s)\n",
    "type(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Boolean values are particular useful within control flows structures. We examine here `while` loops and `if` conditions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1. while loop <a name=\"while\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A [`while` loop](https://docs.python.org/3.7/tutorial/introduction.html#first-steps-towards-programming) in Python is declared as follows:\n",
    "```python\n",
    "while condition:\n",
    "    statement(s)\n",
    "```\n",
    "The Python interpreter evaluates the logical `condition`; if it is `True`, `statement(s)` (all the lines of code _indented_ w.r.t. the `while` keyword) are executed. Then `condition` is evaluated again and, if `True`, the `statement(s)` are executed again. The loop ends when (and if) `condition` becomes `False`.\n",
    "\n",
    "**Warning**: if `condition` never becomes `False`, you end up with an infinite loop, which will execute forever. Needless to say you should avoid infinite loops!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An academic example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# while 1:\n",
    "#    print(\"I'm into an infinite loop...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To stop execution:\n",
    "- in a Jupyter Notebook: press _Kernel_ and then _Interrupt_ (see picture):\n",
    "<img src=\"../images/KernelInterrupt.png\" width=\"200\">\n",
    "\n",
    "\n",
    "- in a script (using Spyder IDE): press the red square (&#x1f7e5;) on the top-right angle of the _IPython console,_ which is the interactive console on the bottom-right panel where you see the output of the code you type in the _Editor_ (see picture). A `KeyboardInterrupt` message will confirm the stop.\n",
    "\n",
    "<img src=\"../images/KeyboardInterrupt.png\" width=\"200\">\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example**: A [Fibonacci number](https://en.wikipedia.org/wiki/Fibonacci_number) $F_n$ is the sum of its two preceeding numbers. It is defined by the initial conditions:\n",
    "\n",
    "$$\n",
    "F_0 = 0\\\\\n",
    "F_1 = 1\n",
    "$$\n",
    "\n",
    "and satisfies the relation\n",
    "\n",
    "$$\n",
    "F_n = F_{n-1} + F_{n-2}\n",
    "$$\n",
    "\n",
    "This code prints the first few Fibonacci numbers smaller than a constant $C$. \n",
    "\n",
    "To do this we define a function `fib(C)` which takes in input the stopping constant `C`, uses a `while` loop to compute the numbers and returns the greatest number Fibonacci number satisfying condition $F_n < C$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(C):\n",
    "    \"\"\"\n",
    "    This function computes the greatest Fibonacci number smaller than consant 'C'.\n",
    "    \n",
    "    Parameters:\n",
    "        C (float): stopping constant.\n",
    "    \n",
    "    Returns:\n",
    "        F_n2 (int): greatest Fibonacci number smaller than C.\n",
    "    \"\"\"\n",
    "    \n",
    "    # initialization\n",
    "    F_n2 = 0 # F_{n-2}\n",
    "    F_n1 = 1 # F_{n-1}\n",
    "\n",
    "    while F_n1 < C:\n",
    "\n",
    "        # uncomment this line below if you want to print to screen the current number\n",
    "        # print(F_n2)\n",
    "\n",
    "        # store F_{n-1} + F_{n-2} into a temporary variable \n",
    "        temp = F_n1 + F_n2\n",
    "\n",
    "        # update the last two numbers\n",
    "        F_n2 = F_n1\n",
    "        F_n1 = temp\n",
    "        \n",
    "    return F_n2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's set the stopping constant $C=10^4$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "C_stop_const = 10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6765"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib(C_stop_const)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can print on screen the whole Fibonacci series until $F_n < C$ simly removing the comment at `print(F_n2)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can easily test the speed of our code using the [%timeit](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-timeit) directive, which runs the same line of code (in this case the calls of function `fib(C)`) several times to have statistically significant averages of its running-time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.04 µs ± 29 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fib(C_stop_const)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Running `fib(10000)` takes on average 1.1$\\mu s$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can exploit Python inline assignments to make this code more this function more compact."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib_inline(C):\n",
    "    \"\"\"\n",
    "    This function computes the greatest Fibonacci number smaller than consant 'C' using inline assignments.\n",
    "    \n",
    "    Parameters:\n",
    "        C (float): stopping constant.\n",
    "    \n",
    "    Returns:\n",
    "        F_n2 (int): greatest Fibonacci number smaller than C.\n",
    "    \"\"\"\n",
    "    \n",
    "    # inline initialization\n",
    "    F_n2, F_n1 = 0, 1 # F_{n-2}, F_{n-1}\n",
    "\n",
    "    while F_n1 < C:\n",
    "\n",
    "        # uncomment this line below if you want to print to screen the current number\n",
    "        # print(F_n2)\n",
    "\n",
    "        # inline update of the last two numbers\n",
    "        F_n2, F_n1 = F_n1, F_n1 + F_n2\n",
    "    \n",
    "    return F_n2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6765"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fib_inline(C_stop_const)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.09 µs ± 71.4 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit fib_inline(C_stop_const)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The inline assignments lead to a slightly performance improvement too."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2. if statement <a name=\"if\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An [`if` statement](https://docs.python.org/3.7/tutorial/controlflow.html#if-statements) in Python is declared as follows:\n",
    "```python\n",
    "if condition:\n",
    "    statement(s)\n",
    "elif alternative_condition:\n",
    "    statement(s)\n",
    "else:\n",
    "    statement(s)\n",
    "```\n",
    "The Python interpreter evaluates the logical `condition` next to the `if`; if it is `True`, the `statement(s)` indented under the `if` statement are executed. If `condition` is `False`, the logical `alternative_condition` next to the `elif` statement is evaluated; if it is `True` the `statement(s)` indented under the `elif` are executed. If also  `alternative_condition` is `False`, the `statement(s)` indented under the `else` statement are executed. \n",
    "\n",
    "Notice that:\n",
    "- `elif` statement is optional and there can be more than one;\n",
    "- `else` statement is optional."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a is greater than b\n"
     ]
    }
   ],
   "source": [
    "a = 17\n",
    "b = -1\n",
    "\n",
    "if a < b:\n",
    "    print(\"a is smaller than b\")\n",
    "elif a == b:\n",
    "    print(\"a equals b\")\n",
    "else:\n",
    "    print(\"a is greater than b\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Strings <a name=\"str\"></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One or more text characters are represented in Python as [`str` data type](https://docs.python.org/3.7/tutorial/introduction.html#strings). Use the double quotes `\"\"` to define a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"My name is Gabriele\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Type `str` is a very versatile data type. It can be splitted in single words (that is, considering as separator the white space ` `):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['My', 'name', 'is', 'Gabriele']"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s.split()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Moreover, strings can be _indexed_ treating its single characters as elements of the strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I\n",
      "_\n"
     ]
    }
   ],
   "source": [
    "s = \"IT_For_Business_And_Finance_2019_20\"\n",
    "\n",
    "print(s[0])\n",
    "print(s[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and index access can be also from last character. Index `-1` points to the last one, `-2` to the second-last..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(s[-1])\n",
    "print(s[-2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can be _sliced_. That is, you can select portions of it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IT\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s_slice = s[0:2] # characters from position 0 (included) to 2 (excluded)\n",
    "\n",
    "print(s_slice)\n",
    "type(s_slice)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'_Fo'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[2:5] # characters from position 2 (included) to 5 (excluded)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'IT'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:2]   # character from the beginning to position 2 (excluded) --- equivalent to s[0:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'20'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-2:]  # characters from the second-last (included) to the end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are _immutable_. If you try to change one of its characters, you get\n",
    "```python\n",
    "TypeError: 'str' object does not support item assignment\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "# s[0] = \"A\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if you really want to modify a string, simply define a new one (even with the same name). Suppose you want to change the first element of string `s` from \"I\" to \"A\". You can do this way (notice the behavior of the `+` operator on strings):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'AT_For_Business_And_Finance_2019_20'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"A\" + s[1:]\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As all sequence-like data structures, strings have a length `len()`, which is the number of its characters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To conclude, a string in Python is a _data type_ in that even a single character is a string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(\"c\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but, as we have just seen, it also behaves as a sequence-like _data structure,_ since it can be indexed, sliced, ... as if it is an _array_ of characters."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}