Plongez au coeur de Python ,De débutant à expert

Exemple 3.1. Définition d'un dictionnaire▲

	>>> d = {"server":"mpilgrim", "database":"master"} ***1***
	>>> d
	{'server': 'mpilgrim', 'database': 'master'}
	>>> d["server"]                                    ***2***
	'mpilgrim'
	>>> d["database"]                                  ***3***
	'master'
	>>> d["mpilgrim"]                                  ***4***
	Traceback (innermost last):
	  File "<interactive input>", line 1, in ?
	KeyError: mpilgrim

Exemple 3.2. Modification d'un dictionnaire▲

>>> d
{'server': 'mpilgrim', 'database': 'master'}
>>> d["database"] = "pubs" 1
>>> d
{'server': 'mpilgrim', 'database': 'pubs'}
>>> d["uid"] = "sa"        2
>>> d
{'server': 'mpilgrim', 'uid': 'sa', 'database': 'pubs'}

Exemple 3.3. Les clés des dictionnaires sont sensibles à la casse▲

>>> d = {}
>>> d["key"] = "value"
>>> d["key"] = "other value" ***1***
>>> d
{'key': 'other value'}
>>> d["Key"] = "third value" ***2***
>>> d
{'Key': 'third value', 'key': 'other value'}

Exemple 3.4. Mélange de types de données dans un dictionnaire▲

>>> d
{'server': 'mpilgrim', 'uid': 'sa', 'database': 'pubs'}
>>> d["retrycount"] = 3 1
>>> d
{'server': 'mpilgrim', 'uid': 'sa', 'database': 'master', 'retrycount': 3}
>>> d[42] = "douglas"   2
>>> d
{'server': 'mpilgrim', 'uid': 'sa', 'database': 'master',
42: 'douglas', 'retrycount': 3}

Exemple 3.5. Enlever des éléments d'un dictionnaire▲

>>> d
{'server': 'mpilgrim', 'uid': 'sa', 'database': 'master',
42: 'douglas', 'retrycount': 3}
>>> del d[42] ***1***
>>> d
{'server': 'mpilgrim', 'uid': 'sa', 'database': 'master', 'retrycount': 3}
>>> d.clear() ***2***
>>> d
{}

Exemple 3.6. Definition d'une liste▲

>>> li = ["a", "b", "mpilgrim", "z", "example"] ***1***
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[0]                                       ****2***
'a'
>>> li[4]                                       ***3***
'example'

Exemple 3.7. Indices de liste négatifs▲

>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[-1] 1
'example'
>>> li[-3] 2
'mpilgrim'

Exemple 3.8. Découpage d'une liste▲

>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[1:3]  ***1***
['b', 'mpilgrim']
>>> li[1:-1] ***2***
['b', 'mpilgrim', 'z']
>>> li[0:3]  ***3***
['a', 'b', 'mpilgrim']

Exemple 3.9. Raccourci pour le découpage▲

>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[:3] ***1***
['a', 'b', 'mpilgrim']
>>> li[3:] ***2*** ***3***
['z', 'example']
>>> li[:]  ***4***
['a', 'b', 'mpilgrim', 'z', 'example']

Exemple 3.10. Ajout d'éléments à une liste▲

>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li.append("new")               ***1***
>>> li
['a', 'b', 'mpilgrim', 'z', 'example', 'new']
>>> li.insert(2, "new")            ***2***
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new']
>>> li.extend(["two", "elements"]) ***3***
>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']

Exemple 3.11. Différence entre extend et append▲

>>> li = ['a', 'b', 'c']
>>> li.extend(['d', 'e', 'f']) ***1***
>>> li
['a', 'b', 'c', 'd', 'e', 'f']
>>> len(li)                    ***2***
6
>>> li[-1]
'f'
>>> li = ['a', 'b', 'c']
>>> li.append(['d', 'e', 'f']) ***3***
>>> li
['a', 'b', 'c', ['d', 'e', 'f']]
>>> len(li)                    ***4***
4
>>> li[-1]
['d', 'e', 'f']

Exemple 3.12. Recherche dans une liste▲

>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
>>> li.index("example") ***1***
5
>>> li.index("new")     ***2***
2
>>> li.index("c")       ***3***
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
ValueError: list.index(x): x not in list
>>> "c" in li           ***4***
False

Exemple 3.13. Enlever des éléments d'une liste▲

