Les fichiers

1Ouvrir, lire, ecrire un fichier texte

Jusqu'ici les donnees disparaissaient a la fin du programme. Les fichiers assurent la persistance : ils permettent de conserver des resultats, de traiter des jeux de donnees trop volumineux pour etre saisis a la main, et d'echanger de l'information entre programmes.

Ouvrir et fermer

f = open("donnees.txt", "r", encoding="utf-8")
contenu = f.read()
f.close()                       # obligatoire, et facile a oublier

with open("donnees.txt", "r", encoding="utf-8") as f:
    contenu = f.read()
# ici le fichier est FERME, meme si une exception a ete levee

Les modes d'ouverture

Lire

with open("f.txt", encoding="utf-8") as f:
    tout = f.read()             # UNE chaine contenant tout le fichier

with open("f.txt", encoding="utf-8") as f:
    lignes = f.readlines()      # liste des lignes, AVEC le "\n" final

with open("f.txt", encoding="utf-8") as f:
    premiere = f.readline()     # une seule ligne

with open("f.txt", encoding="utf-8") as f:
    for ligne in f:             # LA BONNE FACON : ligne par ligne, paresseuse
        traite(ligne.rstrip("\n"))

for ligne in f:
    print(len(ligne))           # compte le "\n" final !
    n = int(ligne)              # fonctionne ici, int ignore les blancs
    mots = ligne.split()        # split() sans argument ignore aussi le "\n"
    ligne = ligne.rstrip("\n")  # la facon explicite et sure

Ecrire

with open("sortie.txt", "w", encoding="utf-8") as f:
    f.write("premiere ligne\n")        # le \n n'est PAS ajoute automatiquement
    f.write(f"resultat : {42}\n")
    f.writelines(["a\n", "b\n"])       # n'ajoute aucun \n non plus
    print("via print", file=f)         # print ajoute le \n : souvent plus pratique

def sauvegarde(nom, lignes):
    """Ecrit une liste de chaines, une par ligne."""
    with open(nom, "w", encoding="utf-8") as f:
        for l in lignes:
            f.write(str(l) + "\n")

def ajoute_journal(nom, message):
    """Ajoute une ligne a la fin d'un journal, sans ecraser."""
    with open(nom, "a", encoding="utf-8") as f:
        f.write(message + "\n")

2Fichiers CSV, traitement de donnees et erreurs

Le format CSV

nom,classe,note
Amine,MPSI,15
Sara,PCSI,18
Youssef,MPSI,12

def lit_csv(nom, sep=","):
    """Lit un CSV a en-tete et renvoie une liste de dictionnaires."""
    with open(nom, encoding="utf-8") as f:
        entetes = f.readline().rstrip("\n").split(sep)
        lignes = []
        for ligne in f:
            ligne = ligne.rstrip("\n")
            if not ligne:                    # on ignore les lignes vides
                continue
            valeurs = ligne.split(sep)
            lignes.append(dict(zip(entetes, valeurs)))
    return lignes

def ecrit_csv(nom, lignes, colonnes, sep=","):
    """Ecrit une liste de dictionnaires au format CSV."""
    with open(nom, "w", encoding="utf-8") as f:
        f.write(sep.join(colonnes) + "\n")
        for l in lignes:
            f.write(sep.join(str(l.get(c, "")) for c in colonnes) + "\n")

import csv

with open("notes.csv", encoding="utf-8", newline="") as f:
    for ligne in csv.DictReader(f):
        print(ligne["nom"], ligne["note"])

with open("sortie.csv", "w", encoding="utf-8", newline="") as f:
    w = csv.DictWriter(f, fieldnames=["nom", "classe", "note"])
    w.writeheader()
    w.writerows(donnees)

Chaine de traitement type

