Introduction au langage Python 2 par l'exemple

IV. Les bases▲

IV-A. Un exemple de programme Python▲

Ci-dessous, on trouvera un programme présentant les premières caractéristiques de Python.

Programme (bases_01)

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.

# -*- coding=utf-8 -*-

# ----------------------------------
def affiche(chaine):
    # affiche chaine
    print "chaine=%s" % (chaine)


# ----------------------------------
def afficheType(variable):
    # affiche le type de variable
    print "type[%s]=%s" % (variable,type(variable))

# ----------------------------------
def f1(param):
    # ajoute 10 à param
    return param+10

# ----------------------------------
def f2():
    # rend 3 valeurs
    return ("un",0,100);


# -------------------------------- programme principal ------------------------------------
# ceci est un commentaire
# variable utilisée sans avoir été déclarée
nom="dupont"

# un affichage écran
print "nom=%s" % (nom)

# une liste avec des éléments de types différents
liste=["un","deux",3,4]

# son nombre d'éléments
n=len(liste)

# une boucle
for i in range(n):
  print "liste[%d]=%s" % (i,liste[i])

# initialisation de 2 variables avec un tuple
(chaine1,chaine2)=("chaine1","chaine2")

# concaténation des 2 chaînes
chaine3=chaine1+chaine2

# affichage résultat
print "[%s,%s,%s]" % (chaine1,chaine2,chaine3)

# utilisation fonction
affiche(chaine1)

# le type d'une variable peut être connu
afficheType(n)
afficheType(chaine1)
afficheType(liste)

# le type d'une variable peut changer en cours d'exécution
n="a change"
afficheType(n)

# une fonction peut rendre un résultat
res1=f1(4)
print "res1=%s" % (res1)

# une fonction peut rendre une liste de valeurs
(res1,res2,res3)=f2()
print "(res1,res2,res3)=[%s,%s,%s]" % (res1,res2,res3)

# on aurait pu récupérer ces valeurs dans une variable
liste=f2()
for i in range(len(liste)):
    print "liste[%s]=%s" % (i, liste[i])

# des tests
for i in range(len(liste)):
    # n'affiche que les chaînes
    if (type(liste[i])=="str"):
        print "liste[%s]=%s" % (i,liste[i])

# d'autres tests
for i in range(len(liste)):
    # n'affiche que les entiers >10
    if (type(liste[i])=="int" and liste[i]>10):
        print "liste[%s]=%s" % (i,liste[i])

# une boucle while
liste=(8,5,0,-2,3,4)
i=0
somme=0
while(i<len(liste) and liste[i]>0):
    print "liste[%s]=%s" % (i,liste[i])
    somme+=liste[i] #somme=somme+t[i]
    i+=1 #i=i+1
print "somme=%s" % (somme)
# fin programme

À noter :

ligne 1 : un commentaire particulier servant à déclarer le type d'encodage du script, ici UTF-8. Cela est dépendant de l'éditeur de texte utilisé. Ici avec Notepad++ :

ligne 4 : le mot-clé def définit une fonction ;
lignes 5-6 : le contenu de la fonction. Il est décalé à droite d'une tabulation. C'est cette indentation associée au caractère : de l'instruction def qui définit le contenu de la fonction. Cela est vrai pour toutes les instructions ayant du contenu : if, else, while, for, try, except ;
ligne 12 : Python gère en interne le type des variables. On peut connaître le type d'une variable avec la fonction type(variable) qui rend une variable de type 'type'. L'expression '%s' % (type(variable)) est une chaîne de caractères représentant le type de la variable ;
ligne 25 : le programme principal. Celui-ci vient après la définition de toutes les fonctions du script. Son contenu est non indenté ;
ligne 28 : en Python, on ne déclare pas les variables. Python est sensible à la casse. La variable Nom est différente de la variable nom. Une chaîne de caractères peut être entourée de guillemets " ou d'apostrophes '. On peut donc écrire 'dupont' ou "dupont" ;
ligne 31 : l'expression "xxxx%syyyy%szzzz" % (100, 200) est la chaîne de caractères "xxxx100yyy200szzzz" où chaque %s a été remplacé par un élément du tuple. %s est le format d'affichage des chaînes de caractères. Il existe d'autres formats ;
ligne 34 : il y a une différence entre un tuple (1,2,3) (notez les parenthèses) et une liste [1,2,3] (notez les crochets). Le tuple est non modifiable alors que la liste l'est. Dans les deux cas, l'élément n° i est noté [i] ;
ligne 40 : range(n) est le tuple (0,1,2,…,n-1) ;
ligne 74 : len(var) est le nombre d'éléments de la collection var (tuple, liste, dictionnaire…) ;
ligne 86 : les autres opérateurs booléens sont or et not.

