01.basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--<div class=\"alert alert-block alert-info\">\n",
    "<span style=\"font-size:xx-large;\"><center>Basics</center></span>\n",
    "</div> -->\n",
    "# Basics"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## History\n",
    "\n",
    "- 1989: **Guido van Rossum** (At CWI, Netherland)\n",
    "- 1991: First public release\n",
    "- 1995: CNRI, USA\n",
    "- 1999: Computer Programming for Everybody (CNRI + DARPA)  \n",
    "    *Objective : python for **teaching** programming*\n",
    "- 2001: Python software fundation (free from governments)\n",
    "- 2008: version 3\n",
    "- 2013: widely use in post-graduate\n",
    "- 2018: 4th most popular language (behind Java, C and C++)\n",
    "- 2020: death of python 2.x?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Advantages of Python \n",
    "- **Batteries included** (+numpy, scipy, scikits)\n",
    "- **Easy to learn**\n",
    "- **Easy communication**\n",
    "- **Efficient code**\n",
    "- **Universal**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Install\n",
    "- Windows : anaconda + conda + pip\n",
    "- Linux : already install + apt + pip --user\n",
    "- Mac : homebrew + brew python3 + pip --user"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Interface\n",
    "vim+terminal / pycharm / spyder / jupyter / python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## First examples\n",
    "### Helloworld"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Arithmetic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(2 + 3 * 9 / 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--<div class=\"alert alert-success\">\n",
    "<span style=\"font-size:xx-large;\"><center>**As simple as that!**</center></span>\n",
    "</div>-->\n",
    "\n",
    "# **As simple as that!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vocabulary\n",
    "- `mutable` / `immutable`  \n",
    "  `unashable` / `hashable`  \n",
    "  a mutable object can be altered an immutable object can not    \n",
    "  obviously numerical object are immutable\n",
    "  \n",
    "- `exception`  \n",
    "  wathever you do, python never crash (almost never)  \n",
    "  Errors detected during execution are called exceptions and you can handle them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def test():\n",
    "    error = {[0]:4}\n",
    "test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Help\n",
    "\n",
    "- help\n",
    "- dir\n",
    "- internet\n",
    "  - docs.python.org\n",
    "  - stackoverflow\n",
    "  - reddit\n",
    "  - ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Syntax\n",
    "\n",
    "- Commments\n",
    "    - use hash symbol (`#`) to start a comment "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Variables:\n",
    "  - name (identifier)\n",
    "    - combination of letters or digits or an underscore (`_`)\n",
    "    - cannot start with a digit\n",
    "    - case sensitive\n",
    "    - no keywords\n",
    "    - no operator symbol\n",
    "    - accented caracter allowed (but to avoid)\n",
    "  - dynamic type\n",
    "    - `None`\n",
    "    - numericals type\n",
    "      - integer infinite precision\n",
    "      - float double precision\n",
    "      - complex\n",
    "    - iterables type\n",
    "      - tuple\n",
    "      - list\n",
    "      - set\n",
    "      - dist\n",
    "      - str\n",
    "      - frozenset\n",
    "      - bytarray"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- operators  \n",
    "  ` + - * ** / // % = < > <= >= == != () {} [] ‘ \" @ . ~ & | `  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- keywords:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keyword import kwlist\n",
    "print(kwlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple exemple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A comment\n",
    "a_variable = 1\n",
    "another_variable = 1.2\n",
    "another_Variable = a_variable + another_variable\n",
    "print(a_variable, another_variable, another_Variable)\n",
    "\n",
    "a_variable = \"spam \"\n",
    "a_variable2 = \"egg\"\n",
    "print(a_variable * 2 + a_variable2)\n",
    "\n",
    "print(10 ** 180 + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--<div class=\"alert alert-block alert-warning\"> \n",
    "<span style=\"font-size:xx-large;\"><center>First exercise</center></span>\n",
    "</div> -->\n",
    "\n",
    "# First exercise\n",
    "\n",
    "From a radius ```R``` and a length ```l```, compute the perimetre, the surface and the volume of a cylinder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R = 0.7\n",
    "l = 0.1\n",
    "pi = 3.14\n",
    "\n",
    "# TODO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--REMOVE BUTTON FOR GITHUB\n",
    "<button data-toggle=\"collapse\" data-target=\"#simple\">Solution</button>\n",
    "<div id=\"simple\" class=\"collapse\" markdown=1>-->\n",
    "\n",
    "```python\n",
    "perimetre = 2 * (2 * pi * R)\n",
    "surface =  2 * pi * R * (R + l)\n",
    "volume = l * pi * R ** 2\n",
    "\n",
    "print(\"Perimetre = \", perimetre)\n",
    "print(\"Surface = \", surface)\n",
    "print(\"Volume = \", volume)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code blocks  \n",
    "  ```\n",
    "  code block:\n",
    "      stuff inside the code block\n",
    "      more stuff  inside the code block\n",
    "      pass # do nothing\n",
    "  outside of the code block\n",
    "  ```\n",
    "  - tests : ```if test```\n",
    "  - functions : ```def functionname()```\n",
    "  - loops : ```for variable in iterable```, ```while test```\n",
    "  - objects : ```class objectname()```\n",
    "  - contexts : ```with context```\n",
    "  - exception handling : ```try```, ```except```\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `def` Statements\n",
    "\n",
    "```python\n",
    "def a_function(arg, optionnal_arg=default_value):\n",
    "    #...\n",
    "    return something\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quadcube(x):           # define a function with argument\n",
    "    return x ** 2, x ** 3  # multiple returns\n",
    "\n",
    "x1, x2 = quadcube(7)       # multiple assignment \n",
    "print(x1, x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  `if` Statements\n",
    "\n",
    "```python\n",
    "if test:\n",
    "    action\n",
    "else:\n",
    "    other_action\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Equivalent forms of True:\n",
    "- `True`\n",
    "- any non-zero value\n",
    "- an non-empty iterable\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Equivalent forms of False:\n",
    "- `False`\n",
    "- `None`\n",
    "- `0`\n",
    "- an empty iterable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For tests, you can use those operators:\n",
    "```python\n",
    "and, or, not, ==, !=, is, is not, >, >=, <, <=, in, not in\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if n < 2:                          # define a test\n",
    "        return 1                       # value return\n",
    "    else:\n",
    "        return n * factorial(n - 1)    # recursion\n",
    "    \n",
    "res = factorial(30)                    # call the function\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial_six():                # function without argument\n",
    "    return factorial(6)\n",
    "\n",
    "res = factorial_six()\n",
    "print(res)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `while` loop\n",
    "```python\n",
    "i = 0\n",
    "while i < 4:\n",
    "    ...\n",
    "    i += 1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loop over iterable object\n",
    "```python\n",
    "for i in [5, 3, 4]:\n",
    "    ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usualy, we use `range(start=0, end, step=1)`  \n",
    "which kind of create `[start, start + step, ..., end - step]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--<div class=\"alert alert-block alert-danger\">\n",
    "<span style=\"font-size:xx-large;\">\n",
    "    <center>\n",
    "        ***WARNING***<br/><br/> \n",
    "        `end` is the first value **never** reached\n",
    "    </center></span>\n",
    "</div> -->\n",
    "# ***WARNING*** :  `end` is the first value **never** reached"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_prime(num):\n",
    "    if num == 1:\n",
    "        return False\n",
    "    i = 2\n",
    "    while i < int(num ** 0.5) + 1:\n",
    "        if (num % i) == 0:\n",
    "            return False\n",
    "        i += 1\n",
    "    return True\n",
    "\n",
    "def is_prime2(num):                          # equivalant variation\n",
    "    if num == 1:\n",
    "        return False\n",
    "    for i in range(2, int(num ** 0.5) + 1):  # using range\n",
    "        if (num % i) == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "print(is_prime(7))                # chain functions (f(g(...)))\n",
    "print(is_prime2(13))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def compute_pi(err, nmax=float(\"inf\")):    #optional argument\n",
    "    n = 0\n",
    "    error = float(\"inf\")\n",
    "    \n",
    "    a_n = 1.\n",
    "    b_n = 2 ** -0.5\n",
    "    t = 0.25\n",
    "    while error > err and n < nmax:\n",
    "        a_np = 0.5 * (a_n + b_n)\n",
    "        b_np = (a_n * b_n) ** 0.5\n",
    "        t -= (2 ** n) * (a_n - a_np) ** 2  # inplace substraction\n",
    "        \n",
    "        a_n, b_n = a_np, b_np              # double assigment\n",
    "        \n",
    "        error = abs(a_n - b_n)\n",
    "        n += 1                             # inplace addition\n",
    "        \n",
    "    pi = (a_n + b_n) ** 2 / (4 * t)\n",
    "    return pi, n, error\n",
    "\n",
    "print(compute_pi(1e-15))\n",
    "print(compute_pi(1e-15, 3))\n",
    "print(compute_pi(1e-15, nmax=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- <div class=\"alert alert-block alert-warning\"> \n",
    "<span style=\"font-size:xx-large;\"><center>Second exercise</center></span>\n",
    "</div> -->\n",
    "\n",
    "# Second exercise\n",
    "\n",
    "A pythagorean triplet is a triplet of positive integers $a$, $b$ and $c$ such that $a^2+b^2=c^2$.\n",
    "\n",
    "For each pair of positive integers $m,n$:\n",
    "- a $=m^2-n^2$\n",
    "- b $=2mn$\n",
    "- c $=m^2+n^2$  \n",
    "is a pythagorean triplet if and only if $a$, $b$ and $c$ are strictly positive.\n",
    "\n",
    "Write a function ```pythagorean_triplet(limit)``` who:\n",
    "1. loops on $n$ and $m$\n",
    "2. use the previous property in order to detect a triplet\n",
    "3. print all the triplet until a limit, i.e. $c<limit$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Exercise\n",
    "def pythagorean_triplets(limit):\n",
    "    \"\"\"\n",
    "    Print all pythagorean triplets below a limit\n",
    "    \n",
    "    A pythagorean triplet is a triplet of integers a, b and c such that\n",
    "    a^2 + b^2 = c^2\n",
    "    \n",
    "    My solution :\n",
    "    3 4 5\n",
    "    8 6 10\n",
    "    5 12 13\n",
    "    15 8 17\n",
    "    12 16 20\n",
    "    7 24 25\n",
    "    24 10 26\n",
    "    21 20 29\n",
    "    \n",
    "    \"\"\"                                       # use a docstring\n",
    "    \n",
    "help(pythagorean_triplets)\n",
    "pythagorean_triplets(30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--REMOVE BUTTON FOR GITHUB\n",
    "<button data-toggle=\"collapse\" data-target=\"#pythagore\">Solution</button>\n",
    "<div id=\"pythagore\" class=\"collapse\">-->\n",
    "    \n",
    "### Solution\n",
    "\n",
    "```python\n",
    "def pythagorean_triplets(limit):\n",
    "    \"\"\"\n",
    "    Print all pythagorean triplets below a limit\n",
    "\n",
    "    A pythagorean triplet is a triplet of integers a, b and c such that\n",
    "    a^2 + b^2 = c^2\n",
    "    \"\"\"                                   # use a docstring\n",
    "    \n",
    "    ## compute range of m ##\n",
    "    \n",
    "    # m ** 2 cannot be bigger than limit\n",
    "    m_max = limit ** 0.5\n",
    "    \n",
    "    # m_max must be an integer\n",
    "    m_max = int(m_max)\n",
    "    \n",
    "    # m will be 1, 2, ..., m_max\n",
    "    for m in range(1, m_max + 1):         \n",
    "      \n",
    "        ## compute range of n ##\n",
    "        \n",
    "        # n cannot be bigger than m\n",
    "        # otherwise a would be negative\n",
    "        n_max_a = m - 1\n",
    "        \n",
    "        # n cannot be bigger than nmax_c\n",
    "        # otherwise c would be above the limit\n",
    "        n_max_c = (limit - m * m) ** 0.5\n",
    "\n",
    "        n_max = min(n_max_a, n_max_c)\n",
    "        \n",
    "        # n_max must be an integer\n",
    "        n_max = int(n_max)\n",
    "        \n",
    "        # n will be 1, 2, ..., n_max\n",
    "        for n in range(1, n_max + 1):\n",
    "            \n",
    "            # compute the triplets\n",
    "            a = m * m - n * n\n",
    "            b = 2 * m * n\n",
    "            c = m * m + n * n\n",
    "            \n",
    "            # print result\n",
    "            print(a, b, c)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists, dicts and others iterables\n",
    "--------------------------\n",
    "- Common types\n",
    "  - ****list**** : ```[a, b, c]```\n",
    "    - mutable\n",
    "    - indexable with integer\n",
    "    - initialization :\n",
    "        - ```l = [0] * n```\n",
    "        - ```l = [0 for i in range(n)]```\n",
    "    - operators\n",
    "      - concatenation : ```+```\n",
    "      - repetition : ```*```\n",
    "  - str : ```\"spam\" == 'spam' == \"\"\"spam\"\"\"```\n",
    "    - immutable\n",
    "    - indexable with integer\n",
    "    - can contains only decoded characters\n",
    "    - unicode par default\n",
    "    - operators\n",
    "      - concatenation : ```+```\n",
    "      - repetition : ```*```\n",
    "  - tuple : ```(a, b, c)```\n",
    "    - immutable\n",
    "    - indexable with integer\n",
    "    - parentheses optional ( ```a, b = c, d``` )\n",
    "  - set : ```{a, b, c}```\n",
    "    - mutable\n",
    "    - indexable with integer\n",
    "    - no duplicate\n",
    "    - can contains only immutables\n",
    "  - dict : ```{a:b, c:d}```\n",
    "    - mutable\n",
    "    - indexable with keys (here a and c)\n",
    "    - keys are unique and of immutable type\n",
    "    - no need to initialize before registering a value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Uncommon types\n",
    "  - frozenset\n",
    "    - immutable\n",
    "    - indexable with integer\n",
    "    - no duplicate\n",
    "    - can contains only immutables\n",
    "  - bytearray\n",
    "    - mutable\n",
    "    - indexable with integer\n",
    "    - can contains only encoded characters"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Slicing \n",
    "  - ```A[1]``` : 2nd item\n",
    "  - ```A[-1]``` : last item\n",
    "  - ```A[4:8]``` : sublist\n",
    "  - ```A[4:8:2]``` : sublist by step of 2 (i.e. 5th and 7th item) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Methods\n",
    "  - ```len```\n",
    "  - ```append```\n",
    "  - ```sort``` / ```sorted```\n",
    "  - ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Loop on iterable object\n",
    "  ```for i in [a, b, c]:```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Comprehension\n",
    "  ```[x**2 for x in range(10)]```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Generators / Iterator\n",
    "  - ```range```\n",
    "  - ```enumerate```\n",
    "  - ```zip```\n",
    "  - ```open(\"filename\")```\n",
    "  - ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### An example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def slow_list_primes(n):\n",
    "    primes = []                      # empty list\n",
    "    for suspect in range(2, n + 1):\n",
    "        is_prime = True\n",
    "        for prime in primes:\n",
    "            if suspect % prime == 0:\n",
    "                is_prime = False                \n",
    "                break\n",
    "        if is_prime:\n",
    "            primes.append(suspect)   # add item in list\n",
    "    return primes\n",
    "\n",
    "print(slow_list_primes(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- <div class=\"alert alert-block alert-warning\"> \n",
    "<span style=\"font-size:xx-large;\"><center>Third exercise</center></span>\n",
    "</div> -->\n",
    "\n",
    "# Third exercise\n",
    "\n",
    "The sieve of Eratosthenes is a ancient algorithm for finding all prime numbers up to a given limit $n$.\n",
    "\n",
    "![Animation of the sieve of Eratosthenes](images/Sieve_of_Eratosthenes.gif)\n",
    "\n",
    "The Eratosthenes' method is as follow:\n",
    "\n",
    "1. Consider a list of consecutive integers from 2 through $n$: (2, 3, 4, ..., $n$).  \n",
    "   Initially suppose they are all primes  \n",
    "  \n",
    "2. Let $p$ the first prime number of the list (initially $p=2$ the smallest prime number).  \n",
    "   Enumerate the multiples of $p$ ($2p$, $3p$, $4p$, ....) until $n$ and mark them as 'not prime'\n",
    "\n",
    "3. Find the first number greater than $p$ in the list that is not marked 'not prime'  \n",
    "   (which is the next prime number after $p$)  \n",
    "   and repeat from strep 2\n",
    "\n",
    "When the algorithm terminates, the numbers remaining not marked in the list are all the primes below $n$\n",
    "\n",
    "Define a function '''list_prime(n)''' who use the Erathosthenes' method to find all primes until $n$.  \n",
    "Use a list of boolean indexed by 0:n to mark numbers. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Exercise\n",
    "def list_primes(n):\n",
    "    \"\"\"\n",
    "    List all prime number below n\n",
    "    My solution : [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59]\n",
    "    \"\"\"\n",
    "    #TODO\n",
    "print(list_primes(60))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--REMOVE BUTTON FOR GITHUB\n",
    "<button data-toggle=\"collapse\" data-target=\"#eratosthenes\">Solution</button>\n",
    "<div id=\"eratosthenes\" class=\"collapse\">-->\n",
    "    \n",
    "### Solution\n",
    "\n",
    "```python\n",
    "def list_primes(n):\n",
    "    \"\"\"\n",
    "    List all prime number below n\n",
    "    \"\"\"\n",
    "    \n",
    "    # initialize result array\n",
    "    primes = []\n",
    "    \n",
    "    # initialisation of the sieve using list concatenation (+) and repeat (*n)\n",
    "    sieve = [False] * 2 + [True] * (n - 2)\n",
    "    \n",
    "    # iterate through the sieve\n",
    "    for prime, is_prime in enumerate(sieve):\n",
    "        if is_prime:\n",
    "    \n",
    "            # We find a prime! Save it\n",
    "            primes.append(prime)\n",
    "    \n",
    "            # slicing to mark all mutliple as non prime\n",
    "            sieve[::prime] = [False for i in range(0, n, prime)]\n",
    "    return primes\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionnaries\n",
    "They are usefull to store metadata"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#define an empty dictonnary\n",
    "my_emptydict = dict()\n",
    "another_emptydict = {}\n",
    "print(my_emptydict, another_emptydict)\n",
    "print()\n",
    "\n",
    "# define a dictionnary with items\n",
    "personnal_information = {\"lastname\":\"Gaston\", \"firstname\":\"Benoist\"}\n",
    "print(personnal_information)\n",
    "\n",
    "# add new item\n",
    "personnal_information[\"birthday\"] = (10, 27)\n",
    "print(personnal_information)\n",
    "print(personnal_information[\"birthday\"])\n",
    "print()\n",
    "\n",
    "# loop by key\n",
    "for key in personnal_information:\n",
    "    print(key)\n",
    "print()\n",
    "\n",
    "# loop by value\n",
    "for value in personnal_information.values():\n",
    "    print(value)\n",
    "print()\n",
    "\n",
    "# loop by items\n",
    "for key, value in personnal_information.items():\n",
    "    print(key, \" : \", value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## I/O\n",
    "- Generally : use dedicated packages (pillow for images, ...) -> ecosystem\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Strings\n",
    "- String can be enclosed by single quotes ('...') or double (\"...\"). Use \\ for escape quote"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "# single quote\n",
    "print('Être ange')\n",
    "\n",
    "# escape the second single quote\n",
    "print('C\\'est étrange')\n",
    "\n",
    "# double quote enclosement single quote as a character\n",
    "print(\"Dit l'ange\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Strings can be concatenated by + operator and repeated by * operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3*'Hip '+'Hourra')\n",
    "\n",
    "a_long_string = (\"This is \"  # the + operator is optionnal here\n",
    "                 \"a long string \")\n",
    "print(a_long_string)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Mutilines strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# with explicit special character\n",
    "str1 = 'Être âne\\nC\\'est étrane\\nDit l\\'âne'  \n",
    "\n",
    "# with triple quotes\n",
    "str2 = \"\"\"Être âne\n",
    "C'est étrane\n",
    "Dit l'âne\"\"\" \n",
    "\n",
    "if str1 == str2:\n",
    "    print(\"The two strings are identical\")\n",
    "else:\n",
    "    print(\"The two strings are different\")\n",
    "print()\n",
    "\n",
    "print(str1)\n",
    "print(str2) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- formatting strings\n",
    "  - ```print(\"un nombre : %d\" % nombre)```\n",
    "  - ```print(\"un nombre : {:}\".format(nombre))```\n",
    "  - ```print(f\"un nombre : {nombre:}\")``` (only in Python 3.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"{:<6} {:^5} | {:^5} | {:^5}\".format(\"\", \"spam\", \"eggs\", \"bacon\"))\n",
    "\n",
    "format_array = \"{:<6} {:^5.1f} | {:^5.1f} | {:^5.1f}\"\n",
    "print(format_array.format(\"David:\", 0, 1, 5))\n",
    "print(format_array.format(\"John:\", 0, 2, 0))\n",
    "print(format_array.format(\"Paul:\", 1.5, 0, 0))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ascii files\n",
    "**Always** decode in input  \n",
    "**Always** encode in output  \n",
    "`open` do it for you, but this is not always the case. Be careful\n",
    "- read  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# use of encoding strongly encouraged\n",
    "# when working whith ascii files, utf-8 is used by default\n",
    "for i, line in enumerate(open(\"README.md\", encoding=\"utf-8\")):\n",
    "    print(line.split())\n",
    "    if i>5:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- write"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using context\n",
    "with open(\"output_filenamme\", 'w', encoding=\"utf-8\") as f:\n",
    "    f.write(\"{:>10} is formated text\".format(\"This\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--<div class=\"alert alert-block alert-warning\"> \n",
    "<span style=\"font-size:xx-large;\"><center>Fourth exercise</center></span>\n",
    "</div> -->\n",
    "\n",
    "# Fourth exercise\n",
    "\n",
    "A palindrome is a word (sequence of characters) which reads the same backward as forward, such as madam or radar.  \n",
    "Write the code who read lines in \"data/filein.txt\" and write in \"fileout.txt\" lines who are palindrom"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for line in open(\"data/filein.txt\", \"r\", encoding=\"utf-8\"):\n",
    "    print(line, end=\"\")\n",
    "# Exercise\n",
    "#TODO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--REMOVE BUTTON FOR GITHUB\n",
    "<button data-toggle=\"collapse\" data-target=\"#solution2\">Solution</button>\n",
    "<div id=\"solution2\" class=\"collapse\">-->\n",
    "\n",
    "### Solution\n",
    "    \n",
    "``` python\n",
    "with open(\"fileout.txt\", \"w\", encoding=\"utf-8\") as file_out:\n",
    "    for line in open(\"data/filein.txt\", \"r\", encoding=\"utf-8\"):\n",
    "        if line[:-1] == line[-2::-1]:                           #  Ignore the \\n at the end of line\n",
    "            file_out.write(line)\n",
    "            print(line[:-1])\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- <div class=\"alert alert-success\">-->\n",
    "<!-- <center> -->\n",
    "<!-- <span style=\"font-size:xx-large;\">You're almost ready to Pythonize!</span><br/> -->\n",
    "<!-- (You'll also need modules) -->\n",
    "<!-- </center> -->\n",
    "<!-- </div> -->\n",
    "\n",
    "# You're almost ready to Pythonize!\n",
    "(You'll also need modules)\n",
    "\n",
    "## Best practices\n",
    "### The zen of Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this # PEP 20"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Respect [PEP 8](https://www.python.org/dev/peps/pep-0008/)\n",
    "- 4 spaces no tabs\n",
    "- do not reinvent the wheel \n",
    "- wrong comments are worst than no comments, clear code is better than obscur code \n",
    "- use docstrings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### More on this\n",
    "- [The Hitchhiker’s Guide to Python!](http://docs.python-guide.org/en/latest/)\n",
    "- http://www.scipy-lectures.org"
   ]
  }
 ],
 "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}