Python 3¶

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:¶

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:¶

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

print(somme)

Conditions:¶

if:¶

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

Compréhension de liste:¶

# 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]

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

Collections:¶

liste:

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

# modifiable, ordonée

set:

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

# ni ordonnée, ni indexée

tuple:

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

# non modifiable, ordonée

dictionnaire:

>>> 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:

<, <=, >, >=, == et !=

Opérateurs booléens:

and, or et not

Instruction pass:

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

Fonction (def):¶

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

def x2(x):
    return x * 2

test.py

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

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

import datetime

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

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

print(c.month_name[1])

Exécuter un script Python¶

$ python /chemin/script.py

Exceptions (try / except / finally)¶

>>> 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:

import pdb; pdb.set_trace()

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

\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’.

Dernière mise à jour: May 28, 2019