Les résultats écran sont les suivants :

Résultats

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

nom=dupont
liste[0]=un
liste[1]=deux
liste[2]=3
liste[3]=4
[chaine1,chaine2,chaine1chaine2]
chaine=chaine1
type[4]=<type 'int'>
type[chaine1]=<type 'str'>
type[['un', 'deux', 3, 4]]=<type 'list'>
type[a change]=<type 'str'>
res1=14
(res1,res2,res3)=[un,0,100]
liste[0]=un
liste[1]=0
liste[2]=100
liste[0]=8
liste[1]=5
somme=13

IV-B. Changements de type▲

On s'intéresse ici aux changements de type avec des données de type str (chaîne de caractères), int (entier), float (réel), bool (booléen).

Programme (bases_01b)

Sélectionnez

# -*- coding=utf-8 -*-

# changements de type
# int --> str, float, bool
x=4
print x, type(x)
x=str(4)
print x, type(x)
x=float(4)
print x, type(x)
x=bool(4)
print x, type(x)

# bool --> int, float, str
x=True
print x, type(x)
x=int(True)
print x, type(x)
x=float(True)
print x, type(x)
x=str(True)
print x, type(x)

# str --> int, float, bool
x="4"
print x, type(x)
x=int("4")
print x, type(x)
x=float("4")
print x, type(x)
x=bool("4")
print x, type(x)

# float --> str, int, bool
x=4.32
print x, type(x)
x=str(4.32)
print x, type(x)
x=int(4.32)
print x, type(x)
x=bool(4.32)
print x, type(x)

# gestion des erreurs de changement de type
try:
    x=int("abc")
    print x, type(x)
except ValueError, erreur:
    print erreur

# cas divers du booléen
x=bool("abc")
print x, type(x)
x=bool("")
print x, type(x)
x=bool(0)
print x, type(x)
x=None
print x, type(x)
x=bool(None)
print x, type(x)

De nombreux changements de type sont possibles. Certains peuvent échouer, comme celui des lignes 45-49 qui essaient de transformer la chaîne 'abc' en nombre entier. On a géré l'erreur avec une structure try / except. Une forme générale de cette structure est la suivante :

Sélectionnez

1.
2.
3.
4.
5.
6.

try:
    actions
except Exception, Message:
    actions
finally:
    actions

Si l'une des actions du try provoque une exception (signale une erreur), il y a branchement immédiat sur la clause except. Si les actions du try ne lancent pas d'exception, la clause except est ignorée. Les attributs Exception et Message de l'instruction except sont facultatifs. Lorsqu'ils sont présents, Exception précise le type d'exception interceptée par l'instruction except et Message contient le message d'erreur lié à l'exception. Il peut y avoir plusieurs instructions except, si on veut gérer différents types d'exception dans le même try.

L'instruction finally est facultative. Si elle est présente, les actions du finally sont toujours exécutées qu'il y ait eu exception ou non.

Nous reviendrons sur les exceptions un peu plus loin.

Les lignes 52-61 montrent diverses tentatives pour transformer (ou caster) une donnée de type str, int, float, NoneType en booléen. C'est toujours possible. Les règles sont les suivantes :

