Introduction au langage Python par l’exemple

La portée des variables

Programme (bases_02)
# -*- coding=utf-8 -*-
# portée des variables
def f1():
# on utilise la variable globale i
global i
i+=1
j=10
print « f1[i,j]=[%s,%s] » % (i,j)
def f2():
# on utilise la variable globale i
global i
i+=1
j=20
print « f2[i,j]=[%s,%s] » % (i,j)
def f3():
# on utilise une variable locale i
i=1
j=30
print « f3[i,j]=[%s,%s] » % (i,j)
# tests
i=0
j=0 # ces deux variables ne sont connues d’une fonction f
# que si celle-ci déclare explicitement par l’instruction global
# qu’elle veut les utiliser
f1()
f2()
f3()
print « test[i,j]=[%s,%s] » % (i,j)
Résultats
f1[i,j]=[1,10]
f2[i,j]=[2,20]
f3[i,j]=[1,30]
test[i,j]=[2,0]
Note :
le script montre l’utilisation de la variable i, déclarée globale dans les fonctions f1 et f2. Dans ce cas, le programme principal et les fonctions f1 et f2 partagent la même variable i.

Les listes, tuples et dictionnaires

Listes à une dimension

Programme (bases_03)
# -*- coding=utf-8 -*-
# listes à 1 dimension
# initialisation
list1=[0,1,2,3,4,5]
# parcours – 1
print « list1 a %s elements » % (len(list1))
for i in range(len(list1)):
print « list1[%s]=%s » % (i, list1[i])
list1[1]=10;
# parcours – 2
print « list1 a %s elements » % (len(list1))
for element in list1:
print element
# ajout de deux éléments
list1[len(list1):]=[10,11]
print (« %s ») % (list1)
# suppression des deux derniers éléments
list1[len(list1)-2:]=[]
print (« %s ») % (list1)
25.
# ajout en début de liste d’un tuple
list1[:0]=[-10, -11, -12]
print (« %s ») % (list1)
29.
# insertion en milieu de liste de deux éléments
list1[3:3]=[100,101]
print (« %s ») % (list1)
33.
# suppression de deux éléments en milieu de liste
list1[3:4]=[]
print (« %s ») % (list1)
Notes :
la notation tableau[i:j] désigne les éléments i à j-1 du tableau ;
la notation [i:] désigne les éléments i et suivants du tableau ;
la notation [:i] désigne les éléments 0 à i-1 du tableau ;
ligne 20 : print (%s) % (list1) affiche la chaîne de caractères : « [ list1[0], list1[2], …, list1[n-1]] ».
Résultats
list1 a 6 elements
list1[0]=0
list1[1]=1
list1[2]=2
list1[3]=3
list1[4]=4
list1[5]=5
list1 a 6 elements
0
10
2
3
4
5
[0, 10, 2, 3, 4, 5, 10, 11]
[0, 10, 2, 3, 4, 5]
[-10, -11, -12, 0, 10, 2, 3, 4, 5]
[-10, -11, -12, 100, 101, 0, 10, 2, 3, 4, 5]
[-10, -11, -12, 101, 0, 10, 2, 3, 4, 5]
Le code précédent peut être écrit différemment (bases_03b) en utilisant certaines méthodes des listes :
Programme (bases_03b)
# -*- coding=utf-8 -*-
# listes à 1 dimension
# initialisation
list1=[0,1,2,3,4,5]
# parcours – 1
print « list1 a %s elements » % (len(list1))
for i in range(len(list1)):
print « list1[%s]=%s » % (i, list1[i])
list1[1]=10
# parcours – 2
print « list1 a %s elements » % (len(list1))
for element in list1:
print element
# ajout de deux éléments
list1.extend([10,11])
print (« %s ») % (list1)
# suppression des deux derniers éléments
del list1[len(list1)-2:]
print (« %s ») % (list1)
# ajout en début de liste d’un tuple
for i in (-12, -11, -10):
list1.insert(0,i)
print (« %s ») % (list1)
# insertion en milieu de liste
for i in (101,100):
list1.insert(3,i)
print (« %s ») % (list1)
# suppression en milieu de liste
del list1[3:4]
print (« %s ») % (list1)
Les résultats obtenus sont les mêmes qu’avec la version précédente.

Le dictionnaire

