S2_TD1_python_notebook_en_student.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/lionelalexandre/4TPU271/blob/main/S2_TD1_python_notebook_en_teacher.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nv0Y9pmYeuWZ"
   },
   "source": [
    "# <span style=\"color:blue\"> <center>Student / TD1 : 4TPU279U $-$ Bachelor 1st year $-$ spring 2023</center></span>\n",
    "# <center>Introduction to python programming</center>\n",
    "# <hr style=\"border:1px solid black\"><center>  The basics </center><hr style=\"border:1px solid black\">\n",
    "</br>\n",
    "\n",
    "*This notebook has been prepared using various materials, the main reference being \"How to Think Like a Computer Scientist\" learning with python available on-line [here](http://www.openbookproject.net/thinkcs/archive/python/thinkcspy3e_abandoned/index.html)*\n",
    "\n",
    "</br>\n",
    "<div style=\"text-align: right\"> Credits: R. Boisgard, L. Truflandier, Philippe Paillou, Julien Burgin, Sara Zein, Leo Delmarre, Simon Villain-Guillot </div>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sQhR2AsdF74-"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WjQWi3fWeuWc"
   },
   "source": [
    "The goal of this first session is to familiarize with basic programming using the `python` language.\n",
    "As a result there are two main points : access to the programming basics and get use of formal language such as `python`. \n",
    "\n",
    "In all the languages there are rules to respect in order to communicate and understand each other. In natural language (speak/write) this rules can evolved. When they are not respected (spelling mistakes or lack of pronunciation) we tend to interpret the message. Formal languages are designed for specific applications and generally possess stricter syntax. Mathematics, physics, and chemistry have all a formal syntax. The formal syntax may also have some variants but a positive outcome for an interpretation of a deffective formal syntax is much more reduced compare to natural language. Python is qualified as to high-level interpreted language which allows for manipulate abstract objects. Nevertheless, a strict syntax must be respected in order to avoid the commonly found `syntax eror`. \n",
    "\n",
    "A program is a sequence of statements or instructions which follows a *logic* order. Program are written to perform some computations or/and process some data. Programming and mathematics have a strong link through the notion of algorithm. Algorithms constitute the core of a program. They are build from basics constructs which will be described latter in this document. From an *input*, they proceed through a finite set of instructions to deliver an *output*. \n",
    "\n",
    "The following topics will be cover in this notebook:\n",
    "\n",
    "0. Installation of python\n",
    "1. Try the console! \n",
    "2. Basic types, assignment and operators\n",
    "3. Sequence types\n",
    "4. Basic constructs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "M2CEBhD5euWd"
   },
   "source": [
    "## <hr style=\"border:1px solid black\">  Installation of python  <hr style=\"border:1px solid black\">\n",
    "\n",
    "Depending on your OS [<sup>1</sup>](#fn1) (LINUX/MacOSX/Windows) there exists several ways of installing python packages. For this course we recommend the [Anaconda](https://www.anaconda.com/products/distribution) distribution which is free, easy to install and contains the essential libraries.\n",
    "\n",
    "<span id=\"fn1\"> $^1$ Operating system.</span>\n",
    "\n",
    "</br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0FoW8o7beuWd"
   },
   "source": [
    "## <hr style=\"border:1px solid black\"> Try the console ! <hr style=\"border:1px solid black\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "g3rd8ra-euWe"
   },
   "source": [
    "You need basically a Console. Several possibilities:\n",
    "\n",
    "1. It can be provided by a simple LINUX terminal:\n",
    " * Open a terminal and type `python` and push `enter`\n",
    " * A message giving python version and provider should appear ; something like:\n",
    " \n",
    "     `Python 3.8.5 (default, Sep  4 2020, 02:22:02) \n",
    "     [Clang 10.0.0 ] :: Anaconda, Inc. on darwin\n",
    "     Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.`\n",
    "\n",
    " and the symbol `>>>` indicating that python is ready for instruction\n",
    " \n",
    " \n",
    "2. A `IPython` console provided for instance by an IDE [<sup>1</sup>](#fn1) like [Spyder](https://www.spyder-ide.org)\n",
    "\n",
    "\n",
    "3. A `Jupyter notebook` like the file you are currently using which does countain `Cells`\n",
    "which are either:\n",
    " * `Code` to code in python ; see [Python for beginners](https://wiki.python.org/moin/BeginnersGuide)\n",
    " * `Markdown` formated text ; see [Markdown for beginners](https://www.markdownguide.org)\n",
    " * `Raw NBConvert` which is just simple raw text in ASCII.\n",
    "\n",
    "Do not hesitate to visit the beginner links, but we think that this document will be sufficient\n",
    "for a good introduction to python\n",
    "\n",
    "<span id=\"fn1\"> $^1$ Integrated Development Environment (software).</span>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "0_ujBldHeuWf",
    "outputId": "b09ff60c-0cfe-4d27-fc55-f4bb074fbbac"
   },
   "outputs": [],
   "source": [
    "3*6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "tP2WeJ1OeuWg",
    "outputId": "f9b64aae-5a70-4ee9-c1e4-f07ca053fc55",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "5+4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oL9jUVADeuWg",
    "outputId": "8de44826-aaa2-4aa9-d25b-4551119a5cf5",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "5-14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "o3bpgfxUeuWh",
    "outputId": "be5ea5c2-cd4e-4f65-d8d5-6f092ab37cdf",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "3/9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aPWEedmiFHam"
   },
   "source": [
    "## <hr style=\"border:1px solid black\"> Python syntax <hr style=\"border:1px solid black\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "BVsQR3Z4euWh"
   },
   "source": [
    "## <hr style=\"border:1px solid black\"> Basic types, assignment and operators <hr style=\"border:1px solid black\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U-XaTgOOeuWi"
   },
   "source": [
    "#### Assignment : variable types are defined by the assignment\n",
    "\n",
    "> $a\\in\\mathbb{Z}$ ; $b\\in\\mathbb{R}$ ; $c$ is a string of characters ; $d\\in\\mathbb{B}$ ; $e\\in\\mathbb{C}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Egdg8lyheuWi",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "a = 1        # integer \n",
    "b = 5.4      # float\n",
    "c = 'blabla' # string\n",
    "d = True     # boolean \n",
    "e = 2+1.j    # complex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "a-k31pTIeuWj"
   },
   "source": [
    "> the equal symbol is an assignment operator\n",
    "\n",
    "> other assignment operator exist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "jDCr5IxMeuWj",
    "outputId": "e0cb89d8-4dfc-45e9-df69-0eee7cab4556"
   },
   "outputs": [],
   "source": [
    "a += 1 \n",
    "print(a)\n",
    "b -= 1\n",
    "print(b)\n",
    "a *= 2 \n",
    "print(a)\n",
    "b /= 2\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "osriSoVyeuWk"
   },
   "source": [
    "#### Printing the type (the class indeed)\n",
    "\n",
    "> below `print(message, value, type)` will print a character string *message* then what is contained in *value* and finally the *type of value*. The comma ',' is called separator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NyECu_3FeuWk",
    "outputId": "792cb116-e1a2-4c90-e104-f627b27eebf2",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "print('integer a = ', a, type(a))\n",
    "print('float   b = ', b, type(b))\n",
    "print('string  c = ', c, type(c))\n",
    "print('boolean d = ', d, type(d))\n",
    "print('complex e = ', e, type(e))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_1JSxZI6euWl"
   },
   "source": [
    "#### Distributed assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "vcZYW9BneuWl",
    "outputId": "2b4994e3-c24e-42e5-e7cd-eb622064d50c"
   },
   "outputs": [],
   "source": [
    "a, b, c = 2, 7.45, 'toto'\n",
    "print(a,type(a))\n",
    "print(b,type(b))\n",
    "print(c,type(c))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "eULB0R3beuWm",
    "scrolled": false
   },
   "source": [
    "#### Basic (arithmetic) operators in $\\mathbb{R}$ and $\\mathbb{C}$ \n",
    "\n",
    "> addition (substraction): $c = x + y$  $(d = x - y)$\n",
    "\n",
    "> multiplication (division): $e = x \\times y $  $(f = x/y)$\n",
    "\n",
    "> power: $g = x^y $   $(h = x^{-y})$\n",
    "\n",
    "for $(x,y)\\in\\mathbb{R}$ we have:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "FBHlN8oMeuWm",
    "outputId": "16c321e0-4afc-409b-d7e7-2abb018a364b"
   },
   "outputs": [],
   "source": [
    "x = 1.0 ; y = 2.0\n",
    "c = x + y\n",
    "d = x - y\n",
    "e = x * y\n",
    "f = x / y\n",
    "g = x ** y\n",
    "print(x,y,c,d,e,f,g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jPwQKUoleuWm"
   },
   "source": [
    "for $(x,y)\\in\\mathbb{C}$ where $y=x^*$ we have:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Rw1Q0xCreuWn",
    "outputId": "6f0bd0d9-6bf7-4f48-8f4f-7545a8e6ff08"
   },
   "outputs": [],
   "source": [
    "x = 1.0-2.0j ; y = 1.0+2.0j\n",
    "c = x + y\n",
    "d = x - y\n",
    "e = x * y\n",
    "f = x / y\n",
    "g = x ** 10\n",
    "print(x,y,c,d,e,f,g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VQrpL7pueuWn"
   },
   "source": [
    "#### Arithmetic operator precedence (= priority)\n",
    "\n",
    "> arithmetic operators have a priority which follows, from the highest precedence to the lowest:\n",
    "\n",
    "> `power > multiplication (division) > addition (substraction)` \n",
    "\n",
    "For instance : $a^b\\times c + d \\Rightarrow$ $x^b$ is performd first, then $\\times$ and $+$\n",
    "\n",
    "> remark 1: operation enclosed in parentheses have the highest priority over all other operations\n",
    "\n",
    "For instance : $a^b\\times (c + d) \\Rightarrow$ $x^b$ is performed first, then $+$, then $\\times$\n",
    "\n",
    "> remark 2: if two operator have the same priority, the operation should be performed from left to right\n",
    "\n",
    "For instance : $a-b+c \\Rightarrow$ $-$ is performed first, then $+$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0RwAOv7JeuWo"
   },
   "source": [
    "##### Exercise 1.0 <hr style=\"border:1px solid grey\">\n",
    "\n",
    "> Compute : \n",
    "\n",
    "$$ s_1=1+\\cfrac{1}{2+\\cfrac{1}{2+\\cfrac{1}{2}}} $$\n",
    "\n",
    "\n",
    "$$ s_2=1+\\cfrac{1}{ 2 + \\cfrac{1}{ 2+ \\cfrac{1}{2 + \\cfrac{1}{2} } } } $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Ol_cL_hZJg71",
    "outputId": "70f7ac72-769a-47e3-fb98-a5187157b597"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WrlEujM9euWp"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "bokXharZeuWp"
   },
   "source": [
    "##### Exercise 1.1 <hr style=\"border:1px solid grey\">\n",
    "> For $(x,y)\\in\\mathbb{C}$, shuch that $x=a+bi$ and $y=c+di$ show that x/y = z with\n",
    "\n",
    "$$z= \\frac{(ac+bd)+(bc-ad)i}{c^2+d^2}$$\n",
    "\n",
    "> using for instance $x=1-2i$ and $y = 1+2i$\n",
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "QN8CzhHqeuWp",
    "outputId": "b6514b4f-46c0-4b9d-a0b5-ba09c44b9e1c"
   },
   "outputs": [],
   "source": [
    "x = 1-2j ; y = 1+2j\n",
    "a = x.real # extract real part of x\n",
    "b = x.imag # extract imaginary part of x\n",
    "c = y.real\n",
    "d = y.imag\n",
    "print(a,b,c,d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ALk5bC1-euWq",
    "outputId": "cedb0212-d617-4ebc-a83c-4b581078f065"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "7yVqrBQjeuWq"
   },
   "source": [
    "#### Remarks on integer divisions and modulo operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "99HzvZSXeuWq",
    "scrolled": false
   },
   "source": [
    "> by default the *integer* division is converted to *float* division"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "twMEtXWaeuWq"
   },
   "source": [
    "for $(x,y)\\in\\mathbb{Z}$ where $y/x$ we have:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NEo9wyNDeuWq",
    "outputId": "5560eab5-06d4-45b7-ce20-629ef3523330",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "x = 20\n",
    "y = 7\n",
    "print(x/y )          # float division\n",
    "print(round(x/y,2))  # rounding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JaXT451feuWr"
   },
   "source": [
    "> the *whole part* and *remainder* can be accessed using special operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "qC72hTEBeuWr",
    "outputId": "cf363b44-8f5f-4bc7-c9c6-b00a9b1a849a"
   },
   "outputs": [],
   "source": [
    "print(x//y) # floor division operator => whole part\n",
    "print(x%y ) # modulo operator         => remainder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O0TR_iqfeuWr"
   },
   "source": [
    "#### Basic operators in $\\mathbb{B}$\n",
    "\n",
    "> Boolean or logic operators are : \n",
    "\n",
    "> Conjunction: $x$ `and` $y$\n",
    "\n",
    "> Disjunction: $x$ `or` $y$\n",
    "\n",
    "> Negation: `not` $x$ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HGS_FoDBeuWr"
   },
   "source": [
    "for $(x,y)\\in\\mathbb{B}$ we have:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "KhGx9yIGeuWr",
    "outputId": "a5d0220c-a1ff-48e5-b367-183478012a48"
   },
   "outputs": [],
   "source": [
    "x = True ; y = False\n",
    "c = x and y\n",
    "d = x or  y\n",
    "e = not x\n",
    "f = not y\n",
    "print(c,d,e,f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O7eRXNqOeuWr"
   },
   "source": [
    "##### Exercise 1.2 <hr style=\"border:1px solid grey\">\n",
    "\n",
    "> Using the boolean operators, verify the truth tables given below:\n",
    "\n",
    "| x | y | `or` |    | x | y | `and`|   | x | y | `nor`| \n",
    "|---|---| :--: |    |---|---| :--: |   |---|---| :--: |\n",
    "| T | T |  T   |    | T | T |  T   |   | T | T |  F   |\n",
    "| T | F |  T   |    | T | F |  F   |   | T | F |  F   |\n",
    "| F | T |  T   |    | F | T |  F   |   | F | T |  F   |\n",
    "| F | F |  F   |    | F | F |  F   |   | F | F |  T   |\n",
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "c87FuXrKeuWs",
    "outputId": "204c9d2b-238e-4a9d-88c2-52380cf60724"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "nGmozNeGeuWs"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "jGBKSQvreuWs"
   },
   "source": [
    "#### Remarks on boolean using arithmetic operators\n",
    "\n",
    "> if arithmetic operators are applied to boolean variables, the laters are converted to binary: $0$ (False) and $1$ (True) of integer type."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "nRxcZkJ7euWs",
    "outputId": "f590570f-cd3b-40bd-a699-9015ddc5d2d7"
   },
   "outputs": [],
   "source": [
    "x = True ; y = True\n",
    "c = x + y\n",
    "d = x - y\n",
    "e = x * y\n",
    "f = x / y\n",
    "g = y ** x\n",
    "print(type(d))\n",
    "print(type(e))\n",
    "print(x,y,c,d,e,f,g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZvAbMjUdeuWs"
   },
   "source": [
    "#### Operators for character strings and operator overloading\n",
    "\n",
    "> addition operator $\\{+\\}$ becomes the concatenate operator \n",
    "\n",
    "> multiplication operator $\\{*\\}$ becomes the repetition operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "71-UyDkFeuWt",
    "outputId": "df4dbcb3-fe3f-4ab7-e715-b1b3e58462fa"
   },
   "outputs": [],
   "source": [
    "c1 = 'bla'\n",
    "c2 = '-bli'\n",
    "print(c1+c2)\n",
    "print(c1*5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uC19IuI4euWt"
   },
   "source": [
    "#### Comparison operators (also referred to as Relational operators)\n",
    "\n",
    "> there exists 6 comparison operators described below\n",
    "\n",
    " \n",
    " | operator | description | example | allowed type |\n",
    " | :-:      | :-:         | :-:     | :-:           |\n",
    " | ==       | equal       | x == y  | $\\mathbb{Z,R,C,B}$ and string |\n",
    " | !=       | not equal   | x != y  | $\\mathbb{Z,R,C,B}$ and string |\n",
    " | >        | greater than| x > y   | $\\mathbb{Z,R,B}$[<sup>1</sup>](#fn1) and string[<sup>2</sup>](#fn2) |\n",
    " | >=       | greater than or equal | x >= y   | $\\mathbb{Z,R,B}$ and string |\n",
    " | <        | lower than  | x < y   | $\\mathbb{Z,R,B}$ and string |\n",
    " | <=       | lower than or equal   | x <= y   | $\\mathbb{Z,R,B}$ and string |\n",
    "\n",
    "> these operators compare two values and return the boolean value `True` or `False`.\n",
    "\n",
    "<span id=\"fn1\"> $^1$ In case of boolean `True` and `False` are converted to 1 and 0 respectively.</span>\n",
    "<span id=\"fn2\"> $^2$ In case of characters string the operators (>,>=,<,<=) *compare* the length of the string not the characters!</span>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pxw45DyLeuWt"
   },
   "source": [
    "#### Casting or type conversion\n",
    "\n",
    "> convert from one type to another is possible using:\n",
    "\n",
    "\n",
    " | function | description       | example        | allowed type | remark |\n",
    " | :-:      | :-:         | :-:     | :-:           | |\n",
    " | str()    | convert to string | str(240.25)    | all          | all alpha-numeric characters|\n",
    " | bool()   | convert to boolean| bool()         | all          | return `False` if empty variable, and `True` in all other cases|\n",
    " | complex()| convert to complex| complex(240.25)| $\\mathbb{Z,R,B}$ and string | for $\\mathbb{Z,R,B}$ imaginary part set to 0 |\n",
    " | float()  | convert to float  | float(240)     | $\\mathbb{Z,R,B}$ and string | "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "p_B_bwC0euWt",
    "outputId": "ce52ee32-1a87-4ce0-b87b-e647359c3f1d",
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "s1 = '240.25'     # s1 is a string\n",
    "s2 = '240.25+2j'  # s2 is also a string\n",
    "r1 =  240.25      # r1 is a float\n",
    "\n",
    "print(float(s1),  type( float(s1)  ) )\n",
    "print(complex(s2),type( complex(s2)) )\n",
    "print(int(r1),    type( int(r1) ) )\n",
    "print(bool(r1),   type( bool(r1)) )\n",
    "\n",
    "i2 = 67 # i2 is an integer\n",
    "s2 = '' # s2 i an empty string\n",
    "\n",
    "print(bool(s2), type( bool(s2)) )\n",
    "print(str(i2),  type( str(i2) ) )\n",
    "print(float(i2),type( float(i2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "tgogJuXVeuWt"
   },
   "source": [
    "#### Distributed assignment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oMZVlfMJeuWt",
    "outputId": "fd81396e-adec-44aa-f0a9-ba8669be37a5"
   },
   "outputs": [],
   "source": [
    "a, b, c = 2, 7.45, 'toto'\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HtEh9s9neuWu"
   },
   "source": [
    "## <hr style=\"border:1px solid black\"> Sequence types <hr style=\"border:1px solid black\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-tmrJRRheuWu"
   },
   "source": [
    "### `List`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "mpUiSa2qeuWu"
   },
   "source": [
    "> A list is a sequence of elements ; you are free to mix types !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "NyjaFsHUeuWu",
    "outputId": "93e14e60-1dad-4561-a8b7-f324e83be075"
   },
   "outputs": [],
   "source": [
    "L = [2,7.45,'blabla',True]\n",
    "print(L, type(L))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LfOzC4pyeuWu"
   },
   "source": [
    "> the length of a list, ie. the number of elements is given by"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "4XtofufPeuWu",
    "outputId": "6ef1cd43-6d75-4d23-e9dc-fcd94ffa5505"
   },
   "outputs": [],
   "source": [
    "len(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wBHEFHl-euWu"
   },
   "source": [
    "> create an empty list using $[]$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "JXOoadizeuWu",
    "outputId": "d328fa64-fb09-4c29-ec3a-2e08cd04b7f0"
   },
   "outputs": [],
   "source": [
    "M = []\n",
    "print(M, type(M))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qzQ7uWHqeuWv"
   },
   "source": [
    "#### Accessing `list` elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "-ujcLLtVeuWv"
   },
   "source": [
    "> elements are accessed by the index $i$ using square brackets.\n",
    "\n",
    "> Since in python indexing starts from 0,\n",
    "$L[i]$ is the $(i+1)^{\\mathrm{th}}$ element of the list $L$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "n53i2buJeuWv",
    "outputId": "19917784-d105-4d7f-cbd5-59dc25fa19bf"
   },
   "outputs": [],
   "source": [
    "print(L[0], L[1], L[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LeA2kaBjeuWv"
   },
   "source": [
    "> the last element can be accessed by index -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "mIjx0OcUeuWv",
    "outputId": "6bfc5516-1744-4cad-c057-b0fac79197ec"
   },
   "outputs": [],
   "source": [
    "print(L[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6hGKXAAKeuWv"
   },
   "source": [
    "> remark: a characters string is a list !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "eROrWyp-euWv",
    "outputId": "d3ac4c6f-a104-4655-a25e-325a5c18a0c3"
   },
   "outputs": [],
   "source": [
    "words = 'Hello_world'\n",
    "index = '012345678910'\n",
    "\n",
    "print(words)\n",
    "print(index)\n",
    "\n",
    "print(words[4])     # access the 5th element \n",
    "print(words[4:])    # access from 5th to the last element\n",
    "print(words[:5])    # access from 0 to 5th (excluded)\n",
    "print(words[2:8:1]) # access from 2 to 8th (excluded) with step size 1 \n",
    "print(words[2:8:2]) # access from 2 to 8th (excluded) with step size 2 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WCs2srgLeuWv"
   },
   "source": [
    "#### Operating on a `list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "fMObO-KoeuWw",
    "outputId": "6e110cba-6665-46eb-93c7-ab6e5d7f5bef"
   },
   "outputs": [],
   "source": [
    "L1 = [1, 6,'toto']\n",
    "L2 = [3.14,'titi',23]\n",
    "L3 = L1[1:] + L2\n",
    "print(L3)\n",
    "L4 = L1*4\n",
    "print(L4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vleI8XoveuWw"
   },
   "source": [
    "#### Mutable operations using `list` build-in functions\n",
    "\n",
    "> These operations modify the list and they are part. They are part of the `list` class attributes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "h7-KFcereuWw"
   },
   "outputs": [],
   "source": [
    "L = []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "opG2W9L3euWw"
   },
   "source": [
    "> `list.append(x)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hBo9ki0VeuWw",
    "outputId": "7c389cee-ef5c-4888-9c8f-72cd9c4a14ce"
   },
   "outputs": [],
   "source": [
    "L.append(1)\n",
    "L.append('h')\n",
    "L.append(6.626e-34)\n",
    "L.append(False)\n",
    "L.append(2+1.j)\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "aZGEzUz7euWw"
   },
   "source": [
    "> `list.extend()` or `+` operator overloading"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "mnz26BQDeuWw",
    "outputId": "48c3d94a-ecaf-473f-b8e8-97f6da96083f"
   },
   "outputs": [],
   "source": [
    "L.extend(['m0',9.109e-31])\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "99h-_mQ1euWw",
    "outputId": "43853bbe-d7b0-4344-f0d6-0a7abbef8902"
   },
   "outputs": [],
   "source": [
    "L = L + ['qe',1.602e-19]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QfsAiXv8euWx"
   },
   "source": [
    " > `list.insert(i, x)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "WkGMlU6JeuWx",
    "outputId": "a4713b2e-1897-4869-f9a6-6d05e7d6c104"
   },
   "outputs": [],
   "source": [
    "L.insert(2,'hbar')\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "x-khxm8heuWx"
   },
   "source": [
    "> `list.remove(x)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "YXlNc7mteuWx",
    "outputId": "bc30a573-d729-43cf-aacb-71211666f404"
   },
   "outputs": [],
   "source": [
    "L.remove('qe')\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QAvxCawveuWx"
   },
   "source": [
    " > `list.pop()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "3Fv6DnWveuWx",
    "outputId": "225e7753-4fcd-434d-d156-29e39b6b8c36"
   },
   "outputs": [],
   "source": [
    "toto = L.pop(0)\n",
    "print(toto)\n",
    "print(L)\n",
    "\n",
    "toto = L.pop()\n",
    "print(toto)\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "EY_5lGZyeuWx"
   },
   "source": [
    "> `list.sort()` ; can be applied only on uniform list, that is with all the elements of same type $(\\mathbb{Z,R,B})$ and string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "rdIiFQG3euWy",
    "outputId": "754e201d-cbd3-4ad5-89e5-7136f2aa84cb"
   },
   "outputs": [],
   "source": [
    "L = [1,8,5,-9]\n",
    "L.sort()\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zycULNk8euWy"
   },
   "source": [
    "> `list.reverse()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "YkFfMmZgeuWy",
    "outputId": "3e2bb53d-61e9-4a0d-b361-39b92419eaa7",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "L = [1, 'hbar', 6.626e-34, False, (2+1j), 4, 'm0']\n",
    "L.reverse()\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "b0GyUTa5euWy"
   },
   "source": [
    "##### Exercise 1.3 <hr style=\"border:1px solid grey\">\n",
    "> Try to understand what are the rules used by `list.sort()` when operating on a list of strings. Example is given below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "pjykZ8baeuWy",
    "outputId": "c3ea52e0-451d-492f-e92c-610990a8cb00"
   },
   "outputs": [],
   "source": [
    "L = ['abd', 'abc', 'h', 'bcde', '1ed']\n",
    "L.sort()\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "j49aMNMIeuWy"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "x_UAtfofeuWy"
   },
   "source": [
    "#### Ummutable operations using list external functions\n",
    "\n",
    "> These functions are used to search/process/interrogate the elements of a list. \n",
    "Some of them are attributes of the `list`class, others are `Python` build-in functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3F97pThjeuWy"
   },
   "source": [
    " > `sorted(list)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "CWPOcPE4euWz",
    "outputId": "a5c40000-889e-4035-db20-1832efcd828a"
   },
   "outputs": [],
   "source": [
    "L = [1,8,5,-9]\n",
    "K = sorted(L)\n",
    "print(L)\n",
    "print(K)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IkbOh2rYeuWz"
   },
   "source": [
    "> `min(list)` / `max(list)` / `sum(list)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Je2qMEpkeuWz",
    "outputId": "7ae3166d-5be4-4697-87ca-fc2a3bd73d77"
   },
   "outputs": [],
   "source": [
    "print(min(L))\n",
    "print(max(L))\n",
    "print(sum(L))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dbpTqd35euWz"
   },
   "source": [
    "> `list.index()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "MVIGpeTheuWz",
    "outputId": "51b297a8-2423-4a68-f5cd-b4100e42cbdb"
   },
   "outputs": [],
   "source": [
    "L = [1, 'hbar', 6.626e-34, False, (2+1j), 4, 'm0']\n",
    "print(L.index('hbar'))\n",
    "print(L.index(False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "kx-oCbW3euWz"
   },
   "source": [
    "> `in`: to test if an element is in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "eGf4Ut_leuWz",
    "outputId": "cab58c4c-f889-450a-d5a6-5076cbbc1bbd"
   },
   "outputs": [],
   "source": [
    "print('hbar' in L)\n",
    "print(6.627e-34 in L)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ozsM86XleuWz"
   },
   "source": [
    "> `list.count(x)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Z3msJ2X8euWz",
    "outputId": "e837e009-8f72-40e5-8cd7-e02f3c9aaeb6"
   },
   "outputs": [],
   "source": [
    "L = [1,2,3,5,2,4,89,1,1,2,2]\n",
    "print(L.count(1))\n",
    "print(L.count(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1g6rztwFeuW0"
   },
   "source": [
    "#### Function `range`\n",
    "\n",
    "> range($n_{inf}$, $n_{sup}$, $\\sigma$) with $\\sigma$ the step and $(n_{inf},n_{sup},\\sigma)\\in\\mathbb{Z}$\n",
    "\n",
    "> create a `list` of integers $n\\in[n_{inf},n_{sup}[$\n",
    "such that $n=\\{n_{inf},\\;n_{inf}+\\sigma,\\;n_{inf}+2\\sigma,...\\}$\n",
    "\n",
    "> it stops before $n_{sup}$ !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5CXe07T3euW0",
    "outputId": "21c6d000-4f36-4acd-a8ac-29717f2b1bfb"
   },
   "outputs": [],
   "source": [
    "L = range(10)\n",
    "print(L)\n",
    "print(list(L))\n",
    "\n",
    "L = range(1,10,1)\n",
    "print(L)\n",
    "print(list(L))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "BJqKmTpWeuW0",
    "outputId": "54c83b5e-969a-4015-ff22-78a7025c5f13"
   },
   "outputs": [],
   "source": [
    "L = range(4,119,4)\n",
    "print(list(L))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "r6w-x6LieuW0"
   },
   "source": [
    "#### Tuples\n",
    "\n",
    "> A tuple is a sequence of elements which are write-protected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "piakjSYteuW0",
    "outputId": "ccbefcff-7864-4a1e-f665-1f89da8c1cb6"
   },
   "outputs": [],
   "source": [
    "T = (2,8.67,'toto')\n",
    "print(T, type(T))\n",
    "print(T[2])\n",
    "\n",
    "S = (True,'titi',3+2j)\n",
    "R = S + T\n",
    "print(R)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "sglJvYxgeuW0"
   },
   "source": [
    "> a distributed assignment is a tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ANwhzbrieuW0",
    "outputId": "e32f5a65-2b83-4518-f8a4-808e02ec742c"
   },
   "outputs": [],
   "source": [
    "a, b, c = 2, 7.45, 'toto'\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "\n",
    "T = a, b, c\n",
    "print(T)\n",
    "print(type(T))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ZxfmY5EMeuW0"
   },
   "source": [
    "##### Exercice 1.4 <hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Df84PeZ8euW0"
   },
   "source": [
    "1. Create 2 list ranging from 0 to 5 and 6 to 9, that is: $v=[0,1,2,...,5]$ and $w=[6,7,8,9]$ \n",
    "1. From $v$ and $w$ create a unique list containing the firsts 9 integers, that is : $x=[0,1,2,...,9]$\n",
    "1. Add 10 to the end of list, that is: $x=[0,1,2,...,9,10]$\n",
    "1. Remove the last element from the list, that is : $x=[0,1,2,...9]$ \n",
    "1. Move the last element to first position : $x=[9,0,1,2,...8]$ "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "zGy3-VPLeuW1",
    "outputId": "22aa3cd5-aa33-48d6-bd0b-642d138919d0"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HA38uUHQeuW1"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WMcl-8CxeuW1"
   },
   "source": [
    "## <hr style=\"border:1px solid black\">  Basic constructs <hr style=\"border:1px solid black\">\n",
    "\n",
    "> Programming languages should follow some structure which are defined by 3 basic [control structures:](https://en.wikipedia.org/wiki/Structured_programming)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yAEpzsk6ouMe"
   },
   "source": [
    "### ***Sequence*** : \n",
    "\n",
    "ordered statements (or subroutines) executed in sequence. In the example below, each line countains 1 statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "giJH4_EHeuW1"
   },
   "outputs": [],
   "source": [
    "x1 = 3       # statement A\n",
    "y1 = 4       # statement B\n",
    "z1 = x1 + y1 # statement C"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "LD0fLPSDeuW1"
   },
   "source": [
    "`statement C` depends upon `statement A` and `statement B`, then it should be written\n",
    "at the end. Note that, in this case, the order of `statement A` and `statement B` is inconsequent. Statements can also by\n",
    "written on a same line using the separator symbol `;`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "z0DK_CxIeuW1"
   },
   "outputs": [],
   "source": [
    "x2 = 3 ; y2 = 4 ; z2 = x2 + y2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6OSnj7RgeuW1"
   },
   "source": [
    "Note again that here, statements should follow an order since last statement on the line depends upon the firsts 2."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JG4XEdWLeuW1"
   },
   "source": [
    "### ***Selection*** : \n",
    "\n",
    "one or a number of statements is executed depending on the state of the program. This is managed by the `if():...else:` decision structure described below by an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "SomDdLqaeuW1",
    "outputId": "967a06ca-2d85-49c6-c89b-3af71c1ad074"
   },
   "outputs": [],
   "source": [
    "# assign a value to the number to be tested\n",
    "a = 4\n",
    "\n",
    "# compute the remainder of the integer division num/2\n",
    "modulo = a%2\n",
    "\n",
    "# Test weither or not the remainder is 0 and decide\n",
    "if ( modulo == 0 ):\n",
    "    print('a is even')\n",
    "else:\n",
    "    print('a is odd' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YvkgaLFueuW1"
   },
   "source": [
    "In python, the **condition** which involves **comparison** (and/or **boolean**) operators is written in between the parenthesis. The `if`and `else` statements are terminated by a colon symbol `:`. Importantly, statements related to the *decision* **must be** indented! The `if():...else:` decision structure can have several exit points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "z3eTJ3dOeuW2",
    "outputId": "8a5e7bd7-be8c-4d4d-e00f-2fdb1862f15b"
   },
   "outputs": [],
   "source": [
    "# assign a value to the number to be tested\n",
    "a = 4.5\n",
    "\n",
    "# compute the remainder of the integer division a/2\n",
    "modulo = a%2\n",
    "\n",
    "# Test weither or not the remainder is 0 and decide\n",
    "if ( modulo == 0 ):\n",
    "    print('a is even')\n",
    "elif ( modulo == 1  ):\n",
    "    print('a is odd' )\n",
    "else:\n",
    "    print('a is not an integer' )    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HbMOlR15euW2"
   },
   "source": [
    "The `if():...else:` decision structure can have several conditions:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "m9FQ7FXIeuW2",
    "outputId": "f4177ab7-64e4-469d-c656-f14a3322550c"
   },
   "outputs": [],
   "source": [
    "# assign a value to the number to be tested\n",
    "a = -4\n",
    "\n",
    "# compute the remainder of the integer division a/2\n",
    "modulo = a%2\n",
    "\n",
    "# Test weither or not the remainder is 0 and negative of positive\n",
    "if   ( modulo == 0 and a < 0 ):\n",
    "    print('a is even and negative')\n",
    "\n",
    "elif ( modulo == 0 and a > 0 ):\n",
    "    print('a is even and positive')\n",
    "    \n",
    "elif ( modulo == 1 and a < 0  ):\n",
    "    print('a is odd and negative' )\n",
    "\n",
    "elif ( modulo == 1 and a > 0  ):\n",
    "    print('a is odd and positive' )  \n",
    "\n",
    "else:\n",
    "    print('a is not an integer' )    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "m6Am3ZizeuW2"
   },
   "source": [
    "### ***Iteration*** : \n",
    "\n",
    "a statement or block is executed until operations have been applied to every element of a collection or the program reaches a certain state. In the example below we use a `for:` loop to iterate through a list of number. The `for` statement must ends with `:`. The following instructions must be indented."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "YO9hPas7euW2",
    "outputId": "51b4d12a-fdc6-40e5-80f0-41a81b4e0b96"
   },
   "outputs": [],
   "source": [
    "for x in [1,2,3,4,5,6,7,8,9]:\n",
    "    p = x**2 - x + 41\n",
    "    print(p)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "yE7_mvQzeuW2",
    "outputId": "cf600fc6-6fe1-40e0-9227-24bc82c11820"
   },
   "outputs": [],
   "source": [
    "L = [1,2,3,4,5,6,7,8,9]\n",
    "for x in L:\n",
    "    p = x**2 - x + 41\n",
    "    print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oIWyn9TbeuW2"
   },
   "source": [
    "> iterate using indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "gnDQ2wAOeuW2",
    "outputId": "c92669e3-a74e-4d6d-a906-babdad66a3d6"
   },
   "outputs": [],
   "source": [
    "for x in range(1,len(L)):\n",
    "    p = x**2 - x + 41\n",
    "    print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "6Yf811XieuW2"
   },
   "source": [
    "> Does work as well with tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "kC8NeCdUeuW2",
    "outputId": "87043a1d-5ec1-489d-9720-770df60f0c5f"
   },
   "outputs": [],
   "source": [
    "L = (1,2,3,4,5,6,7,8,9)\n",
    "for x in L:\n",
    "    p = x**2 - x + 41\n",
    "    print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "i86ixX3XeuW3"
   },
   "source": [
    "##### Exercise 1.5 : sum and product using  `for` construct <hr style=\"border:1px solid grey\">\n",
    "1. Using a `for` loop perform the sum: $s=\\sum_{i=1}^ni$ with $n=100$\n",
    "2. Compare to the `python` intrinsic function: `sum()`\n",
    "3. Using a `for` loop perform the product: $p=\\prod_{i=1}^ni$ with $n=10$\n",
    "4. Compare with the `numpy` function `prod()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "k_CB7J_NeuW3",
    "outputId": "cccc67b5-2f6e-4963-cdde-fe24b0586234"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "zycJox1meuW3"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "pMFg_Lb1euW3"
   },
   "source": [
    "##### Exercise 1.6 : factorial using `for` construct <hr style=\"border:1px solid grey\">\n",
    "\n",
    "\n",
    "The factorial of a number $n\\in\\mathbb{N}_0$ is given by: $n!=1\\times 2\\times\\cdots \\times(n-1)\\times n$ ; by convention $0!=1$.\n",
    "1. Using a `for:` construct compute the factorial of a number $n=14$\n",
    "2. Compare to the `numpy.math` function `factorial`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "oPUoM48leuW3",
    "outputId": "8a660125-f626-462a-ecee-d5a81bee48e5"
   },
   "outputs": [],
   "source": [
    "import numpy\n",
    "numpy.math.factorial(14)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "58OnvSQ7euW3",
    "outputId": "dcb0b028-763c-4451-c688-b61c635d8f1d"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uIs_ougueuW3"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ROa2bevSeuW3"
   },
   "source": [
    "##### Exercice 1.7 : `if` construct <hr style=\"border:1px solid grey\">\n",
    "Given a wave length (in nm) $x\\in[10,10^5]$, print the range it falls into:\n",
    "> UV for $x\\in[10,390[$\n",
    "\n",
    "> visible for $x\\in[390,750[$\n",
    "\n",
    "> IR for $x\\in[750,10^5[$\n",
    "\n",
    "The wavelength must be given by the user using the function `input()` ; an example is given below:\n",
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "5mY7yHsdeuW4",
    "outputId": "4f28a165-a64e-4b76-f769-aaf84c6c3126"
   },
   "outputs": [],
   "source": [
    "# Ask for some input value and store in x\n",
    "x = input('Give a wavelength in the range [10,10^5[ nm : ')\n",
    "\n",
    "# By default input() function output a string \n",
    "print(x,type(x))\n",
    "\n",
    "# You need then to convert (to float in this case)\n",
    "x = float(x)\n",
    "print(x,type(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "IKz195EheuW4",
    "outputId": "ee3b839e-1977-4bf3-b8cb-248c9c971eec"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Yp0FmhsHeuW4"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NOiCEaeReuW4"
   },
   "source": [
    "##### Exercice 1.8 : roots of 2nd order polynomial using `if` construct <hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "lo6hF4V4euW4"
   },
   "source": [
    "Write a program to solve for the following quadratic function: $ ax^2+bx+c=0$\n",
    "1. Compute the discriminant $\\Delta= b^2-4ac$\n",
    "2. Depending on the values of $\\Delta$ compute the roots:\n",
    "\\begin{eqnarray}\n",
    "\\mathrm{if}\\ \\Delta > 0 &:& x_{\\pm} = \\frac{-b \\pm \\sqrt{\\Delta}}{2a} \\\\\n",
    "\\mathrm{if}\\ \\Delta = 0 &:& x_{+} = x_{-} = -\\frac{b}{2a} \\\\\n",
    "\\mathrm{if}\\ \\Delta < 0 &:& z_{\\pm} = \\frac{-b \\pm i\\sqrt{-\\Delta}}{2a} \\\\\n",
    "\\end{eqnarray}\n",
    "3. Print the discriminant and the roots values.\n",
    "4. Check that, given these roots $ax^2+bx+c=0$ \n",
    "\n",
    "> First write down on your paper an algorithm. Then code it in python. \n",
    "\n",
    "> To test your code, you can use the 3 following sets of parameters: \n",
    "\n",
    ">$(a = 1 ; b = -1 ; c = -1)$\n",
    "\n",
    "> $(a = 1 ; b = -1 ; c =  1)$\n",
    "\n",
    ">$(a = 1 ; b =  2 ; c =  1)$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Dkekcw9ueuW4"
   },
   "outputs": [],
   "source": [
    "from numpy import sqrt\n",
    "\n",
    "a = 1 ; b = -1 ; c = -1\n",
    "#a = 1 ; b = -1 ; c =  1\n",
    "#a = 1 ; b =  2 ; c =  1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "rbzUEQw3euW4",
    "outputId": "1e10160d-4aec-4ceb-c5e2-c76f4b080653"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "U3Gytaw-euW5"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rij9F2r3euW5"
   },
   "source": [
    "### ***Repeat with decision : while***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "Ku3kZMCqeuW5",
    "outputId": "b86acbb4-da5f-488e-c46d-3b8d5bb3577f"
   },
   "outputs": [],
   "source": [
    "a =  0\n",
    "b = -10\n",
    "while (a < 9 and b < 0):\n",
    "    print(a, b)\n",
    "    a = a + 1\n",
    "    b = b + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PjddbIjWeuW5"
   },
   "source": [
    "##### Exercice 1.9 : `while` struct<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "WbB1JOgEeuW5"
   },
   "source": [
    "> Improve the code of ***Exercice 1.6*** by repeating the input if $x\\notin[10,10^5[$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "hGP5St5leuW5",
    "outputId": "6f1f18d3-a4ed-4acd-877e-826cc09f86b6"
   },
   "outputs": [],
   "source": [
    "x = input('Give a wavelength in the range [10,10^5[ nm : ')\n",
    "x = float(x)\n",
    "\n",
    "if ( x >= 10 and x < 390 ):\n",
    "    print('UV')\n",
    "elif ( x >= 390 and x < 750 ):\n",
    "    print('visible')\n",
    "elif ( x >= 750 and x < 1e5 ):\n",
    "    print('IR')\n",
    "else:\n",
    "    print('wrong value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "GynDqR9_euW5",
    "outputId": "9a09ca9e-bd4c-4aa3-d744-59ae8400396f"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f_9m9VEyeuW5"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "V9MHY6EDeuW5"
   },
   "source": [
    "##### Exercice 1.10 : iterative square-root using `while` construct<hr style=\"border:1px solid grey\">\n",
    "\n",
    "> Given a number $S$ the square-root $\\sqrt{S}$ can be computed using the following recursion:\n",
    "\\begin{eqnarray}\n",
    "x_{n+1} &=& \\frac{1}{2}\\left(x_n + \\frac{S}{x_n}\\right)\\\\\n",
    "\\mathrm{such\\ \\ that}\\ \\ \\sqrt{S} &=& \\lim_{n\\rightarrow\\infty}x_n\n",
    "\\end{eqnarray}\n",
    "> with $x_0$ an estimate of $\\sqrt{S}$. The recursion should stop when the absolute difference between\n",
    "the current iterate and previous one is below some threshold value $\\epsilon$, that is, when:\n",
    "$|x_{n+1}-x_{n}| < \\mathrm{\\epsilon}$.\n",
    "\n",
    "> Test your algorithm for $S=3$ with $x_0=1.5$ and $\\epsilon=10^{-6}$. Print the number of iterations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ddo6kHwXeuW6",
    "outputId": "d3542c05-ffeb-4cf3-fff7-b0dd16cc00d1"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "O8OHxE2reuW6"
   },
   "source": [
    "<hr style=\"border:1px solid grey\">"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Diaporama",
  "colab": {
   "include_colab_link": true,
   "provenance": []
  },
  "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}