Manipuler les chaînes de caractères en Python

Une chaîne de caractères est une séquence de caractères de type str. Elle peut contenir un nom, une phrase, un code ou aucun caractère. Python conserve les caractères dans l’ordre, y compris les espaces et la ponctuation.

Écrire la valeur entre des guillemets assortis

Les guillemets simples et doubles créent le même type de valeur : 'hello' et "hello" sont égaux. Les guillemets extérieurs marquent les bornes ; ils ne sont pas des caractères de la valeur. Choisis des guillemets qui rendent ceux de l’intérieur faciles à lire :

message = "It's late"
reply = 'She said "yes"'
empty = ""

Dans 'It's late', l’apostrophe ferme la chaîne trop tôt, ce qui provoque une SyntaxError. Les guillemets doubles résolvent ce problème ; tu peux aussi écrire 'It\'s late'. Utilise des guillemets droits dans le code.

Stocker des sauts de ligne et des barres obliques inverses

Une séquence d’échappement commence par une barre oblique inverse. Python lit \n comme un saut de ligne, \t comme une tabulation et \\ comme une barre oblique inverse. Les guillemets échappés, \' et \", insèrent des guillemets dans le texte.

text = "a\nb"
print(len(text))  # 3
print(text)

Le dernier appel affiche a et b sur deux lignes distinctes. La valeur contient trois caractères : a, un saut de ligne et b. Les séquences d’échappement sont traitées lorsque Python lit le littéral. La console affiche une représentation avec des guillemets et les séquences d’échappement nécessaires ; print() affiche les caractères eux-mêmes. Par exemple, "\x41" devient "A", donc la console n’a pas besoin d’afficher la séquence d’échappement d’origine.

Les guillemets triples permettent à un littéral de s’étendre sur plusieurs lignes. Chaque saut de ligne à l’intérieur devient un caractère de saut de ligne :

notice = """Door closed
Use side entrance"""

Une chaîne brute comporte un r avant ses guillemets. Dans r"C:\new", la barre oblique inverse et n restent séparés, ce qui donne six caractères. Dans "C:\new", \n devient un saut de ligne, ce qui en donne cinq. Les littéraux bruts sont utiles lorsque les barres obliques inverses font partie du texte.

Mesurer et combiner du texte

len() compte chaque caractère, y compris les espaces : len("Hi there!") vaut 9, et len("") vaut 0. Plus précisément, cette fonction compte les points de code Unicode. len("café") vaut 4 lorsque é est un seul point de code ; len("👍🏽") vaut 2, même si l’émoji ressemble à un seul symbole.

Utilise + pour concaténer des chaînes et * pour répéter une chaîne :

first = "Ada"
last = "Lovelace"
full = first + " " + last  # "Ada Lovelace"
rule = "-" * 10           # ten dashes

La concaténation n’insère rien automatiquement. Sans " ", les noms deviennent "AdaLovelace". Répéter "ab" zéro fois donne la chaîne vide.

Déterminer si les chiffres sont du texte ou des nombres

Les deux opérandes d’une concaténation de chaînes doivent être des chaînes. "Age: " + 30 lève TypeError ; "Age: " + str(30) donne "Age: 30". À l’inverse, input() renvoie du texte : "3" + "4" donne "34". Pour additionner leurs valeurs numériques, convertis-les d’abord : int("3") + int("4") donne 7.

Un indice sélectionne un caractère selon sa position. Python commence à compter à zéro : la position d’un caractère est donc inférieure de un à son rang dans un comptage ordinaire depuis la gauche.

Représenter les positions

Pour word = "Python", chaque caractère possède un indice positif ou nul et un indice négatif :

word = "Python"
print(word[0])   # P
print(word[1])   # y
print(word[-1])  # n

Les crochets après la chaîne sélectionnent le caractère. Le résultat est une chaîne de longueur un : Python n’a pas de type distinct pour les caractères. Tu peux assembler les caractères sélectionnés : word[0] + word[-1] donne donc "Pn".

Pour une longueur n, les indices valides vont de -n à n - 1 lorsque n > 0. Les indices positifs ou nuls comptent depuis le début ; les indices négatifs comptent depuis la fin. L’indice -k sélectionne le même caractère que n - k ; dans ce mot de six caractères, -2 et 4 sélectionnent tous deux "o".

Distinguer la longueur du dernier indice

len(word) vaut 6, mais word[6] lève IndexError : il n’y a pas de septième caractère. Le dernier caractère est word[len(word) - 1], ou simplement word[-1]. Dépasser l’une ou l’autre extrémité provoque une erreur ; word[-7] lève aussi IndexError.

Un indice doit être un entier. word[1.0] lève TypeError, même si le flottant a une valeur entière. Utilise // pour calculer une position centrale :

word = "Pyt"
middle = len(word) // 2  # 1
print(word[middle])      # y

L’opérateur / produirait 1.5, qui ne peut pas servir d’indice dans une chaîne. Pour une longueur impaire, len(word) // 2 sélectionne le caractère du milieu. Pour une longueur paire, il sélectionne celui de droite parmi les deux caractères du milieu : "Python"[3] vaut "h".

Construire des initiales à partir des premiers caractères

first = "Grace"
last = "Hopper"
initials = first[0] + last[0]
print(initials)  # GH

Chaque nom fournit son caractère à l’indice 0. Avec first[-1], tu obtiendrais "e", la dernière lettre. Cette méthode suppose que chaque nom comporte au moins un caractère.

Vérifier une saisie vide avant l’accès par indice

La chaîne vide a une longueur nulle et aucun indice de caractère valide. ""[0] lève IndexError. Une vérification de la longueur peut empêcher un programme de lire un caractère inexistant :

line = input("Comment: ")
if len(line) > 0 and line[0] == "#":
    print("Comment line")

Python évalue and de gauche à droite. Si la vérification de longueur est fausse, il ignore line[0]. Inverser ces deux tests tenterait d’abord l’accès par indice non protégé. Si tu veux seulement savoir si une ligne commence par "#", line.startswith("#") fonctionne aussi sur une saisie vide et renvoie False.

Une tranche sélectionne une suite de caractères et la renvoie sous forme de chaîne. Elle permet de prendre un préfixe, de supprimer une fin ou de séparer des champs qui occupent des positions fixes.

Le début est inclus ; la fin est exclue

Écris text[start:stop]. Avec s = "Monty Python", s[0:5] donne "Monty", et s[6:12] donne "Python". L’espace est à l’indice 5, donc la deuxième tranche commence à 6.

Imagine que les nombres de la tranche désignent les espaces entre les caractères. L’espace 0 se trouve avant le premier caractère, et l’espace 5 après les cinq premiers. Tout prendre entre les deux donne cinq caractères. Pour 0 <= start <= stop <= len(text), la longueur est stop - start.

word = "Monty"
print(word[0:4])  # Mont
print(word[0:5])  # Monty

La position de fin est la première position exclue. Ajouter un au dernier indice souhaité permet d’inclure ce dernier caractère.

Omettre une borne

À toute position de découpage k, s[:k] + s[k:] redonne s. Les tranches se rejoignent au même espace, sans caractère manquant ni répété.

Les bornes de tranche qui dépassent les extrémités sont ramenées à celles-ci. "cat"[1:100] vaut "at" ; "cat"[5:] vaut "". Pour une tranche parcourue vers l’avant, un début égal ou supérieur à la fin donne une chaîne vide, comme dans s[4:2]. Contrairement à l’accès à un caractère par indice, une tranche hors limites ne lève pas IndexError.

Choisir un pas

Le troisième emplacement dans text[start:stop:step] définit l’écart entre les positions sélectionnées :

letters = "abcdefgh"
print(letters[::2])   # aceg
print(letters[1::2])  # bdfh
print(letters[::-1])  # hgfedcba

Un pas négatif fait avancer à l’envers. Lorsque les deux bornes sont omises, [::-1] commence au dernier caractère et parcourt tous les caractères dans l’ordre inverse. Un pas de zéro lève ValueError. Le sens doit correspondre aux bornes : la règle ci-dessus selon laquelle un début égal ou supérieur à la fin donne un résultat vide s’applique à un pas positif.

Appliquer les tranches à une structure fixe

d = "2026-07-04"
year = d[:4]
month = d[5:7]
day = d[8:10]
print(month + "/" + day + "/" + year)  # 07/04/2026

Les positions fonctionnent parce que cette structure utilise toujours quatre chiffres pour l’année et deux pour le mois et le jour. Un texte dont les champs ont des longueurs variables nécessite une recherche ou un découpage.

L’inversion permet aussi de tester un palindrome : word == word[::-1]. "level" réussit, mais "Level" échoue, car la casse compte. Affecte clean = word.lower() et teste clean == clean[::-1] pour ignorer la casse.

Utilise une boucle lorsqu’une décision doit être prise pour chaque caractère. La boucle peut compter les correspondances, utiliser leurs positions, s’arrêter à la première ou recueillir les caractères qui doivent figurer dans un résultat.

Parcourir directement les caractères

for ch in "hi!":
    print(ch)

Le corps s’exécute trois fois, avec ch égal tour à tour à "h", "i" et "!". Avec la chaîne vide, le corps ne s’exécute aucune fois. Une boucle directe sur les caractères n’a pas besoin d’indice si tu utilises uniquement le caractère courant.

Pour compter, initialise le compteur avant la boucle et augmente-le uniquement lorsque le test réussit :

text = "Programming in Python"
count = 0
for ch in text.lower():
    if ch in "aeiou":
        count += 1
print(count)  # 5