bool(int i) vaut False si i vaut 0, True dans tous les autres cas ;
bool(float f) vaut False si f vaut 0.0, True dans tous les autres cas ;
bool(str chaine) vaut False si chaine a 0 caractère, True dans tous les autres cas ;
bool(None) vaut False. None est une valeur spéciale qui signifie que la variable existe mais n'a pas de valeur.

Les résultats écran sont les suivants :

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

4 <type 'int'>
4 <type 'str'>
4.0 <type 'float'>
True <type 'bool'>
True <type 'bool'>
1 <type 'int'>
1.0 <type 'float'>
True <type 'str'>
4 <type 'str'>
4 <type 'int'>
4.0 <type 'float'>
True <type 'bool'>
4.32 <type 'float'>
4.32 <type 'str'>
4 <type 'int'>
True <type 'bool'>
invalid literal for int() with base 10: 'abc'
True <type 'bool'>
False <type 'bool'>
False <type 'bool'>
None <type 'NoneType'>
False <type 'bool'>
False <type 'bool'>

IV-C. La portée des variables▲

Programme (bases_02)

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.

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

Sélectionnez

1.
2.
3.
4.

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.

IV-D. Les listes, tuples et dictionnaires▲

IV-D-1. Listes à une dimension▲

Programme (bases_03)

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.

# -*- 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)

# ajout en début de liste d'un tuple
list1[:0]=[-10, -11, -12]
print ("%s") % (list1)

# insertion en milieu de liste de deux éléments
list1[3:3]=[100,101]
print ("%s") % (list1)

# 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

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.

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)

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.

# -*- 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.

IV-D-2. Le dictionnaire▲

Le programme (bases_04)

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.

# -*- 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)


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

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.

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'}

IV-D-3. Les tuples▲

Programme (bases_05)

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

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

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.

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é.

IV-D-4. Les listes à plusieurs dimensions▲

Programme (bases_06)

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.

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

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.

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

IV-D-5. Liens entre chaînes et listes▲

Programme (bases_07)

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.

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

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.

<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', '', '']

IV-E. Les expressions régulières▲

Programme (bases_09)

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.

# -*- 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+).*?$"

# on confronte la chaîne au modèle
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

# 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+)(.*?)$"

# on confronte la chaîne au modèle
compare(modele,"xyz1234abcd")
compare(modele,"12 34")
compare(modele,"abcd")

# 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")

# 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

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.

Resultats(xyz1234abcd,^.*?(\d+).*?$)
('1234',)

Resultats(12 34,^.*?(\d+).*?$)
('12',)

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*$)
('04', '04', '01')

Resultats(5/1/01,^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$)
La chaine [5/1/01] ne correspond pas au modele [^\s*(\d\d)\/(\d\d)\/(\d\d)\s*$]

Resultats(187.8,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '187.8')

