Chaînes de caractères en Python

Les chaînes de caractères Python

Les chaînes de caractères (ou strings) sont l’un des types de données les plus fondamentaux et les plus couramment utilisés en Python. Elles représentent des séquences de caractères.

Création de chaînes de caractères

Créez des chaînes de caractères en plaçant les caractères entre guillemets simples ('...'), guillemets doubles ("..."), ou guillemets triples ('''...''' ou """..."""). Les guillemets simples et doubles sont équivalents pour les chaînes de caractères sur une seule ligne. Les guillemets triples permettent aux chaînes de s’étendre sur plusieurs lignes.

single_quoted = 'Hello World!'
double_quoted = "Python Programming"
multi_line = '''This is a string
spanning multiple
lines.'''

print(single_quoted)
print(double_quoted)
print(multi_line)

En Python 3, les chaînes de caractères gèrent nativement les caractères Unicode.

Accès aux caractères et aux sous-chaînes (Slicing)

Les chaînes de caractères sont des séquences ; vous pouvez donc accéder aux caractères individuels en utilisant leur index (commençant à 0) entre crochets []. Vous pouvez également extraire des sous-chaînes à l’aide du slicing [début:fin:pas].

#!/usr/bin/env python3

my_string = "Python Programming"

# Accéder aux caractères individuels
print(f"my_string[0]: {my_string[0]}")    # Sortie : P
print(f"my_string[7]: {my_string[7]}")    # Sortie : P
print(f"my_string[-1]: {my_string[-1]}")   # Sortie : g (dernier caractère)
print(f"my_string[-3]: {my_string[-3]}") # Sortie : i (troisième en partant de la fin)

# Slicing [début:fin] (l'index de fin est exclusif)
print(f"my_string[0:6]: {my_string[0:6]}")  # Sortie : Python
print(f"my_string[7:18]: {my_string[7:18]}") # Sortie : Programming

# Raccourcis de slicing
print(f"my_string[:6]: {my_string[:6]}")   # Sortie : Python (du début à l'index 5)
print(f"my_string[7:]: {my_string[7:]}")   # Sortie : Programming (de l'index 7 à la fin)
print(f"my_string[:]: {my_string[:]}")    # Sortie : Python Programming (une copie de la chaîne entière)

# Slicing avec pas [début:fin:pas]
print(f"my_string[::2]: {my_string[::2]}") # Sortie : Pto rgamn (un caractère sur deux)
print(f"my_string[::-1]: {my_string[::-1]}")# Sortie : gnimmargorP nohtyP (inverse la chaîne)

Immuabilité des chaînes de caractères

Les chaînes de caractères en Python sont immuables, ce qui signifie que vous ne pouvez pas modifier un objet string en place après sa création. Les opérations qui semblent modifier une chaîne créent et renvoient en fait un nouvel objet string.

#!/usr/bin/env python3

message = "Hello World!"
print(f"Message original : {message}, ID : {id(message)}")

# Ceci crée une NOUVELLE chaîne
new_message = message[:6] + "Python!"
print(f"Nouveau message : {new_message}, ID : {id(new_message)}")

# Tenter de modifier un caractère directement provoque une erreur :
# message[0] = 'J' # Lève TypeError : l'objet 'str' ne supporte pas l'assignation d'éléments

Caractères d’échappement

L’antislash (\) est utilisé pour échapper les caractères qui ont une signification spéciale ou qui sont non-imprimables.

Notation	Description
\n	Nouvelle ligne
\t	Tabulation horizontale
\r	Retour chariot
\b	Retour arrière
\f	Saut de page
\'	Guillemet simple
\"	Guillemet double
\\	Antislash lui-même
\xhh	Caractère avec valeur hexadécimale hh
\uxxxx	Caractère Unicode avec valeur hexadécimale 16 bits xxxx
\Uxxxxxxxx	Caractère Unicode avec valeur hexadécimale 32 bits xxxxxxxx
\ooo	Caractère avec valeur octale ooo (moins courant)

Exemple :

print("First line\nSecond line")
print("Path: C:\\Users\\Name")
print('He said, \'Hello!\'')

Chaînes brutes (Raw Strings)

Préfixer un littéral de chaîne par r ou R crée une chaîne brute (raw string), où les antislashs sont traités comme des caractères littéraux et non comme des séquences d’échappement. C’est particulièrement utile pour les expressions régulières et les chemins de fichiers Windows.

print(r"This is a raw string.\nNo newline here.")
# Sortie : This is a raw string.\nNo newline here.

print(R"C:\Users\Name\Documents")
# Sortie : C:\Users\Name\Documents

Remarque : Une chaîne brute ne peut pas se terminer par un seul antislash.

Opérateurs de chaînes de caractères