La conversion en minuscules permet aussi de reconnaître les voyelles majuscules. La chaîne du test définit les voyelles comptées ; elle ne contient pas y. Réinitialiser count dans la boucle ferait perdre le total des passages précédents.

Utiliser les positions lorsque les caractères voisins comptent

range(len(text)) fournit les indices de zéro jusqu’au dernier indice valide. Pour une tâche qui nécessite à la fois la position et le caractère, enumerate(text) les fournit ensemble :

for i, ch in enumerate("abc"):
    print(i, ch)

Cela affiche 0 a, puis 1 b, puis 2 c. Les deux variables de boucle reçoivent l’indice et le caractère de chaque paire.

Pour comparer des caractères voisins, le dernier indice ne peut pas être la position courante, car il n’a pas de caractère suivant :

text = "bookkeeper"
pairs = 0
for i in range(len(text) - 1):
    if text[i] == text[i + 1]:
        pairs += 1
print(pairs)  # 3

Les correspondances sont oo, kk et ee. Avec range(len(text)), le dernier passage tenterait d’accéder à text[len(text)] et lèverait IndexError.

Gérer une position avec while

i = 0
while i < len(text):
    print(text[i])
    i += 1

Le test utilise strictement < : la position len(text) dépasse la fin. L’incrémentation fait progresser la boucle vers son arrêt ; si tu l’omets, elle continue indéfiniment à lire le même caractère dans un texte non vide. Pour parcourir le texte à l’envers, commence à len(text) - 1, continue tant que i >= 0 et soustrais un à chaque passage.

Rechercher ou recueillir

Pour trouver le premier chiffre dans "Room 42B", arrête-toi après avoir utilisé une correspondance :

for ch in "Room 42B":
    if ch.isdigit():
        print(ch)  # 4
        break

Sans break, les deux chiffres seraient affichés. Pour un simple test de présence, "4" in text répond déjà par oui ou par non.

Pour recueillir du texte, commence par result = "" et ajoute chaque caractère souhaité. Pour "a b c", ajouter un caractère uniquement lorsque ch != " " construit "abc". L’affectation ch = ch.upper() dans une boucle ne change que la variable de boucle ; elle ne modifie pas les caractères stockés dans text.

Les chaînes sont immuables : leurs caractères ne peuvent pas être modifiés une fois la chaîne créée. Un programme qui semble modifier du texte construit une autre chaîne et choisit la variable qui y fera référence.

Lire un caractère sans lui affecter de valeur

name = "Jane"
name[0] = "D"  # TypeError

L’indice permet de lire "J", mais ne peut pas être la cible d’une affectation. del name[0] lève aussi TypeError. Pour obtenir "Dane", combine le premier caractère souhaité avec la fin inchangée :

name = "Jane"
name = "D" + name[1:]
print(name)  # Dane

Python évalue d’abord le membre de droite et produit une nouvelle chaîne. Il fait ensuite référence à ce résultat par l’intermédiaire de name.

Remplacer ou insérer à une position connue

Pour un indice i valide et positif ou nul, ces expressions utilisent des tranches différentes à droite :

Le remplacement saute l’ancien caractère ; l’insertion le conserve. Avec text = "cat", i = 1 et new = "X", le remplacement donne "cXt", tandis que l’insertion donne "cXat".

Convertis un indice négatif en son équivalent positif ou nul avant d’utiliser ce schéma de remplacement. Pour le dernier caractère de "cat", i = len(text) - 1 vaut 2. Si tu places directement -1 dans text[i + 1:], cette expression devient text[0:], ce qui ajoute toute l’ancienne chaîne et donne "caXcat".

Conserver le résultat d’une méthode

Les méthodes de transformation suivent la même règle d’immuabilité :

msg = "hello"
msg.upper()
print(msg)       # hello
msg = msg.upper()
print(msg)       # HELLO

Le premier appel calcule un résultat que le programme abandonne. L’affectation conserve le second résultat. Les méthodes de chaîne ne modifient jamais la chaîne d’origine, mais leurs types de retour diffèrent : upper() renvoie une chaîne, find() un entier et isdigit() un booléen.

Suivre deux noms pour une même valeur

Après a = "cat" et b = a, les deux variables font référence à "cat". L’exécution de a = a + "s" donne à a la nouvelle valeur "cats" ; b fait toujours référence à "cat". Aucun caractère de l’ancienne chaîne partagée n’a changé. a += "s" effectue le même type de réaffectation pour une chaîne.

Construire une valeur modifiée dans une boucle

word = "secret"
masked = ""
for ch in word:
    if ch in "aeiou":
        masked += "*"
    else:
        masked += ch
print(masked)  # s*cr*t
print(word)    # secret

Chaque passage ajoute un caractère choisi à masked. Placer chaque caractère au début, avec result = ch + result, inverse le texte : les passages sur "drawer" construisent "d", "rd", "ard", "ward", "eward" et "reward".