Le programme (bases_04)
# -*- coding=utf-8 -*-
def existe(conjoints,mari):
# vérifie si la clé mari existe dans le dictionnaire conjoints
if(conjoints.has_key(mari)):
print « La cle [%s] existe associee a la valeur [%s] » % (mari, conjoints[mari])
else:
print « La cle [%s] n’existe pas » % (mari)
9.
10.
# —————————– Main
# dictionnaires
conjoints={« Pierre »: »Gisele », « Paul »: »Virginie », « Jacques »: »Lucette », »Jean »: » »}
# parcours – 1
print « Nombre d’elements du dictionnaire : %s  » % (len(conjoints))
for (cle,valeur) in conjoints.items():
print « conjoints[%s]=%s » % (cle,valeur)
# liste des clés du dictionnaire
print « liste des cles————- »
cles=conjoints.keys()
print (« %s ») % (cles)
# liste des valeurs du dictionnaire
print « liste des valeurs———— »
valeurs=conjoints.values()
print (« %s ») % (valeurs)
# recherche d’une clé
existe(conjoints, »Jacques »)
existe(conjoints, »Lucette »)
existe(conjoints, »Jean »)
# suppression d’une clé-valeur
del (conjoints[« Jean »])
print « Nombre d’elements du dictionnaire : %s  » % (len(conjoints))
print (« %s ») % (conjoints)
Notes :
ligne 17 : conjoints.items() rend la liste des couples (clé,valeur) du dictionnaire conjoints ;
ligne 22 : conjoints.keys() rend les clés du dictionnaire conjoints ;
ligne 27 : conjoints.values() rend les valeurs du dictionnaire conjoints ;
ligne 5 : conjoints.has_key(mari) rend True si la clé mari existe dans le dictionnaire conjoints, False sinon ; ligne 38 : un dictionnaire peut être affiché en une seule ligne.
Les résultats
Nombre d’elements du dictionnaire : 4
conjoints[Paul]=Virginie
conjoints[Jean]=
conjoints[Pierre]=Gisele
conjoints[Jacques]=Lucette
liste des cles————-
[‘Paul’, ‘Jean’, ‘Pierre’, ‘Jacques’]
liste des valeurs————
[‘Virginie’,  », ‘Gisele’, ‘Lucette’]
La cle [Jacques] existe associee a la valeur [Lucette]
La cle [Lucette] n’existe pas
La cle [Jean] existe associee a la valeur []
Nombre d’elements du dictionnaire : 3
{‘Paul’: ‘Virginie’, ‘Pierre’: ‘Gisele’, ‘Jacques’: ‘Lucette’}

Les tuples

Programme (bases_05)
# -*- coding=utf-8 -*-
# tuples
# initialisation
tab1=(0,1,2,3,4,5)
# parcours – 1
print « tab1 a %s elements » % (len(tab1))
for i in range(len(tab1)):
print « tab1[%s]=%s » % (i, tab1[i])
# parcours – 2
print « tab1 a %s elements » % (len(tab1))
for element in tab1:
print element
# modification d’un élément
tab1[0]=-1
Les résultats
tab1 a 6 elements
tab1[0]=0
tab1[1]=1
tab1[2]=2
tab1[3]=3
tab1[4]=4
tab1[5]=5
tab1 a 6 elements
0
1
2
3
4
5
Traceback (most recent call last):
File « exemple_05.py », line 18, in <module>
tab1[0]=-1
TypeError: ‘tuple’ object does not support item assignment
Notes :
lignes 15-18 des résultats : montre qu’un tuple ne peut pas être modifié.

Les listes à plusieurs dimensions

Programme (bases_06)
# -*- coding=utf-8 -*-
# listes multidimensionnelles
# initialisation
multi=[[0,1,2], [10,11,12,13], [20,21,22,23,24]]
# parcours
for i1 in range(len(multi)):
for i2 in range(len(multi[i1])):
print « multi[%s][%s]=%s » % (i1,i2,multi[i1][i2])
# dictionnaires multidimensionnels
# initialisation
multi={« zero »:[0,1], « un »:[10,11,12,13], « deux »:[20,21,22,23,24]}
# parcours
for (cle,valeur) in multi.items():
for i2 in range(len(multi[cle])):
print « multi[%s][%s]=%s » % (cle,i2,multi[cle][i2])
Résultats
multi[0][0]=0
multi[0][1]=1
multi[0][2]=2
multi[1][0]=10
multi[1][1]=11
multi[1][2]=12
multi[1][3]=13
multi[2][0]=20
multi[2][1]=21
multi[2][2]=22
multi[2][3]=23
multi[2][4]=24
multi[zero][0]=0
multi[zero][1]=1
multi[un][0]=10
multi[un][1]=11
multi[un][2]=12
multi[un][3]=13
multi[deux][0]=20
multi[deux][1]=21
multi[deux][2]=22
multi[deux][3]=23
multi[deux][4]=24