Opérateurs courants qui fonctionnent avec les chaînes de caractères :

Opérateur	Nom	Description	Exemple
+	Concaténation	Joint deux chaînes	'Hello' + ' ' + 'World' -> 'Hello World'
*	Répétition	Répète la chaîne	'Hi!' * 3 -> 'Hi!Hi!Hi!'
[]	Indexation	Accède à un caractère	'Python'[0] -> 'P'
[:]	Tranchage (Slicing)	Extrait une sous-chaîne	'Python'[1:4] -> 'yth'
in	Appartenance	Vérifie si la sous-chaîne existe	'th' in 'Python' -> True
not in	Appartenance	Vérifie si la sous-chaîne n’existe pas	'x' not in 'Python' -> True

Formatage de chaînes de caractères

Créer des chaînes de caractères avec des valeurs de variables intégrées est crucial. Python moderne offre plusieurs méthodes :

1. f-Strings (Littéraux de chaînes formatées) - Recommandé (Python 3.6+)

Préfixez la chaîne avec f ou F. Intégrez des expressions entre accolades {}.

name = "Alice"
age = 30
pi = 3.14159

# Utilisation de base
print(f"My name is {name} and I am {age} years old.")

# Expressions entre accolades
print(f"Next year, I will be {age + 1}.")

# Spécificateurs de formatage (après le signe deux-points :)
print(f"Pi is approximately {pi:.2f}") # Formater un flottant à 2 décimales
print(f"Age: {age:03d}")            # Remplir un entier avec des zéros de début sur 3 caractères
print(f"Name aligned: '{name:<10}'") # Aligner à gauche dans un champ de 10 caractères
print(f"Name aligned: '{name:>10}'") # Aligner à droite
print(f"Name aligned: '{name:^10}'") # Centrer

2. Méthode str.format()

Utilise les accolades {} comme marqueurs de position à l’intérieur de la chaîne et appelle la méthode format().

name = "Bob"
age = 25

# Arguments positionnels
print("Name: {}, Age: {}".format(name, age))

# Arguments nommés
print("Name: {n}, Age: {a}".format(n=name, a=age))

# Arguments indexés
print("Name: {0}, Age: {1}, Repeat Name: {0}".format(name, age))

# Spécificateurs de formatage (similaires aux f-strings)
print("Value: {:.3f}".format(10/3)) # Sortie : Value: 3.333

3. Opérateur % (Ancien style)

Utilise les marqueurs de position % (comme %s pour une chaîne, %d pour un entier, %f pour un flottant) de manière similaire à printf en C. Généralement non recommandé pour le nouveau code par rapport aux f-strings ou à str.format() en raison d’une flexibilité moindre et d’un potentiel d’erreurs.

name = "Charlie"
age = 42

print("My name is %s and weight is %d kg!" % (name, age))

# Spécificateurs de formatage
print("Value: %.2f" % (12.3456)) # Sortie : Value: 12.35

Tableau des codes de format % (pour référence) :

Symbole de format	Conversion
%c	Caractère unique
%s	Chaîne de caractères (ou tout objet utilisant str())
%d ou %i	Entier décimal signé
%u	Obsolète (identique à %d)
%o	Entier octal
%x	Entier hexadécimal (minuscules)
%X	Entier hexadécimal (majuscules)
%f	Décimal à virgule flottante
%e	Notation exponentielle (‘e’ minuscule)
%E	Notation exponentielle (‘E’ majuscule)
%g	Le plus court entre %f et %e
%G	Le plus court entre %f et %E
%%	Caractère littéral ’%‘

Méthodes de chaînes de caractères intégrées

Les chaînes de caractères Python disposent d’un riche ensemble de méthodes intégrées pour les manipulations courantes. N’oubliez pas que ces méthodes renvoient de nouvelles chaînes ; elles ne modifient pas l’originale.

Méthodes de chaînes de caractères courantes :

