Dict et fichier Python

Table de hachage de dictée

La structure efficace de la table de hachage clé/valeur 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, ... }. Le "dicteur vide" est simplement une paire vide d'accolades {}.

Pour rechercher ou définir une valeur dans un dictionnaire, vous utilisez des crochets. 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"). .

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

dicter avec les clés "a" "o" "g"

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 fonction items() qui renvoie une liste de tuples (clé, valeur), 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 triée().

  ## 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, et 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. Après avoir lu l'intégralité du fichier, vous pouvez rechercher n'importe quelle adresse IP et voir instantanément sa liste de lignes. Le dictionnaire reçoit des données dispersées et les transforme en quelque chose de cohérent.

Mise en forme des dictées

L'opérateur % permet de remplacer facilement les valeurs d'un dict dans une chaîne par leur 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

Le "del" effectue des suppressions. Dans le cas le plus simple, vous pouvez supprimer la définition d'une variable, comme si cette variable n'avait pas été définie. La fonction Del peut également être utilisée 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 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 norme for-loop fonctionne pour les fichiers texte, avec une itération sur les lignes du fichier (cela ne fonctionne que pour les fichiers texte, pas pour les fichiers binaires). La technique "for-loop" 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(string) est le moyen le plus simple d'écrire des données dans un fichier de sortie ouvert. Ou vous pouvez utiliser « imprimer » par 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'

Exercice de développement incrémentiel

Lorsque vous créez un programme Python, n'écrivez pas tout en une seule étape. Identifiez plutôt un premier jalon, par exemple "Eh bien, la première étape consiste à extraire la liste de mots." Écrivez le code pour accéder à ce jalon, puis imprimez vos structures de données à ce stade. Vous pouvez ensuite exécuter une commande sys.exit(0) pour que le programme n'entre pas dans les parties non terminées. Une fois que le code du jalon fonctionne, vous pouvez travailler sur le code du prochain jalon. 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 cette procédure rapide pour créer votre programme en quelques étapes.

Exercice: wordcount.py

Essayez l'exercice récapitulatif wordcount.py dans les exercices de base en combinant tout le matériel Python de base (chaînes, listes, dictionnaires, tuples, fichiers).