Commit 7bda5f14 authored by paugier's avatar paugier
Browse files

Fix advanced matplotlib

parent ccc84288
Pipeline #75925 passed with stage
in 59 seconds
......@@ -2231,8 +2231,8 @@
"name": "stdout",
"output_type": "stream",
"text": [
"integer remove from the list: 2\n",
"shuffled list: [11, 5, 3, 18, 16, 14, 13, 0, 17, 10, 15, 7, 6, 12, 4, 8, 9, 1, 19]\n"
"integer remove from the list: 10\n",
"shuffled list: [5, 14, 2, 17, 18, 13, 12, 4, 16, 6, 15, 7, 8, 1, 19, 0, 3, 11, 9]\n"
]
}
],
......@@ -2278,9 +2278,9 @@
"name": "stdout",
"output_type": "stream",
"text": [
"[11, 5, 3, 18, 16, 14, 13, 0, 17, 10, 15, 7, 6, 12, 4, 8, 9, 1, 19]\n",
"[0, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n",
"missing 2\n"
"[5, 14, 2, 17, 18, 13, 12, 4, 16, 6, 15, 7, 8, 1, 19, 0, 3, 11, 9]\n",
"[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n",
"missing 10\n"
]
}
],
......@@ -2308,7 +2308,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
"missing 2\n"
"missing 10\n"
]
}
],
......@@ -2329,7 +2329,7 @@
"name": "stdout",
"output_type": "stream",
"text": [
"missing 2\n"
"missing 10\n"
]
}
],
......@@ -2559,8 +2559,9 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.8.0"
}
"version": "3.9.7"
},
"toc-showcode": false
},
"nbformat": 4,
"nbformat_minor": 4
......
%% Cell type:markdown id: tags:
# Python training UGA 2021
**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: stream
hello
%% Cell type:markdown id: tags:
Some functions return a result.
%% Cell type:code id: tags:
``` python
round(1.2)
```
%%%% Output: execute_result
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: stream
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: stream
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: stream
True
False
%% Cell type:markdown id: tags:
##### Keywords `and` and `or`
%% Cell type:code id: tags:
``` python
True and True
```
%%%% Output: execute_result
True
%% Cell type:code id: tags:
``` python
True and False
```
%%%% Output: execute_result
False
%% Cell type:code id: tags:
``` python
False and False
```
%%%% Output: execute_result
False
%% Cell type:code id: tags:
``` python
True or True
```
%%%% Output: execute_result
True
%% Cell type:code id: tags:
``` python
True or False
```
%%%% Output: execute_result
True
%% Cell type:code id: tags:
``` python
False or False
```
%%%% Output: execute_result
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 = 0.2
```
%% Cell type:code id: tags:
``` python
# complex (2 floats)
c = complex("1")
c = 1 + 2j
print(c, c.real, c.imag)
```
%%%% Output: stream
(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: stream
2.0
%% Cell type:markdown id: tags:
Very general issue (not Python):
see https://en.wikipedia.org/wiki/Floating-point_arithmetic
%% 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: stream
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: stream
['__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', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']
%% Cell type:markdown id: tags:
Let's hide the internal variables starting and ending with `__` (for now you don't need to understand the code used for that).
%% Cell type:code id: tags:
``` python
print([name_attr for name_attr in dir(s) if not name_attr.startswith("__")])
```
%%%% Output: stream
['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', 'removeprefix', 'removesuffix', '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: execute_result
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: execute_result
'a = 1.23456789'
%% Cell type:code id: tags:
``` python
"a = {:.4f}".format(a)
```
%%%% Output: execute_result
'a = 1.2346'
%% Cell type:code id: tags:
``` python
"a = {:8.4f}".format(a)
```
%%%% Output: execute_result
'a = 1.2346'
%% Cell type:code id: tags:
``` python
"a = {:.4e} (scientific notation)".format(a)
```
%%%% Output: execute_result
'a = 1.2346e+00 (scientific notation)'
%% Cell type:code id: tags:
``` python
print("{}\t{}\t{}".format(1, 2, 3))
```
%%%% Output: stream
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: execute_result
'a = 1.23456789'
%% Cell type:code id: tags:
``` python
f"a = {a:.4f}"
```
%%%% Output: execute_result
'a = 1.2346'
%% Cell type:code id: tags:
``` python
f"a = {a:8.4f}"
```
%%%% Output: execute_result
'a = 1.2346'
%% Cell type:code id: tags:
``` python
f"a = {a:.4e} (scientific notation)"
```
%%%% Output: execute_result
'a = 1.2346e+00 (scientific notation)'
%% Cell type:code id: tags:
``` python
print(f"{1}\t{1+1}\t{2+1}")
```
%%%% Output: stream
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: stream
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: stream
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: execute_result
'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: stream
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: execute_result
'ce'
%% Cell type:code id: tags:
``` python
# s[start:stop]
s[2:6]
```
%%%% Output: execute_result
'cdef'
%% Cell type:code id: tags:
``` python
# s[start:]
s[1:]
```
%%%% Output: execute_result
'bcdef'
%% Cell type:code id: tags:
``` python
# s[:stop]
s[:2]
```
%%%% Output: execute_result
'ab'
%% Cell type:code id: tags:
``` python
# step = -1: goes through the string in reverse order
s[::-1]
```
%%%% Output: execute_result
'fedcba'
%% 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: execute_result
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.0])
print(l)
```
%%%% Output: stream
['2', 6, 3.0]
%% Cell type:code id: tags:
``` python
# concatenate lists with the operator +
print(l + ["hello", 3])
```
%%%% Output: stream
['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: stream
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: execute_result
tuple
%% Cell type:code id: tags:
``` python
t[1] # indexing
```
%%%% Output: execute_result
'a'
%% Cell type:code id: tags:
``` python
t[1:] # slicing
```
%%%% Output: execute_result
('a', 1.2)
%% Cell type:code id: tags:
``` python
a, b = t1 # tuple assigment
print(b)
```
%%%% Output: stream
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: stream
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: stream
[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: stream
['a']
%% Cell type:markdown id: tags:
### More on slicing (shallow copy)
#### 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: stream
[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: stream
[0, 1, 2, 3, 4, 5, 'a']
[0, 1, 2, 3, 4, 5]
%% Cell type:markdown id: tags:
### More examples of 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: execute_result
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:
1. Remove leading and ending blanks (with `str.strip`)
2. Extract the first field (with `str.find` and slicing)
3. Extract the last field (with `str.rfind` and slicing)
4. Check for empty field (with the `";;" in ...` pattern)
5. Remove empty field (with `str.replace`)
For each task, do not hesitate to print the help of the method by writing `s.strip?` in IPython.
%% Cell type:markdown id: tags:
#### A possible solution:
%% Cell type:code id: tags:
``` python
s = " wind;temperature;;pressure "
# remove leading blanks
s = s.strip()
f"--{s}--"
```
%%%% Output: execute_result
'--wind;temperature;;pressure--'
%% Cell type:code id: tags:
``` python
# extract the first field
idx = s.find(";")
s0 = s[0:idx]
s0
```
%%%% Output: execute_result
'wind'
%% Cell type:code id: tags:
``` python
# extract the second field
idx1 = s.find(";", idx + 1) # start the search after the first ";"
s1 = s[idx + 1 : idx1]
s1
```
%%%% Output: execute_result
'temperature'
%% Cell type:code id: tags:
``` python
# extract the last field
idx2 = s.rfind(";")
s2 = s[idx2 + 1 :]
s2
```
%%%% Output: execute_result
'pressure'
%% Cell type:code id: tags:
``` python
# check presence of ";;"
";;" in s
```
%%%% Output: execute_result
True
%% Cell type:code id: tags:
``` python
# remove empty field
s_no_empty = s.replace(";;", ";")
s_no_empty
```
%%%% Output: execute_result
'wind;temperature;pressure'
%% 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: execute_result
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: execute_result
[1, 3, 5, 7]
%% Cell type:code id: tags:
``` python
# start, stop (step=1)
list(range(2, 8))
```
%%%% Output: execute_result
[2, 3, 4, 5, 6, 7]
%% Cell type:code id: tags:
``` python
# stop argument (start=0, step=1)
list(range(8))
```
%%%% Output: execute_result
[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: stream
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: stream
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: stream
i = 4
%% Cell type:code id: tags:
``` python
i = 0
while i < 4:
i += 1
print("i =", i)
```
%%%% Output: stream
i = 1
i = 2
i = 3
i = 4
%% Cell type:markdown id: tags:
### Loops with the keyword `for`
%% Cell type:code id: tags:
``` python
values = range(5)
for value in values:
print(value, end=", ")
```
%%%% Output: stream
0, 1, 2, 3, 4,
%% Cell type:code id: tags:
``` python
values = "abcd"
for ind in range(len(values)):
print(f"values[{ind}] = '{values[ind]}'", end="; ")
```
%%%% Output: stream
values[0] = 'a'; values[1] = 'b'; values[2] = 'c'; values[3] = 'd';
%% Cell type:code id: tags:
``` python
# the built-in function enumerate is very useful
for index, value in enumerate(["a", "b", "c"]):
print(f"({index}, {value})")
```
%%%% Output: stream
(0, a)
(1, b)
(2, c)
%% Cell type:code id: tags:
``` python
print(list(enumerate(["a", "b", "c"])))
```
%%%% Output: stream
[(0, 'a'), (1, 'b'), (2, 'c')]
%% 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: stream
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: stream
1, 2, 3, 4,
%% Cell type:markdown id: tags:
### Do it yourself
- Edit a script with Spyder 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 (without `sum`), using the keyword `while`
* check that the 2 methods give the same results with
```assert avg0 == avg1```
- 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]
avg0 = sum(numbers) / len(numbers)
tmp = 0
i = 0
while i < len(numbers):
tmp += numbers[i]
i = i + 1
avg1 = tmp / len(numbers)
assert avg0 == avg1
```
%% Cell type:markdown id: tags:
### Do it yourself
We build a list:
%% Cell type:code id: tags:
``` python
from random import randint, shuffle
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: stream
integer remove from the list: 2
shuffled list: [11, 5, 3, 18, 16, 14, 13, 0, 17, 10, 15, 7, 6, 12, 4, 8, 9, 1, 19]
integer remove from the list: 10
shuffled list: [5, 14, 2, 17, 18, 13, 12, 4, 16, 6, 15, 7, 8, 1, 19, 0, 3, 11, 9]
%% 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: stream
[11, 5, 3, 18, 16, 14, 13, 0, 17, 10, 15, 7, 6, 12, 4, 8, 9, 1, 19]
[0, 1, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
missing 2
[5, 14, 2, 17, 18, 13, 12, 4, 16, 6, 15, 7, 8, 1, 19, 0, 3, 11, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19]
missing 10
%% 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: stream
missing 2
missing 10
%% 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: stream
missing 2
missing 10
%% 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: stream
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: stream
hello is not a int
hello is not a float
1.5 is not a int
['hello', 1.5, 2]
......
This diff is collapsed.
Supports Markdown
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment