Tutoriel Python

Maintenant que vous êtes tout excité par Python, vous voudrez l'examiner plus en détail. Puisque la meilleure façon d'apprendre un langage est de l'utiliser, vous êtes invité à le faire dès maintenant.

Dans le chapitre suivant, les éléments nécessaires à l'utilisation de l'interpréteur sont expliqués. Ce sont des informations plutôt rébarbatives, mais essentielles pour pouvoir tester les exemples donnés plus loin.

Le reste de ce tutoriel présentera les différentes caractéristiques du langage et du système Python à travers des exemples, en commençant par les expressions, instructions et types de données simples, puis les fonctions et modules, et enfin en survolant des concepts avancés comme les exceptions et les classes définies par l'utilisateur.

L'interpréteur Python est habituellement installé à l'emplacement /usr/local/bin/python sur les machines Unix sur lesquelles il est disponible ; placer /usr/local/bin dans le path de votre shell Unix permet de le lancer en tapant la commande

python

sous le shell. Puisque le choix du répertoire dans lequel est installé l'interpréteur est une option d'installation, d'autres endroits sont possibles ; vérifiez avec votre gourou Python local ou votre administrateur système. (Par exemple, /usr/local/python est un autre emplacement populaire.)

Tapez le caractère EOF (Control-D sur Unix, Control-Z sur DOS ou Windows) à l'invite (prompt) principale pour quitter l'interpréteur avec un code de retour de zéro. Si ça ne marche pas, vous pouvez quitter l'interpréteur en tapant les commandes suivantes : "import sys; sys.exit()".

Les fonctions d'édition de ligne de l'interpréteur ne sont habituellement pas très sophistiquées. Sur Unix, celui qui a installé l'interpréteur peut avoir activé le support de la bibliothèque GNU Readline, qui ajoute une édition interactive plus élaborée et des fonctions d'historique. Peut-être la vérification la plus rapide pour savoir si l'édition de ligne de commande est supportée consiste à taper Control-P au premier prompt affiché par Python. Si ça fait un bip, vous disposez de l'édition de ligne de commande ; voir l'annexe A pour une introduction aux touches. Si rien ne semble se passer, ou si P est affiché, l'édition de ligne de commande n'est pas disponible ; vous pourrez seulement utiliser backspace pour enlever des caractères de la ligne courante.

L'interpréteur fonctionne en quelque sorte comme le shell Unix : lorsqu'il est lancé avec l'entrée standard connectée à un périphérique tty, il lit et exécute les commandes interactivement ; lorsqu'il est lancé avec un nom de fichier en argument ou avec un fichier comme entrée standard, il lit et exécute un script depuis ce fichier.

Une troisième façon de lancer l'interpréteur est "python -c commande [arg]…", ce qui exécute les instructions dans commande, de façon analogue à l'option -c du shell. Puisque les instructions en Python contiennent souvent des espaces ou d'autres caractères qui sont spéciaux pour le shell, il est conseillé de mettre entièrement entre guillemets (doubles-quotes) la commande.

Notez qu'il y a une différence entre "python fichier" et "python <fichier". Dans le second cas, les requêtes en entrée du programme, comme les appels à input() et raw_input(), sont effectuées depuis fichier. Puisque ce fichier a déjà été lu jusqu'à la fin par l'interpréteur avant que le programme ne commence à s'exécuter, le programme rencontrera immédiatement EOF. Dans le premier cas (qui est habituellement ce qu'on souhaite) les requêtes sont satisfaites par l'éventuel fichier ou périphérique qui est connecté à l'entrée standard de l'interpréteur Python.

Lorsqu'un fichier script est utilisé, il est parfois utile de pouvoir lancer le script et de passer ensuite en mode interactif. Ceci peut être fait en passant en paramètre -i avant le script. (Ceci ne marche pas si le script est lu depuis l'entrée standard, pour la même raison expliquée dans le paragraphe précédent.)

II-A-1. Passage de paramètres▲

II-A-2. Mode interactif▲

python
Python 1.5.2b2 (#1, Feb 28 1999, 00:02:06)  [GCC 2.8.1] on sunos5
Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam
>>>

>>> le_monde_est_plat = 1
>>> if le_monde_est_plat:
...     print "Gaffe à pas tomber par-dessus bord !"
...
Gaffe à pas tomber par-dessus bord !

II-B-1. Gestion des erreurs▲

II-B-2. Scripts Python exécutables▲

#! /usr/bin/env python

II-B-3. Le fichier de démarrage interactif▲

import os
filename = os.environ.get('PYTHONSTARTUP')
if filename and os.path.isfile(filename):
    execfile(filename)

Essayons quelques commandes Python simples. Lancez l'interpréteur et attendez l'apparition du prompt principal, ">>>". (Ça ne devrait pas être très long.)

III-A-1. Nombres▲

>>> 2+2
4
>>> # Ceci est un commentaire
... 2+2
4
>>> 2+2  # et un commentaire sur la même ligne que le code
4
>>> (50-5*6)/4
5
>>> # La division des entiers retourne l'entier immédiatement inférieur :
... 7/3
2
>>> 7/-3
-3

>>> largeur = 20
>>> hauteur = 5*9
>>> largeur * hauteur
900

>>> x = y = z = 0  # Mettre à zéro x, y et z
>>> x
0
>>> y
0
>>> z
0

>>> 4 * 2.5 / 3.3
3.0303030303030303
>>> 7.0 / 2
3.5
>>> 1j * 1J
(-1+0j)
>>> 1j * complex(0,1)
(-1+0j)
>>> 3+1j*3
(3+3j)
>>> (3+1j)*3
(9+3j)
>>> (1+2j)/(1+1j)
(1.5+0.5j)

>>> a=1.5+0.5j
>>> a.real
1.5
>>> a.imag
0.5

>>> a=1.5+0.5j
>>> float(a)
Traceback (innermost last):
  File "<stdin>", line 1, in ?
TypeError: can't convert complex to float; use e.g. abs(z)
>>> a.real
1.5
>>> abs(a)
1.5811388300841898

>>> tva = 17.5 / 100
>>> prix = 3.50
>>> prix * tva
0.6125
>>> prix + _
4.1125
>>> round(_, 2)
4.11

III-A-2. Chaînes de caractères▲

>>> 'spam eggs'
'spam eggs'
>>> 'n\'est-ce pas'
"n'est-ce pas"
>>> "n'est-ce pas"
"n'est-ce pas"
>>> '"Oui," dit-il.'
'"Oui," dit-il.'
>>> "\"Oui,\" dit-il."
'"Oui," dit-il.'
>>> '"N\'est-ce pas," repondit-elle.'
'"N\'est-ce pas," repondit-elle.'

salut = "Ceci est une chaîne plutot longue contenant\n\
plusieurs lignes de texte exactement comme on le ferait en C.\n\
    Notez que les blancs au début de la ligne sont\
 significatifs.\n"
print salut

Ceci est une chaîne plutot longue contenant
plusieurs lignes de texte exactement comme on le ferait en C.
    Notez que les blancs au début de la ligne sont significatifs.

print """
Usage: trucmuche [OPTIONS]
     -h                        Affiche cette notice d'usage
     -H hôte                   hôte auquel il faut se connecter
"""

Usage: trucmuche [OPTIONS]
     -h                        Affiche cette notice d'usage
     -H hôte                   hôte auquel il faut se connecter

>>> word = 'Help' + 'A'
>>> word
'HelpA'
>>> '<' + word*5 + '>'
'<HelpAHelpAHelpAHelpAHelpA>'

>>> import string
>>> 'cha' 'ine'                   #  <-  C'est ok
'chaine'
>>> string.strip('cha') + 'ine'   #  <-  C'est ok
'chaine'
>>> string.strip('cha') 'ine'     #  <-  Ca c'est faux
  File "<stdin>", line 1
    string.strip('cha') 'ine'
                            ^
SyntaxError: invalid syntax

>>> mot[4]
'A'
>>> mot[0:2]
'He'
>>> mot[2:4]
'lp'

>>> mot[0] = 'x'
Traceback (innermost last):
  File "<stdin>", line 1, in ?
TypeError: object doesn't support item assignment
>>> mot[:-1] = 'Splat'
Traceback (innermost last):
  File "<stdin>", line 1, in ?
TypeError: object doesn't support slice assignment

>>> 'x' + mot[1:]
'xelpA'
>>> 'Splat' + mot[-1:]
'SplatA'

>>> mot[:2]    # Les deux premiers caractères
'He'
>>> mot[2:]    # Tout sauf les deux premiers caractères
'lpA'

>>> mot[:2] + mot[2:]
'HelpA'
>>> mot[:3] + mot[3:]
'HelpA'

>>> mot[1:100]
'elpA'
>>> mot[10:]
''
>>> mot[2:1]
''

>>> mot[-1]     # Le dernier caractère
'A'
>>> mot[-2]     # L'avant-dernier caractère
'p'
>>> mot[-2:]    # Les deux derniers caractères
'pA'
>>> mot[:-2]    # Tout sauf les deux derniers caractères
'Hel'

>>> mot[-0]     # (puisque -0 égale 0)
'H'

>>> mot[-100:]
'HelpA'
>>> mot[-10]    # erreur
Traceback (innermost last):
  File "<stdin>", line 1
IndexError: string index out of range

+---+---+---+---+---+
 | H | e | l | p | A |
 +---+---+---+---+---+
 0   1   2   3   4   5
-5  -4  -3  -2  -1

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

III-A-3. Chaînes Unicode▲

>>> u'Bonjour !'
u'Bonjour !'

>>> u'Salut\\u0020tout le monde !'
u'Salut tout le monde !'

>>> ur'Salut\u0020tout le monde !'
u'Salut tout le monde !'
>>> ur'Salut\\u0020tout le monde !'
u'Salut\\\\u0020tout le monde !'

>>> u"äöü"
u'\344\366\374'
>>> str(u"äöü")
'\303\244\303\266\303\274'

>>> unicode('\303\244\303\266\303\274','UTF-8')
u'\344\366\374'

>>> u"äöü".encode('UTF-8')
'\303\244\303\266\303\274'

III-A-4. Listes▲

>>> a = ['spam', 'eggs', 100, 1234]
>>> a
['spam', 'eggs', 100, 1234]

>>> a[0]
'spam'
>>> a[3]
1234
>>> a[-2]
100
>>> a[1:-1]
['eggs', 100]
>>> a[:2] + ['bacon', 2*2]
['spam', 'eggs', 'bacon', 4]
>>> 3*a[:3] + ['Boe!']
['spam', 'eggs', 100, 'spam', 'eggs', 100, 'spam', 'eggs', 100, 'Boe!']

>>> a
['spam', 'eggs', 100, 1234]
>>> a[2] = a[2] + 23
>>> a
['spam', 'eggs', 123, 1234]

>>> # Remplacer certains éléments :
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # En enlever certains :
... a[0:2] = []
>>> a
[123, 1234]
>>> # En insérer
... a[1:1] = ['bletch', 'xyzzy']
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> a[:0] = a     # Insère (une copie de) soi-même au début
>>> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]

>>> len(a)
8

>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append('xtra')     # See section 5.1
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']

Bien sûr, nous pouvons utiliser Python pour des tâches plus compliquées que d'ajouter 2 et 2. Par exemple, nous pouvons écrire une sous-séquence de la suite de Fibonacci de la façon suivante :

>>> # Suite de Fibonacci
... # La somme de deux éléments définit le suivant
... a, b = 0, 1
>>> while b < 10:
...       print b
...       a, b = b, a+b
...
1
1
2
3
5
8

Cet exemple introduit plusieurs fonctionnalités nouvelles.

• La première ligne contient une affectation multiple : les variables a et b prennent simultanément les nouvelles valeurs 0 et 1. Sur la dernière ligne l'affectation multiple est utilisée à nouveau, montrant que les expressions en partie droite sont d'abord toutes évaluées avant qu'aucune affectation ne se fasse.
• La boucle while s'exécute tant que la condition (ici : b < 10) reste vraie. En Python, comme en C, toute valeur entière différente de zéro est vraie ; zéro est faux. La condition pourrait aussi être une chaîne ou une valeur de type liste, en fait n'importe quelle séquence ; n'importe quoi avec une longueur différente de zéro est vrai, les séquences vides correspondent à faux. Le test utilisé dans l'exemple est une simple comparaison. Les opérateurs de comparaison standards sont écrits de la même façon qu'en C : <, >, ==, <=, >= et !=.
• Le corps de la boucle est indenté : l'indentation est le moyen par lequel Python regroupe les instructions. Python ne fournit pas (encore) une fonction d'édition de ligne intelligente, donc vous devez insérer une tabulation ou un espace pour chaque ligne indentée. En pratique vous préparerez les saisies plus compliquées avec un éditeur de texte ; la plupart des éditeurs de texte ont une fonction d'autoindentation. Lorsqu'une instruction composée est entrée en mode interactif, elle doit être suivie d'une ligne vide pour indiquer qu'elle est terminée (car l'interpréteur ne peut pas deviner si vous avez tapé la dernière ligne).
• L'instruction print écrit la valeur de la ou des expressions qui lui sont données. Elle diffère de la simple écriture de l'expression (comme tout à l'heure dans les exemples de la calculatrice) dans la mesure où elle accepte plusieurs expressions et chaînes. Les chaînes sont imprimées sans quotes, et un espace est inséré entre les éléments, ce qui vous permet de les afficher dans un format plus sympathique, comme ceci :

>>> i = 256*256
>>> print 'La valeur de i est', i
La valeur de i est 65536

>>> a, b = 0, 1
>>> while b < 1000:
...     print b,
...     a, b = b, a+b
...
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

Peut-être l'instruction la plus connue est-elle l'instruction if. Par exemple :

>>> if x < 0:
...      x = 0
...      print 'Négatif changé en zéro'
... elif x == 0:
...      print 'Zéro'
... elif x == 1:
...      print 'Un seul'
... else:
...      print 'Plus'
...

Il peut y avoir aucune ou plusieurs sections elif, et la section else est optionnelle. Le mot-clé `elif' est une abréviation de `else if', et est utile pour éviter une indentation excessive. Une séquence if ... elif ... elif ... est un substitut pour les instructions switch ou case qu'on trouve dans d'autres langages.

L'instruction for en Python diffère un petit peu de ce que vous avez pu utiliser en C ou en Pascal. Au lieu d'itérer toujours dans une progression arithmétique de nombres (comme en Pascal), ou de laisser l'utilisateur complètement libre dans les tests et les pas d'itération (comme en C), l'instruction for de Python itère parmi les éléments de n'importe quelle séquence (par ex., une liste ou une chaîne), dans l'ordre où ils apparaissent dans la séquence. Par exemple (aucun jeu de mots volontaire) :

>>> # Mesurer quelques chaînes :
... a = ['chat', 'fenêtre', 'défenestrer']
>>> for x in a:
...     print x, len(x)
...
chat 4
fenêtre 7
défenestrer 11

Il n'est pas prudent de modifier la séquence sur laquelle on itère dans la boucle (ceci peut seulement arriver pour les types de séquences modifiables, par exemple, les listes). Si vous avez besoin de modifier la liste sur laquelle vous itérez, par exemple, pour dupliquer des éléments sélectionnés, vous devez itérer sur une copie. La notation de découpage rend ceci particulièrement pratique :

>>> for x in a[:]: # fait une copie de la liste entière par découpage
...    if len(x) > 8: a.insert(0, x)
...
>>> a
['défenestrer', 'chat', 'fenêtre', 'défenestrer']

Si vous avez besoin d'itérer sur une séquence de nombres, la fonction intégrée range() vient à point. Elle génère des listes contenant des progressions arithmétiques, par ex. :

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Le nombre de fin qui lui est passé n'est jamais dans la liste générée ; range(10) génère une liste de 10 valeurs, exactement les indices des éléments d'une séquence de longueur 10. Il est possible de faire commencer l'intervalle à un autre nombre, ou de spécifier un incrément différent (même négatif) :

>>> range(5, 10)
[5, 6, 7, 8, 9]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(-10, -100, -30)
[-10, -40, -70]

Pour parcourir les indices d'une séquence, combinez range() et len() comme ci-dessous :

>>> a = ['Marie', 'avait', 'un', 'petit', 'mouton']
>>> for i in range(len(a)):
...     print i, a[i]
...
0 Marie
1 avait
2 un
3 petit
4 mouton

L'instruction break, comme en C, sort de la plus petite boucle for ou while englobante.

L'instruction continue, également empruntée au C, continue sur la prochaine itération de la boucle.

Les instructions de boucle ont une clause else ; elle est exécutée lorsque la boucle se termine par épuisement de la liste (avec for) ou quand la condition devient fausse (avec while), mais pas quand la boucle est interrompue par une instruction break. Ceci est expliqué dans la boucle suivante, qui recherche des nombres premiers :

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...            print n, 'égale', x, '*', n/x
...            break
...     else:
...          print n, 'est un nombre premier'
...
2 est un nombre premier
3 est un nombre premier
4 égale 2 * 2
5 est un nombre premier
6 égale 2 * 3
7 est un nombre premier
8 égale 2 * 4
9 égale 3 * 3

L'instruction pass ne fait rien. Elle peut être utilisée lorsqu'une instruction est requise syntaxiquement, mais que le programme ne nécessite aucune action. Par exemple :

>>> while 1:
...       pass # Attente active d'une interruption au clavier
...

Nous pouvons créer une fonction qui écrit la série de Fibonacci jusqu'à une limite quelconque :

>>> def fib(n):    # écrit la série de Fibonacci jusqu'à n
...     "Affiche une suite de Fibonacci jusqu'à n"
...     a, b = 0, 1
...     while b < n:
...         print b,
...         a, b = b, a+b
...
>>> # Maintenant on appelle la fonction qui vient juste d'être définie
... fib(2000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597

Le mot-clé def commence la définition d'une fonction. Il doit être suivi par le nom de la fonction et une liste entre parenthèses de paramètres formels. Les instructions qui forment le corps de la fonction commencent sur la ligne suivante, indentée par une tabulation. La première instruction du corps de la fonction peut éventuellement être un texte dans une chaîne de caractères ; cette chaîne est la chaîne de documentation de la fonction, ou docstring.

Il y a des outils qui utilisent les docstrings pour générer automatiquement de la documentation papier, ou pour permettre à l'utilisateur de naviguer interactivement dans le code ; c'est une bonne technique que d'inclure les docstrings dans le code que vous écrivez, donc essayez de vous y habituer.

L'exécution d'une fonction génère une nouvelle table de symboles, utilisée pour les variables locales de la fonction. Plus précisément, toutes les affectations de variables dans une fonction stockent la valeur dans la table de symboles locale ; alors que les références à des variables regardent en premier dans la table de symboles locale, puis dans la table de symboles globale, et enfin dans la table des noms intégrés. Ainsi, on ne peut affecter directement une valeur aux variables globales à l'intérieur d'une fonction (à moins de les déclarer avec une instruction global), bien qu'on puisse y faire référence.

Les vrais paramètres (arguments) d'un appel de fonction sont introduits dans la table de symboles locale de la fonction appelée quand elle est appelée ; ainsi, les arguments sont passés en utilisant un passage par valeur.(3) Quand une fonction appelée appelle à son tour une autre fonction, une nouvelle table de symboles locale est créée pour cet appel.

La définition d'une fonction introduit le nom de la fonction dans la table de symboles courante. La valeur du nom de la fonction a un type qui est reconnu par l'interpréteur comme une fonction définie par l'utilisateur. Cette valeur peut être affectée à un autre nom qui peut alors être utilisé aussi comme une fonction. Ceci permet de disposer d'un mécanisme général de renommage :

>>> fib
<function object at 10042ed0>
>>> f = fib
>>> f(100)
1 1 2 3 5 8 13 21 34 55 89

Vous pourriez objecter que fib n'est pas une fonction, mais une procédure. En Python, comme en C, les procédures sont juste des fonctions qui ne retournent pas de valeur. En fait, techniquement parlant, les procédures retournent bien une valeur, bien qu'elle soit plutôt décevante. Cette valeur est appelée None (c'est un nom intégré). La valeur None n'est normalement pas affichée par l'interpréteur si elle devait être la seule valeur écrite. Vous pouvez le vérifier si vous y tenez vraiment :

>>> print fib(0)
None

Écrire une fonction qui retourne une liste des nombres de la suite de Fibonacci, au lieu de les imprimer, est très simple :

>>> def fib2(n): # retourne la série de Fibonacci jusqu'à n
...     "Retourne une liste contenant la série de Fibonacci jusqu'à n"
...     resultat = []
...     a, b = 0, 1
...     while b < n:
...         resultat.append(b)    # voir ci-dessous
...         a, b = b, a+b
...     return resultat
...
>>> f100 = fib2(100)    # on l'appelle
>>> f100                # écrire le résultat
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]

Cet exemple, comme d'habitude, démontre quelques nouvelles caractéristiques de Python :

• l'instruction return termine une fonction en renvoyant une valeur. return sans une expression en argument est utilisé pour retourner depuis le milieu d'une procédure (aboutir à la fin termine aussi la procédure), auquel cas la valeur None est retournée ;
• l'instruction result.append(b) appelle une méthode de l'objet result. Une méthode est une fonction qui « appartient » à un objet et est nommée obj.nommethode, où obj est un objet (cela pourrait être une expression), et nommethode est le nom d'une méthode qui est définie d'après le type de l'objet. Différents types définissent différentes méthodes. Les méthodes de types différents peuvent avoir le même nom sans que cela soit source d'ambiguïtés. (Il est possible de définir vos propres types d'objets et méthodes, en utilisant des classes, de la façon décrite en 9.) La méthode append() montrée précédemment, est définie pour les objets listes ; elle ajoute un nouvel élément à la fin de la liste. Dans cet exemple, c'est équivalent à "result = result + [b]", mais en plus performant.

Il est aussi possible de définir des fonctions à nombre d'arguments variable. Il y a trois façons de faire, qui peuvent être combinées.

IV-G-1. Valeurs d'argument par défaut▲

def demande_ok(question, tentatives=4, plainte='Oui ou non, svp!'):
    while 1:
        ok = raw_input(question)
        if ok in ('o', 'ou', 'oui'): return 1
        if ok in ('n', 'no', 'non', 'niet'): return 0
        tentatives = tentatives - 1
        if tentatives < 0: raise IOError, 'utilisateur refusenik'
        print plainte

i = 5
def f(arg = i): print arg
i = 6
f()

def f(a, l = []):
    l.append(a)
    return l
print f(1)
print f(2)
print f(3)

[1]
[1, 2]
[1, 2, 3]

def f(a, l = None):
    if l is None:
        l = []
    l.append(a)
    return l

IV-G-2. Arguments à mot-clé▲

def perroquet(voltage, etat='c\'est du solide', action='voom', type='Bleu Norvégien'):
    print "-- Ce perroquet ne fera pas", action,
    print "si vous le mettez sous", voltage, "Volts."
    print "-- Beau plumage, le", type
    print "-- Ca", etat, "!"

perroquet(1000)
perroquet(action = 'VOOOOOM', voltage = 1000000)
perroquet('un millier', etat = 'fait bouffer les pissenlits par la racine')
perroquet('un milion', 'vous dégoute de la vie', 'de bonds')

perroquet()                          # manque un argument obligatoire
perroquet(voltage=5.0, 'rend mort')  # un argument non-mot-clé suit un mot-clé
perroquet(110, voltage=220)          # doublon de valeurs pour un argument
perroquet(acteur='John Cleese')      # mot-clé inconnu

>>> def function(a):
...     pass
...
>>> function(0, a=0)
Traceback (innermost last):
  File "<stdin>", line 1, in ?
TypeError: keyword parameter redefined

def fromagerie(type, *arguments, **motcles):
    print "-- Avez-vous du", type, '?'
    print "-- Je suis désolé, plus personne n'a de", type
    for arg in arguments: print arg
    print '-'*40
    for mc in motcles.keys(): print mc, ':', motcles[mc]

fromagerie('Camembert', "Il est très coulant, monsieur.",
           "Il est vraiment très, TRÈS coulant, monsieur.",
           client='John Cleese',
           proprietaire='Michael Palin',
           sketch='Sketch de la fromagerie' )

-- Avez-vous du Camembert ?
-- Je suis désolé, plus personne n'a de Camembert
Il est très coulant, monsieur.
Il est vraiment très, TRÈS coulant, monsieur.
----------------------------------------
client : John Cleese
proprietaire : Michael Palin
sketch : Sketch de la fromagerie

IV-G-3. Listes d'arguments arbitraires▲

def fprintf(fichier, format, *args):
    fichier.write(format % args)

IV-G-4. Les formes lambda▲

def fabrique_incrementeur(n):
    return lambda x, incr=n: x+incr

IV-G-5. Chaînes de documentation (Docstrings)▲

>>> def ma_fonction():
...     """Ne fait rien, mais le documente.
...
...     Non, vraiment, elle ne fait rien.
...     """
...     pass
...
>>> print ma_fonction.__doc__
Ne fait rien, mais le documente.

    Non, vraiment, elle ne fait rien.

Le type de données liste possède d'autres méthodes. Voici toutes les méthodes des objets listes :

append(x)

Équivalent à a.insert(len(a), x).

extend(L)

Rallonge la liste en ajoutant à la fin tous les éléments de la liste donnée ; équivalent à a[len(a):] = L.

insert(i, x)

Insère un élément à une position donnée. Le premier argument est l'indice de l'élément avant lequel il faut insérer, donc a.insert(0, x) insère au début de la liste, et a.insert(len(a), x) est équivalent à a.append(x).

remove(x)

Enlève le premier élément de la liste dont la valeur est x. Il y a erreur si cet élément n'existe pas.

pop([i])

Enlève l'élément présent à la position donnée dans la liste, et le renvoie. Si aucun indice n'est spécifié, a.pop() renvoie le dernier élément de la liste. L'élément est aussi supprimé de la liste.

index(x)

Retourne l'indice dans la liste du premier élément dont la valeur est x. Il y a erreur si cet élément n'existe pas.

count(x)

Renvoie le nombre de fois que x apparaît dans la liste.

sort()

Trie les éléments à l'intérieur de la liste.

reverse()

Renverse l'ordre des éléments à l'intérieur de la liste.

Un exemple qui utilise toutes les méthodes des listes :

>>> a = [66.6, 333, 333, 1, 1234.5]
>>> print a.count(333), a.count(66.6), a.count('x')
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.6, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.6, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.6]
>>> a.sort()
>>> a
[-1, 1, 66.6, 333, 333, 1234.5]

V-A-1. Utiliser les listes comme des piles▲

>>> pile = [3, 4, 5]
>>> pile.append(6)
>>> pile.append(7)
>>> pile
[3, 4, 5, 6, 7]
>>> pile.pop()
7
>>> pile
[3, 4, 5, 6]
>>> pile.pop()
6
>>> pile.pop()
5
>>> pile
[3, 4]

V-A-2. Utiliser les listes comme des files▲

>>> file = ["Eric", "John", "Michael"]
>>> file.append("Terry")           # Terry arrive
>>> file.append("Graham")          # Graham arrive
>>> file.pop(0)
'Eric'
>>> file.pop(0)
'John'
>>> file
['Michael', 'Terry', 'Graham']

V-A-3. Outils de programmation fonctionnelle▲

>>> def f(x): return x % 2 != 0 and x % 3 != 0
...
>>> filter(f, range(2, 25))
[5, 7, 11, 13, 17, 19, 23]

>>> def cube(x): return x*x*x
...
>>> map(cube, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

>>> seq = range(8)
>>> def carre(x): return x*x
...
>>> map(None, seq, map(carre, seq))
[(0, 0), (1, 1), (2, 4), (3, 9), (4, 16), (5, 25), (6, 36), (7, 49)]

>>> def ajoute(x,y): return x+y
...
>>> reduce(ajoute, range(1, 11))
55

>>> def somme(seq):
...     def ajoute(x,y): return x+y
...     return reduce(ajoute, seq, 0)
...
>>> somme(range(1, 11))
55
>>> somme([])
0

V-A-4. List comprehensions▲

>>> fruitfrais = ['  banane', '  myrtille ', 'fruit de la passion  ']
>>> [projectile.strip() for projectile in fruitfrais]
['banane', 'myrtille', 'fruit de la passion']
>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
>>> [{x: x**2} for x in vec]
[{2: 4}, {4: 16}, {6: 36}]
>>> [[x,x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
>>> [x, x**2 for x in vec]      # erreur - parenthèses obligatoires pour les tuples
  File "<stdin>", line 1
    [x, x**2 for x in vec]
               ^
SyntaxError: invalid syntax
>>> [(x, x**2) for x in vec]
[(2, 4), (4, 16), (6, 36)]
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]

Il y a un moyen d'enlever un élément d'une liste en ayant son indice au lieu de sa valeur : l'instruction del. Ceci peut aussi être utilisé pour enlever des tranches dans une liste (ce que l'on a fait précédemment par remplacement de la tranche par une liste vide). Par exemple :

>>> a
[-1, 1, 66.6, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.6, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.6, 1234.5]

del peut aussi être utilisé pour supprimer des variables complètes :

>>> del a

Faire par la suite référence au nom a est une erreur (au moins jusqu'à ce qu'une autre valeur ne lui soit affectée). Nous trouverons d'autres utilisations de del plus tard.

Nous avons vu que les listes et les chaînes ont plusieurs propriétés communes, par ex., l'indexation et les opérations de découpage. Elles sont deux exemples de types de données de type séquence. Puisque Python est un langage qui évolue, d'autres types de données de type séquence pourraient être ajoutés. Il y a aussi un autre type de données de type séquence standard : le tuple (n-uplet).

Un n-uplet consiste en un ensemble de valeurs séparées par des virgules, par exemple :

>>> t = 12345, 54321, 'salut!'
>>> t[0]
12345
>>> t
(12345, 54321, 'salut!')
>>> # Les Tuples peuvent être imbriqués:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'salut!'), (1, 2, 3, 4, 5))

Comme vous pouvez le voir, à l'affichage, les tuples sont toujours entre parenthèses, de façon à ce que des tuples de tuples puissent être interprétés correctement ; ils peuvent être saisis avec ou sans parenthèses, bien que des parenthèses soient souvent nécessaires (si le tuple fait partie d'une expression plus complexe).

Les tuples ont plein d'utilisations, par exemple, les couples de coordonnées (x, y), les enregistrements des employés d'une base de données, etc. Les tuples, comme les chaînes, sont non modifiables : il est impossible d'affecter individuellement une valeur aux éléments d'un tuple (bien que vous puissiez simuler quasiment cela avec le découpage et la concaténation).

Un problème particulier consiste à créer des tuples contenant 0 ou 1 élément : la syntaxe reconnaît quelques subtilités pour y arriver. Les tuples vides sont construits grâce à des parenthèses vides ; un tuple avec un élément est construit en faisant suivre une valeur d'une virgule (il ne suffit pas de mettre une valeur seule entre parenthèses). Moche, mais efficace. Par exemple :

>>> empty = ()
>>> singleton = 'salut',    # <-- notez la virgule en fin de ligne
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('salut',)

L'instruction t = 12345, 54321, 'salut!' est un exemple d'emballage en tuple (tuple packing) : les valeurs 12345, 54321 et 'salut!' sont emballées ensemble dans un tuple. L'opération inverse est aussi possible, par ex. :

>>> x, y, z = t

Ceci est appelé, fort judicieusement, déballage de tuple (tuple unpacking). Le déballage d'un tuple nécessite que la liste des variables à gauche ait un nombre d'éléments égal à la longueur du tuple. Notez que des affectations multiples ne sont en réalité qu'une combinaison d'emballage et déballage de tuples !

Un autre type de données intégré à Python est le dictionnaire. Les dictionnaires sont parfois trouvés dans d'autres langages sous le nom de « mémoires associatives » ou « tableaux associatifs »'. À la différence des séquences, qui sont indexées par un intervalle numérique, les dictionnaires sont indexés par des clés, qui peuvent être de n'importe quel type non modifiable ; les chaînes et les nombres peuvent toujours être des clés. Les tuples peuvent être utilisés comme clés s'ils ne contiennent que des chaînes, des nombres ou des tuples. Vous ne pouvez pas utiliser des listes comme clés, puisque les listes peuvent être modifiées en utilisant leur méthode append().

Il est préférable de considérer les dictionnaires comme des ensembles non ordonnés de couples clé:valeur, avec la contrainte que les clés soient uniques (à l'intérieur d'un même dictionnaire). Un couple d'accolades crée un dictionnaire vide : {}. Placer une liste de couples clé:valeur séparés par des virgules à l'intérieur des accolades ajoute les couples initiaux clé:valeur au dictionnaire ; c'est aussi de cette façon que les dictionnaires sont affichés.

Les opérations principales sur un dictionnaire sont le stockage d'une valeur à l'aide d'une certaine clé et l'extraction de la valeur en donnant la clé. Il est aussi possible de détruire des couples clé:valeur avec del. Si vous stockez avec une clé déjà utilisée, l'ancienne valeur associée à cette clé est oubliée. C'est une erreur d'extraire une valeur en utilisant une clé qui n'existe pas.

La méthode keys() d'un objet de type dictionnaire retourne une liste de toutes les clés utilisées dans le dictionnaire, dans un ordre quelconque (si vous voulez qu'elle soit triée, appliquez juste la méthode sort() à la liste des clés). Pour savoir si une clé particulière est dans le dictionnaire, utilisez la méthode has_key() du dictionnaire.

Voici un petit exemple utilisant un dictionnaire :

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> tel.keys()
['guido', 'irv', 'jack']
>>> tel.has_key('guido')
1

Les conditions utilisées dans les instructions while et if peuvent contenir d'autres opérateurs en dehors des comparaisons.

Les opérateurs de comparaison in et not in vérifient si une valeur apparaît (ou non) dans une séquence. Les opérateurs is et is not vérifient si deux objets sont réellement le même objet ; ceci se justifie seulement pour les objets modifiables comme les listes. Tous les opérateurs de comparaison ont la même priorité, qui est plus faible que celle de tous les opérateurs numériques.

Les comparaisons peuvent être enchaînées : par ex., a < b == c teste si a est inférieur ou égal à b et de plus si b est égal à c.

Les comparaisons peuvent être combinées avec les opérateurs booléens and (et) et or (ou), et le résultat d'une comparaison (ou de n'importe quelle autre expression booléenne) peut être inversé avec not (pas). Ces opérateurs ont encore une fois une priorité inférieure à celle des opérateurs de comparaison ; et entre eux, not a la plus haute priorité, et or la plus faible, de sorte que A and not B or C est équivalent à (A and (not B)) or C. Bien sûr, les parenthèses peuvent être utilisées pour exprimer les compositions désirées.

Les opérateurs booléens and et or sont des opérateurs dits raccourcis : leurs arguments sont évalués de gauche à droite, et l'évaluation s'arrête dès que le résultat est trouvé. Par exemple, si A et C sont vrais, mais que B est faux, A and B and C n'évalue pas l'expression C. En général, la valeur de retour d'un opérateur raccourci, quand elle est utilisée comme une valeur générale et non comme un booléen, est celle du dernier argument évalué.

Il est possible d'affecter le résultat d'une comparaison ou une autre expression booléenne à une variable. Par exemple,

>>> chaine1, chaine2, chaine3 = '', 'Trondheim', 'Hammer Dance'
>>> non_null = chaine1 or chaine2 or chaine3
>>> non_null
'Trondheim'

Notez qu'en Python, au contraire du C, les affectations ne peuvent pas être effectuées à l'intérieur des expressions.

Les objets de type séquence peuvent être comparés à d'autres objets appartenant au même type de séquence. La comparaison utilise l'ordre lexicographique : les deux premiers éléments sont d'abord comparés, et s'ils diffèrent ceci détermine le résultat de la comparaison ; s'ils sont égaux, les deux éléments suivants sont comparés, et ainsi de suite, jusqu'à ce que l'une des deux séquences soit épuisée. Si deux éléments à comparer sont eux-mêmes des séquences du même type, la comparaison lexicographique est reconsidérée récursivement. Si la comparaison de tous les éléments de deux séquences les donne égaux, les séquences sont considérées comme égales. Si une séquence est une sous-séquence initiale de l'autre, la séquence écourtée est la plus petite. L'ordonnancement lexicographique pour les chaînes utilise l'ordonnancement ASCII pour les caractères. Quelques exemples de comparaisons de séquences du même type :

(1, 2, 3)              < (1, 2, 4)
[1, 2, 3]              < [1, 2, 4]
'ABC' < 'C' < 'Pascal' < 'Python'
(1, 2, 3, 4)           < (1, 2, 4)
(1, 2)                 < (1, 2, -1)
(1, 2, 3)             == (1.0, 2.0, 3.0)
(1, 2, ('aa', 'ab'))   < (1, 2, ('abc', 'a'), 4)

Notez que la comparaison d'objets de types différents est licite. Le résultat est déterministe, mais arbitraire : les types sont triés selon leur nom. Ainsi une liste (list) est toujours inférieure à une chaîne (string), une chaîne (string) est toujours inférieure à un n-uplet (tuple), etc. Les types numériques mélangés sont comparés en fonction de leur valeur numérique, ainsi 0 est égal à 0.0, etc.(5)

Un module peut contenir des instructions exécutables aussi bien que des définitions de fonction. Ces instructions sont destinées à initialiser le module. On les exécute seulement la première fois que le module est importé quelque part.(6)

Chaque module a sa propre table de symboles privée, qui est utilisée comme table de symboles globale par toutes les fonctions définies dans le module. Ainsi, l'auteur d'un module peut utiliser des variables globales dans le module sans s'inquiéter des désaccords accidentels avec les variables globales d'un utilisateur. D'autre part, si vous savez ce que vous faites, vous pouvez accéder aux variables globales d'un module avec la même notation que celle employée pour se référer à ses fonctions, nommodule.nomelem.

Les modules peuvent importer d'autres modules. Il est d'usage, mais pas obligatoire de placer toutes les instructions import au début d'un module (ou d'un script). Les noms du module importé sont placés dans la table globale de symboles du module importateur.