Liens entre chaînes et listes

Programme (bases_07)
# -*- coding=Utf-8 -*-
# chaîne vers liste
chaine=’1:2:3:4′
tab=chaine.split(‘:’)
print type(tab)
# affichage liste
print « tab a %s elements » % (len(tab))
print (« %s ») % (tab)
# liste vers chaîne
chaine2= »: ».join(tab)
print « chaine2=%s » % (chaine2)
# ajoutons un champ vide
chaine+= »: »
print « chaine=%s » % (chaine)
tab=chaine.split(« : »)
# affichage liste
print « tab a %s elements » % (len(tab))
print (« %s ») % (tab)
# ajoutons de nouveau un champ vide
chaine+= »: »
print « chaine=%s » % (chaine)
tab=chaine.split(« : »)
# affichage liste
print « tab a %s elements » % (len(tab))
print (« %s ») % (tab)
Notes :
ligne 5 : la méthode chaine.split(séparateur) découpe la chaîne de caractères chaine en éléments séparés par séparateur et les rend sous forme de liste. Ainsi l’expression ‘1:2:3:4’.split(« : ») a pour valeur la liste (‘1′,’2′,’3′,’4’) ;
ligne 13 : ‘separateur’.join(liste) a pour valeur la chaîne de caractères ‘liste[0]+separateur+liste[1]+separateur +…’.
Résultats
<type ‘list’>
tab a 4 elements
[‘1’, ‘2’, ‘3’, ‘4’]
chaine2=1:2:3:4
chaine=1:2:3:4:
tab a 5 elements
[‘1’, ‘2’, ‘3’, ‘4’,  »]
chaine=1:2:3:4::
tab a 6 elements
[‘1’, ‘2’, ‘3’, ‘4’,  »,  »]

Les expressions régulières

