Table de hachage Dict
La structure de table de hachage clé-valeur efficace de Python s'appelle un "dict". 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, ...}. Un "dict vide" n'est qu'une paire vide d'accolades {}.
Pour rechercher ou définir une valeur dans un dictionnaire, vous devez utiliser 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 ne pas fonctionner correctement en tant que clés (les chaînes et les tuples fonctionnent parfaitement, car ils sont immuables). La recherche d'une valeur qui ne figure pas dans dict génère une erreur KeyError. Utilisez "in" pour vérifier si la clé se trouve dans le dict, 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 lorsque le cas est introuvable).
## 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 d'un dictionnaire effectue une itération 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 tuples (clé, valeur), ce qui est le moyen le plus efficace d'examiner toutes les données de valeur de clé dans le dictionnaire. Toutes ces listes peuvent être transmises à la fonction Sort().
## 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
Note de stratégie: du point de vue des performances, le dictionnaire est l'un de vos meilleurs outils et vous devez l'utiliser là où vous pouvez le faire pour organiser facilement les 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 en tant que valeur. Une fois que vous avez lu l'intégralité du fichier, vous pouvez rechercher n'importe quelle adresse IP et voir instantanément la liste des lignes. Le dictionnaire prend des données dispersées et les transforme en quelque chose de cohérent.
Mise en forme Dict
L'opérateur % remplace facilement les valeurs d'un dictionnaire par 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)
Del
L'opérateur "del" effectue les suppressions. Dans le plus simple des cas, elle permet de supprimer la définition d'une variable, comme si celle-ci n'avait pas été définie. La commande "del" peut également être utilisée sur des éléments ou des secteurs d'une liste pour supprimer une partie de la liste ou 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 gestionnaire 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 la lecture des opérations et utilise f.close() lorsque vous avez terminé. Au lieu de "r", utilisez "w" pour écrire et "a" pour ajouter. La boucle For standard fonctionne pour les fichiers texte, en parcourant les lignes du fichier (cela ne fonctionne que pour les fichiers texte, pas pour les fichiers binaires). La technique de la 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 bonne qualité : tout le fichier n'a pas besoin de tenir en mémoire en même temps, ce qui est pratique si vous souhaitez examiner chaque ligne d'un fichier de 10 Go sans utiliser cette quantité de mémoire. La méthode f.readlines() lit l'intégralité du fichier en mémoire et en renvoie le contenu sous la forme d'une liste de lignes. La méthode f.read() lit l'intégralité du fichier dans une seule chaîne, ce qui peut être un moyen pratique de traiter le texte en une seule fois, comme avec des expressions régulières que nous verrons plus tard.
Pour l'écriture, la méthode f.write(string) est la méthode la plus simple pour é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 le 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'
Exercez un développement progressif
Si vous construisez un programme Python, n'écrivez pas tout en une seule étape. Identifiez plutôt un premier jalon, par exemple « et la première étape consiste à extraire la liste de mots. » Écrivez le code pour accéder à ce jalon, puis imprimez simplement vos structures de données à ce stade. Vous pouvez ensuite exécuter une commande sys.exit(0) afin que le programme ne passe pas dans ses parties non terminées. Une fois que le code de l'étape suivante fonctionne, vous pouvez travailler dessus. Être capable d'afficher l'impression de vos variables dans un état donné peut vous aider à réfléchir à la façon dont vous devez transformer ces variables 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 en quelques étapes.
Exercice: wordcount.py
En combinant tous les éléments Python de base (chaînes, listes, dictionnaires, tuples et fichiers), essayez l'exercice wordcount.py dans les exercices de base.