La concaténation répétée est pratique pour les exemples courts. Lorsque les éléments existent déjà dans une liste, "".join(pieces) construit directement un résultat et peut aussi placer un séparateur entre eux.

Une méthode est une fonction attachée à une valeur. Les méthodes de chaîne effectuent des tâches courantes, comme changer la casse, nettoyer les extrémités d’une saisie et remplacer du texte. Chaque appel renvoie un résultat et laisse la chaîne d’origine inchangée.

Appeler une méthode avec la notation pointée

Écris value.method(arguments), comme dans "hello".upper(). Les parenthèses déclenchent l’appel. name.upper sans parenthèses désigne la méthode elle-même ; elle ne produit pas de texte en majuscules. L’écriture upper(name) ne trouve pas de fonction indépendante nommée upper. Utilise dir("") pour répertorier les méthodes de chaîne et help(str.upper) pour lire la description de l’une d’elles.

Choisir une opération sur la casse

capitalize() modifie le premier caractère et met le reste en minuscules ; title() commence de nouveaux mots après les caractères qui ne sont pas des lettres. Ainsi, "they're".title() devient "They'Re" : il peut donc être nécessaire de vérifier les résultats de la mise en majuscules automatique des titres.

Pour les comparaisons sans distinction de casse, casefold() traite plus de cas dans différentes langues que lower(). "Straße".lower() vaut "straße", tandis que "Straße".casefold() vaut "strasse". Effectue le repliement de casse des deux chaînes avant de les comparer.

Nettoyer les extrémités du texte

strip() supprime les caractères d’espacement au début et à la fin, notamment les espaces, tabulations et sauts de ligne. La méthode conserve les espacements internes : " New York \n".strip() vaut "New York". lstrip() nettoie uniquement l’extrémité gauche ; rstrip() uniquement la droite.

Avec un argument, la suppression retire de façon répétée chacun des caractères indiqués aux extrémités. Elle ne supprime pas un mot exact :

print("...Wow!!!".strip(".!"))          # Wow
print("report.txt".rstrip(".txt"))     # repor
print("report.txt".removesuffix(".txt"))  # report

Le t final de report appartient aussi à l’ensemble des caractères à supprimer : il disparaît donc. removeprefix() et removesuffix() suppriment un texte exact à une extrémité ; ces méthodes sont disponibles dans Python 3.9 et les versions ultérieures.

Remplacer les correspondances et chaîner les transformations

replace(old, new) remplace chaque correspondance exacte. Un troisième argument limite le nombre de correspondances modifiées : "a-b-c".replace("-", "", 1) donne "ab-c". Un remplacement vide supprime les correspondances. La casse compte : "Cat cat".replace("cat", "dog") donne donc "Cat dog".

answer = "  YES \n"
answer = answer.strip().lower()
print(answer == "yes")  # True

Les appels s’exécutent de gauche à droite : strip() renvoie "YES", puis lower() renvoie "yes". Un chaînage fonctionne lorsque la méthode suivante convient au type du résultat précédent. Un résultat de recherche est un entier : il ne prend donc pas en charge les méthodes de nettoyage des chaînes.

Pour le remplissage, "7".zfill(3) donne "007", "Total".ljust(8) ajoute trois espaces à droite et "Hi".center(8, "*") donne "***Hi***". rjust() ajoute du remplissage à gauche. Ces largeurs sont des minimums ; un texte plus long est conservé en entier.

Une recherche peut répondre à trois questions différentes : si un texte est présent, où il commence et combien de fois il apparaît. Choisis le résultat qui convient à la décision que ton programme doit prendre.

Choisir un résultat de recherche

Une sous-chaîne est une suite de caractères consécutifs. "py" in "happy" vaut True, mais "hpy" in "happy" vaut False. La recherche respecte la casse : "Py" in "python" vaut False. not in inverse le test de présence. La chaîne vide est présente dans toute chaîne.

Trouver la bonne occurrence

text = "banana"
print(text.find("an"))     # 1
print(text.find("an", 2))  # 3
print(text.rfind("an"))    # 3

La position de début facultative ignore les possibilités précédentes. L’indice renvoyé reste compté depuis le début de la chaîne entière. index() renvoie la même position lorsqu’une correspondance existe, mais l’erreur levée en son absence rend cette méthode utile lorsque l’absence indique un problème inattendu.

Vérifier une position avant d’extraire une tranche

email = "maria.lopez@example.org"
at = email.find("@")
if at != -1:
    user = email[:at]
    domain = email[at + 1:]
    print(user)    # maria.lopez
    print(domain)  # example.org

La recherche renvoie 11. La première tranche s’arrête avant @ ; la seconde commence un caractère après. Si le repère était absent, at vaudrait -1. Utiliser cette valeur comme borne de tranche sélectionnerait du texte près de la fin sans signaler d’erreur : traite donc le cas où le repère manque avant d’extraire les parties.