>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
>>> li.remove("z")   ***1***
>>> li
['a', 'b', 'new', 'mpilgrim', 'example', 'new', 'two', 'elements']
>>> li.remove("new") ***2***
>>> li
['a', 'b', 'mpilgrim', 'example', 'new', 'two', 'elements']
>>> li.remove("c")   ***3***
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
ValueError: list.remove(x): x not in list
>>> li.pop()         ***4***
'elements'
>>> li
['a', 'b', 'mpilgrim', 'example', 'new', 'two']

Exemple 3.14. Opérateurs de listes▲

>>> li = ['a', 'b', 'mpilgrim']
>>> li = li + ['example', 'new'] ***1***
>>> li
['a', 'b', 'mpilgrim', 'example', 'new']
>>> li += ['two']                ***2***
>>> li
['a', 'b', 'mpilgrim', 'example', 'new', 'two']
>>> li = [1, 2] * 3              ***3***
>>> li
[1, 2, 1, 2, 1, 2]

>>> t = ("a", "b", "mpilgrim", "z", "example") ***1***
>>> t
('a', 'b', 'mpilgrim', 'z', 'example')
>>> t[0]                                       ***2***
'a'
>>> t[-1]                                      ***3***
'example'
>>> t[1:3]                                     ***4***
('b', 'mpilgrim')

***1*** Un tuple est défini de la même manière qu'une liste sauf que l'ensemble d'éléments est entouré de parenthèses plutôt que de crochets.
***2*** Les éléments d'un tuple ont un ordre défini, tout comme ceux d'une liste. Les indices de tuples débutent à zéro, tout comme ceux d'une liste, le premier élément d'un tuple non vide est toujours t[0].
***3*** Les indices négatifs comptent à partir du dernier élément du tuple, tout comme pour une liste.
***4***Le découpage fonctionne aussi, tout comme pour une liste. Notez que lorsque vous découpez une liste, vous obtenez une nouvelle liste, lorsque vous découpez un tuple, vous obtenez un nouveau tuple.

>>> t
('a', 'b', 'mpilgrim', 'z', 'example')
>>> t.append("new")    ***1***
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
AttributeError: 'tuple' object has no attribute 'append'
>>> t.remove("z")      ***2***
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
AttributeError: 'tuple' object has no attribute 'remove'
>>> t.index("example") ***3***
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
AttributeError: 'tuple' object has no attribute 'index'
>>> "z" in t           ***4***
True

***1*** Vous ne pouvez pas ajouter d'élément à un tuple. Les tuples n'ont pas de méthodes append ou extend.
***2*** Vous ne pouvez pas enlever d'éléments d'un tuple. Les tuples n'ont pas de méthodes remove ou pop.
***3*** Vous ne pouvez pas rechercher d'éléments dans un tuple. Les tuples n'ont pas de méthode index.
***4*** Vous pouvez toutefois utiliser in pour vérifier l'existence d'un élément dans un tuple.

Mais à quoi servent donc les tuples ?

• Les tuples sont plus rapides que les listes. Si vous définissez un ensemble constant de valeurs et que tout ce que vous allez faire est le parcourir, utilisez un tuple au lieu d'une liste.
• Votre code est plus sûr si vous «protégez en écriture» les données qui n'ont pas besoin d'être modifiées. Utiliser un tuple à la place d'une liste revient à avoir une assertion implicite que les données sont constantes et que des mesures spécifiques sont nécéssaires pour modifier cette définition.
• Vous vous souvenez que j'avais dit que que les clés de dictionnaire pouvaient être des entiers, des chaînes et «quelques autres types» ? Les tuples sont un de ces types. Ils peuvent être utilisé comme clé dans un dictionnaire, ce qui n'est pas le cas des listes. En fait, c'est plus compliqué que ça. Les clés de dictionnaire doivent être non-mutables. Les tuples sont non-mutables mais si vous avez un tuple contenant des listes, il est considéré comme mutable et n'est pas utilisable comme clé de dictionnaire. Seuls les tuples de chaînes, de nombres ou d'autres tuples utilisable comme clé peuvent être utilisés comme clé de dictionnaire.
• Les tuples sont utilisés pour le formatage de chaînes, comme nous le verrons bientôt.

