Mon`tit Python — PF. Bonnefoi - p

Cours Python « Mon’tit Python » – P-F. Bonnefoi – http://libpfb.so/ — 10 septembre 2012 — 1
Master 1 — UE Réseaux Avancés I
Mon’tit Python — P-F. Bonnefoi
Version du 10 septembre 2012
Table des matières
1 PourquoiPython? ...................................................... 2
1.1 Pourquoi Python ? Ses caractéristiques
1.2 Pourquoi Python ? Ses usages
2 UnprogrammePython .................................................. 2
3 Structured’unsourcePython ............................................. 3
4 Lesvariables .......................................................... 3
5 Lesvaleursettypesdebase .............................................. 3
6 Les structures de contrôle – Instructions & Conditions . . . . . . . . . . . . . . . . . . . . . . . . . 4
6.1 Les structures de contrôle – Itérations
7 Lesopérateurs ......................................................... 4
8 Lagestiondescaractères ................................................. 4
9 Leschaînesdecaractères ................................................ 5
10 Leslistes ............................................................. 5
10.1 Les listes — Exemples d’utilisation
10.2 Les listes — Utilisation comme « pile » et « file »
10.3 Utilisation spéciale des listes
10.4 L’accès aux éléments d’une liste ou d’un tuple
10.5 Des listes comme tableau à 2 dimensions
10.6 Un accès par indice aux éléments d’une chaîne
11 Lesdictionnaires ....................................................... 7
12 Lesmodulesetl’espacedenom ........................................... 7
13 Lessortiesécran ....................................................... 7
14 Lesentréesclavier ...................................................... 7
15 Lesconversions ........................................................ 8
16 Quelquesremarques .................................................... 8
17 Gestiondeserreurs ..................................................... 8
17.1 Gestion des erreurs & Exceptions
18 Lesfichiers:création ................................................... 9
18.1 Les fichiers : lecture par ligne
18.2 Les fichiers : lecture spéciale et écriture
18.3 Manipulation des données structurées
19 Expressions régulières ou expressions rationnelles ........................... 10
19.1 Expressions régulières en Python
19.2 ER – Compléments : gestion du motif
19.3 ER – Compléments : éclatement et recomposition
20 Génération de valeurs aléatoires : le module random ......................... 11
21 Les options en ligne de commande : le module optparse ..................... 11
22 Débogage:utilisationdumodeinteractif ................................... 12
22.1 Débogage avec le module « pdb », « Python Debugger »
22.2 Surveiller l’exécution, la « journalisation » : le module logging
23 Lesobjets ........................................................... 13
24 Lecontrôled’erreur ................................................... 13
25 Gestion de processus : lancer une commande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
25.1 Gestion de processus. . . Nouvelle Version !
25.2 Gestion de processus : création d’un second processus
26 Lesfonctions:définition&arguments ..................................... 14
27 ProgrammationSocket:protocoleTCP .................................... 15
27.1 Programmation Socket : client TCP
27.2 Programmation Socket : serveur TCP
27.3 Programmation Socket : TCP & gestion par ligne
27.4 Programmation Socket : TCP & utilisation spéciale
27.5 Programmation Socket : lecture par ligne
27.6 Programmation Socket : mode non bloquant
27.7 Programmation socket : gestion par événement
27.8 Programmation socket : le select
27.9 Programmation socket : le protocole UDP
28 Multithreading–Threads ............................................... 17
28.1 Multithreading – Sémaphores
29 Manipulations avancées : système de fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
29.1 Manipulations avancées : UDP & Broadcast, Scapy
29.2 Manipulation avancées : l’écriture de Script système
29.3 Manipulations avancées : construction de listes
30 Pouraméliorerl’expériencedePython ..................................... 19

Cours Python « Mon’tit Python » – P-F. Bonnefoi – http://libpfb.so/ — 10 septembre 2012 — 2
1 Pourquoi Python ?
Il est :
portable, disponible sous toutes les plate-formes (de Unix à Windows) ;
simple, avec une syntaxe claire, privilégiant la lisibilité, libérée de celle de C/C++ ;
riche. Il incorpore de nombreuses possibilités de langage
tiré de la programmation impérative :structure de contrôle, manipulation de nombres
comme les flottants, doubles, complexe, de structures complexes comme les tableaux, les
dictionnaires, etc.
tiré des langages de script : accès au système, manipulation de processus, de l’arbores-
cence fichier, d’expressions rationnelles, etc.
tiré de la programmation fonctionnelle :les fonctions sont dites « fonction de première
classe », car elles peuvent être fournies comme argument d’une autre fonction, il dispose
aussi de lambda expression, de générateur etc.
tiré de la programmation orienté objet :définition de classe, héritage multiple, in-
trospection (consultation du type, des méthodes proposées), ajout/retrait dynamique de
classes, de méthode, compilation dynamique de code, délégation ("duck typing"), passi-
vation/activation, surcharge d’opérateurs, etc.
1.1 Pourquoi Python ? Ses caractéristiques
Il est :
dynamique : il n’est pas nécessaire de déclarer le type d’une variable dans le source. Le type
est associé lors de l’exécution du programme ;
fortement typé : les types sont toujours appliqués (un entier ne peut être considéré comme
une chaîne sans conversion explicite, une variable possède un type lors de son affectation).
compilé/interprété à la manière de Java. Le source est compilé en bytecode (pouvant être
sauvegardé) puis exécuté sur une machine virtuelle.
Il dispose d’une gestion automatique de la mémoire ("garbage collector").
Il dispose de nombreuses bibliothèques : interface graphique (TkInter), développement Web
(le serveur d’application ZOPE, gestion de document avec Plone par exemple), inter-opérabilité
avec des BDs, des middlewares ou intergiciels objets( SOAP/COM/CORBA/.NET), d’analyse
réseau (SCAPY), manipulation d’XML, etc.
Il existe même des compilateurs vers C, CPython, vers la machine virtuelle Java (Jython), vers
.NET (IronPython) !
Il est utilisé comme langage de script dans PaintShopPro, Blender3d, Autocad, Labview, etc.
1.2 Pourquoi Python ? Ses usages
Il permet de faire du prototypage d’applications.
C’est un langage « agile », adapté à l’eXtreme programming :
« Personnes et interaction plutôt que processus et outils »
« Logiciel fonctionnel plutôt que documentation complète »
« Collaboration avec le client plutôt que négociation de contrat »
« Réagir au changement plutôt que suivre un plan »
Intégrer de nombreux mécanismes de contrôle d’erreur (exception, assertion), de test (pour éviter les régres-
sions, valider le code, ...).
Et il permet de faire de la programmation réseaux !
Dans le cadre du module Réseaux avancés I
Les éléments combinés que sont : la gestion des expressions rationnelles, la programmation
socket et l’utilisation de certaines classes d’objets nous permettrons de faire efficacement et
rapidement des applications réseaux conforme à différents protocoles de communication.
Remarques
La programmation objet ne sera pas obligatoire.
De même que l’utilisation de bibliothèques pour résoudre les problèmes de TPs est for-
mellement déconseillée !
2 Un programme Python
Mode interactif
Sur tout Unix, Python est intégré et disponible.
Sous la ligne de commande (shell), il suffit de lancer la commande « python » pour passer en mode
interactif : on peut entrer du code et en demander l’exécution, utiliser les fonctions intégrées (buil-
tins), charger des bibliothèques etc
pef@darkstar:~$ python
Python 2.7.1 (r271:86832, Jun 16 2011, 16:59:05)
[GCC 4.2.1 (Based on Apple Inc. build 5658) (LLVM build 2335.15.00)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> 10+20
30
>>> _
30
>>> _*2
60
>>> help()
La variable « _» mémorise automatiquement le résultat précédent.
Documentation
Sous ce mode interactif, il est possible d’obtenir de la documentation en appelant la fonction
help(), puis en entrant l’identifiant de la fonction ou de la méthode.
La documentation complète du langage est disponible sur le réseau à http://docs.python.org/.

Cours Python « Mon’tit Python » – P-F. Bonnefoi – http://libpfb.so/ — 10 septembre 2012 — 3
Un programme Python
Écriture de code et exécution
L’extension par défaut d’un source Python est « .py ».
Pour exécuter un source python (compilation et exécution sont simultanées), il existe deux mé-
thodes :
1. en appelant l’interprète Python de l’extérieur du programme :
$ python mon_source.py
2. en appelant l’interprète Python de l’intérieur du programme :
on rend le source exécutable, comme un script :
$ chmod +x mon_source.py
on met en première ligne du source la ligne :
1 #!/usr/bin/python
on lance directement le programme :
$ ./mon_source.py
Le « ./ » indique au système de rechercher le script dans le répertoire courant.
3 Structure d’un source Python
Les instructions
Les commentaires vont du caractère # jusqu’à la fin de la ligne.
Il n’existe pas de commentaire en bloc comme en C (/* ... */).
Chaque instruction s’écrit sur un ligne, il n’y a pas de séparateur d’instruction. Si une ligne est
trop grande, le caractère \permet de passer à la ligne suivante.
Les blocs d’instructions
Les blocs d’instruction sont matérialisés par des indentations (plus de {et }!).
1 #!/usr/bin/python
2 # coding= latin1
3 # les modules utilises
4 import sys, socket
5 # le source utilisateur
6 if (a == 1) :
7 # sous bloc
8 # indente (1 ou 4 espaces)
Le caractère :sert à introduire les blocs.
La syntaxe est allégée, facile à lire et agréable (si si !).
La ligne 2, # coding= latin1, permet d’utiliser des accents dans le source Python.
4 Les variables
Une variable doit exister avant d’être référencée dans le programme Il faut l’instancier avant de s’en servir,
sinon il y aura une erreur (une exception sera levée comme nous le verrons plus loin).
1 print a # provoque une erreur car a n’existe pas
1 a = ’bonjour’
2 print a # fonctionne car a est définie
La variable est une référence vers une entité du langage
1 a = ’entite chaine de caracteres’
2 b = a
les variables aet bfont références à la même chaîne de caractères.
Une variable ne référençant rien, a pour valeur None.
Il n’existe pas de constante en Python (pour signifier une constante, on utilise un nom tout en majuscule).
Choix du nom des variables
Python est sensible à la casse, il fait la différence entre minuscules et majuscules.
Les noms des variables doivent être différents des mots réservés du langage.
Les mots réservés « Less is more ! »
and
assert
break
class
continue
def
del
elif
else
except
exec
finally
for
from
global
if
import
in
is
lambda
not
or
pass
print
raise
return
try
while
5 Les valeurs et types de base
Il existe des valeurs prédéfinies : True valeur booléenne vraie
False valeur booléenne vide
None objet vide retourné par certaines méthodes/fonctions
Python interprète tout ce qui n’est pas faux à vrai.
Est considéré comme faux : 0 ou 0.0 la valeur 0
”chaîne vide
"" chaîne vide
() liste non modifiable ou tuple vide
[] liste vide
{} dictionnaire vide
Et les pointeurs ?
Il n’existe pas de pointeur en Python : tous les éléments étant manipulés par référence, il n’y a donc
pas besoin de pointeurs explicites !
Quand deux variables référencent la même donnée, on parle « d’alias ».
On peut obtenir l’adresse d’une donnée (par exemple pour comparaison) avec la fonction id().

Cours Python « Mon’tit Python » – P-F. Bonnefoi – http://libpfb.so/ — 10 septembre 2012 — 4
6 Les structures de contrôle – Instructions & Conditions
Les séquences d’instructions
Une ligne contient une seule instruction. Mais il est possible de mettre plusieurs instructions
sur une même ligne en les séparant par des ;(syntaxe déconseillée).
1 a=1;b=2;c=a*b
Les conditions
Faire toujours attention aux tabulations !
1 if <test1> :
2 <instructions1>
3 elif <test2>:
4 <instructions2>
5 else:
6 <instructions3>
Lorsqu’une seule instruction compose la condition, il est possible de l’écrire en une seule ligne :
1 ifa>3:b=3*a
6.1 Les structures de contrôle – Itérations
Les itérations
La boucle while dépend d’une condition.
1 while <test>:
2 <instructions1>
3 else :
4 <instructions2>
Les ruptures de contrôle
continue continue directement à la prochaine itération de la
boucle
break sort de la boucle courante (la plus imbriquée)
pass instruction vide (ne rien faire)
Le else de la structure de contrôle n’est exécuté que si la boucle n’a pas été interrompue par un
break.
Boucle infinie
Il est souvent pratique d’utiliser une boucle while infinie (dont la condition est toujours vraie), et
d’utiliser les ruptures de séquences.
1 while 1:
2 if <condition> : break
7 Les opérateurs
Logique
or OU logique
and ET logique
not négation logique
Binaires (bit à bit)
|OU bits à bits
^OU exclusif
&ET
«décalage à gauche
»décalage à droite
Comparaison
<,>,<=,>=,==,!= inférieur, sup., inférieur ou égale, sup. ou égale, égale, différent
is, is not comparaison d’identité (même objet en mémoire)
1 c1= ’toto’
2 c2 = ’toto’
3 print c1 is c2, c1 == c2 # teste l’identité et teste le contenu
Arithmétique
+, -, *, /,//,% addition, soustraction, multiplication, division, division entière, modulo
+=,-=,... opération +affectation de la valeur modifiée
Python v3
L’opérateur <> est remplacé définitivement par !=.
L’opérateur /retourne toujours un flottant, et // est utilisé pour la division entière.
8 La gestion des caractères
Il n’existe pas de type caractère mais seulement des chaînes contenant un caractère unique.
Une chaîne est délimitée par des ’ou des "ce qui permet d’en utiliser dans une chaîne :
1 le_caractere = ’c’
2 a = "une chaine avec des ’quotes’" # ou ’une chaine avec des "doubles quotes"’
3 print len(a) # retourne 28
La fonction len() permet d’obtenir la longueur d’une chaîne. Il est possible d’écrire une chaîne
contenant plusieurs lignes sans utiliser le caractère ’\n’, en l’entourant de 3 guillemets :
1 texte =""" premiere ligne
2 deuxieme ligne"""
Pour pouvoir utiliser le caractère d’échappement dans une chaîne il faut la faire précéder de r
(pour raw) :
1 une_chaine = r’pour passer à la ligne il faut utiliser \n dans une chaine’
En particulier, ce sera important lors de l’entrée d’expressions régulières.
Concaténation
Il est possible de concaténer deux chaines de caractères avec l’opérateur +:
1 a = "ma chaine"+" complete"

Cours Python « Mon’tit Python » – P-F. Bonnefoi – http://libpfb.so/ — 10 septembre 2012 — 5
9 Les chaînes de caractères
Il est possible d’insérer le contenu d’une variable dans une chaîne de caractères à l’aide du %.
1 a = 120
2 b = ’La valeur est %d’ % a # b contient la chaîne ’La valeur est 120’
Les caractères de formatage sont :
%s chaîne de caractères, en fait récupère le résultat de la commande str()
%f valeur flottante, par ex. %.2f pour indiquer 2 chiffres après la virgule
%d un entier
%x entier sous forme hexadécimal
Les chaînes sont des objets −→ un objet offre des méthodes
Les chaînes proposent différentes méthodes :
rstrip supprime les caractères en fin de chaîne (par ex. le retour à la ligne)
Exemple : chaine.rstrip(’\n ’)
upper passe en majuscule
Exemple : chaine.upper()
splitlines décompose une chaîne suivant les lignes et retourne une liste de « lignes », sous
forme d’une liste de chaîne de caractères.
etc.
10 Les listes
Ces listes peuvent contenir n’importe quel type de données.
Il existe deux types de listes :
1. celles qui ne peuvent être modifiées, appelées tuples ;
2. les autres, qui sont modifiables, appelées simplement liste !
Les tuples
Il sont notés sous forme d’éléments entre parenthèses séparés par des virgules.
1 a = (’un’, 2, ’trois’)
Une liste d’un seul élément correspond à l’élément lui-même
La fonction len() renvoie le nombre d’éléments de la liste.
Les listes modifiables
Elles sont notées sous forme d’éléments entre crochets séparés par des virgules.
Elles correspondent à des objets contrairement aux tuples.
1 a = [10, ’trois’, 40]
Les méthodes sont :
append(e) ajoute un élément e pop() enlève le dernier élément
pop(i) retire le ième élément extend concaténe deux listes
sort trie les éléments reverse inverse l’ordre des éléments
index(e) retourne la position de l’élément e
10.1 Les listes — Exemples d’utilisation
1 a = [1, ’deux’, 3]
2 a.append(’quatre’)
3 print a
[1, ’deux’, 3, ’quatre’]
4 element = a.pop()
5 print element, a
quatre [1, ’deux’, 3]
6 a.sort()
7 print a
[1, 3, ’deux’]
8 a.reverse()
9 print a
[’deux’, 3, 1]
10 print a.pop(0)
deux
10.2 Les listes — Utilisation comme « pile » et « file »
Pour une approche « algorithmique » de la programmation, il est intéressant de pouvoir disposer
des structures particulières que sont les piles et files.
La pile
empiler ma_pile.append(element)
dépiler element = ma_pile.pop()
>>> ma_pile = []
>>> ma_pile.append(’sommet’)
>>> ma_pile
[’sommet’]
>>> element = ma_pile.pop()
>>> element
’sommet’
La file
enfiler ma_file.append(element)
defiler element = ma_file.pop(0)
>>> ma_file = []
>>> ma_file.append(’premier’)
>>> ma_file.append(’second’)
>>> element = ma_file.pop(0)
>>> element
’premier’
Attention
Si « element » est une liste, alors il ne faut pas utiliser la méthode append mais extend.