N’utilise pas if text.find("x"): comme test de présence. Une correspondance à l’indice 0 est considérée comme fausse dans une condition, tandis que la valeur -1, qui indique l’absence de résultat, est considérée comme vraie. Utilise if "x" in text: ou compare explicitement la position à -1.

Rechercher à partir d’un repère connu

Pour line = "Order #4521 shipped", le numéro suit # et se termine à l’espace suivant :

start = line.find("#") + 1
end = line.find(" ", start)
number = line[start:end]
print(number)  # 4521

Ici, les deux repères existent. Commencer la seconde recherche à start permet d’ignorer l’espace précédent après Order. Si des repères peuvent manquer, vérifie chaque résultat de recherche brut avant d’ajouter un ou d’extraire une tranche ; ajouter un à -1 masquerait l’échec de la recherche en transformant le résultat en 0.

Compter les occurrences entières

"banana".count("a") vaut 3, et "banana".count("ana") vaut 1. Les deux occurrences possibles de ana se chevauchent, donc count() ne les compte pas toutes les deux. De même, "aaaa".count("aa") vaut 2.

Pour ignorer la casse, effectue la recherche dans une version convertie, comme avec "python" in sentence.lower(). La recherche trouve toujours les caractères exacts dans cette version. Les comptages et les tests de présence peuvent utiliser directement la chaîne convertie ; un indice appartient à la chaîne précise dans laquelle la recherche a été effectuée.

Les tests sur les chaînes renvoient des booléens qui peuvent guider une condition. Ils t’aident à accepter une saisie conforme à une règle et à comparer du texte sous une forme cohérente.

Tester les extrémités ou les caractères

startswith() et endswith() testent un texte exact aux extrémités. Un tuple permet à un test d’accepter plusieurs fins : name.endswith((".jpg", ".png")). La chaîne "photo.PNG", dont l’extension est en majuscules, échoue à ce test sauf si tu la convertis d’abord en minuscules.

Les cinq renvoient False pour "". Les lettres ne se limitent pas à l’alphabet anglais : "café".isalpha() vaut True. L’espace dans "hello world" rend le test isalpha() faux.

isupper() et islower() examinent les caractères qui ont une casse et en exigent au moins un. "ABC1".isupper() vaut True ; le chiffre ne change rien au fait que les lettres sont en majuscules. "123" ne contient aucun caractère ayant une casse, donc les deux tests sont faux.

Valider avant la conversion

Un test de chiffres ne décrit pas tous les nombres que Python peut lire. "-5".isdigit(), "3.5".isdigit() et " 42".isdigit() sont faux, car un signe, un point ou une espace n’est pas un chiffre. De plus, "²".isdigit() est vrai alors que int("²") échoue. isdecimal() rejette ce caractère en exposant et convient à une saisie d’entier positif ou nul écrite uniquement avec des chiffres.

text = input("Tickets: ").strip()
if text.isdecimal() and int(text) > 0:
    print("Accepted")
else:
    print("Enter a positive whole number")

Le test de chaîne s’exécute en premier. Lorsqu’il est faux, and ignore la conversion, ce qui protège le programme contre une saisie vide ou non numérique. " 12 " devient "12" et réussit le test ; "0" se convertit sans erreur, mais échoue au test de valeur positive. Cette règle rejette volontairement les saisies comportant un signe ou un point décimal.

Une règle pour un nom d’utilisateur peut combiner des vérifications de longueur et de caractères : 3 <= len(name) <= 12 and name.isalnum(). "ada99" réussit, "ada 99" échoue au test de caractères et "ad" échoue au test de longueur.

Comparer du texte nettoyé

L’égalité exige les mêmes caractères dans le même ordre. "Yes" == "yes" et "yes " == "yes" sont faux. Pour les réponses dont la casse et les caractères d’espacement aux extrémités doivent être ignorés, compare typed.strip().casefold() à expected.strip().casefold().

Le classement s’effectue caractère par caractère. Le premier point de code Unicode différent détermine le résultat. ord("A") vaut 65, ord("Z") vaut 90 et ord("a") vaut 97 ; chr(97) donne "a". Ainsi, "Zebra" < "apple" est vrai. Lorsqu’une chaîne est un préfixe de l’autre, la plus courte vient en premier : "app" < "apple".

Les chaînes de chiffres suivent aussi l’ordre des caractères : "10" < "9" est vrai parce que "1" vient avant "9". Convertis-les en nombres pour comparer des quantités. Les lettres accentuées demandent aussi de l’attention : ord("é") vaut 233, donc "école" > "zoo" est vrai. Cet ordre intégré suit les points de code, et non l’ordre d’un dictionnaire de langue.

split() transforme une chaîne en une liste de chaînes. Une liste est une collection ordonnée écrite entre crochets. Tu peux lire un élément par son indice, parcourir les éléments ou les compter avec len().

Choisir les caractères d’espacement ou un séparateur exact

