Collections, itertools et fichiers

Collections, itertools et fichiers

1. Listes, tuples, ensembles, dictionnaires

   Ces quatre structures couvrent l'essentiel des besoins. Choisir la bonne, c'est déjà une bonne part de la qualité du code.

   # liste : ordonnée, modifiable
   nombres = [3, 1, 2]
   nombres.append(4)          # [3, 1, 2, 4]
   nombres.sort()             # [1, 2, 3, 4]
   nombres.remove(1)
   
   # tuple : ordonné, NON modifiable
   coordonnees = (48.85, 2.35)
   
   # ensemble : sans doublon, non ordonné
   tags = {"python", "web", "python"}    # {'python', 'web'}
   
   # dictionnaire : clé → valeur
   stock = {"clavier": 12}
   stock["souris"] = 40
   stock.get("ecran", 0)                  # 0 au lieu d'une erreur

   Choisir en pratique

   Besoin	Structure
   Liste ordonnée, modifiée	list
   Valeurs fixes	tuple
   Sans doublon, test d'appartenance rapide	set
   Accès par clé	dict

   Déballage et nettoyage

   premier, second = [10, 20]
   cle, valeur = ("a", 1)
   
   notes = [("alice", 15), ("bob", 12), ("alice", 18)]
   mieux = {}
   for nom, note in notes:
       if nom not in mieux or note > mieux[nom]:
           mieux[nom] = note

2. itertools et functools

   Ces deux modules de la bibliothèque standard remplacent beaucoup de boucles manuelles, en plus lisible et plus rapide.

   import itertools
   
   nombres = [1, 2, 3, 4, 5]
   list(itertools.chain([1, 2], [3, 4]))      # [1, 2, 3, 4]
   list(itertools.combinations(["a", "b", "c"], 2))  # [('a','b'), ('a','c'), ('b','c')]
   list(itertools.groupby(sorted(["a", "ab", "b"])))  # groupes de valeurs voisines
   
   import functools
   f = functools.reduce(lambda acc, x: acc * x, [1, 2, 3, 4])   # 24
   total = functools.partial(sum, [1, 2, 3])      # sum([1,2,3], ...)

   Attention à groupby : il ne groupe que les éléments consécutifs. Il faut trier avant, sinon le résultat est faux.

   enumerate et zip

   for index, valeur in enumerate(["a", "b"], start=1):
       print(index, valeur)          # 1 a  /  2 b
   
   for nom, note in zip(["alice", "bob"], [15, 12]):
       print(nom, note)

   Tri clé

   eleves = [("bob", 12), ("alice", 18), ("carol", 12)]
   # par note décroissante, puis par nom
   eleves.sort(key=lambda e: (-e[1], e[0]))

3. Fichiers et données

   On lit et on écrit avec open(), toujours dans un bloc with, qui ferme le fichier même en cas d'erreur.

   with open("notes.txt", "w", encoding="utf-8") as f:
       f.write("Alice 15\n")
   
   with open("notes.txt", encoding="utf-8") as f:
       for ligne in f:
           nom, note = ligne.strip().split()
           print(nom, int(note))

   Les modes utiles : r lecture, w écriture (écrase), a ajout, x écriture qui échoue si le fichier existe.

   encoding="utf-8" n'est pas facultatif : sans lui, la lecture dépend de la configuration système et peut échouer sur un accents selon la machine.

   Chemin et dossiers

   from pathlib import Path
   
   dossier = Path("data")
   dossier.mkdir(exist_ok=True)          # ne lève pas si le dossier existe
   chemin = dossier / "notes.txt"
   chemin.write_text("contenu", encoding="utf-8")
   
   for fichier in dossier.glob("*.txt"):
       print(fichier.name, fichier.stat().st_size)

   CSV et JSON

   import csv
   import json
   
   with open("clients.csv", newline="", encoding="utf-8") as f:
       lecteur = csv.DictReader(f)       # première ligne = en-têtes
       for ligne in lecteur:
           print(ligne["nom"], ligne["ville"])
   
   with open("config.json", "w", encoding="utf-8") as f:
       json.dump({"debug": True}, f, indent=2)
   
   with open("config.json", encoding="utf-8") as f:
       config = json.load(f)

   newline="" est requis par csv : sans lui, les retours à la ligne sont mal interprétés sur certains systèmes.

4. Exercices

   1. Annuaire : à partir d'un fichier CSV contacts.csv (nom, email), compter les doublons d'emails et écrire les doublons dans un autre fichier.
   2. Refactoriser : réécrivez avec itertools.

      paires = []
      for i in range(len(nombres)):
          for j in range(i + 1, len(nombres)):
              paires.append((nombres[i], nombres[j]))

   3. Compte à rebours : écrivez un script qui accepte un nombre en argument de ligne de commande et affiche un compte à rebours, ou une erreur claire si l'argument n'est pas un entier.