Table de hachage de dictionnaire
La structure de table de hachage clé/valeur efficace de Python est appelée "dictionnaire". Le contenu d'un dictionnaire peut être écrit sous la forme d'une série de paires clé-valeur entre accolades { }, par exemple : dict = {clé1:valeur1, clé2:valeur2, ...}. Le "dictionnaire vide" n'est qu'une paire d'accolades vides {}.
Pour rechercher ou définir une valeur dans un dictionnaire, utilisez des crochets. Par exemple, dict['foo'] recherche la valeur sous la clé "foo". Les chaînes, les nombres et les tuples fonctionnent comme des clés, et n'importe quel type peut être une valeur. D'autres types peuvent ou non fonctionner correctement en tant que clés (les chaînes et les tuples fonctionnent correctement puisqu'ils sont immuables). La recherche d'une valeur qui ne figure pas dans le dictionnaire génère une erreur KeyError. Utilisez "in" pour vérifier si la clé figure dans le dictionnaire, ou dict.get(key), qui renvoie la valeur ou None si la clé n'est pas présente (ou get(key, not-found) vous permet de spécifier la valeur à renvoyer dans le cas de non-trouvabilité).
## Can build up a dict by starting with the empty dict {}
## and storing key/value pairs into the dict like this:
## dict[key] = value-for-that-key
dict = {}
dict['a'] = 'alpha'
dict['g'] = 'gamma'
dict['o'] = 'omega'
print(dict) ## {'a': 'alpha', 'o': 'omega', 'g': 'gamma'}
print(dict['a']) ## Simple lookup, returns 'alpha'
dict['a'] = 6 ## Put new key/value into dict
'a' in dict ## True
## print(dict['z']) ## Throws KeyError
if 'z' in dict: print(dict['z']) ## Avoid KeyError
print(dict.get('z')) ## None (instead of KeyError)
Par défaut, une boucle for sur un dictionnaire itère sur ses clés. Les clés apparaîtront dans un ordre arbitraire. Les méthodes dict.keys() et dict.values() renvoient explicitement des listes de clés ou de valeurs. Il existe également une méthode items() qui renvoie une liste de tupels (clé, valeur), ce qui est le moyen le plus efficace d'examiner toutes les données de clé-valeur du dictionnaire. Toutes ces listes peuvent être transmises à la fonction sorted().
## By default, iterating over a dict iterates over its keys.
## Note that the keys are in a random order.
for key in dict:
print(key)
## prints a g o
## Exactly the same as above
for key in dict.keys():
print(key)
## Get the .keys() list:
print(dict.keys()) ## dict_keys(['a', 'o', 'g'])
## Likewise, there's a .values() list of values
print(dict.values()) ## dict_values(['alpha', 'omega', 'gamma'])
## Common case -- loop over the keys in sorted order,
## accessing each key/value
for key in sorted(dict.keys()):
print(key, dict[key])
## .items() is the dict expressed as (key, value) tuples
print(dict.items()) ## dict_items([('a', 'alpha'), ('o', 'omega'), ('g', 'gamma')])
## This loop syntax accesses the whole dict by looping
## over the .items() tuple list, accessing one (key, value)
## pair on each iteration.
for k, v in dict.items(): print(k, '>', v)
## a > alpha o > omega g > gamma
Remarque sur la stratégie: du point de vue des performances, le dictionnaire est l'un de vos meilleurs outils. Vous devez l'utiliser là où vous le pouvez pour organiser facilement vos données. Par exemple, vous pouvez lire un fichier journal dans lequel chaque ligne commence par une adresse IP, puis stocker les données dans un dictionnaire en utilisant l'adresse IP comme clé et la liste des lignes où elle apparaît comme valeur. Une fois que vous avez lu l'intégralité du fichier, vous pouvez rechercher n'importe quelle adresse IP et afficher instantanément sa liste de lignes. Le dictionnaire collecte des données éparses et les transforme en quelque chose de cohérent.
Mise en forme du dictionnaire
L'opérateur % permet de remplacer les valeurs d'un dictionnaire dans une chaîne par nom :
h = {}
h['word'] = 'garfield'
h['count'] = 42
s = 'I want %(count)d copies of %(word)s' % h # %d for int, %s for string
# 'I want 42 copies of garfield'
# You can also use str.format().
s = 'I want {count:d} copies of {word}'.format(h)
Suppr
L'opérateur "del" permet de supprimer des éléments. Dans le cas le plus simple, il peut supprimer la définition d'une variable, comme si cette variable n'avait pas été définie. Vous pouvez également utiliser Del sur des éléments ou des tranches de liste pour supprimer cette partie de la liste et supprimer des entrées d'un dictionnaire.
var = 6
del var # var no more!
list = ['a', 'b', 'c', 'd']
del list[0] ## Delete first element
del list[-2:] ## Delete last two elements
print(list) ## ['b']
dict = {'a':1, 'b':2, 'c':3}
del dict['b'] ## Delete 'b' entry
print(dict) ## {'a':1, 'c':3}
Fichiers
La fonction open() s'ouvre et renvoie un handle de fichier qui peut être utilisé pour lire ou écrire un fichier de la manière habituelle. Le code f = open('name', 'r') ouvre le fichier dans la variable f, prêt pour les opérations de lecture, et utilise f.close() une fois terminé. Au lieu de "r", utilisez "w" pour l'écriture et "a" pour l'ajout. La boucle for standard fonctionne pour les fichiers texte, en itérant sur les lignes du fichier (cela ne fonctionne que pour les fichiers texte, et non pour les fichiers binaires). La technique de boucle for est un moyen simple et efficace d'examiner toutes les lignes d'un fichier texte :
# Echo the contents of a text file
f = open('foo.txt', 'rt', encoding='utf-8')
for line in f: ## iterates over the lines of the file
print(line, end='') ## end='' so print does not add an end-of-line char
## since 'line' already includes the end-of-line.
f.close()
Lire une ligne à la fois offre une qualité suffisante pour que tous les fichiers ne puissent pas être stockés en mémoire en même temps, ce qui est pratique si vous souhaitez consulter chaque ligne d'un fichier de 10 Go sans utiliser 10 Go de mémoire. La méthode f.readlines() lit l'intégralité du fichier en mémoire et renvoie son contenu sous forme de liste de ses lignes. La méthode f.read() lit l'intégralité du fichier en une seule chaîne, ce qui peut être un moyen pratique de traiter le texte en une seule fois, comme avec les expressions régulières que nous verrons plus tard.
Pour l'écriture, la méthode f.write(chaîne) est le moyen le plus simple d'écrire des données dans un fichier de sortie ouvert. Vous pouvez également utiliser "print" avec un fichier ouvert tel que "print(string, file=f)".
Fichiers Unicode
Pour lire et écrire des fichiers encodés en Unicode, utilisez un mode "t" et spécifiez explicitement un encodage :
with open('foo.txt', 'rt', encoding='utf-8') as f:
for line in f:
# here line is a *unicode* string
with open('write_test', encoding='utf-8', mode='wt') as f:
f.write('\u20ACunicode\u20AC\n') # €unicode€
# AKA print('\u20ACunicode\u20AC', file=f) ## which auto-adds end='\n'
Exercice de développement incrémental
Lorsque vous créez un programme Python, n'écrivez pas l'intégralité du code en une seule étape. Au lieu de cela, identifiez uniquement un premier jalon, par exemple « Eh bien, la première étape consiste à extraire la liste de mots. » Écrivez le code pour atteindre cet objectif, puis imprimez simplement vos structures de données à ce stade. Vous pouvez ensuite effectuer une opération sys.exit(0) pour que le programme ne s'exécute pas dans ses parties inachevées. Une fois le code de la première étape fonctionnel, vous pouvez travailler sur le code de la deuxième étape. Le fait de pouvoir consulter l'impression de vos variables à un état peut vous aider à réfléchir à la manière dont vous devez les transformer pour passer à l'état suivant. Python est très rapide avec ce modèle, ce qui vous permet d'apporter une petite modification et d'exécuter le programme pour voir comment il fonctionne. Profitez de ce délai rapide pour créer votre programme par petites étapes.
Exercice : wordcount.py
En combinant tous les éléments de base de Python (chaînes, listes, dictionnaires, tupels, fichiers), essayez l'exercice récapitulatif wordcount.py dans les exercices de base.