# Python 3



1. collections:
   1. [liste []](liste.md)
   2. [dictionnaire {}](dictionnaire.md)
   3. [tuple ()](tuple.md)
   4. [set {}](set.md)
2. [class - objet](class.md)
3. [date](date.md)
4. [fichiers](fichiers.md)
5. [fonctions](fonctions.md)
6. [fabric-ssh](fabric-ssh.md)
7. [regex](regex.md)
8. [strings](string.md)
9. [json](json.md)
10. [requests](requests.md)
11. [zip](zip.md)





https://www.tutorialspoint.com/python3/index.htm

https://www.w3schools.com/python/default.asp



| Hashable (non modifiable) | Unhashable      |
| ------------------------- | --------------- |
| int                       | liste []        |
| float                     | set {}          |
| bool                      | dictionnaire {} |
| str                       |                 |
| tuples ()                 |                 |



#### Instruction de boucles

##### while:

```python
while n != 1:
   if n % 2 == 0 :  # si un nombre entier modulo 2 vaut 0, il est pair
       n = n // 2
   else:                 # cas où le nombre est impair
       n = 3*n + 1

print(n)
```

##### for:

```python
somme = 0
for val in range(5):    # 0 1 2 3 4
    somme += val

print(somme)
```



#### Conditions:

##### if:

```python
>>> x = 1
>>> if x > 5:
...     x = x + 1
... elif x == 5:
...     x = x + 1000
... else:
...     x = x - 1
... 
>>> x
0
```



#### Compréhension de liste:

```python
# Soit une liste:
>>> a = [1,4,2,7,1,9,0,3,4,6,6,6,8,3]

# On veut filtrer les nombres > 5
>>> b = []
>>> for x in a:
...     if x > 5:
...         b.append(x)
... 
>>> b
[7, 9, 6, 6, 6, 8]

# La même chose sur une seule ligne
>>> [x for x in a if x > 5]
[7, 9, 6, 6, 6, 8]

```

```python
# Convertir plusueurs chaines en entiers
>>> items = ["5", "10", "15"]
>>> items = [int(x) for x in items]
>>> print(items)
[5, 10, 15]
```



#### Collections:

[liste](liste.md):

```python
>>> liste = [1,2,3]
>>> liste
[1, 2, 3]

# modifiable, ordonée
```

[set](set.md):

```python
>>> un_set = {"apple", "banana", "cherry"}
>>> un_set
{'apple', 'cherry', 'banana'}

# ni ordonnée, ni indexée
```

[tuple](tuple.md):

```python
>>> un_tuple = ("alpha","beta","gamma")
>>> un_tuple
('alpha', 'beta', 'gamma')

# non modifiable, ordonée
```

[dictionnaire](dictionnaire.md):

```python
>>> un_dict =  {
...   "brand": "Ford",
...   "model": "Mustang",
...   "year": 1964
... }
>>> un_dict
{'brand': 'Ford', 'model': 'Mustang', 'year': 1964}

# modifiable, non ordonée, indexée
```



#### Opérateurs:

Operateurs relationnels:

```python
<, <=, >, >=, == et !=
```

Opérateurs booléens:

```python
and, or et not
```



Instruction `pass`:

```python
if x < 0 :
   pass  # TODO compléter le code (cas où x < 0)
else :
   print('traitement du cas où x est positif')
```



#### Fonction (def):

```python
def pgcd(x, y):
    """
    calcule le pgcd de 2 nombres entiers positifs
    """
    while (y > 0):
        x, y  =  y, x % y
    return x

>>> pgcd(45, 78)
3

# utiliser une liste pour paramètres
>>> param = [45, 78]
>>> pgcd(*param)
3
# * => opérateur splat

# rendre obligatoire uniquement certains paramètres
>>> def fiche(prenom, nom, *reste):
...     return prenom + " " + nom
...
>>> fiche("john", "doe")
'john doe'

# utiliser un dictionnaire pour paramèttres
>>> param = {"prenom": "john", "nom": "doe"}
>>> def fiche(**param):
...     return param["nom"]
...
>>> fiche(nom="doe")
'doe'

>>> def fiches(prenom="", nom=""):
...     return "{} {}".format(prenom, nom)
...
>>> fiches(*param)
'prenom nom'
>>> fiches(**param)
'john doe'
```