Méthode	Description
capitalize()	Renvoie une copie avec le premier caractère en majuscule, le reste en minuscules.
casefold()	Renvoie une copie « casefolded » (conversion agressive en minuscules pour la correspondance insensible à la casse).
center(width[, fillchar])	Renvoie la chaîne centrée dans la largeur spécifiée, remplie avec fillchar (espace par défaut).
count(sub[, start[, end]])	Renvoie le nombre d’occurrences non chevauchantes de la sous-chaîne sub.
encode(encoding='utf-8', errors='strict')	Renvoie un objet bytes représentant la chaîne encodée selon encoding.
endswith(suffix[, start[, end]])	Renvoie True si la chaîne se termine par suffix.
expandtabs(tabsize=8)	Renvoie une copie avec les caractères de tabulation (\t) remplacés par des espaces.
find(sub[, start[, end]])	Renvoie le plus petit index où sub est trouvé, ou -1 si non trouvé.
index(sub[, start[, end]])	Comme find(), mais lève une ValueError si sub n’est pas trouvé.
isalnum()	Renvoie True si tous les caractères sont alphanumériques et qu’il y a au moins 1 caractère.
isalpha()	Renvoie True si tous les caractères sont alphabétiques et qu’il y a au moins 1 caractère.
isascii()	Renvoie True si la chaîne est vide ou si tous les caractères sont ASCII.
isdecimal()	Renvoie True si tous les caractères sont des caractères décimaux et qu’il y a au moins 1 caractère.
isdigit()	Renvoie True si tous les caractères sont des chiffres et qu’il y a au moins 1 caractère.
isidentifier()	Renvoie True si la chaîne est un identificateur Python valide.
islower()	Renvoie True si tous les caractères avec casse sont en minuscules et qu’il y a au moins 1 caractère avec casse.
isnumeric()	Renvoie True si tous les caractères sont numériques et qu’il y a au moins 1 caractère.
isprintable()	Renvoie True si tous les caractères sont imprimables ou si la chaîne est vide.
isspace()	Renvoie True si tous les caractères sont des espaces blancs et qu’il y a au moins 1 caractère.
istitle()	Renvoie True si la chaîne est en casse de titre et qu’il y a au moins 1 caractère.
isupper()	Renvoie True si tous les caractères avec casse sont en majuscules et qu’il y a au moins 1 caractère avec casse.
join(iterable)	Concatène les éléments d’un itérable (doivent être des chaînes) en utilisant la chaîne comme séparateur.
ljust(width[, fillchar])	Renvoie la chaîne justifiée à gauche dans la largeur spécifiée.
lower()	Renvoie une copie avec tous les caractères avec casse convertis en minuscules.
lstrip([chars])	Renvoie une copie avec les caractères de début supprimés (espaces blancs par défaut).
maketrans(x[, y[, z]])	Renvoie une table de traduction pour translate().
partition(sep)	Divise la chaîne à la première occurrence de sep, renvoie le tuple (avant, sep, après).
removeprefix(prefix)	Renvoie une copie avec le préfixe supprimé si la chaîne commence par celui-ci (Python 3.9+).
removesuffix(suffix)	Renvoie une copie avec le suffixe supprimé si la chaîne se termine par celui-ci (Python 3.9+).
replace(old, new[, count])	Renvoie une copie avec les occurrences de old remplacées par new (facultativement jusqu’à count fois).
rfind(sub[, start[, end]])	Comme find() mais recherche depuis la droite.
rindex(sub[, start[, end]])	Comme index() mais recherche depuis la droite.
rjust(width[, fillchar])	Renvoie la chaîne justifiée à droite dans la largeur spécifiée.
rpartition(sep)	Comme partition() mais divise à la dernière occurrence de sep.
rsplit(sep=None, maxsplit=-1)	Comme split() mais divise depuis la droite.
rstrip([chars])	Renvoie une copie avec les caractères de fin supprimés (espaces blancs par défaut).
split(sep=None, maxsplit=-1)	Renvoie une liste de mots, en utilisant sep comme délimiteur (espaces blancs par défaut), divisant au maximum maxsplit fois.
splitlines(keepends=False)	Renvoie une liste de lignes, en se basant sur les sauts de ligne.
startswith(prefix[, start[, end]])	Renvoie True si la chaîne commence par prefix.
strip([chars])	Renvoie une copie avec les caractères de début/fin supprimés (espaces blancs par défaut).
swapcase()	Renvoie une copie avec les caractères majuscules convertis en minuscules et vice versa.
title()	Renvoie la version en casse de titre (les mots commencent par une majuscule, le reste en minuscules).
translate(table)	Renvoie une copie avec les caractères mappés via table (issue de maketrans).
upper()	Renvoie une copie avec tous les caractères avec casse convertis en majuscules.
zfill(width)	Renvoie une copie remplie à gauche avec des ‘0’ jusqu’à la largeur spécifiée.

Exemple d’utilisation des méthodes :

text = "   Hello World!   "

print(f"Original : '{text}'")
print(f"strip() : '{text.strip()}'")
print(f"lower() : '{text.lower()}'")
print(f"upper() : '{text.upper()}'")
print(f"replace('o', 'X') : '{text.replace('o', 'X')}'")
print(f"split() : {text.split()}") # Divise par les espaces blancs

words = ["Python", "is", "fun"]
separator = " "
print(f"join() : '{separator.join(words)}'")

print(f"startswith('   H') : {text.startswith('   H')}")
print(f"find('World') : {text.find('World')}")