Sans argument, split() traite une suite de caractères d’espacement comme une seule séparation et ignore ceux qui se trouvent aux deux extrémités :

words = "  the quick  brown fox ".split()
print(words)       # ['the', 'quick', 'brown', 'fox']
print(len(words))  # 4
print(words[0])    # the

Avec un séparateur explicite, chaque occurrence exacte produit un découpage. Des séparateurs consécutifs conservent un champ vide :

fields = "red,green,,blue".split(",")
# ["red", "green", "", "blue"]

Le troisième élément vide peut représenter une valeur laissée vide. Il compte tout de même comme un élément de la liste.

Un séparateur peut contenir plusieurs caractères, mais ils doivent tous correspondre. Si aucun séparateur n’apparaît, le résultat contient la chaîne d’origine entière comme seul élément. Découper sur une virgule suivie d’une espace diffère donc d’un découpage sur une virgule.

Limiter le découpage du texte

Le deuxième argument, maxsplit, limite le nombre de découpages, et non le nombre d’éléments obtenus :

print("key=value=more".split("=", 1))
# ["key", "value=more"]
print("archive.tar.gz".rsplit(".", 1))
# ["archive.tar", "gz"]

split() commence par la gauche ; rsplit() commence par la droite. Un découpage depuis la droite sépare la dernière extension du fichier sans découper aux points précédents.

Lire les champs et convertir les quantités

line = "Lovelace,Ada,1815"
parts = line.split(",")
if len(parts) == 3:
    last = parts[0]
    first = parts[1]
    year = int(parts[2])
    print(f"{first} {last} was born in {year}.")

La sortie est "Ada Lovelace was born in 1815.". La vérification de la longueur empêche qu’un élément manquant provoque IndexError. Elle ne vérifie pas que l’année est numérique ; une règle de saisie distincte est nécessaire lorsque les données peuvent être invalides.

Chaque partie obtenue par découpage est d’abord une chaîne. Pour faire le total de "3 14 15", initialise total = 0, parcours line.split() et ajoute int(part). Le résultat est 32 ; concaténer les éléments sans les convertir assemblerait les chiffres.

Un séparateur explicite conserve les espaces qui entourent les éléments. "a, b".split(",") donne ["a", " b"]. Appelle strip() sur chaque partie si ces espaces sont indésirables.

Reconnaître deux résultats apparentés

splitlines() découpe aux sauts de ligne : "line one\nline two".splitlines() donne deux chaînes. partition("=") renvoie toujours un tuple de trois parties : le texte avant le premier séparateur, le séparateur et le texte après. "user=ada".partition("=") donne ("user", "=", "ada") ; avec "user", il donne ("user", "", "").

join() construit une chaîne à partir d’une séquence de chaînes. La chaîne placée avant le point fournit le séparateur, qui apparaît entre les éléments voisins.

Placer le séparateur en premier

colors = ["red", "green", "blue"]
text = ", ".join(colors)
print(text)  # red, green, blue

Lis cela comme « utilise une virgule suivie d’une espace pour assembler les couleurs ». Il n’y a pas de séparateur avant le premier élément ni après le dernier. Tu peux changer la présentation de la sortie en modifiant uniquement le séparateur :

join() appartient à la chaîne qui sert de séparateur. Écrire ["a", "b"].join(",") lève AttributeError, car la liste n’a pas de méthode join. Un seul appel s’adapte aussi au nombre d’éléments ; tu n’as pas besoin d’écrire une nouvelle suite d’opérations + pour chaque longueur de liste.

Convertir d’abord les éléments qui ne sont pas des chaînes

Tous les éléments doivent déjà être des chaînes. ", ".join([1, 2, 3]) lève TypeError. map(str, items) applique str() à chaque élément, donc ceci fonctionne :

items = [1, 2, 3]
text = " ".join(map(str, items))
print(text)  # 1 2 3

Le str passé à map() est la fonction de conversion. join() reçoit les éléments convertis et renvoie une chaîne.

Une chaîne est elle-même une séquence de chaînes d’un caractère : " ".join("ABC") donne donc "A B C". Cela peut être utile, mais passer un seul mot alors que tu voulais une liste de mots place des séparateurs entre ses caractères.

Modifier les espacements et les séparateurs

text = "too   many    spaces"
cleaned = " ".join(text.split())
print(cleaned)  # too many spaces

Le découpage sur les caractères d’espacement produit d’abord les trois mots. Les assembler avec une seule espace crée un espacement uniforme et ne laisse aucune espace aux extrémités. Les espacements d’origine sont perdus à l’étape du découpage.

Avec un séparateur explicite, les champs vides conservent assez d’informations pour reconstituer le texte exact. Si s = "a,,b,", alors s.split(",") donne ["a", "", "b", ""], et ",".join(...) redonne "a,,b,". Le séparateur doit être le même pour cette reconstitution exacte.