Les tuples peuvent être convertis en listes et vice-versa. La fonction prédéfinie tuple prends une liste et retourne un tuple contenant les mêmes éléments et la fonction list prends un tuple et retourne une liste. En fait, tuple gèle une liste et list dégèle un tuple.

Pour en savoir plus sur les tuples

• How to Think Like a Computer Scientistexplique les tuples et montre comment concaténer des tuples.
• LaPython Knowledge Basevous apprendra àtrier un tuple.
• Le Python Tutorial explique comment définir un tuple avec un seul élément.

if __name__ == "__main__":
    myParams = {"server":"mpilgrim", \
                "database":"master", \
                "uid":"sa", \
                "pwd":"secret" \
                }

Il y a plusieurs points intéressants ici. Tout d'abord, notez l'indentation. Une instruction if est un bloc de code et nécessite d'être indenté tout comme une fonction.
Deuxièmement, l'assignation de variable est une commande étalée sur plusieurs lignes avec une barre oblique («\») servant de marque de continuation de ligne.

Lorsq'une commande est étalée sur plusieurs lignes avec le marqueur de continuation de ligne («\»), les lignes suivantes peuvent être indentées de n'importe qu'elle manière, les règles d'indentation strictes habituellement utilisées en Python ne s'appliquent pas. Si votre IDE Python indente automatiquement les lignes continuées, vous devriez accepter ses réglages par défauts sauf raison impérative.

Les expressions entre parenthèses, crochets ou accolades (comme la définition d'un dictionnaire) peuvent être réparties sur plusieurs lignes avec ou sans le caractère de continuation («\»). Je préfère inclure la barre oblique même lorsqu'elle n'est pas requise car je pense que cela rends le code plus lisible mais c'est une question de style.

Troisièmement, vous n'avez jamais déclaré la variable myParams, vous lui avez simplement assigné une valeur. C'est comme en VBScript sans l'option option explicit. Heureusement, à l'inverse de VBScript, Python ne permet pas de référencer une variable à laquelle aucune valeur n'a été assigné. Tenter de le faire déclenchera une exception.

Exemple 3.18. Référencer une variable non assignée▲

>>> x
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
NameError: There is no variable named 'x'
>>> x = 1
>>> x
1

Un des raccourcis les plus réjouissants existant en Python est l'utilisation de séquences pour assigner plusieurs valeurs en une fois.

Exemple 3.19. Assignation simultanée de plusieurs valeurs▲

>>> v = ('a', 'b', 'e')
>>> (x, y, z) = v     1
>>> x
'a'
>>> y
'b'
>>> z
'e'

Exemple 3.20. Assignation de valeurs consécutives▲

>>> range(7)                                                                    ***1***
[0, 1, 2, 3, 4, 5, 6]
>>> (MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7) ***2***
>>> MONDAY                                                                      ***3***
0
>>> TUESDAY
1
>>> SUNDAY
6

>>> k = "uid"
>>> v = "sa"
>>> "%s=%s" % (k, v) ***1***
'uid=sa'

***1*** L'expression entière est évaluée en chaîne. Le premier %s est remplacé par la valeur de k, le second %s est remplacé par la valeur de v. Tous les autres caractères de la chaînes (le signe d'égalité dans le cas présent) restent tels quels.

Notez que (k, v) est un tuple. Je vous avais dit qu'ils servaient à quelque chose.
Vous pourriez pensez que cela représente beaucoup d'efforts pour le formatage de chaîne se bornait à la concaténation. Il n'y est pas question uniquement de formatage mais également de conversion de types.

>>> uid = "sa"
>>> pwd = "secret"
>>> print pwd + " is not a good password for " + uid      ***1***
secret is not a good password for sa
>>> print "%s is not a good password for %s" % (pwd, uid) ***2***
secret is not a good password for sa
>>> userCount = 6
>>> print "Users connected: %d" % (userCount, )           ***3*** ***4***
Users connected: 6
>>> print "Users connected: " + userCount                 ***5***
Traceback (innermost last):
  File "<interactive input>", line 1, in ?
TypeError: cannot concatenate 'str' and 'int' objects