def analyse_notes(fichier):
    """Lit un CSV de notes et renvoie des statistiques par classe."""
    # 1. LECTURE : convertir les types des la lecture
    donnees = []
    with open(fichier, encoding="utf-8") as f:
        entetes = f.readline().rstrip("\n").split(",")
        for numero, ligne in enumerate(f, start=2):
            champs = ligne.rstrip("\n").split(",")
            if len(champs) != len(entetes):
                print(f"ligne {numero} ignoree : {len(champs)} champs au lieu de {len(entetes)}")
                continue
            enreg = dict(zip(entetes, champs))
            try:
                enreg["note"] = float(enreg["note"])
            except ValueError:
                print(f"ligne {numero} ignoree : note illisible {enreg['note']!r}")
                continue
            donnees.append(enreg)

    # 2. TRAITEMENT : regroupement puis agregation
    par_classe = {}
    for e in donnees:
        par_classe.setdefault(e["classe"], []).append(e["note"])

    # 3. RESULTAT
    return {c: {"effectif": len(v),
                "moyenne": sum(v) / len(v),
                "min": min(v), "max": max(v)}
            for c, v in par_classe.items()}

Gestion des erreurs

def lit_ou_defaut(nom, defaut=""):
    """Contenu du fichier, ou une valeur par defaut en cas de probleme."""
    try:
        with open(nom, encoding="utf-8") as f:
            return f.read()
    except FileNotFoundError:
        print(f"fichier introuvable : {nom}")
    except PermissionError:
        print(f"acces refuse : {nom}")
    except UnicodeDecodeError:
        print(f"encodage incorrect : {nom} n'est pas de l'UTF-8")
    return defaut

Chemins

import os

os.path.exists("donnees.txt")          # le fichier existe-t-il ?
os.path.getsize("donnees.txt")         # taille en octets
os.listdir(".")                        # contenu du dossier courant
os.path.join("dossier", "f.txt")       # separateur adapte au systeme

Un chemin relatif part du dossier courant ; un chemin absolu part de la racine. Toujours preferer os.path.join a une concatenation manuelle, car le separateur differe selon les systemes.

3Simulateur des modes et etude de cas

Etude de cas complete — un carnet de notes

import os

FICHIER = "carnet.csv"
COLONNES = ["nom", "matiere", "note"]

def charge(fichier=FICHIER):
    """Charge le carnet, ou renvoie une liste vide s'il n'existe pas encore."""
    if not os.path.exists(fichier):
        return []
    donnees = []
    with open(fichier, encoding="utf-8") as f:
        entetes = f.readline().rstrip("\n").split(",")
        for ligne in f:
            ligne = ligne.rstrip("\n")
            if not ligne:
                continue
            e = dict(zip(entetes, ligne.split(",")))
            try:
                e["note"] = float(e["note"])
            except (KeyError, ValueError):
                continue
            donnees.append(e)
    return donnees

def enregistre(donnees, fichier=FICHIER):
    """Ecrit tout le carnet (ecrasement volontaire)."""
    with open(fichier, "w", encoding="utf-8") as f:
        f.write(",".join(COLONNES) + "\n")
        for e in donnees:
            f.write(",".join(str(e[c]) for c in COLONNES) + "\n")

def ajoute(nom, matiere, note, fichier=FICHIER):
    """Ajoute une note SANS relire tout le fichier : mode append."""
    nouveau = not os.path.exists(fichier)
    with open(fichier, "a", encoding="utf-8") as f:
        if nouveau:
            f.write(",".join(COLONNES) + "\n")
        f.write(f"{nom},{matiere},{note}\n")

def moyennes(donnees):
    """Moyenne par eleve."""
    par_eleve = {}
    for e in donnees:
        par_eleve.setdefault(e["nom"], []).append(e["note"])
    return {n: sum(v) / len(v) for n, v in par_eleve.items()}

# utilisation
for n, m, x in [("Amine", "info", 15), ("Amine", "maths", 13), ("Sara", "info", 18)]:
    ajoute(n, m, x)
d = charge()
print(moyennes(d))          # {'Amine': 14.0, 'Sara': 18.0}
os.remove(FICHIER)          # nettoyage

Noter le choix des modes : "a" pour ajouter une ligne (peu couteux), "w" pour reecrire l'ensemble apres une modification. Reecrire tout le fichier a chaque ajout serait en \(\Theta(n)\) par ajout, soit \(\Theta(n^2)\) au total.