Il y a une variante de l'instruction import qui importe des noms d'un module directement dans la table de symboles du module importateur. Par exemple :

>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

Ceci n'introduit pas dans la table de symboles locale le nom du module duquel les éléments importés sont issus (ainsi dans l'exemple, fibo n'est pas défini).

Il y a même une variante pour importer tous les noms qu'un module définit :

>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377

Ceci importe tous les noms excepté ceux qui commencent par un tiret bas (_).

VI-A-1. Le chemin de recherche du module▲

VI-A-2. Fichiers "compilés" de Python▲

Python est livré avec une bibliothèque de modules standards, décrite dans un document séparé, Python Library Reference (« Library Reference » ci-après). Quelques modules sont intégrés dans l'interpréteur ; ceux-ci permettent d'accéder à des opérations qui ne font pas partie du noyau du langage, mais sont néanmoins intégrées, pour des raisons d'efficacité ou pour permettre d'accéder aux primitives du système d'exploitation telles que les appels système. La définition de l'ensemble de ces modules standards est une option de configuration ; par exemple, le module amoeba est seulement fourni sur les systèmes qui supportent d'une façon ou d'une autre les primitives d'Amoeba. Un module particulier mérite une certaine attention : sys, qui est intégré dans chaque interpréteur de Python. Les variables sys.ps1 et sys.ps2 définissent les chaînes de caractères utilisées en tant qu'invites primaire et secondaire :

