Chaînes de caractères en Python

✂️ Le cours : les chaînes de caractères

Une chaîne de caractères (str) est une suite de caractères Unicode. C'est une séquence (comme une liste, on peut la parcourir et prendre des tranches) mais elle est immuable : une fois créée, on ne peut pas en changer un caractère.

Écrire une chaîne

On écrit une chaîne entre guillemets simples ou doubles (utile pour inclure l'autre sorte dans le texte), ou entre triples guillemets pour s'étendre sur plusieurs lignes. Le caractère \ introduit une séquence d'échappement : \n est un saut de ligne, \t une tabulation, \\ une barre oblique inverse. Une chaîne préfixée par r (*raw*) garde les barres obliques telles quelles : pratique pour les chemins Windows et les expressions régulières.

a = "Bonjour"
b = 'Il dit "salut"'
c = "L'été"
d = """Ligne 1
Ligne 2"""
e = "un\ndeux"
chemin = r"C:\nouveau\test"
print(a, b, c, sep=" | ")
print(d)
print(e)
print(chemin, len(chemin))

Bonjour | Il dit "salut" | L'été
Ligne 1
Ligne 2
un
deux
C:\nouveau\test 15

Indices et tranches

Les indices commencent à 0 et les indices négatifs comptent depuis la fin. Une tranche s[debut:fin:pas] renvoie une nouvelle chaîne (la fin est exclue). s[::-1] renvoie le texte à l'envers. L'opérateur in teste la présence d'un morceau de texte.

mot = "Python"
print(mot[0], mot[-1], len(mot))
print(mot[1:4], mot[:2], mot[3:], mot[::2], mot[::-1])
print("th" in mot, "z" in mot)

P n 6
yth Py hon Pto nohtyP
True False

Une chaîne est immuable

Aucune opération ne modifie une chaîne en place : mot[0] = "J" est une erreur, et les méthodes comme upper() renvoient une nouvelle chaîne sans toucher à l'originale. Pour « modifier » un texte, on en construit un nouveau et on le range dans une variable.

mot = "python"
nouveau = "J" + mot[1:]
print(nouveau, mot)
mot.upper()
print(mot)
mot = mot.upper()
print(mot)

Jython python
python
PYTHON

Parcourir une chaîne

Un for parcourt un texte caractère par caractère. list(texte) donne la liste des caractères, et "".join(liste) fait le chemin inverse.

texte = "Programmation"
voyelles = 0
for lettre in texte.lower():
    if lettre in "aeiouy":
        voyelles += 1
print(voyelles)
print(list("NSI"), list("abc"), "".join(sorted("python")))

5
['N', 'S', 'I'] ['a', 'b', 'c'] hnopty

Codes des caractères : ord et chr

Chaque caractère a un code numérique (sa position dans la table Unicode, qui prolonge l'ASCII). ord(c) donne le code d'un caractère, chr(n) le caractère d'un code. C'est la base du chiffrement de César et de nombreux traitements de texte.

print(ord("A"), ord("a"), ord("é"))
print(chr(65), chr(97), chr(8364))
decale = "".join(chr(ord(c) + 1) for c in "HAL")
print(decale)

65 97 233
A a €
IBM

Casse et espaces

s = "  bonjour le monde  "
print(s.strip())
print(s.upper().strip())
print(s.strip().capitalize())
print(s.strip().title())
print("Bonjour".swapcase())
print(s.replace("o", "0").strip())
print("xxabcxx".strip("x"))

bonjour le monde
BONJOUR LE MONDE
Bonjour le monde
Bonjour Le Monde
bONJOUR
b0nj0ur le m0nde
abc

Chercher dans une chaîne

find(x) renvoie l'indice de la première occurrence de x, ou -1 s'il est absent ; index(x) fait pareil mais lève une ValueError. Les deux acceptent un indice de départ. count(x) compte les occurrences, startswith et endswith testent le début et la fin, in teste la présence.

phrase = "le chat et le chien"
print(phrase.find("le"), phrase.find("le", 1), phrase.find("souris"))
print(phrase.count("le"), phrase.startswith("le"), phrase.endswith("chat"))
print(phrase.index("chat"))
print("chat" in phrase, "souris" not in phrase)

0 11 -1
2 True False
3
True True

Découper et recoller : split et join

s.split(separateur) découpe un texte en liste de morceaux ; sans argument, il découpe sur les espaces (en ignorant les espaces multiples). separateur.join(liste) fait l'inverse : il colle les éléments d'une liste de textes avec le séparateur. splitlines() découpe aux retours à la ligne, partition(sep) coupe en trois parties (avant, séparateur, après).

ligne = "Ada;17;Lyon"
champs = ligne.split(";")
print(champs, len(champs))
phrase = "le  cours   de NSI"
print(phrase.split(), phrase.split(" "))
print(" ".join(phrase.split()))
print("-".join(["2026", "10", "04"]))
print("un\ndeux\ntrois".splitlines())
print("a=b=c".split("=", 1), "nom.prenom".partition("."))

['Ada', '17', 'Lyon'] 3
['le', 'cours', 'de', 'NSI'] ['le', '', 'cours', '', '', 'de', 'NSI']
le cours de NSI
2026-10-04
['un', 'deux', 'trois']
['a', 'b=c'] ('nom', '.', 'prenom')

Tester ce que contient une chaîne

Les méthodes isdigit(), isalpha(), isalnum(), isspace(), isupper(), islower()… répondent par un booléen. Elles sont fausses sur la chaîne vide, et isdigit() n'accepte ni signe moins ni virgule : "-5".isdigit() est faux.

for s in ["2026", "NSI", "nsi2", " ", "Python"]:
    print(repr(s), s.isdigit(), s.isalpha(), s.isalnum(), s.isupper())

'2026' True False True False
'NSI' False True True True
'nsi2' False False True False
' ' False False False False
'Python' False True True False

Aligner et compléter

print("NSI".center(9, "*"))
print("NSI".ljust(6, ".") + "|")
print("NSI".rjust(6, ".") + "|")
print("42".zfill(5), "-7".zfill(4))

***NSI***
NSI...|
...NSI|
00042 -007

Formater un texte

Trois façons d'insérer des valeurs dans un texte : les f-strings (f"...{valeur}...", la plus lisible, voir variables et types pour les spécifications de format), la méthode format ("{}".format(x)) et l'ancien opérateur %. Dans une f-string, {x!r} affiche la représentation de x et {x=} affiche le nom et la valeur.

prenom = "Ada"
note = 17.456
print(f"{prenom} : {note:.1f}/20")
print("{} a {}/20".format(prenom, 17))
print("{nom} a {n}".format(nom=prenom, n=18))
print("%s a %d ans" % (prenom, 36))
print(f"{prenom!r} {len(prenom)=}")

Ada : 17.5/20
Ada a 17/20
Ada a 18
Ada a 36 ans
'Ada' len(prenom)=3

Chaînes et nombres

+ concatène des textes ("3" + "4" donne "34") et * les répète. Pour calculer, il faut convertir avec int() ou float() ; int(texte, base) lit un entier écrit dans une autre base, bin, hex et oct font la conversion inverse.

print("3" + "4", "3" * 4, int("3") + int("4"))
print(str(3.5) + "!", f"{10:b}", bin(10), hex(255), int("ff", 16), int("1010", 2))

34 3333 7
3.5! 1010 0b1010 0xff 255 10

Unicode et encodage

En mémoire, une chaîne est une suite de caractères Unicode : len("été") vaut 3. Pour l'écrire dans un fichier ou l'envoyer sur un réseau, il faut la transformer en octets (bytes) avec un encodage, presque toujours "utf-8" ; decode fait le chemin inverse. En UTF-8, un caractère accentué occupe deux octets.

mot = "été"
print(len(mot))
octets = mot.encode("utf-8")
print(octets, len(octets))
print(octets.decode("utf-8"))

3
b'\xc3\xa9t\xc3\xa9' 5
été

Comparer des chaînes

Les textes se comparent caractère par caractère, selon leurs codes : "chat" < "chien" est vrai, toutes les majuscules passent avant les minuscules ("Zèbre" < "abeille") et "10" < "9" est vrai. Pour comparer sans tenir compte de la casse, on met les deux textes en minuscules (ou avec casefold()).

print("chat" < "chien", "Zèbre" < "abeille", "10" < "9")
print("Python".lower() == "python", "ß".casefold() == "ss")

True True True
True True

Trois classiques : palindrome, anagramme, chiffre de César

def est_palindrome(texte):
    propre = texte.lower().replace(" ", "")
    return propre == propre[::-1]

def sont_anagrammes(a, b):
    return sorted(a.lower()) == sorted(b.lower())

def cesar(texte, decalage):
    resultat = ""
    for c in texte:
        if c.isalpha():
            base = ord("A") if c.isupper() else ord("a")
            resultat += chr((ord(c) - base + decalage) % 26 + base)
        else:
            resultat += c
    return resultat

print(est_palindrome("Esope reste ici et se repose"))
print(sont_anagrammes("Marie", "aimer"))
print(cesar("Bonjour, NSI !", 3))

True
True
Erqmrxu, QVL !

Aperçu des expressions régulières

Pour chercher un motif (des chiffres, une date, une adresse e-mail…) plutôt qu'un texte exact, on utilise le module re (voir importation). re.findall(motif, texte) renvoie toutes les correspondances, re.sub(motif, remplacement, texte) remplace.

import re

texte = "Rendez-vous le 04/10/2026 ou le 12/11/2026"
print(re.findall(r"\d{2}/\d{2}/\d{4}", texte))
print(re.sub(r"\d", "#", "tel 0612"))

['04/10/2026', '12/11/2026']
tel ####

⚠️ Erreurs fréquentes

Vouloir modifier un caractère

Une chaîne est immuable : mot[0] = "J" est une TypeError. Construis un nouveau texte avec la concaténation et une tranche.

mot = "python"
mot[0] = "J"

TypeError: 'str' object does not support item assignment

mot = "python"
mot = "J" + mot[1:]
print(mot)

Jython

Oublier de récupérer le résultat

s.upper() ne change pas s : elle renvoie une nouvelle chaîne. Sans affectation, le résultat est perdu.

s = "nsi"
s.upper()
print(s)

nsi

s = "nsi"
s = s.upper()
print(s)

NSI

Additionner un texte et un nombre

+ ne convertit rien tout seul : un texte et un entier ne s'additionnent pas. Utilise une f-string (ou str()).

note = 17
print("Note : " + note)

TypeError: can only concatenate str (not "int") to str

note = 17
print(f"Note : {note}")

Note : 17

Un indice qui dépasse

mot = "abc"
print(mot[3])

IndexError: string index out of range

mot = "abc"
print(mot[-1], mot[len(mot) - 1])

c c

index ou find ?

index lève une ValueError quand le morceau est absent ; find renvoie -1. Pour un simple test de présence, écris x in s.

print("abc".index("z"))

ValueError: substring not found

print("abc".find("z"), "z" in "abc")

-1 False

split(" ") ou split() ?

split(" ") coupe à chaque espace : des espaces doubles produisent des morceaux vides. split() sans argument traite les espaces multiples comme un seul séparateur : c'est lui qu'il faut pour compter des mots.

phrase = "le  chat"
print(len(phrase.split(" ")), len(phrase.split()))

3 2

Les barres obliques inverses d'un chemin

Dans "C:\new\table", Python lit \n comme un saut de ligne et \t comme une tabulation. Écris les chemins en *raw string* (r"C:\new\table") ou double les barres.

print(len("C:\new\table"), len(r"C:\new\table"))

10 12

strip retire des caractères, pas un morceau de texte

s.strip("ban") retire du début et de la fin tous les caractères b, a ou n, dans n'importe quel ordre. Pour retirer un préfixe ou un suffixe précis, utilise removeprefix / removesuffix (Python 3.9+).

print("banane".strip("ban"))
print("banane".removeprefix("ban"))

e
ane

Trier sans tenir compte de la casse

Par défaut, les majuscules passent avant les minuscules. Avec key=str.lower, le tri ignore la casse (et reste stable).

lettres = ["b", "A", "a", "B"]
print(sorted(lettres))
print(sorted(lettres, key=str.lower))

['A', 'B', 'a', 'b']
['A', 'a', 'b', 'B']

📋 Aide-mémoire

• Une chaîne est immuable : toute méthode renvoie une nouvelle valeur qu'il faut ranger dans une variable.
• split() + join() : découper un texte puis le recoller ; list(s) et "".join(liste) pour passer par les caractères.
• find renvoie -1 si absent, index lève une erreur ; in suffit pour un test de présence.
• str + int est une erreur : f-string ou str() ; int(texte) pour calculer.
• L'ordre des textes suit les codes des caractères : majuscules avant minuscules, "10" < "9".