Changer le séparateur change la présentation : "-".join("2026/07/04".split("/")) donne "2026-07-04". Ici, replace("/", "-") est aussi une solution directe.

Recueillir un petit résultat à partir de mots

Pour obtenir un sigle, découpe "portable network graphics", commence par acronym = "" et ajoute word[0].upper() pour chaque mot. Le découpage sur les caractères d’espacement fournit des mots non vides, donc leurs premiers caractères existent. Cela construit "PNG". Si les lettres sont déjà dans une liste, ".".join(["P", "N", "G"]) construit "P.N.G" sans point final.

Une f-string est un littéral de chaîne qui comporte f ou F avant son guillemet ouvrant. À l’intérieur, les accolades contiennent des expressions dont les valeurs sont insérées dans le texte.

Insérer des variables et des expressions

name = "Ada"
age = 36
message = f"{name} is {age} years old."
print(message)  # Ada is 36 years old.

Les nombres deviennent automatiquement du texte dans un champ. Le même message pourrait utiliser la concaténation et str(age), mais la f-string permet de voir la présentation finale en un seul endroit.

Les accolades peuvent contenir des calculs, des appels de méthodes ou des appels de fonctions :

price = 4.5
qty = 3
print(f"Cost: {price * qty}")  # Cost: 13.5
print(f"Name: {name.upper()}")  # Name: ADA
word = "Python"
print(f"{len(word)} letters")  # 6 letters

Python évalue chaque expression lorsque la ligne s’exécute. Une chaîne enregistrée ne reste pas liée aux variables utilisées pour la construire. Si qty change après la construction de message, cette chaîne conserve ses caractères.

Distinguer le texte ordinaire des champs

Sans le préfixe, "Hello {name}" est du texte ordinaire qui conserve ses accolades. L’absence de f est une raison fréquente pour laquelle un programme affiche le nom de la variable au lieu de sa valeur. Avec le préfixe, un nom auquel aucune valeur n’a été affectée lève NameError lorsque l’expression s’exécute.

Pour afficher une accolade littérale, double-la :

x = 5
print(f"{{x}} = {x}")  # {x} = 5

Les accolades doublées fournissent le texte littéral {x}. La paire simple autour du dernier x fournit sa valeur.

Garder les expressions entre guillemets faciles à lire

Utilise l’autre type de guillemets à l’intérieur d’un champ :

print(f"Shout: {'hi'.upper()}")  # Shout: HI

Cette écriture fonctionne dans toutes les versions de Python qui proposent les f-strings, apparues dans la version 3.6. Python 3.12 et les versions ultérieures permettent aussi de réutiliser le type de guillemets extérieur à l’intérieur du champ. Les séquences d’échappement fonctionnent toujours dans les f-strings : f"Name: {name}\nAge: {age}" s’affiche sur deux lignes.

Pour un affichage rapide lors du débogage, Python 3.8 et les versions ultérieures acceptent = après une expression. Avec x = 5, f"{x=}" donne "x=5" ; avec total = 12, f"{total = }" donne "total = 12". Les espaces saisies autour de l’expression et du signe égal apparaissent à l’affichage.

Lire les anciennes formes de mise en forme

Le code Python existant peut construire le même texte d’autres façons :

str.format() remplit les champs entre accolades avec ses arguments. Des champs numérotés peuvent réutiliser un argument : "{0} {1} {0}".format("a", "b") donne "a b a". Dans la mise en forme avec le signe pourcentage, %s insère du texte et %d un entier. Reconnaître ces champs t’aide à lire un programme, même s’il a été écrit avant que les f-strings soient courantes.

Une spécification de format contrôle la façon dont une valeur est affichée. Place deux-points après l’expression, puis les instructions : f"{value:spec}". La mise en forme renvoie du texte et laisse la valeur numérique d’origine inchangée.

Définir le nombre de décimales et comprendre l’arrondi

.Nf affiche exactement N chiffres après le point décimal. f"{3.14159:.2f}" donne "3.14", f"{2/3:.3f}" donne "0.667" et f"{5:.2f}" donne "5.00". .0f n’affiche pas de point décimal : f"{7.6:.0f}" donne "8".

L’arrondi utilise la valeur réellement stockée. La plupart des fractions décimales sont des approximations binaires très proches. Le flottant 2.675 est légèrement inférieur à cette valeur décimale exacte, donc f"{2.675:.2f}" donne "2.67". Les valeurs exactement à mi-chemin sont arrondies au chiffre final pair : 0.125 s’affiche sous la forme "0.12", tandis que 0.375 s’affiche sous la forme "0.38" avec deux décimales. f"{2.5:.0f}" donne "2". Les programmes qui nécessitent des calculs d’argent exacts stockent souvent les centimes entiers sous forme d’entiers.

Ajouter le groupement et les pourcentages

Une virgule groupe les milliers ; le point introduit la précision décimale. Pour un montant en dollars, garde le symbole dollar en dehors du champ : avec amount = 1250.5, f"${amount:,.2f}" donne "$1,250.50".