>>> import sys
>>> sys.ps1
'>>> '
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print 'Yuck!'
Yuck!
C>

Ces deux variables sont seulement définies si l'interpréteur est en mode interactif.

La variable sys.path est une liste de chaînes de caractères qui déterminent le chemin de recherche des modules pour l'interpréteur. Il est initialisé à un chemin par défaut à partir de la variable d'environnement $PYTHONPATH, ou d'une valeur par défaut intégrée au programme si $PYTHONPATH n'est pas renseigné. Vous pouvez la modifier en utilisant des opérations standards sur des listes, par exemple :

>>> import sys
>>> sys.path.append('/ufs/guido/lib/python')

La fonction intégrée dir() est employée pour découvrir les noms qu'un module définit. Elle renvoie une liste triée de chaînes de caractères :

>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)
['__name__', 'argv', 'builtin_module_names', 'copyright', 'exit',
'maxint', 'modules', 'path', 'ps1', 'ps2', 'setprofile', 'settrace',
'stderr', 'stdin', 'stdout', 'version']

Sans arguments, dir() énumère les noms que vous avez définis :

>>> a = [1, 2, 3, 4, 5]
>>> import fibo, sys
>>> fib = fibo.fib
>>> dir()
['__name__', 'a', 'fib', 'fibo', 'sys']

Notez qu'elle énumère tous les types de noms : les variables, les modules, les fonctions, etc.

dir() n'énumère pas les noms des fonctions et des variables intégrées. Si vous en voulez une liste, elles sont définies dans le module standard __builtin__ :

>>> import __builtin__
>>> dir(__builtin__)
['AccessError', 'AttributeError', 'ConflictError', 'EOFError', 'IOError',
'ImportError', 'IndexError', 'KeyError', 'KeyboardInterrupt',
'MemoryError', 'NameError', 'None', 'OverflowError', 'RuntimeError',
'SyntaxError', 'SystemError', 'SystemExit', 'TypeError', 'ValueError',
'ZeroDivisionError', '__name__', 'abs', 'apply', 'chr', 'cmp', 'coerce',
'compile', 'dir', 'divmod', 'eval', 'execfile', 'filter', 'float',
'getattr', 'hasattr', 'hash', 'hex', 'id', 'input', 'int', 'len', 'long',
'map', 'max', 'min', 'oct', 'open', 'ord', 'pow', 'range', 'raw_input',
'reduce', 'reload', 'repr', 'round', 'setattr', 'str', 'type', 'xrange']

Les paquetages sont un moyen de structurer l'espace des noms de modules Python en utilisant « les noms de modules pointés ». Par exemple, le nom de module A.B désigne un sous-module nommé "B" dans un module nommé "A". Tout comme l'utilisation des modules permet aux auteurs de différents modules de ne pas s'inquiéter au sujet des noms des variables globales de chacun des autres modules, l'utilisation des noms de modules pointés dispense l'auteur de paquetages multimodules comme NumPy ou PIL de devoir s'inquiéter au sujet de leurs noms de modules.

Supposez que vous vouliez concevoir une collection de modules (un « paquetage ») pour la manipulation uniforme des fichiers de sons et des données de son. Il y a beaucoup de formats de fichier de sons différents (habituellement reconnus par leur extension, par exemple .wav, .ai, .au), ainsi vous pouvez avoir besoin de créer et mettre à jour une collection grandissante de modules pour la conversion entre les divers formats de fichier. Il y a également beaucoup d'opérations différentes que vous pourriez vouloir exécuter sur des données de sons (par exemple le mixage, ajouter de l'écho, appliquer une fonction d'égalisation, créer un effet artificiel de stéréo), ainsi en complément, vous écrirez une série interminable de modules pour réaliser ces opérations. Voici une structure possible pour votre paquetage (exprimé en termes de système de fichiers hiérarchique) :

Sound/                          Paquetage de niveau supérieur
      __init__.py               Initialisation du paquetage sons
      Formats/                  Sous-paquetage pour la conversion des formats de fichiers
              __init__.py
              wavread.py
              wavwrite.py
              aiffread.py
              aiffwrite.py
              auread.py
              auwrite.py
              ...
      Effects/                  Sous-paquetage pour les effets sonores
              __init__.py
              echo.py
              surround.py
              reverse.py
              ...
      Filters/                  Sous-paquetage pour les filtres
              __init__.py
              equalizer.py
              vocoder.py
              karaoke.py
              ...

Les fichiers __init__.py sont obligatoires pour que Python considère les répertoires comme contenant des paquetages ; ceci est fait pour empêcher des répertoires avec un nom commun, tel que "string", de cacher involontairement les modules valides qui apparaissent plus tard dans le chemin de recherche de module. Dans le cas le plus simple, __init__.py peut juste être un fichier vide, mais doit pouvoir également exécuter du code d'initialisation pour le paquetage ou positionner la variable __all__, décrite ci-dessous.

Les utilisateurs du paquetage peuvent importer individuellement des modules du paquetage, par exemple :

import Sound.Effects.echo

Ceci charge le sous-module Sound.Effects.echo. Il doit être référencé avec son nom complet, par exemple.

Sound.Effects.echo.echofilter(input, output, delay=0.7, atten=4)

Une autre solution pour importer le sous-module est :

from Sound.Effects import echo

Ceci charge le sous-module echo, et le rend également disponible sans son préfixe de paquetage, ainsi il peut être utilisé comme suit :

echo.echofilter(input, output, delay=0.7, atten=4)

Une autre variante consiste encore à importer la fonction ou la variable désirée directement :

from Sound.Effects.echo import echofilter

Encore une fois, ceci charge le sous-module echo, et rend sa fonction echofilter disponible directement :

echofilter(input, output, delay=0.7, atten=4)

Notez qu'en utilisant from paquetage import element, l'élément peut être un sous-module (ou sous-paquetage) du paquetage, ou un autre nom défini dans le paquetage, comme une fonction, une classe ou une variable. L'instruction import teste d'abord si l'élément est défini dans le paquetage ; sinon, elle suppose que c'est un module et essaye de le charger. Si elle ne le trouve pas, ImportError est déclenché.

Au contraire, en utilisant la syntaxe import element.souselement.soussouselement, chaque élément excepté le dernier doit être un paquetage ; le dernier élément peut être un module ou un paquetage, mais ne peut pas être une classe ou une fonction ou une variable définie dans l'élément précédent.

VI-D-1. Import * depuis un paquetage▲

__all__ = ["echo", "surround", "reverse"]

import Sound.Effects.echo
import Sound.Effects.surround
from Sound.Effects import *

VI-D-2. Références intrapaquetage▲

Jusqu'ici nous avons rencontré deux manières d'afficher des valeurs : les instructions d'expression et l'instruction print. (Une troisième manière est d'utiliser la méthode write() des objets fichier ; le fichier de sortie standard peut être référencé par sys.stdout. Voyez le manuel Library Reference pour plus d'informations.)

