Comment utiliser les chaînes Python (str)

Créer une chaîne

Une chaîne (str) est un type qui représente une « suite de caractères ». En Python, toute valeur entourée de guillemets est une str.

Il existe trois façons d'entourer une chaîne, et tu choisis celle qui convient à la situation.

Quand tu veux inclure un saut de ligne, tu utilises soit la séquence d'échappement \n, soit tu entoures le texte de guillemets triples.

# Les guillemets simples/doubles servent aux chaînes sur une ligne
fruit1 = 'apple'
fruit2 = "banana"

# Quand le texte contient ', l'entourer de " est plus simple
message = "it's a pen"

# Pour inclure des sauts de ligne -> utilise \n ou des guillemets triples
text_a = "apple\nbanana\ngrape"
text_b = """apple
banana
grape"""

print(fruit1, fruit2)  # apple banana
print(message)         # it's a pen
print(text_a)          # affiché sur 3 lignes
print(text_b)          # même résultat que text_a

Essaie les trois types de guillemets dans la console.

① Crée name = "Alice" et message = 'Hello', puis fais un print() des deux.

② En utilisant \n, stocke "apple", "grape" et "lemon" dans une seule variable et fais un print() pour les afficher sur 3 lignes.

③ En utilisant des guillemets triples ("""), stocke "apple", "grape" et "lemon" dans une seule variable et fais un print() pour les afficher sur 3 lignes.

Extraire des caractères par position (indexation et slicing)

Tu peux aussi extraire des caractères d'une chaîne par position (un index).

Le point important est que les index commencent à 0. Le premier caractère n'est pas à la « position 1 » — il est à la position 0.

Obtenir un caractère — [i]

Écris chaîne[position] pour extraire le caractère unique à cette position.

Utilise un nombre négatif pour compter depuis la fin. -1 est le tout dernier caractère.

fruit = "lemon"  # l e m o n

print(fruit[0])   # l  (premier)
print(fruit[2])   # m  (3ème)
print(fruit[-1])  # n  (dernier)
print(fruit[-2])  # o  (2ème depuis la fin)

# Dépasser la plage lève une erreur
# print(fruit[10]) # IndexError

word = "python" est déjà défini.

① Affiche à la fois le premier caractère et le dernier caractère de word avec print().

② Affiche le caractère du milieu (le 4ème) de word, compté depuis le début.

Extraire une plage — slicing avec [a:b]

Écris chaîne[début:fin] pour extraire tout depuis la position de début jusqu'à, sans l'inclure, la position de fin. C'est ce qu'on appelle un slice.

Le point clé est l'intervalle semi-ouvert — « jusqu'à un avant la fin ». [0:3] te donne les positions 0, 1 et 2 (trois caractères), et n'inclut pas 3.

msg = "0123456789"

print(msg[0:3])    # '012'   (3 n'est pas inclus)
print(msg[:4])     # '0123'  (depuis le début)
print(msg[4:])     # '456789'(jusqu'à la fin)
print(msg[-3:])    # '789'   (les 3 derniers caractères)
print(msg[:-3])    # '0123456'(tout sauf les 3 derniers)

Tu peux aussi ajouter un troisième nombre — [début:fin:pas] — pour prendre un caractère sur deux (ou sur quelques-uns). [::2] attrape un caractère sur deux.

Cela dit, entasser le pas et la plage sur une seule ligne devient difficile à lire, donc pour les slices plus longs, il vaut mieux les répartir sur deux lignes.

msg = "0123456789"

# [::pas] saute dans la chaîne
print(msg[::2])       # '02468' (un sur deux)
print(msg[::3])       # '0369'  (un sur trois)

# Mettre le pas sur sa propre ligne se lit mieux
head = msg[:6]        # '012345'
skip = head[::2]      # '024' (un sur deux)
print(skip)

email = "alice@example.com" est déjà défini.

① Utilise un slice pour extraire le nom d'utilisateur avant @ — c'est-à-dire juste "alice" — et affiche-le (@ est à la position 5).

② Utilise [-3:] pour extraire les 3 derniers caractères "com" et affiche-le.

Méthodes qui transforment une chaîne

Les chaînes sont livrées avec des fonctionnalités intégrées qui produisent une nouvelle chaîne à partir de l'originale, et on les appelle des méthodes.

Tu en appelles une en écrivant variable.nom_de_méthode(). Le point clé est que la chaîne originale n'est jamais modifiée — une nouvelle chaîne est renvoyée.

Changer la casse — upper / lower

upper() convertit tout en majuscules, et lower() convertit tout en minuscules.

L'usage le plus courant est de comparer des chaînes en ignorant la casse. Les noms et adresses e-mail saisis par les utilisateurs arrivent souvent avec une casse incohérente, donc tu normalises les deux côtés à la même casse avant de comparer.

name = "Alice"

print(name.lower())    # alice
print(name.upper())    # ALICE
print(name)            # Alice  (l'original est inchangé)

# Vérifie si les deux noms correspondent, en ignorant la casse
input_a = "ALICE"
input_b = "alice"
print(input_a.lower() == input_b.lower())  # True

Remplacer le contenu et rogner les bords — replace / strip

replace("avant", "après") renvoie une nouvelle chaîne où chaque « avant » a été remplacé par « après ».

strip() est la méthode qui supprime les espaces aux deux extrémités. C'est parfait pour nettoyer les espaces parasites que les utilisateurs collent accidentellement dans un formulaire.

greeting = "Hello World"
print(greeting.replace("World", "Python"))  # Hello Python
print(greeting)                             # Hello World (l'original est inchangé)

# Rogne les espaces parasites (seulement les bords — les espaces à l'intérieur restent)
raw = "  alice@example.com  "
print(raw.strip())        # 'alice@example.com'
print(len(raw))           # 21 (espaces inclus)
print(len(raw.strip()))   # 17 (les espaces ont disparu)

Nettoyons une adresse e-mail saisie par l'utilisateur.

① raw_email = " ALICE@Example.COM " est déjà défini.

② Utilise strip() pour supprimer les espaces aux deux extrémités et lower() pour mettre le texte en minuscules, puis stocke l'e-mail propre dans clean_email.

③ Utilise print() pour afficher à la fois l'original (raw_email) et la version nettoyée (clean_email).

Méthodes qui inspectent une chaîne

Voici maintenant les méthodes qui ne modifient pas la valeur — elles te donnent juste des informations sur la chaîne.

Elles comptent les occurrences d'un caractère, vérifient le début ou la fin, trouvent des positions, et inspectent le type de caractères à l'intérieur.

Vérifier ce qu'il y a à l'intérieur — count / startswith / endswith / find

• count("texte") — renvoie combien de fois texte apparaît, sous forme de nombre
• startswith("texte") — renvoie si la chaîne commence par texte (True / False)
• endswith("texte") — renvoie si la chaîne se termine par texte (True / False)
• find("texte") — renvoie la position de la première correspondance. Si rien n'est trouvé, elle renvoie -1

msg = "abcCBAabc"

print(msg.count("a"))          # 3  (il y a 3 a)
print(msg.count("abc"))        # 1  ('abc' apparaît comme séquence une seule fois)

print(msg.startswith("abc"))   # True
print(msg.endswith("abc"))     # True

print(msg.find("CBA"))         # 3  (commence à la position 3)
print(msg.find("xyz"))         # -1 (non trouvé, donc -1)

endswith est l'outil de choix pour les extensions de fichiers

Quelque chose comme filename.endswith(".png") te donne un moyen rapide de vérifier si un fichier est une image. C'est sensible à la casse, donc si la casse peut être mixte, opte pour filename.lower().endswith(".png") pour être tranquille.

Construisons une vérification rapide pour les lignes qui ressemblent à des erreurs dans un log.

log = "ERROR: disk full at /tmp/log" est déjà défini.

① Utilise startswith pour vérifier si log commence par "ERROR", et affiche le résultat.

② Utilise find pour obtenir la position où le mot "disk" commence dans log, et affiche-la aussi.

Inspecter les types de caractères — isdigit / isalpha / islower / isupper

La famille de méthodes is...() renvoie True / False selon si la chaîne entière satisfait la condition. Note qu'un seul espace ou symbole mélangé suffit à les faire renvoyer False.

print("123".isdigit())       # True
print("12a".isdigit())       # False (un 'a' est mélangé)

print("Tokyo".isalpha())     # True
print("Tokyo 2024".isalpha())# False (contient un espace et des chiffres)

print("HELLO".isupper())     # True
print("Hello".islower())     # False

N'utilise pas isdigit pour vérifier « est-ce que ça peut être un nombre »

isdigit() renvoie True uniquement pour les chaînes qui ressemblent à des entiers non négatifs. "-12" et "3.14" renvoient tous les deux False. Quand tu dois gérer des chaînes avec des signes moins ou des virgules décimales comme des nombres, laisse tomber isdigit() et passe plutôt la chaîne à int() / float() en utilisant la gestion des exceptions pour vérifier si ça a marché.

Vérifions si une chaîne de l'utilisateur est sous une forme numérique utilisable (un entier non négatif).

value = "42" est déjà défini.

① Utilise isdigit() pour vérifier si value est composé uniquement de chiffres, et fais un print() du résultat.

② Si le résultat est True, convertis value en nombre avec int() et affiche le résultat de l'addition de 10. Astuce : isdigit() peut être utilisé directement comme condition dans une instruction if.

Dans cet article, tu as appris les trois types de guillemets, comment extraire des caractères avec l'indexation et le slicing, et un ensemble de méthodes de transformation et d'inspection.

Les chaînes sont l'un des types les plus courants que tu utiliseras dans un programme. Les méthodes présentées ici sont directement réutilisables quand tu commenceras à gérer les saisies utilisateur dans les articles suivants, donc passe un peu de temps à exécuter les exemples pour en acquérir l'intuition.