Retour au cours

chaînes de caractères : f-strings, méthodes, slicing, encodage

dans cette leçon, vous apprenez à manipuler les chaînes de caractères : créer, découper, formater, nettoyer et encoder/décoder.

objectifs

  • créer des chaînes et comprendre leur immutabilité
  • utiliser les f-strings et les spécificateurs de format
  • connaître les méthodes essentielles (strip, split, join, replace, find…)
  • maîtriser slicing et indexation
  • comprendre les bases de l’encodage (utf-8, bytes)

créer des chaînes

littéraux, guillemets simples/doubles, multi-lignes, chaînes brutes.

s1 = "bonjour"
s2 = 'python'
s3 = """ligne 1
ligne 2"""
raw = r"C:\Users\name\docs"    # pas d'échappement pour \ dans une raw string

les chaînes sont immuables : toute “modification” crée une nouvelle chaîne.

name = "ana"
# name[0] = "A"  -> typeerror
name = "A" + name[1:]

longueur, indexation, slicing

index à partir de 0, indices négatifs, tranches [début:fin:pas].

s = "python"
len(s)          # 6
s[0], s[-1]     # 'p', 'n'
s[1:4]          # 'yth'
s[:2], s[2:]    # 'py', 'thon'
s[::2]          # 'pto'
s[::-1]         # 'nohtyp' (renversé)

méthodes utiles du quotidien

nettoyage, tests, recherche, substitution, split/join.

t = "  Salut, Python!  "
t.strip()                 # "Salut, Python!"
"abc".upper()             # "ABC"
"ABC".lower()             # "abc"
"hello".title()           # "Hello"
"data".startswith("da")   # True
"data".endswith("ta")     # True
"42".isdigit()            # True
"abc123".isalnum()        # True
"bonjour bonjour".replace("bonjour", "salut", 1)  # "salut bonjour"
"chercher".find("er")     # 3  (-1 si absent)
"lignes\na\nb".splitlines()   # ["lignes", "a", "b"]
"un,deux,trois".split(",")    # ["un", "deux", "trois"]
"_".join(["a", "b", "c"])     # "a_b_c"
"7".zfill(3)                  # "007"
"OK".center(6, "-")           # "--OK--"

astuce perf : préférez join à l’addition dans une boucle.

# moins bon
out = ""
for part in ["a", "b", "c"]:
    out += part

# meilleur
out = "".join(["a", "b", "c"])

f-strings : formatage moderne

insérer des variables, des expressions et formater nombres/dates.

name = "alex"
n = 1234.567
f"salut {name}"                 # "salut alex"
f"{n:.2f}"                      # "1234.57"
f"{n:,.1f}"                     # selon locale, sinon '1,234.6'
w, h = 3, 4
f"aire {w}x{h} = {w*h}"

from datetime import date
d = date(2025, 7, 12)
f"{d:%Y-%m-%d}"                 # "2025-07-12"

alignement, largeur, remplissage.

f"[{42:>5}]"   # "[   42]"
f"[{42:<5}]"   # "[42   ]"
f"[{42:^5}]"   # "[ 42 ]"

affichage de débogage rapide (python 3.8+).

x = 7 * 6
f"{x=}"         # "x=42"

sous-chaînes et appartenance

"société"[:4]         # "soci"
"py" in "python"      # True
"cat" not in "dog"    # True

comparer et trier des chaînes

comparaison lexicographique sensible à la casse par défaut.

"a" < "b"            # True
"Z" < "a"            # True (car codes unicode)
sorted(["é", "e"])   # ordre unicode, pas forcément ordre “alphabetique” local

pour des tris “humains”, il faut un collationneur (ex: locale, icu) hors scope débutant.

encodage et bytes

passer entre str (texte unicode) et bytes (octets) en utf-8.

s = "café"
b = s.encode("utf-8")     # b'caf\xc3\xa9'
b.decode("utf-8")         # "café"

lire/écrire un fichier texte en utf-8.

from pathlib import Path

Path("note.txt").write_text("café\npython", encoding="utf-8")
content = Path("note.txt").read_text(encoding="utf-8")

normalisation unicode (accents combinés vs précomposés).

import unicodedata as ud

s1 = "e\u0301"            # "e" + accent aigu combinant
s2 = "é"                  # précomposé
s1 == s2                  # False parfois
ud.normalize("NFC", s1) == ud.normalize("NFC", s2)  # True

pièges courants

  • utiliser is au lieu de == pour comparer des chaînes
  • concaténer dans une boucle (préférez join)
  • oublier l’encodage lors de l’ouverture de fichiers texte
  • supposer que len() compte les “caractères visuels” (il compte des points de code, pas les graphèmes)
  • confondre find (retourne -1 si absent) et index (lève une exception si absent)

mini exemples exécutables

# nettoyage d'une colonne csv simulée
cells = ["  jean  ", "ANA", "  élise", "  "]
clean = [unicodedata.normalize("NFC", c.strip().title()) for c in cells if c.strip()]
print(clean)  # ["Jean", "Ana", "Élise"]
# formatage d'un relevé simple
items = [("stylo", 1, 2.5), ("carnet", 2, 4.0)]
total = 0.0
for name, qty, price in items:
    line_total = qty * price
    total += line_total
    print(f"{name:<10} x{qty:>2} = {line_total:>6.2f} €")
print(f"{'total':<10}     {total:>6.2f} €")
# détecter un suffixe et remplacer proprement
filename = "rapport_final.TXT"
if filename.lower().endswith(".txt"):
    normalized = filename.rsplit(".", 1)[0] + ".txt"
    print(normalized)

exercices

  1. nettoyage de noms écrivez clean_name(s) qui retourne s sans espaces superflus, en title case, normalisé en NFC, et sans double espaces internes.

  2. masquage d’email fonction mask_email(email) qui transforme alexandre@data.pm en a********e@data.pm (garder 1ère et dernière lettre de la partie locale).

  3. palindrome écrivez is_palindrome(s) qui ignore les espaces et la casse, puis teste si s se lit pareil dans les deux sens. bonus : supprimer les accents via unicodedata.normalize + filtrage.

  4. résumé de phrase écrivez summary(text, n=40) qui retourne la phrase tronquée à n caractères, sans couper un mot si possible, et ajoute … si tronquée.

  5. compteur de mots écrivez word_count(text) qui retourne un dict {mot: occurrences} en séparant sur les espaces et ponctuations simples (ex: remplacez ,.;:!? par des espaces avant split).

Sujets abordés