Vous souhaiterez souvent avoir plus de contrôle sur le formatage de vos sorties que d'imprimer simplement des valeurs séparées par des espaces. Il y a deux manières de formater vos sorties ; la première manière est de faire toutes les manipulations de chaînes de caractères vous-même ; en utilisant les opérations de concaténation et de découpage de chaînes de caractères, vous pouvez créer n'importe quel format que vous puissiez imaginer. Le module standard string contient quelques opérations utiles pour remplir des chaînes de caractères à une largeur de colonne donnée ; celles-ci seront discutées sous peu. La deuxième manière est d'utiliser l'opérateur % avec une chaîne de caractères comme argument de gauche, % interprète l'argument de gauche comme une chaîne de formatage comme pour la fonction sprintf() du langage C à appliquer à l'argument de droite, et retourne une chaîne de caractères résultant de cette opération de formatage.

Il reste naturellement une question : comment convertissez-vous des valeurs en chaînes de caractères ? Heureusement, Python a un moyen de convertir n'importe quelle valeur en chaîne de caractères : passez-la à la fonction repr(), ou écrivez juste la valeur entre des guillemets renversés (anti-quotes : ``). Quelques exemples :

>>> x = 10 * 3.14
>>> y = 200*200
>>> s = 'La valeur de x est ' + `x` + ', et y est ' + `y` + '...'
>>> print s
La valeur de x est 31.4, et y est 40000...
>>> # Les anti-quotes marchent avec d'autres types en dehors des nombres :
... p = [x, y]
>>> ps = repr(p)
>>> ps
'[31.4, 40000]'
>>> # Convertir une chaîne ajoute des quotes de chaîne et des antislash :
... salut = 'salut, monde\n'
>>> saluts = `salut`
>>> print saluts
'salut, monde\012'
>>> # L'argument des anti-quotes peut être un tuple :
... `x, y, ('spam', 'eggs')`
"(31.4, 40000, ('spam', 'eggs'))"

Voici deux manières d'écrire une table des carrés et des cubes :

>>> import string
>>> for x in range(1, 11):
...     print string.rjust(`x`, 2), string.rjust(`x*x`, 3),
...     # Notez la virgule à la fin de la ligne précédente
...     print string.rjust(`x*x*x`, 4)
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000
>>> for x in range(1,11):
...     print '%2d %3d %4d' % (x, x*x, x*x*x)
...
 1   1    1
 2   4    8
 3   9   27
 4  16   64
 5  25  125
 6  36  216
 7  49  343
 8  64  512
 9  81  729
10 100 1000

(Notez qu'un espace entre chaque colonne a été ajouté à cause de la façon dont print fonctionne : elle ajoute toujours des espaces entre ses arguments.)

Cet exemple présente la fonction string.rjust(), qui justifie à droite une chaîne de caractères dans un champ d'une largeur donnée en la complétant avec des espaces du côté gauche. Il y a les fonctions semblables string.ljust() et string.center(). Ces fonctions n'écrivent rien, elles renvoient juste une nouvelle chaîne de caractères. Si la chaîne de caractères d'entrée est trop longue, elles ne la tronquent pas, mais la renvoient sans changement ; ceci gâchera votre présentation de colonne, mais c'est habituellement mieux que l'alternative, qui serait de tricher au sujet d'une valeur. (Si vous voulez vraiment la troncature vous pouvez toujours ajouter une opération de découpage, comme "string.ljust(x, n)[0:n]".)

Il y a une autre fonction, string.zfill(), qui complète une chaîne de caractères numérique du côté gauche avec des zéros. Elle sait gérer les signes positifs et négatifs :

>>> import string
>>> string.zfill('12', 5)
'00012'
>>> string.zfill('-3.14', 7)
'-003.14'
>>> string.zfill('3.14159265359', 5)
'3.14159265359'

L'utilisation de l'opérateur % ressemble à ceci :

>>> import math
>>> print 'La valeur de PI est approximativement %5.3f.' % math.pi
La valeur de PI est approximativement 3.142.

S'il y a plus d'un descripteur de format dans la chaîne de caractères, vous passez un tuple comme opérande de droite, par exemple.

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> for nom, telephone in table.items():
...     print '%-10s ==> %10d' % (nom, telephone)
...
Jack       ==>       4098
Dcab       ==>    8637678
Sjoerd     ==>       4127

La plupart des formats fonctionnent exactement comme en C et exigent que vous passiez le type approprié ; cependant, si vous ne le faites pas vous obtenez une exception, pas un core dump. Le format de %s est moins strict : si l'argument correspondant n'est pas un objet chaîne de caractères, il est converti en chaîne de caractères en utilisant la fonction intégrée str(). Utiliser * pour passer la largeur ou la précision comme argument (entier) séparé est possible. Les formats %n et %p du C ne sont pas supportés.

Si vous avez une chaîne de caractères de formatage vraiment longue que vous ne voulez pas fractionner, il serait élégant de pouvoir référencer les variables à formater par leur nom et pas par leur position. Ceci peut être fait en utilisant une extension des formats du C en utilisant la forme %(name)format, par exemple.

>>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print 'Jack: %(Jack)d; Sjoerd: %(Sjoerd)d; Dcab: %(Dcab)d' % table
Jack: 4098; Sjoerd: 4127; Dcab: 8637678

C'est particulièrement utile en combinaison avec la fonction intégrée vars(), qui renvoie un dictionnaire contenant toutes les variables locales.

open() renvoie un objet de type fichier, et est utilisée plus généralement avec deux arguments : "open(nomfichier, mode)".

>>> f=open('/tmp/fichiertravail', 'w')
>>> print f
<open file '/tmp/fichiertravail', mode 'w' at 80a0960>

Le premier argument est une chaîne de caractères contenant le nom du fichier. Le deuxième argument est une autre chaîne de caractères contenant quelques caractères décrivant la manière d'utiliser le fichier. mode vaut 'r' quand le fichier doit être seulement lu, 'w' pour seulement écrit (un fichier déjà existant avec le même nom sera effacé), et 'a' ouvre le fichier en ajout ; les données écrites dans le fichier seront automatiquement ajoutées à la fin. 'r+' ouvre le fichier pour la lecture et l'écriture. L'argument mode est facultatif ; 'r' sera pris par défaut s'il est omis.

Sur Windows et Macintosh, 'b' ajouté au mode ouvre fichier en mode binaire, donc il y a aussi des modes comme 'rb', 'wb', et 'r+b'. Windows fait la distinction entre fichier texte et binaire  ; les caractères de fin de ligne dans des fichiers texte sont automatiquement modifiés légèrement quand des données sont lues ou écrites. Cette modification imperceptible des données du fichier marche très bien pour des fichiers textes ASCII, mais elle altèrera des données binaires comme dans des fichiers JPEG ou .EXE. Faites très attention à utiliser le mode binaire en lisant et en écrivant de tels fichiers. (Notez que la sémantique précise du mode texte sur le Macintosh dépend de la bibliothèque C utilisée.)

VII-B-1. Méthodes des objets fichier▲

>>> f.read()
'Ceci est le fichier entier.\012'
>>> f.read()
''

>>> f.readline()
'Ceci est la première ligne du fichier.\012'
>>> f.readline()
'Deuxième ligne du fichier\012'
>>> f.readline()
''

>>> f.readlines()
['Ceci est la première ligne du fichier.\012', 'Deuxième ligne du fichier\012']

>>> f.write('Voici un test\n')

>>> f=open('/tmp/fichiertravail', 'r+')
>>> f.write('0123456789abcdef')
>>> f.seek(5)     # Saute jusqu'au 5e octet dans le fichier
>>> f.read(1)       
'5'
>>> f.seek(-3, 2) # Saute jusqu'au 3e octet avant la fin
>>> f.read(1)
'd'

>>> f.close()
>>> f.read()
Traceback (innermost last):
  File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file

VII-B-2. Le module pickle▲

pickle.dump(x, f)

x = pickle.load(f)

Les erreurs de syntaxe, ou erreurs d'interprétation sont peut-être les formes de messages d'erreur les plus courantes que vous rencontrerez pendant votre apprentissage de Python :

>>> while 1 print 'Bonjour'
  File "<stdin>", line 1
    while 1 print 'Bonjour'
                ^
SyntaxError: invalid syntax

L'interpréteur affiche la ligne où l'erreur a eu lieu, et une petite flèche qui marque le premier point de la ligne où l'erreur a été détectée. L'erreur est causée par le (ou du moins détectée au) lexème qui précède la flèche : dans l'exemple, l'erreur est détectée au mot-clé print, vu qu'il manque un deux-points (":") juste avant. Un nom et un numéro de ligne de fichier sont aussi donnés pour que vous sachiez où aller regarder si les commandes proviennent d'un script.

Même lorsqu'une instruction ou une expression est syntaxiquement correcte, elle peut provoquer une erreur lorsqu'on essaye de l'exécuter. Les erreurs détectées à l'exécution sont appelées exceptions et ne sont pas fatales : vous allez bientôt apprendre à les gérer dans des programmes Python. Néanmoins, la plupart des exceptions ne sont pas gérées par un programme et entraînent des messages d'erreur comme ci-dessous :

>>> 10 * (1/0)
Traceback (innermost last):
  File "<stdin>", line 1
ZeroDivisionError: integer division or modulo
>>> 4 + spam*3
Traceback (innermost last):
  File "<stdin>", line 1
NameError: spam
>>> '2' + 2
Traceback (innermost last):
  File "<stdin>", line 1
TypeError: illegal argument type for built-in operation

La dernière ligne du message d'erreur indique ce qui s'est passé. Les exceptions peuvent être de plusieurs types, le type est écrit dans le message : dans l'exemple, les types sont ZeroDivisionError (erreur de division par zéro), NameError (erreur de nom) et TypeError (erreur de type). La chaîne de caractères affichée comme type de l'exception est le nom intégré pour l'exception qui a eu lieu. C'est le cas pour toutes les exceptions intégrées, mais pas forcément pour les exceptions définies par l'utilisateur (même si c'est une convention utile). Les noms des exceptions standards sont des identifiants intégrés (et non des mots-clés réservés).

Le reste de la ligne contient des détails, dont l'interprétation dépend du type de l'exception.

La partie précédant le message d'erreur affiche le contexte dans lequel l'exception a eu lieu, sous forme de trace de la pile. En général, elle contient une trace de pile avec des lignes de code source ; toutefois, les lignes lues depuis l'entrée standard ne seront pas affichées.

La Library Reference donne la liste des exceptions intégrées et leur signification.

Il est possible d'écrire des programmes qui prennent en charge des exceptions spécifiques. Regardez l'exemple suivant, qui affiche une table des inverses de quelques nombres à virgule flottante :

>>> while 1:
...     try:
...         x = int(raw_input("Veuillez entrer un nombre: "))
...         break
...     except ValueError:
...         print "Aille! Ce n'était pas un nombre valide.  Essayez encore..."
...

L'instruction try fonctionne ainsi :

• d'abord, la clause d'essai (clause try: les instructions entre les mots-clés try et except) est exécutée ;
• s'il ne se produit pas d'exception, la clause d'exception (clause except) est ignorée, et l'exécution du try est terminée ;
• si une exception se produit à un moment de l'exécution de la clause d'essai, le reste de la clause try est ignoré. Puis si son type correspond à l'exception donnée après le mot-clé except, la clause except est exécutée, puis l'exécution reprend après l'instruction try;
• si une exception se produit qui ne correspond pas à l'exception donnée dans la clause except, elle est renvoyée aux instructions try extérieures ; s'il n'y a pas de prise en charge, il s'agit d'une exception non gérée et l'exécution est arrêtée avec un message, comme vu précédemment.

Une instruction try peut avoir plus d'une clause d'exception, de façon à définir des gestionnaires d'exception différents pour des exceptions différentes. Au plus une clause d'exception sera exécutée. Dans une clause d'exception ne seront gérées que les exceptions survenant dans la clause d'essai correspondante, et non pas celles provenant d'autres clauses d'exception. Une clause d'exception peut nommer plusieurs exceptions dans une liste parenthésée, par exemple :