***1*** + est l'opérateur de concaténation de chaînes. ***2*** Dans ce cas trivial, le formatage de chaînes mène au même résultat que la concaténation. ***3*** (userCount, ) est un tuple contenant un seul élément. Oui, la syntaxe est un peu étrange mais il y a un excellente raison : c'est un tuple sans ambiguité aucune. En fait, vous pouvez toujours mettre une virgule après l'élément terminal lors de la définition d'une liste, d'un tuple ou d'un dictionnaire mais cette virgule est obligatoire lors de la définition d'un tuple avec un élément unique. Si ce n'était pas le cas, Python ne pourrait distinguer si (userCount) est un tuple avec un seul élément ou juste la valeur userCount. ***4*** Le formatage de chaîne fonctionne également avec des entiers en spécifiant %d au lieu de %s. ***5*** Si vous tentez de concaténer une chaîne avec un autre type, Python va déclencher une exception. Au contraire du formatage de chaîne, la concaténation ne fonctionne que si tout les objets sont déjà de type chaîne.

Comme la fonction printf en C, le formatage de chaînes en Python est un véritable couteau suisse. Il y a des options à profusion et des modificateurs de format spécifiques pour de nombreux types de valeurs.

>>> print "Today's stock price: %f" % 50.4625   ***1***
50.462500
>>> print "Today's stock price: %.2f" % 50.4625 ***2***
50.46
>>> print "Change since yesterday: %+.2f" % 1.5 ***3***
+1.50

***1*** L'option de formatage %f considère la valeur comme un nombre décimal et l'affiche avec six chiffres après la virgule. ***2*** Le modificateurs ".2" de l'option %f tronque la valeur à deux chiffres après la virgule. ***3*** On peut également combiner les modificateurs. Ajouter le modificateur + affiche le signe positif ou négatif avant la valeur. Notez que le modificateur ".2" est toujours en place et qu'il formate la valeur avec exactement deux chiffres après la virgule.

Pour en savoir plus sur le formatage de liste

• La Python Library Reference résume tous les caractères spéciaux utilisés pour le formatage de chaînes.
• Effective AWK Programming expliquetous les caractères de formatage et des technique de formatage avancées comme le règlage de la largeur ou de la précision et le remplissage avec des zéros.

>>> li = [1, 9, 8, 4]
>>> [elem*2 for elem in li]      ***1***
[2, 18, 16, 8]
>>> li                           ***2***
[1, 9, 8, 4]
>>> li = [elem*2 for elem in li] ***3***
>>> li
[2, 18, 16, 8]

***1*** Pour comprendre cette ligne, observez là de droite à gauche. li est la liste que vous appliquez. Python la parcourt un élément à la fois, en assignant temporairement la valeur de chacun des éléments à la variable elem. Python applique ensuite la fonction elem*2 et ajoute le résultat à la liste retournée.
***2*** Notez que les list comprehensions ne modifient pas la liste initiale.
***3*** Vous pouvez assigner le résultat d'une list comprehension à la variable que vous traitez. Python assemble la nouvelle liste en mémoire et assigne le résultat à la variable une fois la transformation terminée.

Voici les list comprehensions dans la fonction buildConnectionString que nous avons déclaré au Chapitre 2:

["%s=%s" % (k, v) for k, v in params.items()]

Notez tout d'abord que vous appelez la fonction items du dictionnaire params. Cette fonction retourne une liste de tuples avec toutes les données stockées dans le dictionnaire.

>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> params.keys()   ***1***
['server', 'uid', 'database', 'pwd']
>>> params.values() ***2***
['mpilgrim', 'sa', 'master', 'secret']
>>> params.items()  ***3***
[('server', 'mpilgrim'), ('uid', 'sa'), ('database', 'master'), ('pwd', 'secret')]

***1*** La méthode keys d'un dictionnaire retourne la liste de toutes les clés. Cette liste ne suit pas l'ordre dans lequel le dictionnaire a été défini (souvenez-vous, les éléments d'un dictionnaire ne sont pas ordonnés) mais cela reste une liste.
***2*** La méthode values retourne la liste de toutes les valeurs. La liste est dans le même ordre que celle retournée par keys, on a donc params.values()[n] == params[params.keys[n]] pour toute valeur de n.
***3*** La méthode items retourne une liste de tuples de la forme (clé, valeur). La liste contient toutes les données stockées dans le dictionnaire.

Voyons maintenant ce que fait buildConnectionString. Elle prends une liste, param.items(), et crée une nouvelle liste en appliquant une instruction de formatage de chaîne à chacun de ses éléments. La nouvelle liste aura le même nombre d'éléments que params.items() mais chaque élément sera une chaîne qui contient à la fois une clé et la valeur qui lui est associée dans le dictionnaire params.

>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}
>>> params.items()
[('server', 'mpilgrim'), ('uid', 'sa'), ('database', 'master'), ('pwd', 'secret')]
>>> [k for k, v in params.items()]                ***1***
['server', 'uid', 'database', 'pwd']
>>> [v for k, v in params.items()]                ***2***
['mpilgrim', 'sa', 'master', 'secret']
>>> ["%s=%s" % (k, v) for k, v in params.items()] ***3***
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']