Programme (bases_09)
# -*- coding=utf-8 -*-
import re
# ————————————————————————–
def compare(modele,chaine):
# compare la chaine chaîne au modèle modele
# affichage résultats
print « \nResultats(%s,%s) » % (chaine,modele)
match=re.match(modele,chaine)
if match:
print match.groups()
else:
print « La chaine [%s] ne correspond pas au modele [%s] » % (chaine,modele)
# expressions régulières en python
# récupérer les différents champs d’une chaîne
# le modèle : une suite de chiffres entourée de caractères quelconques
# on ne veut récupérer que la suite de chiffres
modele=r »^.*?(\d+).*?$ »
22.
# on confronte la chaîne au modèle
compare(modele, »xyz1234abcd »)
compare(modele, »12 34″)
compare(modele, »abcd »)
27.
# le modèle : une suite de chiffres entourée de caractères quelconques
# on veut la suite de chiffres ainsi que les champs qui suivent et précèdent
modele=r »^(.*?)(\d+)(.*?)$ »
31.
# on confronte la chaîne au modèle
compare(modele, »xyz1234abcd »)
compare(modele, »12 34″)
compare(modele, »abcd »)
36.
# le modèle – une date au format jj/mm/aa
modele=r »^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$ »
compare(modele, »10/05/97″)
compare(modele, » 04/04/01 « )
compare(modele, »5/1/01″)
42.
# le modèle – un nombre décimal
modele=r »^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$ »
compare(modele, »187.8″)
compare(modele, »-0.6″)
compare(modele, »4″)
compare(modele, ».6″)
compare(modele, »4. »)
compare(modele, » + 4″)
# fin
Notes :
noter le module importé en ligne 3. C’est lui qui contient les fonctions de gestion des expressions régulières ;
ligne 10 : la comparaison d’une chaîne à une expression régulière (modèle) rend le booléen True si la chaîne correspond au modèle, False sinon ;
ligne 12 : match.groups() est un tuple dont les éléments sont les parties de la chaîne qui correspondent aux éléments de l’expression régulière entourés de parenthèses. Dans le modèle :
^.*?(\d+).*?, match.groups() sera un tuple d’un élément ;
^(.*?)(\d+)(.*?)$, match.groups() sera un tuple de trois éléments.
Résultats
Resultats(xyz1234abcd,^.*?(\d+).*?$)
(‘1234′,)
3.
Resultats(12 34,^.*?(\d+).*?$)
(’12’,)
6.
Resultats(abcd,^.*?(\d+).*?$)
La chaine [abcd] ne correspond pas au modele [^.*?(\d+).*?$]
Resultats(xyz1234abcd,^(.*?)(\d+)(.*?)$)
(‘xyz’, ‘1234’, ‘abcd’)
Resultats(12 34,^(.*?)(\d+)(.*?)$)
( », ’12’, ‘ 34′)
Resultats(abcd,^(.*?)(\d+)(.*?)$)
La chaine [abcd] ne correspond pas au modele [^(.*?)(\d+)(.*?)$]
Resultats(10/05/97,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
(’10’, ’05’, ’97’)
Resultats( 04/04/01 ,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)

III – Installation d’un interpréteur Python
III-A – ActivePython
III-B – Python Tools for Visual Studio
IV – Les bases
IV-A – Un exemple de programme Python
IV-B – Changements de type
IV-C – La portée des variables
IV-D – Les listes, tuples et dictionnaires
IV-D-1 – Listes à une dimension
IV-D-2 – Le dictionnaire
IV-D-3 – Les tuples
IV-D-4 – Les listes à plusieurs dimensions
IV-D-5 – Liens entre chaînes et listes
IV-E – Les expressions régulières
IV-F – Mode de passage des paramètres des fonctions
IV-G – Les fichiers texte
V – Exercice d’application – [IMPÔTS]
V-A – Le problème
V-B – Version avec listes
V-C – Version avec fichiers texte
VI – Les classes et objets
VI-A – Une classe Objet
VI-B – Une classe Personne
VI-C – La classe Personne avec un constructeur
VI-D – La classe Personne avec contrôles de validité dans le constructeur
VI-E – Ajout d’une méthode faisant office de second constructeur
VI-F – Une liste d’objets Personne
VI-G – Création d’une classe dérivée de la classe Personne
VI-H – Création d’une seconde classe dérivée de la classe Personne
VII – Les exceptions
VIII – Architecture en couches et programmation par interfaces
VIII-A – Introduction
VIII-B – Les entités de l’application
VIII-C – La couche [dao]
VIII-D – La couche [métier]
VIII-E – La couche [console]
IX – Exercice d’application – [IMPOTS] avec objets
IX-A – La couche [DAO]
IX-B – La couche [metier]
IX-C – La couche [console]
IX-D – Résultats
X – Utilisation du SGBD MySQL
X-A – Installation du module MySQLdb
X-B – Installation de MySQL
X-C – Connexion à une base MySQL – 1
X-D – Connexion à une base MySQL – 2
X-E – Création d’une table MySQL
X-F – Remplissage de la table [personnes]
X-G – Exécution de requêtes SQL quelconques
XI – Exercice [IMPOTS] avec MySQL
XI-A – Transfert d’un fichier texte dans une table MySQL
XI-B – Le programme de calcul de l’impôt
XI-C – La classe [ImpotsMySQL]
XI-D – Le script console
XII – Les fonctions réseau de Python
XII-A – Obtenir le nom ou l’adresse IP d’une machine de l’Internet
XII-B – Un client Web
XII-C – Un client SMTP
XII-D – Un second client SMTP
XII-E – Client / serveur d’écho
XII-F – Serveur Tcp générique
XIII – Des services Web en Python
XIII-A – Application client/ serveur de date/heure
XIII-A-1 – Le serveur
XIII-A-2 – Deux tests
XIII-A-3 – Un client programmé
XIII-B – Récupération par le serveur des paramètres envoyés par le client
XIII-B-1 – Le service Web
XIII-B-2 – Le client GET
XIII-B-3 – Le client POST
XIII-C – Récupération des variables d’environnement d’un service Web
XIII-C-1 – Le service Web
XIII-C-2 – Le client programmé
XIV – Exercice [IMPOTS] avec un service Web
XIV-A – Le serveur
XIV-B – Un client programmé
XV – Traitement de documents XML
XVI – Exercice [IMPOTS] avec XML
XVI-A – Le service Web
XVI-B – Le client programmé