... except (RuntimeError, TypeError, NameError):
...     pass

La dernière clause d'exception peut omettre le(s) nom(s) d'exception, et sert alors de passe-partout. Utilisez ceci avec une précaution extrême : il est facile de cacher de cette façon une vraie erreur de programmation !

import string, sys

try:
    f = open('monfichier.txt')
    c = f.readline()
    i = int(string.strip(c))
except IOError, (errno, strerror):
    print "Erreur(s) E/S: c"  (errno, strerror)
except ValueError:
    print "N'a pas pu convertir la donnée en entier."
except:
    print "Erreur non prévue:", sys.exc_info()[0]
    raise

L'instruction try...except admet une clause par défaut (clause else) qui doit suivre toutes les clauses d'exception. Elle est utile pour placer le code qui doit être exécuté si la clause d'essai ne déclenche pas d'exception. Par exemple :

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print 'impossible d'ouvrir', arg
    else:
        print arg, 'comporte', len(f.readlines()), 'lignes'
        f.close()

L'utilisation de la clause else est meilleure que l'ajout d'un code supplémentaire à la clause try parce qu'elle évite d'intercepter de façon accidentelle une exception qui n'a pas été déclenchée par le code qui est protégé par l'instruction try ... except.

Quand une exception survient, elle peut avoir une valeur associée, appelée aussi l'argument de l'exception. La présence et le type de l'argument dépendent du type de l'exception. Pour les types d'exception qui ont un argument, la clause d'exception peut spécifier une variable après le nom (ou la liste) d'exception(s) qui recevra la valeur de l'argument, de la manière suivante :

>>> try:
...     spam()
... except NameError, x:
...     print 'nom', x, 'non défini'
...
nom spam non défini

Si une exception a un argument, celui-ci sera affiché dans la dernière partie ('détail') du message pour une exception non gérée.

Les clauses d'exception ne prennent pas en charge uniquement les exceptions qui surviennent dans la clause d'essai, mais aussi celles qui surviennent dans les fonctions appelées (même de façon indirecte) dans la clause d'essai. Par exemple :

>>> def ceci_ne_marche_pas():
...     x = 1/0
...
>>> try:
...     ceci_ne_marche_pas()
... except ZeroDivisionError, detail:
...     print 'Gestion d'erreur à l'exécution:', detail
...
Gestion d'erreur à l'exécution: integer division or modulo

L'instruction raise permet au programmeur de déclencher une exception. Par exemple :

>>> raise NameError, 'Coucou'
Traceback (innermost last):
  File "<stdin>", line 1
NameError: Coucou

Le premier argument de raise nomme l'exception qui doit être déclenchée. Le second argument (optionnel) spécifie l'argument de l'exception.

Les programmes peuvent nommer leurs propres exceptions en affectant une chaîne de caractères à une variable. Par exemple :

>>> mon_exc = 'mon_exc'
>>> try:
...     raise mon_exc, 2*2
... except mon_exc, val:
...     print 'Mon exception a été déclenchée, valeur:', val
...
Mon exception a été déclenchée, valeur: 4
>>> raise mon_exc, 1
Traceback (innermost last):
  File "<stdin>", line 1
mon_exc: 1

Plusieurs modules standards s'en servent pour rapporter les erreurs qui peuvent survenir dans les fonctions qu'ils définissent.

Plus d'informations au sujet des classes sont données dans le chapitre 9, ''Classes''.

L'instruction try admet une autre clause optionnelle qui permet de définir les actions de nettoyage qui doivent être exécutées impérativement. Par exemple :

>>> try:
...     raise KeyboardInterrupt
... finally:
...     print 'Adieu, monde!'
...
Adieu, monde!
Traceback (innermost last):
  File "<stdin>", line 2
KeyboardInterrupt

Une clause de finalisation (clause finally) est exécutée qu'une exception ait eu lieu ou non dans la clause d'essai. Si une exception a été déclenchée, elle est déclenchée à nouveau après l'exécution de la clause de finalisation. La clause de finalisation est aussi exécutée ''en sortant'' lorsque l'instruction try est interrompue par les instructions break ou return.

Une instruction try doit avoir ou bien une ou plusieurs clauses d'exception, ou bien une clause de finalisation, mais pas les deux.

À défaut d'une terminologie universellement acceptée pour parler des classes, j'utiliserai à l'occasion des termes de Smalltalk et C++. (J'utiliserais volontiers des termes de Modula-3, puisque sa sémantique orientée objet est plus proche de celle de Python que celle de C++, mais j'imagine que peu de lecteurs ont entendu parler de ce langage.)

Je dois aussi vous prévenir qu'il y a un piège terminologique pour les lecteurs familiers de l'orienté objet : le mot « objet » en Python ne veut pas forcément dire instance d'une classe. Comme en C++ et Modula-3 et contrairement à Smalltalk, tous les types Python ne sont pas des classes : les types intégrés de base comme les entiers et les listes ne le sont pas, et même des types plus exotiques comme les fichiers ne le sont pas non plus. Pourtant, tous les types en Python partagent un peu de sémantique commune, décrite au mieux par le mot objet.

Les objets possèdent une individualité, et des noms multiples (dans des portées multiples) peuvent être liés au même objet. Cela s'appelle aliasing dans d'autres langages. On ne le remarque pas de prime abord dans Python, et on peut l'ignorer pour le traitement des types de base non modifiables (nombres, chaînes de caractères, tuples). Néanmoins, l'aliasing a un effet (voulu !) sur la sémantique du code Python qui met en jeu des objets modifiables comme listes, dictionnaires et la plupart des types représentant des entités à l'exception du programme (fichiers, fenêtres, etc.). Ceci est mis à profit dans les programmes, puisque les alias se comportent comme des pointeurs à plusieurs points de vue. Par exemple, le passage en paramètre d'un objet n'est pas coûteux puisque seul un pointeur est transmis par l'implémentation ; et si une fonction modifie un objet reçu en argument, l'appelant verra la modification - ce qui élimine le besoin d'avoir deux mécanismes de passage d'arguments comme en Pascal.

Avant d'introduire les classes, je dois vous dire quelques mots sur les règles de portée en Python. Les définitions de classe jouent astucieusement avec les espaces de noms, et vous devez savoir comment fonctionnent les portées et les espaces de noms pour comprendre ce qui se passe. En fait, la connaissance de ce sujet est utile à tout programmeur Python avancé.

D'abord quelques définitions.

Un espace de noms (name space) est une relation entre des noms et des objets. La plupart des espaces de noms sont actuellement implémentés comme des dictionnaires, mais cela n'est pas visible (sauf sur les performances peut-être) et pourrait changer dans le futur. Quelques exemples d'espaces de noms : l'ensemble des noms intégrés (les fonctions telles que abs(), et les noms d'exception intégrés) ; les noms globaux dans un module ; les noms locaux au cours d'un appel de fonction. En un sens, l'ensemble des attributs d'un objet constitue aussi un espace de noms. La chose importante à savoir sur les espaces de noms est qu'il n'y a absolument aucune relation entre les noms contenus dans les différents espaces de noms ; par exemple, deux modules différents peuvent définir tous les deux une fonction ''maximise'' sans confusion possible - les utilisateurs des modules doivent préfixer par le nom du module à l'utilisation.

Au passage, j'utilise le mot attribut (attribute) pour n'importe quel nom qui suit un point - par exemple, dans l'expression z.real, real est un attribut de l'objet z. Strictement parlant, les références à des noms dans des modules sont des attributs ; dans l'expression nommod.nomfonc, nommod est un objet module et nomfonc en est un attribut. Dans ce cas, il y a un rapport direct entre les attributs du module et les noms globaux définis dans le module : ils partagent le même espace de noms !(7)

Les attributs peuvent être en lecture seule ou bien modifiables. Dans ce cas, on peut affecter des valeurs à des attributs. Les attributs d'un module sont modifiables : vous pouvez faire "nommod.la_reponse = 42". Les attributs modifiables peuvent aussi être effacés avec l'instruction del, par exemple "del nommod.la_reponse".

Les espaces de noms sont créés à des moments différents et ont des durées de vie différentes. L'espace de noms qui contient les noms intégrés est créé au lancement de l'interpréteur Python, et n'est jamais effacé. L'espace de noms global pour un module est créé quand la définition du module est chargée ; normalement, les espaces de noms des modules vivent jusqu'à la mort de l'interpréteur. Les instructions exécutées à l'invocation de l'interpréteur par le niveau supérieur, qu'elles soient lues depuis un fichier ou entrées de façon interactive, sont considérées comme faisant partie d'un module appelé __main__, elles ont donc leur propre espace de noms global. (En fait, les noms intégrés font aussi partie d'un module appelé __builtin__.)

L'espace de noms local à une fonction est créé quand celle-ci est appelée et il est effacé quand la fonction se termine ou déclenche une exception qui n'est pas gérée dans la fonction. (En fait, oublié décrit mieux ce qui se passe vraiment.) Évidemment, les appels récursifs ont chacun leur propre espace de noms.

Une portée (scope) est une région textuelle d'un programme Python dans laquelle un espace de noms est directement accessible. ''Directement accessible'' veut dire qu'une référence non qualifiée à un nom cherchera ce nom dans cet espace de noms.

Bien qu'elles soient déterminées statiquement, les portées sont utilisées dynamiquement. À n'importe quel moment de l'exécution, exactement trois portées imbriquées sont utilisées (c'est-à-dire exactement trois espaces de noms sont accessibles directement) : la portée immédiate, qui est explorée en premier, contient les noms locaux, la portée intermédiaire, explorée ensuite, contient les noms globaux du module courant, et la portée extérieure (explorée en dernier) correspond à l'espace de noms contenant les noms intégrés.

Normalement, la portée locale fait référence aux noms de la fonction courante (textuellement). En dehors des fonctions, la portée locale fait référence au même espace de noms que la portée globale : l'espace de noms du module. Les définitions de classe placent encore un autre espace de noms dans la portée locale.

Il est important de voir que les portées sont déterminées de façon textuelle : la portée globale d'une fonction définie dans un module est l'espace de noms de ce module, peu importe d'où ou à travers quel alias cette fonction est appelée. D'un autre côté, la recherche de noms elle-même est effectuée dynamiquement, à l'exécution - toutefois, la définition du langage tend à évoluer vers la résolution statique de noms, au moment de la ''compilation'', alors ne vous basez pas sur la résolution dynamique de noms ! (En fait, les variables locales sont déjà déterminées de façon statique.)

