Added a link to Python doc for floating point arithmetics

3f7d1271 · Loic Huder · 28ca6ad1 · 3f7d1271
Commit 3f7d1271 authored Dec 02, 2019 by Loic Huder
--- a/ipynb/pres02_basic_statements.ipynb
+++ b/ipynb/pres02_basic_statements.ipynb
@@ -507,7 +507,7 @@
   "source": [
    "Very general issue (not Python): \n",
    "\n",
-    "see https://en.wikipedia.org/wiki/Floating-point_arithmetic"
+    "See https://en.wikipedia.org/wiki/Floating-point_arithmetic and https://docs.python.org/3/tutorial/floatingpoint.html"
   ]
  },
  {
@@ -2624,6 +2624,15 @@
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.2"
+  },
+  "pycharm": {
+   "stem_cell": {
+    "cell_type": "raw",
+    "source": [],
+    "metadata": {
+     "collapsed": false
+    }
+   }
  }
 },
 "nbformat": 4,

 %% Cell type:markdown id: tags:

 # Python training UGA 2017

 **A training to acquire strong basis in Python to use it efficiently**

 Pierre Augier (LEGI), Cyrille Bonamy (LEGI), Eric Maldonado (Irstea), Franck Thollard (ISTerre), Christophe Picard (LJK), Loïc Huder (ISTerre)

 # Standard types and basic statements

 %% Cell type:markdown id: tags:

 ## Function calls

 There are [built-in functions](https://docs.python.org/3/library/functions.html) and the developers can of course define other functions. To call a function:

 %% Cell type:code id: tags:

 ``` python
 print("hello")
 ```

 %% Output

    hello

 %% Cell type:markdown id: tags:

 Some functions return a result.

 %% Cell type:code id: tags:

 ``` python
 round(1.2)
 ```

 %% Output

    1

 %% Cell type:markdown id: tags:

 It's common to store the result in a variable:

 %% Cell type:code id: tags:

 ``` python
 my_var = round(1.2)
 ```

 %% Cell type:markdown id: tags:

 which can then be used:

 %% Cell type:code id: tags:

 ``` python
 print(my_var)
 ```

 %% Output

    1

 %% Cell type:markdown id: tags:

 ## Few standard types

 - Simple types (`int`, `float`, `bool`, `complex`)
 - Standard type `str`
 - Standard type `list`
 - Standard type `tuple`

 %% Cell type:markdown id: tags:

 ### `int` (integers)

 %% Cell type:code id: tags:

 ``` python
 a = 4
 c = -10

 # binary notation (base 2)
 b = 0b010

 # octal notation (base 8)
 o = 0o011

 # hexadecimal (base 16)
 h = 0x1cf0

 a = int('1')       # base 10
 a = int('111', 2)  # base 2
 a = int('70', 8)   # base 8
 a = int('16', 16)  # base 16
 ```

 %% Cell type:markdown id: tags:

 Remark: `int` in Python 3 are impressive! No limit! See https://docs.python.org/3.1/whatsnew/3.0.html#integers

 %% Cell type:markdown id: tags:

 ## Arithmetic operations

 %% Cell type:code id: tags:

 ``` python
 print(10 + 3)
 print(10 - 3)
 print(10 * 3)
 print(10 / 3)  # float division
 print(10 // 3)  # integer division
 print(10 % 3)
 ```

 %% Output

    13
    7
    30
    3.3333333333333335
    3
    1

 %% Cell type:markdown id: tags:

 ### `bool` (booleans)

 %% Cell type:code id: tags:

 ``` python
 b = bool('1')
 b = False
 b = True
 ```

 %% Cell type:markdown id: tags:

 ##### Comparison operations (bool)

 - `==` equal
 - `!=` différent
 - `<` inferior
 - `<=` inferior or equal
 - `>` superior
 - `>=` superior or equal

 %% Cell type:markdown id: tags:

 ##### Keyword `is`: check identity

 %% Cell type:code id: tags:

 ``` python
 a = None
 print(a is None)
 print(a is not None)
 ```

 %% Output

    True
    False

 %% Cell type:markdown id: tags:

 ##### Keywords `and` and `or`

 %% Cell type:code id: tags:

 ``` python
 True and True
 ```

 %% Output

    True

 %% Cell type:code id: tags:

 ``` python
 True and False
 ```

 %% Output

    False

 %% Cell type:code id: tags:

 ``` python
 False and False
 ```

 %% Output

    False

 %% Cell type:code id: tags:

 ``` python
 True or True
 ```

 %% Output

    True

 %% Cell type:code id: tags:

 ``` python
 True or False
 ```

 %% Output

    True

 %% Cell type:code id: tags:

 ``` python
 False or False
 ```

 %% Output

    False

 %% Cell type:markdown id: tags:

 ### `float` (real, double precision) and `complex`

 %% Cell type:code id: tags:

 ``` python
 # float
 a = float('1')
 a = 1.234
 a = 1e2
 a = -1e-2
 a = .2
 ```

 %% Cell type:code id: tags:

 ``` python
 # complex (2 floats)
 c = complex('1')
 c = 1 + 2j
 print(c, c.real, c.imag)
 ```

 %% Output

    (1+2j) 1.0 2.0

 %% Cell type:markdown id: tags:

 Remark: notation `var_name.attr_name` to access to an attribute of an object.

 %% Cell type:markdown id: tags:

 ## Warning about floating-point arithmetic and numerical errors!

 %% Cell type:code id: tags:

 ``` python
 b = 1e16
 c = 1.2 + b
 d = c - b
 print(d)
 ```

 %% Output

    2.0

 %% Cell type:markdown id: tags:

 Very general issue (not Python):

-see https://en.wikipedia.org/wiki/Floating-point_arithmetic
+See https://en.wikipedia.org/wiki/Floating-point_arithmetic and https://docs.python.org/3/tutorial/floatingpoint.html

 %% Cell type:markdown id: tags:

 ### Standard type `str`

 %% Cell type:code id: tags:

 ``` python
 s = 'hello'
 s = "hello"

 s = ('How is it possible to write a very very '
     'very long string with lines limited to 79 characters?')

 s = """Strings on
 more thand
 one line.
 """
 print(s)
 ```

 %% Output

    Strings on
    more thand
    one line.
    

 %% Cell type:markdown id: tags:

 Warning: big difference between Python 2 and Python 3. In Python 3, `str` are unicode and there is another type `bytes`.

 %% Cell type:markdown id: tags:

 #### Methods of the type `str`

 Objects of built-in types have methods associated with their type (object oriented programming). The built-in function `dir` returns a list of name of the attributes. For a string, these attributes are python system attributes (with double-underscores) and several public methods:

 %% Cell type:code id: tags:

 ``` python
 s = 'abcdef'
 print(dir(s))
 ```

 %% Output

    ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

 %% Cell type:markdown id: tags:

 To access an attribute of an object (here, the method `str.startswith`), we use the dot:

 %% Cell type:code id: tags:

 ``` python
 s.startswith('a')
 ```

 %% Output

    True

 %% Cell type:markdown id: tags:

 ### standard type `str`

 #### function `str.format`

 ```text
 Docstring:
 S.format(*args, **kwargs) -> str

 Return a formatted version of S, using substitutions from args and kwargs.
 The substitutions are identified by braces ('{' and '}').
 ```

 %% Cell type:code id: tags:

 ``` python
 a = 1.23456789
 'a = {}'.format(a)
 ```

 %% Output

    'a = 1.23456789'

 %% Cell type:code id: tags:

 ``` python
 'a = {:.4f}'.format(a)
 ```

 %% Output

    'a = 1.2346'

 %% Cell type:code id: tags:

 ``` python
 'a = {:8.4f}'.format(a)
 ```

 %% Output

    'a =   1.2346'

 %% Cell type:code id: tags:

 ``` python
 'a = {:.4e} (scientific notation)'.format(a)
 ```

 %% Output

    'a = 1.2346e+00 (scientific notation)'

 %% Cell type:code id: tags:

 ``` python
 print('{}\t{}\t{}'.format(1, 2, 3))
 ```

 %% Output

    1	2	3

 %% Cell type:markdown id: tags:

 ### standard type `str`

 #### New in Python 3.6: format strings

 %% Cell type:code id: tags:

 ``` python
 a = 1.23456789
 f'a = {a}'
 ```

 %% Output

    'a = 1.23456789'

 %% Cell type:code id: tags:

 ``` python
 f'a = {a:.4f}'
 ```

 %% Output

    'a = 1.2346'

 %% Cell type:code id: tags:

 ``` python
 f'a = {a:8.4f}'
 ```

 %% Output

    'a =   1.2346'

 %% Cell type:code id: tags:

 ``` python
 f'a = {a:.4e} (scientific notation)'
 ```

 %% Output

    'a = 1.2346e+00 (scientific notation)'

 %% Cell type:code id: tags:

 ``` python
 print(f'{1}\t{1+1}\t{2+1}')
 ```

 %% Output

    1	2	3

 %% Cell type:markdown id: tags:

 ### standard type `str`

 Strings are immutable **["sequences"](https://docs.python.org/3/library/stdtypes.html)**.

 - lookup

 %% Cell type:code id: tags:

 ``` python
 s = 'abcdef'
 print('a' in s)
 print('hello' not in s)
 ```

 %% Output

    True
    True

 %% Cell type:markdown id: tags:

 - We can get an element of a string (**index starts from 0**):

 %% Cell type:code id: tags:

 ``` python
 print(s[0])
 ```

 %% Output

    a

 %% Cell type:markdown id: tags:

 - since strings are immutable, they can not be modified inplace. If we try, we get an error:

 ```python
 s[0] = 'b'
 ```
 ```text
 ---------------------------------------------------------------------------
 TypeError                                 Traceback (most recent call last)
 <ipython-input-5-55620f378bce> in <module>()
 ----> 1 s[0] = 'b'

 TypeError: 'str' object does not support item assignment
 ```

 - since strings are sequences, they can be "sliced" (we will soon study in details this powerful notation):

 %% Cell type:code id: tags:

 ``` python
 s[1:3]
 ```

 %% Output

    'bc'

 %% Cell type:markdown id: tags:

 - it is very simple to manipulate strings in many ways:

 %% Cell type:code id: tags:

 ``` python
 print((s.capitalize() + ' ' + s.upper() + '\n') * 4 )
 ```

 %% Output

    Abcdef ABCDEF
    Abcdef ABCDEF
    Abcdef ABCDEF
    Abcdef ABCDEF
    

 %% Cell type:markdown id: tags:

 ### Slicing

 Very general, can be used on all sequences as `str`, `list`, etc... Not simple for beginners but very powerfull (see [here](http://stackoverflow.com/questions/509211/explain-pythons-slice-notation) and [here](http://avilpage.com/2015/03/a-slice-of-python-intelligence-behind.html)).

 Python indexes and slices for a six-element str. Indexes enumerate the elements, slices enumerate the spaces between the elements.

 ```text
 Index from rear:    -6  -5  -4  -3  -2  -1
 Index from front:    0   1   2   3   4   5
                   +---+---+---+---+---+---+
                   | a | b | c | d | e | f |
                   +---+---+---+---+---+---+
 Slice from front:  0   1   2   3   4   5   6
 Slice from rear:  -6  -5  -4  -3  -2  -1   None
 ```

 %% Cell type:code id: tags:

 ``` python
 s = 'abcdef'
 # s[start:stop:step]
 s[2:6:2]
 ```

 %% Output

    'ce'

 %% Cell type:code id: tags:

 ``` python
 # s[start:stop]
 s[2:6]
 ```

 %% Output

    'cdef'

 %% Cell type:code id: tags:

 ``` python
 # s[start:]
 s[1:]
 ```

 %% Output

    'bcdef'

 %% Cell type:code id: tags:

 ``` python
 # s[:stop]
 s[:2]
 ```

 %% Output

    'ab'

 %% Cell type:code id: tags:

 ``` python
 # step = -1: goes through the string in reverse order
 s[::-1]
 ```

 %% Output

    'fedcba'

 %% Cell type:markdown id: tags:

 ### Do it yourself

 Suppose we have a string representing a header line of the form:

 %% Cell type:code id: tags:

 ``` python
 s = ' wind;temperature;;pressure '
 ```

 %% Cell type:markdown id: tags:

 - Remove leading and ending blanks (see `str.replace` and `str.strip`)
 - Extract the first field (e.g. using `find` method and slicing)
 - Extract the last field (e.g. using `rfind` method and slicing)
 - Check for empty field (e.g. `find` ";;" pattern)
 - Remove empty field (e.g. using replace method)
 - BONUS : Extract the second field (tip :`find` can take an argument that tells where to start the search)

 %% Cell type:markdown id: tags:

 #### A possible solution:

 %% Cell type:code id: tags:

 ``` python
 s = ' wind;temperature;;pressure '
 # remove leading blanks
 s = s.strip()
 print("--{}--".format(s))
 # extract the first field
 idx = s.find(";")
 s0 = s[0:idx]
 print(s0)
 # extract the second field
 idx1 = s.find(";", idx+1) # start the search after the first ";"
 s1 = s[idx+1:idx1]
 print(s1)
 # extract the last field
 idx2 = s.rfind(";")
 s2 = s[idx2+1:]
 print(s2)
 idx_first_empty_field = s.find(";;")
 print(idx_first_empty_field)
 # remove empty field
 s_no_empty = s.replace(";;", ";")
 print(s_no_empty)
 ```

 %% Output

    --wind;temperature;;pressure--
    wind
    temperature
    pressure
    16
    wind;temperature;pressure

 %% Cell type:markdown id: tags:

 ### standard type `list`

 A list is a **mutable sequence of (possibly inhomogeneous) elements**.

 %% Cell type:code id: tags:

 ``` python
 type([0, 'a'])
 ```

 %% Output

    list

 %% Cell type:code id: tags:

 ``` python
 # create an empty list
 l = []
 # fill the list (with the function append)
 l.append('2')
 # fill the list (with the function extend)
 l.extend([6, 3.])
 print(l)
 ```

 %% Output

    ['2', 6, 3.0]

 %% Cell type:code id: tags:

 ``` python
 # concatenate lists with the operator +
 print(l + ['hello', 3])
 ```

 %% Output

    ['2', 6, 3.0, 'hello', 3]

 %% Cell type:code id: tags:

 ``` python
 # get values
 print(l[0], l[2], l[-2])
 # slicing
 print(l[0:2])
 ```

 %% Output

    2 3.0 6
    ['2', 6]

 %% Cell type:markdown id: tags:

 ### standard type `tuple`

 A tuple is a **immutable sequence of (possibly inhomogeneous) elements**.

 Remark: when you need a sequence that won't be modified, tuple is usually more efficient than list.

 %% Cell type:code id: tags:

 ``` python
 t = 0, 'a', 1.2
 t1 = (5, 'hello')
 t2 = tuple([1.1, 2])
 type(t)
 ```

 %% Output

    tuple

 %% Cell type:code id: tags:

 ``` python
 t[1]  # indexing
 ```

 %% Output

    'a'

 %% Cell type:code id: tags:

 ``` python
 t[1:]  # slicing
 ```

 %% Output

    ('a', 1.2)

 %% Cell type:code id: tags:

 ``` python
 a, b = t1  # tuple assigment
 print(b)
 ```

 %% Output

    hello

 %% Cell type:markdown id: tags:

 ## Mutable and immutable objects

 The objects of type `str`, `int`, `float`, `bool` are immutable. They can not be modified. Of course, a name that points towards an integer can point towards a different integer.

 %% Cell type:code id: tags:

 ``` python
 i = 1
 i = i + 2  # (or i += 2)
 print(i)
 i = 10
 print(i)
 ```

 %% Output

    3
    10

 %% Cell type:markdown id: tags:

 Here, the objects `1` and `3` have not been modified.


 %% Cell type:markdown id: tags:

 ## Mutable and immutable objects

 An object of type `list` is mutable:

 %% Cell type:code id: tags:

 ``` python
 l = [0, 5]
 print(l)
 l.append('hello')
 print(l)
 ```

 %% Output

    [0, 5]
    [0, 5, 'hello']

 %% Cell type:markdown id: tags:

 Here, the object list tagged by the name `l` has been modified inplace.

 %% Cell type:markdown id: tags:

 ## References and `del` keyword

 `del` removes a reference. If an object in not binded to any names, Python can delete it from its internal memory.

 %% Cell type:code id: tags:

 ``` python
 l = ['a', 'b']
 del l[1]
 print(l)
 ```

 %% Output

    ['a']

 %% Cell type:markdown id: tags:

 ### More on slicing

 Very general, can be used on all sequences as `str`, `list`, etc... Not simple for beginners but very powerfull (see [here](http://stackoverflow.com/questions/509211/explain-pythons-slice-notation) and [here](http://avilpage.com/2015/03/a-slice-of-python-intelligence-behind.html)).

 Python indexes and slices for a six-element str. Indexes enumerate the elements, slices enumerate the spaces between the elements.

 ```text
 Index from rear:    -6  -5  -4  -3  -2  -1
 Index from front:    0   1   2   3   4   5
                   +---+---+---+---+---+---+
                   | a | b | c | d | e | f |
                   +---+---+---+---+---+---+
 Slice from front:  0   1   2   3   4   5   6
 Slice from rear:  -6  -5  -4  -3  -2  -1   0
 ```

 %% Cell type:code id: tags:

 ``` python
 s = 'abcdef'
 # s[start:stop:step]
 s[2:6:2]
 ```

 %% Output

    'ce'

 %% Cell type:markdown id: tags:

 ### More on slicing

 #### Assigment to mutable object

 %% Cell type:code id: tags:

 ``` python
 l = [0, 1, 2, 3, 4, 5]
 l1 = l  # assigment to a new name l1 (no copy of the object).
 # the names l and l1 points towards the same object.
 l1.append('a')
 print(l1)
 print(l)
 ```

 %% Output

    [0, 1, 2, 3, 4, 5, 'a']
    [0, 1, 2, 3, 4, 5, 'a']

 %% Cell type:markdown id: tags:

 #### Shallow copy

 %% Cell type:code id: tags:

 ``` python
 l = [0, 1, 2, 3, 4, 5]
 l1 = l[:] # shallow copy of l
 l1.append('a')
 print(l1)
 print(l)
 ```

 %% Output

    [0, 1, 2, 3, 4, 5, 'a']
    [0, 1, 2, 3, 4, 5]

 %% Cell type:markdown id: tags:

 ### More on slicing

 Other examples of slices for a six-element list. Indexes enumerate the elements, slices enumerate the spaces between the elements.

 %% Cell type:code id: tags:

 ``` python
 a = [0, 1, 2, 3, 4, 5]
 all([
    len(a) == 6,
    a[1:] == [1, 2, 3, 4, 5],
    a[:5] == [0, 1, 2, 3, 4],
    a[0] == 0,
    a[:-2] == [0, 1, 2, 3],
    a[5] == 5,
    a[1:2] == [1],
    a[-1] == 5,
    a[1:-1] == [1, 2, 3, 4],
    a[-2] == 4,
 ])
 ```

 %% Output

    True

 %% Cell type:markdown id: tags:

 ### Do it yourself

 Suppose we have the string containing header line.

 %% Cell type:code id: tags:

 ``` python
 s = 'wind;temperature;pressure'
 ```

 %% Cell type:markdown id: tags:

 - Extract the list of items (i.e. "wind", "temperature", "pressure"; see `str.split`).
 - Add "Snow level" to the list of items (e.g. using append)
 - Build a new header such that items are capitalized (e.g. using the methods `str.join` and `str.capitalize` and iterating on the list)

 %% Cell type:markdown id: tags:

 #### A possible solution:

 %% Cell type:code id: tags:

 ``` python
 s = 'wind;temperature;pressure'
 list_items = s.split(";")
 print(list_items)
 list_items.append("snow level".capitalize())
 list_items[0] = list_items[0].capitalize()
 list_items[1] = list_items[1].capitalize()
 list_items[2] = list_items[2].capitalize()

 print(list_items)
 ";".join(list_items)
 ```

 %% Output

    ['wind', 'temperature', 'pressure']
    ['Wind', 'Temperature', 'Pressure', 'Snow level']

    'Wind;Temperature;Pressure;Snow level'

 %% Cell type:markdown id: tags:

 ### The function `range`

 The function returns a range object:

 %% Cell type:code id: tags:

 ``` python
 # start, stop, step
 range(1, 8, 2)
 ```

 %% Output

    range(1, 8, 2)

 %% Cell type:markdown id: tags:

 We can make a list with the range object:

 %% Cell type:code id: tags:

 ``` python
 # start, stop, step
 list(range(1, 8, 2))
 ```

 %% Output

    [1, 3, 5, 7]

 %% Cell type:code id: tags:

 ``` python
 # start, stop (step=1)
 list(range(2, 8))
 ```

 %% Output

    [2, 3, 4, 5, 6, 7]

 %% Cell type:code id: tags:

 ``` python
 # stop argument (start=0, step=1)
 list(range(8))
 ```

 %% Output

    [0, 1, 2, 3, 4, 5, 6, 7]

 %% Cell type:markdown id: tags:

 ### Do it yourself

 Build a list of odd numbers in decreasing order.

 %% Cell type:markdown id: tags:

 ## Conditions: `if`, `elif`, `else`

 ```python
 if expression:
   statement(s)
 else:
   statement(s)
 ```

 The statement contains the block of code that executes if the conditional expression in the if statement resolves to 1 or a TRUE value.

 %% Cell type:code id: tags:

 ``` python
 a = 0
 if a == 0:
    print('a is equal to 0.')
 ```

 %% Output

    a is equal to 0.

 %% Cell type:code id: tags:

 ``` python
 a = 1
 if a < 0:
    print('a is negative.')
 elif a == 0:
    print('a is equal to 0.')
 elif a > 0:
    print('a is positive.')
 else:
    print("I don't know.")
 ```

 %% Output

    a is positive.

 %% Cell type:markdown id: tags:

 ## Loops

 %% Cell type:markdown id: tags:

 ### Loops with the keyword `while`


 %% Cell type:code id: tags:

 ``` python
 i = 0
 while i < 4:
    i += 1
 print('i =', i)
 ```

 %% Output

    i = 4

 %% Cell type:code id: tags:

 ``` python
 i = 0
 while i < 4:
    i += 1
    print('i =', i)

 ```

 %% Output

    i = 1
    i = 2
    i = 3
    i = 4

 %% Cell type:markdown id: tags:

 ### Do it yourself

 - Edit a script with the spyder editor that calculates the average of a set of numbers. For example `numbers = [67, 12, 2, 9, 23, 5]`

  * using the functions `sum` and `len`
  * manually, using the keyword `while`

 - Run the script

  * in spyder,
  * in a ipython session opened from another terminal,
  * with the command `python`.

 %% Cell type:markdown id: tags:

 #### A possible solution:

 %% Cell type:code id: tags:

 ``` python
 numbers = [67, 12, 2, 9, 23, 5]
 local_sum = 0
 i = 0
 while i < len(numbers):
    local_sum = local_sum + numbers[i]
    i = i+1
 avg = local_sum / len(numbers)
 print(avg)
 ```

 %% Output

    19.666666666666668

 %% Cell type:markdown id: tags:

 ### Loops with the keyword `for`

 %% Cell type:code id: tags:

 ``` python
 for index in range(5):
    print(index, end=', ')
 ```

 %% Output

    0, 1, 2, 3, 4,

 %% Cell type:code id: tags:

 ``` python
 cities = ["grenoble", "paris", "berlin", "london"]
 for city in cities:
    print(city, end=", ")
 ```

 %% Output

    grenoble, paris, berlin, london,

 %% Cell type:code id: tags:

 ``` python
 # the built-in function enumerate is very useful
 for index, city in enumerate(cities):
    print('({}, {})'.format(index, city))
    cities[index] = city.capitalize()
 ```

 %% Output

    (0, grenoble)
    (1, paris)
    (2, berlin)
    (3, london)

 %% Cell type:code id: tags:

 ``` python
 cities
 ```

 %% Output

    ['Grenoble', 'Paris', 'Berlin', 'London']

 %% Cell type:markdown id: tags:

 ### Loops: keywords `continue` and `break`

 - `continue`: passes the block in the loop and continues the loop.

 %% Cell type:code id: tags:

 ``` python
 for x in range(1, 8):
    if x == 5:
        continue
    print(x, end=', ')
 ```

 %% Output

    1, 2, 3, 4, 6, 7,

 %% Cell type:markdown id: tags:

 - `break`: stop the loop.

 %% Cell type:code id: tags:

 ``` python
 for x in range(1, 11):
    if x == 5:
        break
    print(x, end=', ')
 ```

 %% Output

    1, 2, 3, 4,

 %% Cell type:markdown id: tags:

 ### Do it yourself

 - Simplify your script by using a `for` loops.

 - In ipython, try to understand how the function `enumerate` works. Use it in your script.



 %% Cell type:markdown id: tags:

 #### A possible solution:

 %% Cell type:code id: tags:

 ``` python
 l = [67, 12, 2, 9, 23, 5]
 local_sum = 0
 for e in l:
    local_sum += e
 avg = local_sum / len(l)
 print(avg)
 ```

 %% Output

    19.666666666666668

 %% Cell type:markdown id: tags:

 ### Do it yourself

 We build a list:

 %% Cell type:code id: tags:

 ``` python
 from random import shuffle, randint

 n = 20
 i = randint(0, n-1)
 print('integer remove from the list:', i)
 l = list(range(n))
 l.remove(i)
 shuffle(l)
 print('shuffled list: ', l)
 ```

 %% Output

    integer remove from the list: 9
    shuffled list:  [13, 16, 15, 14, 5, 17, 12, 8, 11, 1, 18, 2, 10, 19, 4, 7, 0, 6, 3]

 %% Cell type:markdown id: tags:

 One element has been removed:

 - Find this element (given that you can change the ordering of `l`).
 - Find this element (given that you cannot change the ordering of `l`).

 %% Cell type:markdown id: tags:

 #### A possible solution:

 %% Cell type:code id: tags:

 ``` python
 # we can change ordering, let's sort
 print(l)
 l_sorted = sorted(l)
 print(l_sorted)
 found = None
 for idx, elem in enumerate(l_sorted):
    if elem != idx:
        found = idx
        break
 if found is None:
    found = len(l)
 print("missing ", idx)

 ```

 %% Output

    [13, 16, 15, 14, 5, 17, 12, 8, 11, 1, 18, 2, 10, 19, 4, 7, 0, 6, 3]
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
    missing  9

 %% Cell type:code id: tags:

 ``` python
 # we cannot sort -> higher complexity
 for elem in range(len(l)+1):
    if elem not in l:
        break
 print("missing ", elem)
 ```

 %% Output

    missing  9

 %% Cell type:code id: tags:

 ``` python
 # another solution
 actual_sum = sum(l)
 len_l = len(l)
 original_sum = (len_l + 1) * (len_l) // 2
 print("missing ", original_sum - actual_sum)
 ```

 %% Output

    missing  9

 %% Cell type:markdown id: tags:

 ## Exceptions and `try`, `except` syntax

 %% Cell type:markdown id: tags:

 Exceptions and errors are common in all codes. There is a good system to handle them in Python. Let's first see what gives such buggy code

 ```python
 l = ['a']
 i = 1
 print(l[i])
 ```

 When these lines are executed, Python stops its execution and print a traceback:
 ```text
 ---------------------------------------------------------------------------
 IndexError                                Traceback (most recent call last)
 <ipython-input-30-8df9cec1a0ec> in <module>()
      1 l = ['a']
      2 i = 1
 ----> 3 print(l[i])

 IndexError: list index out of range
 ```

 %% Cell type:markdown id: tags:

 ## Exceptions and `try`, `except` syntax

 Handling exception:

 %% Cell type:code id: tags:

 ``` python
 l = ['a']
 i = 1
 try:
    print(l[i])
 except IndexError as e:
    print(e)
 ```

 %% Output

    list index out of range

 %% Cell type:markdown id: tags:

 Remark: never use
 ```python
 except:
 ```
 It means "except all errors and exceptions". A user Control-C is an exception (`KeyboardInterrupt`) so it would be caught and have no effect.

 %% Cell type:markdown id: tags:

 ## Full syntax

 ```python
 try:
    ...
 except <exception1> as e1:
    ...
 except <exception2> as e2:
    ...
 else:
    ...
 finally:
    ...
 ```

 [Non exhaustive error list](https://docs.python.org/3/library/exceptions.html):

 - ArithmeticError
 - ZeroDivisionError
 - IndexError
 - KeyError
 - AttributeError
 - IOError
 - ImportError
 - NameError
 - SyntaxError
 - TypeError

 %% Cell type:markdown id: tags:

 ### Do it yourself:

 For each line of this string, append a variable of correct type in a list (i.e. "hello" should stay hello,
 2 should become an int and 1.5 a float). Do it by catching errors.

 **Hints:**
  - int("a") and float("a") raise ValueError
  - the above str_variable can be split using "\n"

 %% Cell type:code id: tags:

 ``` python
 str_variables = """hello
 1.5
 2"""

 the_list_you_should_get = ["hello", 1.5, 2]
 ```

 %% Cell type:markdown id: tags:

 #### A possible solution:

 %% Cell type:code id: tags:

 ``` python
 split_list = []
 for value in str_variables.split("\n"):
    try:
        value = int(value)
    except ValueError:
        print(value, "is not a int")
        try:
            value = float(value)
        except ValueError:
            print(value, 'is not a float')
    split_list.append(value)


 print(split_list)
 ```

 %% Output

    hello is not a int
    hello is not a float
    1.5 is not a int
    ['hello', 1.5, 2]