369 lines
6.6 KiB
Markdown
369 lines
6.6 KiB
Markdown
# 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’.
|
||
|
||
|
||
|