Resultats(-0.6,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('-', '0.6')

Resultats(4,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '4')

Resultats(.6,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '.6')

Resultats(4.,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('', '4.')

Resultats( + 4,^\s*([+|-]?)\s*(\d+\.\d*|\.\d+|\d+)\s*$)
('+', '4')

IV-F. Mode de passage des paramètres des fonctions▲

Programme (bases_10)

Sélectionnez

1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.

# -*- coding=utf-8 -*-

def f1(a):
    a=2

def f2(a,b):
    a=2
    b=3
    return (a,b)
  
# ------------------------ main
x=1
f1(x)
print "x=%s" % (x)
(x,y)=(-1,-1)
(x,y)=f2(x,y)
print "x=%s, y=%s" % (x,y)

Résultats

Sélectionnez

1.
2.

x=1
x=2, y=3

Notes :

tout est objet en Python. Certains objets sont dits "immutable" : on ne peut pas les modifier. C'est le cas des nombres, des chaînes de caractères, des tuples. Lorsque des objets Python sont passés en paramètres à des fonctions, ce sont leurs références qui sont passées sauf si ces objets sont "immutable" auquel cas, c'est la valeur de l'objet qui est passée ;
les fonctions f1 (ligne 3), et f2 (ligne 6) veulent illustrer le passage d'un paramètre de sortie. On veut que le paramètre effectif d'une fonction soit modifié par la fonction ;
lignes 3-4 : la fonction f1 modifie son paramètre formel a. On veut savoir si le paramètre effectif va lui aussi être modifié ;
lignes 12-13 : le paramètre effectif est x=1. Le résultat de la ligne 1, montre que le paramètre effectif n'est pas modifié. Ainsi le paramètre effectif x et le paramètre formel a sont deux objets différents ;
lignes 6-9 : la fonction f2 modifie ses paramètres formels a et b, et les rend comme résultats ;
lignes 15-16 : on passe à f2 les paramètres effectifs (x,y) et le résultat de f2 est remis dans (x,y). La ligne 2 des résultats montre que les paramètres effectifs (x,y) ont été modifiés.

On en conclut donc que lorsque des objets "immutable" sont des paramètres de sortie, il faut qu'ils fassent partie des résultats renvoyés par la fonction.

IV-G. Les fichiers texte▲

Programme (bases_11)

Sélectionnez

# -*- coding=utf-8 -*-

import sys

# exploitation séquentielle d'un fichier texte
# celui-ci est un ensemble de lignes de la forme login:pwd:uid:gid:infos:dir:shell
# chaque ligne est mise dans un dictionnaire sous la forme login => [uid,gid,infos,dir,shell]

# --------------------------------------------------------------------------
def afficheInfos(dico,cle):
    # affiche la valeur associée à cle dans le dictionnaire dico si elle existe
    valeur=None
    if dico.has_key(cle):
        valeur=dico[cle]
    if 'list' in str(type(valeur)):
        print "[{0},{1}]".format(cle,":".join(valeur))
    else:
        # cle n'est pas une clé du dictionnaire dico
        print "la cle [{0}] n'existe pas".format(cle)           


def cutNewLineChar(ligne):
    # on supprime la marque de fin de ligne de ligne si elle existe
    l=len(ligne);
    while(ligne[l-1]=="\n" or ligne[l-1]=="\r"):
        l-=1
    return(ligne[0:l]);
    
# on fixe le nom du fichier
INFOS="infos.txt"

# on l'ouvre en création
try:
    fic=open(INFOS,"w")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# on génère un contenu arbitraire
for i in range(1,101):
    ligne="login%s:pwd%s:uid%s:gid%s:infos%s:dir%s:shell%s" % (i,i,i,i,i,i,i)
    fic.write(ligne+"\n")

# on ferme le fichier
fic.close()

# on l'ouvre en lecture
try:
    fic=open(INFOS,"r")
except:
    print "Erreur d'ouverture du fichier INFOS en écriture\n"
    sys.exit()

# dictionnaire vide au départ
dico={}

# lecture ligne  
ligne=fic.readline()  
while(ligne!=''):
    # on enlève le caractère de fin de ligne
    ligne=cutNewLineChar(ligne)
  
    # on met la ligne dans un tableau
    infos=ligne.split(":")
  
    # on récupère le login
    login=infos[0]
  
    # on enlève les deux premiers éléments [login,pwd]
    infos[0:2]=[]
  
    # on crée une entrée dans le dictionnaire
    dico[login]=infos
  
    # lecture ligne  
    ligne=fic.readline()  

# on ferme le fichier
fic.close()

# exploitation du dictionnaire
afficheInfos(dico,"login10")
afficheInfos(dico,"X")

Notes :

ligne 37 : pour terminer le script au milieu du code.

Le fichier infos.txt

Sélectionnez

1.
2.
3.
4.
5.
6.

login0:pwd0:uid0:gid0:infos0:dir0:shell0
login1:pwd1:uid1:gid1:infos1:dir1:shell1
login2:pwd2:uid2:gid2:infos2:dir2:shell2
...
login98:pwd98:uid98:gid98:infos98:dir98:shell98
login99:pwd99:uid99:gid99:infos99:dir99:shell99

Les résultats écran

Sélectionnez

1.
2.

[login10,uid10:gid10:infos10:dir10:shell10]
la cle [X] n'existe pas