***1*** Notez que nous utilisons deux variables pour parcourir la liste params.items(). Il s'agit d'un autre usage de l'assignment multiple. Le premier élément de params.items() est ('server', 'mpilgrim'), donc lors de la première itération de la transformation, k va prendre la valeur 'server' et v la valeur 'mpilgrim'. Dans ce cas, nous ignorons la valeur de v et placons uniquement la valeur de k dans la liste résultante. Cette transformation correspond donc au comportement de params.keys(). (Vous n'utiliseriez pas réellement une list comprehension comme ceci dans du vrai code; il s'agit d'un exemple exagérément simple pour que vous compreniez ce qui se passe.)
***2*** Nous faisons la même chose ici, mais nous ignorons la valeur de k de telle sorte que le résultat est équivalent à celui de params.values().
***3*** En combinant les deux exemples précédent avec le formatage de chaîne, nous obtenons une liste de chaînes comprenant la clé et la valeur de chaque élément du dictionnaire. Cela ressemble étonnament à la sortie du programme, tout ce qui reste à faire maintenant est la jointure des éléments de cette liste en une seule chaîne.

Pour en savoir plus sur les list comprehensions

• Le Python Tutorial traite d'une autre manière de transformer des listes avec la fonction prédéfinie map.
• Le Python Tutorialmontre comment emboîter des mutations de listes.

>>> li = ['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s = ";".join(li)
>>> s
'server=mpilgrim;uid=sa;database=master;pwd=secret'
>>> s.split(";")    ***1***
['server=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s.split(";", 1) ***2***
['server=mpilgrim', 'uid=sa;database=master;pwd=secret']

***1*** split fait l'inverse de join en découpant une chaîne en une liste de plusieurs éléments. Notez que le délimiteur («;») est totalement supprimé, il n'apparaît dans aucun des éléments de la liste retournée. ***2*** split prend en deuxième argument optionnel le nombre de découpages à effectuer («Des arguments optionnels ?» Vous apprendrez à en définir dans vos propres fonctions au prochain chapitre.)

une_chaîne.split(delimiteur, 1) est une technique utile pour chercher une sous-chaîne dans une chaîne et utiliser tout ce qui précède cette sous-chaîne (le premier élément de la liste retournée) et tout ce qui la suit (le second élément de la liste retournée).

Pour en savoir plus sur les méthodes de chaînes

• La Python Knowledge Base répond auxquestions courantes à propose des chaîneset dispose de nombreux exemples de code utilisant des chaînes.
• La Python Library Reference récapitule toutes les méthodes de chaînes.
• La Python Library Reference documente le module string.
• The Whole Python FAQ explique pourquoi join est une méthode de chaîneset non une méthode de liste.

Lorsque j'ai débuté l'apprentissage de Python, je m'attendais à ce que join soit une méthode de liste qui aurait pris un séparateur comme argument. Beaucoup de gens pensent la même chose et il y a une véritable histoire derrière la méthode join. Avant Python 1.6, les chaînes n'étaient pas pourvue de toutes ces méthodes si utiles. Il y avait un module string séparé qui contenait toutes les fonctions de manipulation de chaînes de caractères, chacune prenant une chaîne comme premier argument. Ces fonctions ont été considérées assez importantes pour être intégrées dans les chaînes elles même, ce qui semblait logique pour des fonctions comme lower, upper et split. Mais beaucoup de programmeurs Python issus du noyau dur émirent des objections quant à la méthode join en arguant du fait qu'elle devrait être plutôt une méthode de liste ou tout simplement rester une fonction du module string (qui contient encore bien des choses utiles). J'utilise exclusivement la nouvelle méthode join mais vous verrez du code écrit des deux façons et si cela vous pose un réel problème, vous pouvez toujours opter pour l'ancienne fonction string.join.