Le type % multiplie par 100 et ajoute %. Utilise une fraction comme 0.256 pour afficher 25.6%. Si tu fournis 25.6, le pourcentage affiché est multiplié une nouvelle fois. Sans précision explicite, % affiche six décimales.

Mettre en forme les entiers et les parties d’une date

d sert aux entiers. f"{42:d}" fonctionne, mais f"{3.0:d}" lève ValueError, car un flottant n’est pas un entier. Un zéro placé avant une largeur ajoute un remplissage par des zéros ; un signe plus demande l’affichage du signe :

print(f"{7:03d}")   # 007
print(f"{5:+d}")    # +5
print(f"{-5:+d}")   # -5

Pour le mois 7, le jour 4 et l’année 2026, f"{month:02d}/{day:02d}/{year}" construit "07/04/2026". Pour l’heure 9 et les minutes 5, f"{hour}:{minute:02d}" construit "9:05". Le remplissage par des zéros empêche que des minutes à un chiffre apparaissent sous la forme "9:5".

Combiner les instructions dans l’ordre

L’ordre est le suivant : caractère de remplissage, alignement, signe, zéro, largeur, groupement, précision, type. Tu peux omettre les parties inutiles. f"{12345.678:>12,.2f}" utilise un alignement à droite, une largeur de 12, un groupement par virgule et deux décimales, ce qui donne " 12,345.68".

La précision peut provenir d’une autre variable : avec places = 3, f"{3.14159:.{places}f}" donne "3.142". Les mêmes spécifications fonctionnent dans les champs de format(value, spec) et de str.format(). Garde le nombre d’origine pour les calculs ; round(value, 2) renvoie un nombre arrondi lorsque le calcul l’exige.

Une largeur de champ réserve un nombre minimal de positions de caractères pour une valeur. Combiner les largeurs rend les petits tableaux et les reçus lisibles dans un terminal.

Choisir la largeur et l’alignement

Par défaut, les chaînes s’alignent à gauche et les nombres à droite. f"{'cat':6}" donne "cat ", tandis que f"{42:6}" donne " 42". Utilise un caractère d’alignement pour choisir explicitement :

Lorsque le centrage laisse un nombre impair d’espaces, l’alignement des f-strings place l’espace supplémentaire à droite : f"{'hi':^7}" donne " hi ".

La largeur est un minimum. f"{'elephant':4}" donne toujours "elephant" ; le mot n’est pas tronqué. Une entrée longue peut donc désaligner les colonnes suivantes.

Ajouter un caractère de remplissage ou limiter le texte

Un caractère de remplissage se place immédiatement avant l’alignement. f"{'hi':*^10}" donne "****hi****", et f"{7:0>3}" donne "007". Le remplissage nécessite un caractère d’alignement. f"{'':-^20}" remplit un champ vide avec vingt tirets.

La précision de chaîne limite le nombre de caractères affichés :

place = "Washington"
print(f"{place:.4}")      # Wash
print(f"|{place:10.4}|")  # |Wash      |

La précision limite d’abord le texte affiché à quatre caractères ; la largeur le complète ensuite jusqu’à dix. Utilise une largeur et une précision adaptées lorsque le texte doit rester dans une colonne fixe. La valeur d’origine de place est toujours "Washington".

Construire une ligne de reçu

item = "Apples"
qty = 3
price = 4.50
row = f"{item:<8}{qty:>4}{qty * price:>9.2f}"
print(row)

Le résultat est "Apples 3 13.50". Le champ de l’article contient six lettres et deux espaces. Le champ de quantité ajoute trois espaces avant 3. Le champ de coût ajoute quatre espaces avant 13.50, qui comporte cinq caractères. Ensemble, les champs occupent 21 caractères.

Réutilise ces largeurs pour le pain (1 à 2,25) et le café (2 à 11,00). Leurs lignes sont "Bread 1 2.25" et "Coffee 2 22.00". Une ligne de total peut combiner les deux premiers champs :

print(f"{'Total':<12}{37.75:>9.2f}")
# "Total           37.75"

Le champ de coût commence à la même position et comporte le même nombre de décimales, donc les montants sont alignés.

Adapter la présentation à son affichage

Choisis des largeurs qui laissent assez de place pour les entrées les plus longues et les espacements, ou raccourcis volontairement le texte. Une variable peut fournir une largeur : avec w = 10, f"{name:<{w}}" complète name jusqu’à dix caractères.

Les colonnes fondées sur les caractères nécessitent une police à chasse fixe, comme celle d’un terminal. Pour un remplissage simple hors d’une f-string, ljust() et rjust() se comportent comme < et >. center() et ^ centrent tous deux le texte, mais peuvent répartir différemment un remplissage impair : "hi".center(7) donne " hi ", tandis que f"{'hi':^7}" donne " hi ".