##### Importer des fonctions d'autres fichiers

Le fichier regroupant les fonctions `functions.py` se trouvent dans le même répertoire que le script `test.py`:

`functions.py`

```python
def x2(x):
    return x * 2
```

`test.py`

```python
from functions import *

nb = int(input("Choisissez un nombre : "))
print("Vous avez choisi", nb)

multiplie = x2(nb)
print(nb, " x2 = ", multiplie)
```



##### Importer un module:

L'interpréteur recherche les modules dans

1. le répertoire courant
2. tous les répertoires de la variable `PYTHONPATH`
3. dans le chemin par défaut (`/usr/local/lib/python3/`)

```python
import datetime
```

```python
# importe uniquement la section time du module datetime
from datetime import time
```

```python
# importe le module calendar et crée un alias c
import calendar as c

print(c.month_name[1])
```



##### Exécuter un script Python

```bash
$ python /chemin/script.py
```



##### Exceptions (try / except / finally)

```python
>>> a = 0
>>> b = 2
>>> try:
...     b/a
...     print("Ok", b/a)
... except:
...     print("Erreur")
...
Erreur


>>> try:
...     b/a
...     print("Ok", b/a)
... except ZeroDivisionError:
...     print("Erreur: division par 0")
... finally:
...     print("Instructions exécutées quelque soit les erreurs générées")
...
Erreur: division par 0
Instructions exécutées quelque soit les erreurs générées
```



#### pdb

pdb est un débugger. 

Ajouter ce qui suit à la ligne à étudier:

```python
import pdb; pdb.set_trace()
```

Le programme s'arrête à la ligne et donne accès à un shell:

```python
\r\nDNT: 1\r\nAccept-Encoding: gzip, deflate\r\n\r\n'
> /Users/bruno/PycharmProjects/webserver/serve2.py(23)<module>()
-> client_connection.sendall(http_response)
(Pdb) l
 18  	Hello, World!
 19  	"""
 20  	    import pdb;
 21
 22  	    pdb.set_trace()
 23  ->	    client_connection.sendall(http_response)
 24  	    client_connection.close()
[EOF]
(Pdb) n
TypeError: a bytes-like object is required, not 'str'
> /Users/bruno/PycharmProjects/webserver/serve2.py(23)<module>()
-> client_connection.sendall(http_response)
(Pdb)
```

Les commandes utiles:

-  `l`: Liste quelques lignes de code avant et après là où  vous vous trouver. Utile pour se resituer dans le contexte du programme.  ‘l’ pour ‘list’.
-  `n`: Exécute la ligne suivante. Vous pouvez ainsi  continuer l’exécution du programme de bout en bout, ligne par ligne, et  le tester en entier. ‘n’ pour ‘next’.
-  `s`: Si votre ligne contient un appel de fonction ou de méthode, rentre dans à l’intérieur. ‘s’ pour ‘step in’.
-  `r`: Si vous êtes dans une fonction ou une méthode, celà  permet d’en sortir et de passer dans le scope du dessus. ‘r’ pour  ‘return’.
- `unt`: Si vous êtes à la dernière ligne d’une boucle,  permet de reprendre l’exécution jusqu’à la sortie de la boucle. ‘unt’  pour ‘until’.
- `q`: Quitte brutalement le programme en le faisant crasher. ‘q’ pour ‘quit’.
- `c`: Quitte le debugger et continue l’exécution du  programme normalement. Tous les changements que vous avez fait dans le  code sont pris en compte. ‘c’ pour ‘continue’.