Un point titilleux de Python est que les affectations se font toujours dans la portée immédiate. L'affectation ne copie pas de données - elle ne fait qu'affecter un nom à un objet. Ceci est vrai aussi de l'effacement : l'instruction "del x" enlève le lien vers x de l'espace de noms référencé par la portée locale. En fait, toute opération qui introduit de nouveaux noms utilise la portée locale : en particulier, les instructions d'importation et les définitions de fonction lient le nom du module ou de la fonction à la portée locale. (L'instruction global peut être utilisée pour indiquer que certaines variables vivent dans la portée globale.)

Les classes introduisent un peu de syntaxe nouvelle, trois nouveaux types d'objet, et quelques points de sémantique supplémentaires.

IX-C-1. Syntaxe de la définition de classes▲

class NomClasse:
    <instruction-1>
    .
    .
    .
    <instruction-N>

IX-C-2. Objets Classes▲

class MaClasse:
    "Une classe simple pour exemple''
    i = 12345
    def f(x):
        return 'bonjour'

x = MaClasse()

    def __init__(self):
        self.donnee = []

x = MaClasse()

>>> class Complexe:
...     def __init__(self, partiereelle, partieimaginaire):
...         self.r = partiereelle
...         self.i = partieimaginaire
...
>>> x = Complexe(3.0,-4.5)
>>> x.r, x.i
(3.0, -4.5)

IX-C-3. Objets instances▲

x.compteur = 1
while x.compteur < 10:
    x.compteur = x.compteur * 2
print x.compteur
del x.compteur

IX-C-4. Objets méthodes▲

x.f()

xf = x.f
while 1:
    print xf()

Les données attributs écrasent les méthodes de même nom ; pour éviter des conflits de noms accidentels, qui peuvent causer des bogues difficiles à trouver dans des programmes volumineux, il est sage d'utiliser une convention qui minimise les chances de conflit, par exemple, mettre en majuscules les noms des méthodes, préfixer les noms des données attributs avec une même courte chaîne de caractères (peut-être un simple tiret bas), ou utiliser des verbes pour les méthodes et des substantifs pour les données.

Les données attributs peuvent être référencées par des méthodes aussi bien que par les utilisateurs ordinaires (''clients'') d'un objet. Autrement dit, les classes ne sont pas utilisables pour implémenter des types abstraits purs. En fait, rien dans Python ne permet d'assurer le secret des données - tout est basé sur des conventions. (D'un autre côté, l'implémentation de Python, écrite en C, peut cacher complètement les détails d'implémentation et de contrôle d'accès à un objet si besoin est ; ceci peut être utilisé par les extensions de Python écrites en C.)

Les clients doivent utiliser les données attributs avec précaution - ils peuvent bouleverser des invariants entretenus par les méthodes en écrasant leurs données attributs. Notez bien que les clients peuvent rajouter des données attributs de leur cru à un objet instance sans affecter la validité des méthodes, pourvu que les conflits de noms soient évités - là encore, une convention de nommage peut éviter bien des migraines.

Il n'y a pas de raccourci pour faire référence à des données attributs (ou à d'autres méthodes !) à partir d'une méthode. Je trouve que cela augmente en fait la lisibilité des méthodes : il n'y a aucune chance de confondre les variables locales et les variables d'instance lorsqu'on examine une méthode.

Par convention, le premier argument d'une méthode est souvent appelé self. Ce n'est qu'une convention : le mot self n'a absolument aucun sens spécial pour Python. (Remarquez, tout de même, que si votre code ne suit pas la convention, il peut se révéler moins lisible par d'autres programmeurs Python, et il est aussi concevable qu'un explorateur de classes soit écrit, qui se base sur cette convention.)

Tout objet fonction qui est aussi un attribut d'une classe définit une méthode pour les instances de cette classe. Il n'est pas nécessaire que la définition de la fonction soit textuellement comprise dans la définition de la classe : affecter un objet fonction à une variable locale dans la classe marche aussi. Par exemple :

# Fonction définie en dehors de la classe
def f1(self, x, y):
    return min(x, x+y)

class C:
    f = f1
    def g(self):
        return 'bonjour'
    h = g

Maintenant, f, g et h sont tous trois des attributs de la classe C qui font référence à des objets fonctions, et par conséquent ils sont tous les trois des méthodes des instances de C - h équivaut exactement à g. Remarquez que cette pratique ne sert souvent qu'à embrouiller le lecteur du programme.

Les méthodes peuvent appeler d'autres méthodes en utilisant les attributs méthodes de l'argument self, par exemple :

class Sac:
    def vider(self):
        self.donnees = []
    def ajouter(self, x):
        self.donnees.append(x)
    def ajouterdoublon(self, x):
        self.ajouter(x)
        self.ajouter(x)

Les méthodes peuvent faire référence à des noms globaux de la même façon que les fonctions ordinaires. La portée globale associée à une méthode est celle du module qui contient la définition de la classe. (La classe elle-même ne sert jamais de portée globale !) Alors qu'on trouve rarement de bonnes raisons pour utiliser des données globales dans une méthode, il y a plusieurs utilisations légitimes de la portée globale : ne serait-ce que le fait que les fonctions et les modules importés dans la portée globale peuvent être utilisés par les méthodes, de même que les fonctions et les classes qui y sont définies. D'habitude, la classe qui contient la méthode est elle-même définie dans cette portée globale, et dans la section suivante nous allons voir quelques bonnes raisons pour lesquelles une méthode pourrait vouloir faire référence à sa propre classe !

Bien sûr, une caractéristique du langage ne serait pas digne du mot ''classe'' si elle ne permettait pas l'héritage. La syntaxe pour définir une classe dérivée ressemble à ceci :

class NomClasseDerivee(NomClasseDeBase):
    <instruction-1>
    .
    .
    .
    <instruction-N>

Le nom NomClasseDeBase doit être défini dans une portée contenant la définition de la classe dérivée. À la place d'un nom de classe de base, une expression est acceptée. Ceci est utile lorsque la classe de base est définie dans un autre module, par exemple :

class NomClasseDerivee(nommod.NomClasseDeBase):

L'exécution d'une définition de classe dérivée se déroule comme pour une classe de base. Quand l'objet classe est construit, la classe de base est mémorisée. Ceci est employé dans la résolution des références d'attribut : si l'attribut demandé n'est pas trouvé dans la classe, il est recherché dans la classe de base. Cette règle est employée récursivement si la classe de base est elle-même dérivée depuis une autre classe.

Il n'y a rien de spécial dans l'instanciation d'une classe dérivée : NomClasseDerivee() crée une nouvelle instance de la classe. Les références aux méthodes sont résolues ainsi : l'attribut est recherché dans la classe correspondante, en descendant la chaîne des classes de base si besoin est, et la référence à la méthode est valide si cette recherche aboutit à un objet fonction.

Les classes dérivées peuvent redéfinir les méthodes de leurs classes de base. Puisque les méthodes ne jouissent pas de privilèges particuliers lorsqu'elles appellent d'autres méthodes du même objet, la méthode d'une classe de base qui appelle une autre méthode définie dans la même classe de base peut en définitive appeler une méthode d'une classe dérivée qui a redéfini cette méthode. (Pour les programmeurs C++: toutes les méthodes en Python sont des ''fonctions virtuelles''.)

Une méthode d'une classe dérivée qui redéfinit une fonction peut en fait vouloir étendre et non pas remplacer la méthode de la classe de base de même nom. Il y un moyen simple d'appeler la méthode de la classe de base directement : simplement appelez "NomClasseDeBase.nommethode(self, arguments)". Ceci peut parfois s'avérer utile pour les clients aussi. (Remarquez que ça ne marche que si la classe de base est définie ou importée dans la portée globale.)

IX-E-1. Héritage multiple▲

class NomClasseDerivee(Base1, Base2, Base3):
    <instruction-1>
    .
    .
    .
    <instruction-N>

Il y a un support limité pour des identificateurs privés dans une classe. Tout identificateur de la forme __spam (au moins deux tirets bas au début, au plus un tiret bas à la fin) est maintenant textuellement remplacé par _nomclasse__spam, où nomclasse est le nom de classe courant, duquel les tirets bas de début ont été enlevés. Ce brouillage (mangling) est réalisé indépendamment de la position syntaxique de l'identificateur, donc il peut être utilisé pour définir des variables de classe et d'instance privées, des méthodes, des globales, et même pour enregistrer des variables d'instance privées de cette classe dans des instances d'autres classes. Le nom brouillé peut être tronqué s'il dépasse 255 caractères. En dehors des classes, ou lorsque le nom de la classe ne contient que des tirets bas, le brouillage n'a pas lieu.

