2.2Chaînes, formatage (f-strings) & fichiers
L'essentiel en 30 secondes
- f-strings partout : f"...{var}..." lisible, rapide, avec formatage intégré (:.2f, :.0%) — oublier % et .format() hors legacy.
- split découpe, join assemble, strip nettoie : le trio qui transforme le texte — in teste la présence.
- with ferme tout seul : with open(..., encoding="utf-8") + json/csv + pathlib — vos programmes gardent une mémoire.
Mini-cas filé — Nabil rédige le rapport mensuel
Nabil doit envoyer le rapport mensuel des ventes d'Alger : montants formatés à deux décimales, noms nettoyés (espaces, casse), lignes CSV découpées et réassemblées. Sa première version concatène avec + et oublie de fermer ses fichiers — accents cassés, fichier verrouillé. Il reconstruit : f-strings avec :.2f pour les totaux, strip/lower/split/join pour nettoyer, with open(..., encoding="utf-8") pour lire/écrire, JSON pour rendre le carnet persistant entre deux exécutions. En 2.3, ces lignes deviendront des objets ; en 2.4, le fichier absent sera géré proprement.
Suite du fil rouge 2.1 : les ventes de Nabil deviennent un rapport lisible et persistant — et continue en 2.3 et 2.4.
1. Les f-strings : la seule façon moderne
f"Bonjour {nom}, total : {total:.2f} €" : lisible, rapide, avec formatage intégré (f"{prix:.2f} €", f"{ratio:.0%}"). La variable ou le calcul s'insère directement entre accolades — pas de conversion manuelle, pas d'erreur de type. Oubliez % et .format() hors code ancien : la f-string est le standard depuis Python 3.6. Nabil l'applique : chaque ligne du rapport mensuel est une f-string avec montants à deux décimales et pourcentages calculés à la volée.
2. Méthodes qui paient : split, join, strip
"Alger, Oran, Blida".split(", ") découpe en liste, ", ".join(liste) assemble (l'inverse exact), .strip() nettoie les espaces des saisies, .lower() et .replace() normalisent. .upper() affiche, in teste la présence (if "@" in email:). Ces méthodes ne modifient pas la chaîne d'origine (les chaînes sont immuables) : elles renvoient une nouvelle chaîne. Nabil nettoie ainsi chaque nom de client (strip().title()) avant de le comparer — fini les doublons « alger » vs « Alger ».
3. Fichiers : with, encoding, JSON
with open("ventes.txt", encoding="utf-8") as f: — le with ferme tout seul même en cas d'erreur, et l'encoding="utf-8" évite les accents cassés. Les modes : "r" lit (défaut), "w" écrit en écrasant, "a" ajoute à la fin. Pour structurer : json.load/dump (listes et dicts persistants — le carnet survit au redémarrage), module csv pour les tableurs, pathlib.Path pour des chemins propres sans concaténation. Nabil sauvegarde son récapitulatif en JSON avec ensure_ascii=False pour garder les accents lisibles.
🔎 Exemple concret — 🔎 Exemple concret — Le carnet persistant de Nabil en JSON
Le récapitulatif survit au redémarrage, comme chez Nabil :
import json
from pathlib import Path
fichier = Path("recap.json")
if fichier.exists():
recap = json.loads(fichier.read_text(encoding="utf-8"))
else:
recap = []
recap.append({"wilaya": "Alger", "total": 1650})
fichier.write_text(json.dumps(recap, ensure_ascii=False, indent=2), encoding="utf-8")
print(f"Wilayas suivies : {len(recap)}")Lecture : pathlib vérifie l'existence, json charge et sauvegarde, la f-string affiche.
Leçon : pathlib remplace les concaténations de chemins.
Vocabulaire de la section
- Méthodes de chaîne
- Fonctions attachées au texte : .upper(), .lower(), .strip() (espaces), .split() (découpe), .join() (assemble), .replace(). Renvoient une nouvelle chaîne.
Exemple simple : Nabil nettoie un nom avec nom.strip().title().
Ce que ce n'est pas : des fonctions qui modifient la chaîne en place.
Réflexe : transformer du texte = méthode renvoyée.
- f-string
- Chaîne préfixée par f où {variable} est remplacé par sa valeur : f"Bonjour {nom}". Formatage intégré (:.2f, :.0%). Méthode recommandée depuis Python 3.6.
Exemple simple : Nabil écrit f"Total : {total:.2f} €".
Ce que ce n'est pas : une concaténation avec + et str() partout.
Réflexe : afficher des valeurs = f-string.
- with open()
- Ouvre un fichier en garantissant sa fermeture automatique : with open("f.txt", encoding="utf-8") as f:. Modes r (lit), w (écrase), a (ajoute).
Exemple simple : Nabil lit l'export avec with et encoding utf-8.
Ce que ce n'est pas : un open() sans with ni encoding.
Réflexe : fichier = with + encoding, toujours.
- CSV
- Fichier texte où les valeurs sont séparées par des virgules : format d'échange universel (tableurs). Module csv pour lire/écrire proprement.
Exemple simple : Nabil découpe chaque ligne d'export avec le module csv.
Ce que ce n'est pas : un découpage à la main qui casse sur les guillemets.
Réflexe : tableur à échanger = module csv.
- JSON
- Format texte structuré (clés/valeurs) universel pour les données et les API. Module json : json.load / json.dump, listes et dicts persistants.
Exemple simple : Le récapitulatif de Nabil survit au redémarrage en JSON.
Ce que ce n'est pas : un fichier texte bricolé illisible par d'autres outils.
Réflexe : structuré à garder = JSON.
En pratique — En pratique — Formater du texte et lire/écrire des fichiers
- Nettoyez et transformez une chaîne : " rapport alger ".strip().upper(), puis découpez une ligne CSV en champs avec .split().
- Composez une ligne de rapport avec une f-string incluant un calcul : f"Total : {prix * quantite:.2f} €" (2 décimales).
- Écrivez du texte avec « with open("notes.txt", "w", encoding="utf-8") as f » puis relisez-le en mode « r » : vérifiez la fermeture automatique.
- Chargez/sauvegardez une liste de dicts en JSON avec json.dump et json.load : constatez la persistance entre deux exécutions.
Script prêt à dire — expliquer with à un collègue (30 s)
« Pour le rapport de Nabil, tout passe en f-strings avec :.2f — plus de concaténation. Et chaque fichier s'ouvre avec with et encoding utf-8 : ça ferme tout seul même si ça plante, et les accents d'Alger restent intacts. Le récap part en JSON, il survit au redémarrage. »
À dire en montrant un fichier resté verrouillé sans with, puis propre avec with.
Modèle copier-coller — rapport formaté et sauvegarde JSON
import json
from pathlib import Path
lignes = [" alger,1650 ", "oran,800", " alger,450 "]
total = 0.0
for ligne in lignes:
wilaya, montant = [c.strip() for c in ligne.split(",")]
total += float(montant)
print(f"{wilaya.title():<10} : {float(montant):.2f} €")
print(f"{'Total':<10} : {total:.2f} €")
Path("total.json").write_text(json.dumps({"total": total}, ensure_ascii=False, indent=2), encoding="utf-8")Ligne de rapport
Chaque vente de Nabil devient f"{wilaya} : {montant:.2f} €" — calcul et formatage en une ligne.
Noms à normaliser
Les wilayas saisies en vrac passent en strip().lower() : « Alger » et « alger » ne font plus doublon.
Export CSV à relire
L'export du mois se découpe en split/join via le module csv : champs et guillemets gérés proprement.
Récap à conserver
Le total mensuel part en JSON avec ensure_ascii=False : accents intacts, relu au mois suivant.
✓ Bonnes pratiques
- Utiliser les f-strings partout, avec formatage intégré (:.2f, :.0%).
- Nettoyer systématiquement les saisies (strip, lower) avant de comparer.
- Ouvrir avec with + encoding et préférer pathlib + JSON pour persister.
✗ Pièges fréquents
- Concaténer avec + au lieu d'une f-string (illisible, erreurs de type).
- Ouvrir sans with (fichier non fermé en cas d'erreur).
- Oublier encoding="utf-8" (accents cassés) ou ouvrir en "w" un fichier à conserver (écrasé).
Points clés à retenir
- Les méthodes de chaîne (upper, strip, split, join, replace) transforment le texte (nouvelle chaîne renvoyée).
- Les f-strings (f"...{var}...") sont la façon moderne et lisible de formater, avec :.2f et :.0%.
- with open(..., encoding="utf-8") lit/écrit en fermant automatiquement ; r lit, w écrase, a ajoute.
- CSV et JSON sont les formats d'échange (modules csv et json) ; pathlib pour les chemins.
Défi 48h — appliquez demain
Prenez un vrai fichier texte (celui de Nabil ou le vôtre) : nettoyez-le (strip/split/join), affichez un récap en f-strings avec :.2f, sauvegardez-le en JSON via with + encoding et relisez-le après redémarrage.
- Je peux formater avec des f-strings (variables, calculs, :.2f).
- Je sais nettoyer avec strip/split/join et tester avec in.
- J'ai lu et écrit un fichier avec with + encoding, et persisté en JSON.
Questions fréquentes
Pourquoi préférer les f-strings à la concaténation avec + ?
Les f-strings sont plus lisibles, évitent les erreurs de type (pas besoin de convertir les nombres en str), et permettent le formatage intégré (:.2f pour 2 décimales, alignement, pourcentages). C'est la méthode recommandée officiellement depuis Python 3.6.
Quelle différence entre les modes « r », « w » et « a » de open() ?
« r » lit (par défaut), « w » écrit en ÉCRASANT le contenu existant, « a » ajoute à la fin (append) sans effacer. Attention : ouvrir un fichier existant en « w » supprime son contenu immédiatement — d'où l'intérêt de relire avant d'écrire.
Que garantit le bloc « with open(...) » ?