Le brouillage de noms permet aux classes de définir simplement des variables d'instance et des méthodes ''privées'', sans avoir à se préoccuper des variables d'instance définies par des classes dérivées, ou des problèmes avec des variables d'instance définies en dehors de la classe. Remarquez que les règles de brouillage ont été dessinées surtout pour éviter des accidents ; il reste possible d'accéder ou de modifier une variable considérée comme privée. Ceci peut être utile, par exemple pour le débogage, et c'est une des raisons pour lesquelles ce trou n'est pas comblé. (Petit bogue : dériver une classe en utilisant le même nom de classe permet l'utilisation des variables privées de la classe de base.)

Remarquez que le code passé en argument à exec, eval() ou evalfile() ne considère pas le nom de classe de la classe appelante comme étant le nom de classe courant ; c'est un effet similaire à celui de l'instruction global, limité à du code qui a été compilé en même temps. La même restriction s'applique à getattr(), setattr() et delattr(), de même qu'aux références directes à __dict__.

Voici l'exemple d'une classe qui implémente ses propres méthodes __getattr__ et __setattr__ et enregistre tous les attributs dans une variable privée :

class AttributsVirtuels:
    __vdict = None
    __vdict_name = locals().keys()[0]
    
    def __init__(self):
        self.__dict__[self.__vdict_name] = {}
   
    def __getattr__(self, name):
        return self.__vdict[name]
   
    def __setattr__(self, name, value):
        self.__vdict[name] = value

Il est parfois utile de disposer d'un type de données semblable au ''record'' du Pascal ou au ''struct'' du C, pour lier quelques données nommées. Une définition de classe vide peut servir à cela :

class Employe:
    pass

john = Employe() # Crée un enregistrement vide d'Employe

# Remplit les champs de l'enregistrement
john.nom = 'John Doe'
john.dept = 'computer lab'
john.salaire = 1000

Un bout de code Python qui attend des données d'un certain type abstrait peut souvent recevoir à la place une classe qui simule les méthodes de ce type de données. Par exemple, si vous avez une fonction qui met en forme des données issues d'un objet fichier, vous pouvez définir une classe avec des méthodes read() et readline() qui prend les données d'un tampon et passer celui-ci comme argument.

Les objets méthode d'instance possèdent eux-mêmes des attributs : m.im_self est l'objet duquel la méthode est instance, et m.im_func est l'objet fonction correspondant à la méthode.

Les exceptions définies par l'utilisateur ne sont pas limitées à être des chaînes de caractères - elles peuvent être aussi identifiées comme des classes. En utilisant ce mécanisme, on peut définir des hiérarchies extensibles d'exceptions.

Il y a deux formes sémantiques valides pour l'instruction raise :

raise Classe, instance

raise instance

Dans la première forme, instance doit être une instance de Classe ou d'une de ses classes dérivées. La seconde forme est un raccourci pour :

raise instance.__class__, instance

Une clause d'exception peut lister des classes et des chaînes de caractères. Une classe dans une clause d'exception est compatible avec une exception si celle-ci est la même classe ou une classe qui en est dérivée (mais pas en sens inverse - une clause d'exception qui liste une classe dérivée n'est pas compatible avec une classe de base). Par exemple, le code suivant affichera B, C, D, dans cet ordre :

class B:
    pass
class C(B):
    pass
class D(C):
    pass

for c in [B, C, D]:
    try:
        raise c()
    except D:
        print "D"
    except C:
        print "C"
    except B:
        print "B"

Remarquez que si les clauses d'exception avaient été inversées ("except B" en premier), le code aurait affiché B, B, B - c'est la première clause except qui convient qui est exécutée.

Lorsqu'un message d'erreur est affiché pour une exception non gérée qui est une classe, le nom de la classe est affiché, puis deux-points, un espace, et finalement, l'instance convertie en chaîne de caractères à travers la fonction intégrée str().

Si elle est supportée, l'édition de ligne d'entrée est active lorsque l'interpréteur affiche un prompt primaire ou secondaire. La ligne courante peut être éditée en utilisant les caractères de contrôle conventionnels d'Emacs. Les plus importants sont : C-A (Control-A) déplace le curseur en début de ligne, C-E en fin de ligne, C-B déplace d'une position vers la gauche, C-F vers la droite. Backspace efface le caractère à gauche du curseur, C-D le caractère à droite. C-K tue (efface) le reste de la ligne à droite du curseur, C-Y rappelle la dernière chaîne tuée. C-tiret bas défait le dernier changement réalisé ; il peut être répété pour un effet cumulé.

La substitution historique fonctionne ainsi. Toutes les lignes d'entrée non vides sont enregistrées dans un tampon d'historique, et lorsqu'un nouveau prompt est affiché, vous êtes dans une nouvelle ligne à la fin de ce tampon. C-P déplace d'une ligne vers le haut (vers l'arrière) dans l'historique, C-N vers le bas. Toute ligne de l'historique peut être éditée ; un astérisque apparaît en début de ligne avant le prompt pour indiquer que la ligne a été modifiée. Appuyer sur Entrée passe la ligne courante à l'interpréteur. C-R commence une recherche incrémentale en arrière ; C-S une recherche en avant.

Les associations des touches aux commandes et d'autres paramètres de la bibliothèque Readline peuvent être redéfinis en plaçant des commandes d'initialisation dans le fichier $HOME/.inputrc. Les définitions de raccourcis clavier ont la forme

nom-de-touche: nom-de-fonction

ou bien

"chaîne": nom-de-fonction

et les options sont modifiées avec

set nom-option valeur

Par exemple :

# Je préfère l'édition à la vi:
set editing-mode vi
# Edition sur une seule ligne:
set horizontal-scroll-mode On
# Redéfinir quelques touches:
Meta-h: backward-kill-word
"\C-u": universal-argument
"\C-x\C-r": re-read-init-file

Remarquez que l'action liée à la tabulation en Python est d'insérer une tabulation, au lieu de l'action par défaut de Readline, qui est la complétion de noms. Si vous insistez, vous pouvez redéfinir cela avec

Tab: complete

dans le fichier $HOME/.inputrc. (Bien sûr, cela rend plus difficile l'indentation des lignes de continuation…)

La complétion automatique des noms de variable et de module est disponible en option. Pour l'activer dans le mode interactif de l'interpréteur, rajouter ceci à votre fichier $HOME/.pythonrc :

import rlcompleter, readline
readline.parse_and_bind('tab: complete')

Ceci lie la touche TAB à la fonction de complétion, donc appuyer deux fois sur TAB affiche les suggestions de complétion ; celles-ci sont cherchées parmi les noms d'instructions, les variables locales actuelles et les noms de module disponibles. Pour des expressions avec un point comme string.a, la complétion sera réalisée jusqu'au "." puis les complétions correspondant aux attributs suivants seront suggérées. Remarquez que cela peut amener à exécuter du code propre à une application si un objet avec une méthode __getattr__() apparaît dans l'expression.

Cette commodité est un énorme pas en avant par rapport aux versions plus anciennes de l'interpréteur ; néanmoins, quelques vœux restent à remplir : ce serait bien que l'indentation soit suggérée sur les lignes de continuation (l'interpréteur sait si un lexème d'indentation est requis par la suite). Le mécanisme de complétion pourrait se servir de la table de symboles de l'interpréteur. Une commande pour vérifier (voire suggérer) l'équilibre des parenthèses, des quotes, etc. serait aussi très utile.

Python a été créé au début des années 1990 par Guido van Rossum au Stichting Mathematisch Centrum (CWI) aux Pays-Bas en tant que successeur d'un langage appelé ABC. Guido est l'auteur principal de Python, bien qu'il inclue de nombreuses contributions de la part d'autres personnes. La dernière version diffusée par le CWI a été Python 1.2. En 1995, Guido a continué son travail sur Python au Corporation for National Research Initiatives (CNRI) de Reston, en Virginie (USA) où il a diffusé plusieurs versions de ce logiciel. Python 1.6 a été la dernière des versions diffusées par le CNRI. En 2000, Guido et l'équipe de développement centrale de Python sont partis à BeOpen.com pour former l'équipe BeOpen PythonLabs. Python 2.0 a été la première et seule version diffusée depuis BeOpen.com.

À la suite de la sortie de Python 1.6, et après que Guido van Rossum a quitté CNRI pour travailler avec des développeurs de logiciel commercial, il est apparu clairement que la capacité d'utiliser Python avec du logiciel disponible sous la Licence Publique Générale GNU (GPL) était très souhaitable. Le CNRI et la Free Software Foundation (FSF) ont travaillé ensemble pour mettre au point des changements de formulation dans la licence Python. Python 1.6.1 est essentiellement la même chose que Python 1.6, avec quelques bogues mineurs réglés, et avec une licence différente qui permet aux versions suivantes d'être compatibles GPL. Python 2.0.1 est un travail dérivé de Python 1.6.1, de même que de Python 2.0.

Après que Python 2.0 a été diffusé par BeOpen.com, Guido van Rossum et les autres développeurs des PythonLabs ont rejoint Digital Creations. Toute la propriété intellectuelle ajoutée à partir de ce moment, incluant Python 2.0.1 et ses versions alpha et bêta, est possédée par la Python Software Foundatio (PSF), une organisation sans but lucratif construite sur le modèle de l'Apache Software Foundation. Voir http://www.python.org/psf/ pour plus d'informations à propos de la PSF.

Merci aux nombreux volontaires extérieurs qui ont travaillé sous la direction de Guido pour rendre ces diffusions possibles.

PSF LICENSE AGREEMENT

1. This LICENSE AGREEMENT is between the Python Software Foundation (''PSF''), and the Individual or Organization (''Licensee'') accessing and otherwise using Python 2.0.1 software in source or binary form and its associated documentation.
2. Subject to the terms and conditions of this License Agreement, PSF hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python 2.0.1 alone or in any derivative version, provided, however, that PSF's License Agreement and PSF's notice of copyright, i.e., ''Copyright © 2001 Python Software Foundation; All Rights Reserved'' are retained in Python 2.0.1 alone or in any derivative version prepared by Licensee.
3. In the event Licensee prepares a derivative work that is based on or incorporates Python 2.0.1 or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python 2.0.1.
4. PSF is making Python 2.0.1 available to Licensee on an ''AS IS'' basis. PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 2.0.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 2.0.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 2.0.1, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
7. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between PSF and Licensee. This License Agreement does not grant permission to use PSF trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
8. By copying, installing or otherwise using Python 2.0.1, Licensee agrees to be bound by the terms and conditions of this License Agreement.

BEOPEN.COM TERMS AND CONDITIONS FOR PYTHON 2.0

BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1

1. This LICENSE AGREEMENT is between BeOpen.com (''BeOpen''), having an office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the Individual or Organization (''Licensee'') accessing and otherwise using this software in source or binary form and its associated documentation (''the Software'').
2. Subject to the terms and conditions of this BeOpen Python License Agreement, BeOpen hereby grants Licensee a non-exclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use the Software alone or in any derivative version, provided, however, that the BeOpen Python License is retained in the Software, alone or in any derivative version prepared by Licensee.
3. BeOpen is making the Software available to Licensee on an ''AS IS'' basis. BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
5. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
6. This License Agreement shall be governed by and interpreted in all respects by the law of the State of California, excluding conflict of law provisions. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between BeOpen and Licensee. This License Agreement does not grant permission to use BeOpen trademarks or trade names in a trademark sense to endorse or promote products or services of Licensee, or any third party. As an exception, the ''BeOpen Python'' logos available at http://www.pythonlabs.com/logos.php may be used according to the permissions granted on that web page.
7. By copying, installing or otherwise using the software, Licensee agrees to be bound by the terms and conditions of this License Agreement.

CNRI OPEN SOURCE GPL-COMPATIBLE LICENSE AGREEMENT

1. This LICENSE AGREEMENT is between the Corporation for National Research Initiatives, having an office at 1895 Preston White Drive, Reston, VA 20191 (''CNRI''), and the Individual or Organization (''Licensee'') accessing and otherwise using Python 1.6.1 software in source or binary form and its associated documentation.
2. Subject to the terms and conditions of this License Agreement, CNRI hereby grants Licensee a nonexclusive, royalty-free, world-wide license to reproduce, analyze, test, perform and/or display publicly, prepare derivative works, distribute, and otherwise use Python 1.6.1 alone or in any derivative version, provided, however, that CNRI's License Agreement and CNRI's notice of copyright, i.e., ''Copyright © 1995-2001 Corporation for National Research Initiatives; All Rights Reserved'' are retained in Python 1.6.1 alone or in any derivative version prepared by Licensee. Alternately, in lieu of CNRI's License Agreement, Licensee may substitute the following text (omitting the quotes): ''Python 1.6.1 is made available subject to the terms and conditions in CNRI's License Agreement. This Agreement together with Python 1.6.1 may be located on the Internet using the following unique, persistent identifier (known as a handle): 1895.22/1013. This Agreement may also be obtained from a proxy server on the Internet using the following URL: http://hdl.handle.net/1895.22/1013.''
3. In the event Licensee prepares a derivative work that is based on or incorporates Python 1.6.1 or any part thereof, and wants to make the derivative work available to others as provided herein, then Licensee hereby agrees to include in any such work a brief summary of the changes made to Python 1.6.1.
4. CNRI is making Python 1.6.1 available to Licensee on an ''AS IS'' basis. CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED. BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT INFRINGE ANY THIRD PARTY RIGHTS.
5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON 1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1, OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
6. This License Agreement will automatically terminate upon a material breach of its terms and conditions.
7. This License Agreement shall be governed by the federal intellectual property law of the United States, including without limitation the federal copyright law, and, to the extent such U.S. federal law does not apply, by the law of the Commonwealth of Virginia, excluding Virginia's conflict of law provisions. Notwithstanding the foregoing, with regard to derivative works based on Python 1.6.1 that incorporate non-separable material that was previously distributed under the GNU General Public License (GPL), the law of the Commonwealth of Virginia shall govern this License Agreement only as to issues arising under or with respect to Paragraphs 4, 5, and 7 of this License Agreement. Nothing in this License Agreement shall be deemed to create any relationship of agency, partnership, or joint venture between CNRI and Licensee. This License Agreement does not grant permission to use CNRI trademarks or trade name in a trademark sense to endorse or promote products or services of Licensee, or any third party.
8. By clicking on the ''ACCEPT'' button where indicated, or by copying, installing or otherwise using Python 1.6.1, Licensee agrees to be bound by the terms and conditions of this License Agreement.

ACCEPT

CWI PERMISSIONS STATEMENT AND DISCLAIMER

Copyright © 1991 - 1995, Stichting Mathematisch Centrum Amsterdam, The Netherlands. All rights reserved.

Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Stichting Mathematisch Centrum or CWI not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission.

STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

==========================================================

La version traduite en français de ce document, résultat du travail initial de plusieurs traducteurs (Olivier Berger, Daniel Calvelo Aros, Bruno Liénard) a été assemblée et mise à jour par Olivier Berger dans le cadre du projet bénévole de traduction en français de la documentation Python. Pour contribuer au projet, ou obtenir une mise à jour de ce document, veuillez vous reporter au site Internet suivant : http://sourceforge.net/projects/frpython. Ce document est issu de la traduction du document original en anglais V1.5.1 de Guido Van Rossum, avec son aimable permission. Il a été mis à jour régulièrement pour tenir compte des évolutions du document original. La présente version est à jour par rapport à la V2.0.1. Prière de bien vouloir me signaler (olberger@club-internet.fr) toute erreur de traduction, ou vos remarques concernant cette traduction. Les questions concernant le langage Python ou le contenu du présent document sont à adresser directement à l'auteur.

General comments and questions regarding this document should be sent by email to . If you find specific errors in this document, please report the bug at the Python Bug Tracker at SourceForge.

Questions regarding how to use the information in this document should be sent to the Python news group, comp.lang.python, or the Python mailing list (which is gated to the newsgroup and carries the same content).

For any of these channels, please be sure not to send php email. Thanks.