Participer au site avec un Tip
Rechercher
 

Améliorations / Corrections

Vous avez des améliorations (ou des corrections) à proposer pour ce document : je vous remerçie par avance de m'en faire part, cela m'aide à améliorer le site.

Emplacement :

Description des améliorations :

Manipulation de chaînes de caractères

Manipulation de valeurs flottantes Les chaînes formatées


Accès rapide :
La vidéo
Utilisation de chaînes de caractères
Les syntaxes élémentaires
Utilisation du caractère d'échappement (le caractère \)
Les chaînes de caractères brutes (les « raw strings »)
Utilisation de caractères Unicode
Les chaînes de caractères multi-lignes.
Les opérateurs permettant de manipuler vos chaînes
Les opérateurs +, * et %
Les opérateurs de comparaisons entre chaînes de caractères
L'opérateur [] est ses différentes possibilités
Fonctions et méthodes utilisables sur vos chaînes de caractères
Quelques fonctions utiles pour la manipulation de vos chaînes de caractères
Quelques méthodes utiles pour la manipulation de vos chaînes de caractères
Travaux pratiques
Les énoncés
Les corrections

La vidéo

Cette vidéo vous présente les différentes syntaxes de définition de chaînes de caractères disponibles en Python.


Manipulation de chaînes de caractères

Utilisation de chaînes de caractères

Les syntaxes élémentaires

En Python, une chaîne de caractères est un objet basé sur le type (la classe) str. En fait, il existe de multiples manières de produire une chaîne de caractères en Python : certaines d'entre elles seront vues dans d'autres chapitres. Pour commencer, je vous propose de tester les deux syntaxes les plus couramment utilisées : soit utiliser des doubles-guillemets, soit utiliser des apostrophes (des simples guillemets). Pour ce faire, commencez par lancer un interpréteur Python interactif et exécuter les lignes de code suivantes.

>>> message = "Une chaîne introduite avec des doubles guillemets"
>>> print(message)
Une chaîne introduite avec des doubles guillemets
>>> type(message)
<class 'str'>
>>> 
>>> message2 = 'On peut aussi utiliser des apostrophes (simples guillemets)'
>>> print(message2)
On peut aussi utiliser des apostrophes (simples guillemets)
>>> type(message2)
<class 'str'>
>>> 
Exemples de définitions de chaînes de caractères.

Utilisation du caractère d'échappement (le caractère \)

Dans une chaîne de caractères, vous pouvez utiliser des séquences particulières : elles sont introduites par un caractère \ et permettent d'injecter dans votre chaîne certains caractères spéciaux.

le caractère \ est appelé « backslash » ou « anti-slash » selon les préférences.

Voici les principales syntaxes que vous pouvez utiliser.

Voici quelques exemples d'utilisation de ses séquences de caractères particulières.

>>> three_lines = "First Line\nSecond Line\nThird Line"
>>> print(three_lines)
First Line
Second Line
Third Line
>>> 
>>> string_with_tab = "Begin\tEnd"
>>> print(string_with_tab)
Begin   End
>>> 
>>> message = 'J\'aime l\'histoire'
>>> print(message)
J'aime l'histoire
>>> 
Utilisation de quelques séquences utilisant le caractère d'échappement.

Si vous activer le son sur votre ordinateur, vous pourrez aussi tester cet exemple : il produit un bip sonore.

>>> print("\a")
>>> 
Production d'un bip sonore grâce à la séquence \a.
le son produit est spécifique à chaque système d'exploitation.

Les chaînes de caractères brutes (les « raw strings »)

Afin de comprendre ce que peuvent apporter les chaînes de caractères brutes, analyser bien la variable suivante : à votre avis, que va produire l'affichage de la variable path sur la console ?

>>> path = "C:\newFolder\truc.txt"
>>> print(path)     # Qu'est-ce qui va être affiché ???

Vous l'avez remarqué, cette chaîne de caractères contient deux caractères \. Qui plus est ces deux caractères sont suivis soit d'un n, soit d'un t. Nous avons donc à faire à un retour à la ligne et d'une tabulation. Voici l'affichage produit.

>>> path = "C:\newFolder\truc.txt"
>>> print(path)
C:
ewFolder    ruc.txt
>>> 

Du coup, comment faire en sorte que nous ayons un véritable chemin vers un fichier ? Deux solutions peuvent être envisagées et vous en connaissez déjà une. Effectivement, on peut doubler le caractère \ afin d'avoir réellement à faire à ce caractère.

>>> path = "C:\\newFolder\\truc.txt"
>>> print(path)
C:\newFolder\truc.txt
>>> 
On dé-spécialise le caractère \, pour qu'il passe pour lui-même.

L'autre solution, qui permettrait d'arriver au même résultat, consiste à utiliser une chaîne brute : une « raw string ». Dans une chaîne brute, le caractère \ n'a plus aucune signification. Il passe donc pour lui-même. Une chaîne brute s'introduit via les syntaxes r"" ou r''. Voici quelques exemples d'utilisation.

>>> path = r"C:\newFolder\truc.txt"
>>> print(path)
C:\newFolder\truc.txt
>>> type(path)
<class 'str'>
>>>
>>> path = r'C:\newFolder\truc.txt'     # Ca marche aussi avec des simples guillemets
>>> print(path)
C:\newFolder\truc.txt
Exemple d'utilisation de chaînes brutes (raw strings).

Utilisation de caractères Unicode

Il est à noter que le langage Python est compatible Unicode. Cela veut dire que vous pouvez utiliser n'importe quel caractère Unicode (il y en a vraiment beaucoup) dans vos chaînes. Mais comme tous les caractères ne sont pas accessibles à partir de votre clavier, Python propose une syntaxe permettant de spécifier un caractère à utiliser à partir de son code numérique Unicode. Celui-ci devra être exprimé en hexadécimal sur quatre chiffres à la suite de la séquence \u. Voici un exemple permettant d'afficher le caractère π (de code numérique 960, soit 03c0 en hexadécimal).

>>> print("\u03c0 = 3.141592654")
π = 3.141592654
>>>

La table Unicode définit un très grand nombre de caractères et notamment, les lettres et les chiffres de tous les alphabets, les idéogrammes des pays asiatiques, des émoticons...

pour obtenir une liste des caractères Unicode, vous pouvez activer ce lien. En plaçant la souris sur un caractère, vous pourrez en retrouver son code numérique (en décimal ou en hexadécimal).

Les chaînes de caractères multi-lignes.

Deux autres syntaxes vous permettent de pouvoir définir des chaînes de caractères multi-lignes. Pour ce faire, vous devez commencer votre chaîne par la séquence """ ou la séquence '''. Votre chaîne pourra s'étendre sur plusieurs lignes et, bien entendu, vous devrez terminer la chaîne par la même séquence que celle utilisée pour l'ouverture.

Voici un exemple d'utilisation d'une chaîne de caractères multi-lignes.

>>> message = """Première ligne
... Seconde ligne avec le caractère Unicode \u03c0
... Troisième et dernière ligne"""
>>> print(message)
Première ligne
Seconde ligne avec le caractère Unicode π
Troisième et dernière ligne
>>> 

Les opérateurs permettant de manipuler vos chaînes

Le langage Python propose un certain nombre d'opérateurs que vous pouvez utiliser avec vos chaînes de caractères. Etudions-les plus en détail.

Les opérateurs +, * et %

Il est possible de concaténer des chaînes de caractères. Pour ce faire, il faut utiliser l'opérateur +. Voici un exemple d'utilisation.

>>> begin = "Hello "
>>> end = "World!"
>>> full = begin + end
>>> print(full)
Hello World!
>>> 

Pour concaténer une donnée d'un autre type à une chaîne de caractères, il suffit de convertir cette donnée en une chaîne de caractères.

>>> value = 3.141592654
>>> message = "\u03c0 = " + str(value)
>>> print(message)
π = 3.141592654
>>>
pour ceux qui connaîtraient déjà la Programmation Orientée Objet (POO) dans un autre langage de programmation, nous venons ici d'utiliser le constructeur de la classe str pour produire un nouvel objet de type str. Si vous ne connaissez pas encore la POO, rien de grave : nous apprendrons à utiliser ces concepts dans un prochain chapitre de ce tuto Python.
si vous ne convertissez pas une donnée numérique (ou autre) en chaîne avant une concaténation, une erreur sera produite, comme le montre l'exemple ci-dessous.
>>> value = 3.141592654
>>> message = "\u03c0 = " + value
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "float") to str
>>> 

L'opérateur * permet de répéter une chaîne de caractères un certain nombre de fois. Voici quelques exemples d'utilisation.

>>> print("azerty" * 5)
azertyazertyazertyazertyazerty
>>> print("123" * 5)        # Il n'y a pas de conversion automatique.
123123123123123
>>> separator = "-" * 80
>>> print(separator)
--------------------------------------------------------------------------------
>>> 

L'opérateur % permet de formater des chaînes de caractères en utilisant la manière du langage C (un autre langage de programmation). Voici quelques premiers exemples d'utilisation, en sachant que nous allons parler des possibilités de formatage de chaînes de caractères dans les deux prochains chapitres.

>>> pi = 3.141592654
>>> print(pi)
3.141592654
>>> print("%.2f" % pi)  # Affiche le flottant avec 2 chiffres après la virgule
3.14
>>> num = 1
>>> den = 3
>>> print("fraction %d/%d" % (num, den))       # %d => entier en base décimale
fraction 1/3
>>> 
nous allons revenir en détails dans un prochain chapitre sur l'utilisation de cet opérateur %.
il existe aussi d'autres syntaxes permettant de formater une chaîne de caractères. Celle présentée ci-dessus n'est plus forcément la plus recommandée.

Les opérateurs de comparaisons entre chaînes de caractères

Bien entendu, il est possible de comparer des chaînes de caractères entre elles. C'est l'ordre lexicographique qui sera utilisé lors des comparaisons (en simplifiant, c'est l'ordre du dictionnaire).

A minima, voici les six opérateurs de comparaison à connaître par coeur : < (plus petit), <= (plus petit ou égal), > (plus grand), >= (plus grand ou égal), == (égalité) et != (pour la différence). Voici quelques exemples d'utilisation.

>>> "alambic" < "distillateur"
True
>>> "alambic" <= "distillateur"
True
>>> "alambic" == "distillateur"
False
>>> "alambic" != "distillateur"
True
>>> "alambic" >= "distillateur"
False
>>> "alambic" > "distillateur"
False
>>>
je m'excuse pour le choix des exemples 🍷🥃🤣

Il est aussi possible de vérifier si une chaîne de caractères est dans un intervalle donné (between, en anglais).

>>> to_compare = "machin"
>>> "bibule" < to_compare < "truc"
True
>>> if "bibule" < to_compare < "truc":
...     print("C'est comprit entre les deux bornes")
... 
C'est comprit entre les deux bornes
>>> 

L'opérateur [] est ses différentes possibilités

Une chaîne est, bien entendu, d'un certain nombre de caractères. Il est possible de récupérer un ou plusieurs caractères présents dans la chaîne. Voici un premier exemple qui montre comment récupérer un caractère, par sa position, dans la chaîne, via l'opérateur [].

>>> s = "azerty"
>>> s[0]
'a'
>>> s[1]
'z'
>>> s[5]
'y'
>>> s[6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> 
vous l'aurez remarqué, les indices positionnels commencent à zéro. Le code s[1] accède donc bien au second caractère et non pas au premier. C'est une erreur que font souvent les débutants Python.
une chaîne de caractères est non modifiable. Une fois instanciée, vous ne pouvez plus changer le contenu de la chaîne. Par contre, vous pouvez produire une nouvelle chaîne transformée à partir de la première, comme le montre l'exemple suivant.
>>> message = "petit exemple."
>>> message[0] = "P"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> 
>>> message2 = "P" + message[1:]
>>> print(message2)
Petit exemple.
>>> 
Une chaîne de caractères est non modifiable.

Il est possible de passer un indice négatif : cela peut surprendre, mais ça marche. Dans ce cas, on récupère les caractères par la fin. Ainsi, il n'est pas nécessaire de connaître la taille de la chaîne de caractères pour en lire son dernier caractère.

>>> s = "azerty"
>>> s[-1]
'y'
>>> s[-2]
't'
>>> s[-6]
'a'
>>> s[-7]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
>>> 

Il est aussi possible de récupérer une sous-chaîne de caractères (en fait, nous venons d'en voir un exemple un peu plus haut). Pour ce faire, vous pouvez préciser l'indice du premier caractère de la sous-chaîne à extraire ainsi que l'indice du dernier.

>>> s = "Le langage Python est fantastique"
>>> qui = s[11:17]
>>> qui
'Python'
>>> comment = s[22:]        # En l'absence d'indice de fin, on va jusqu'à la fin.
>>> comment
'fantastique'
>>> 
l'indice de fin, utilisé lors de l'extraction, est exclusif. C'est la position à partir de laquelle on arrête l'extraction. Pour faire simple, le nombre de caractères à extraire est égal à l'indice de fin auquel on soustrait l'indice de début. Dans l'exemple s[11:17], on extrait 6 caractères (17-11), soit la chaîne Python.
si vous ne précisez pas l'indice de fin et qu'il y a bien le caractère :, l'extraction est réalisée jusqu'à la fin de la chaîne. La réciproque est vrai si vous ne spécifiez pas l'indice de début de l'extraction.

Enfin, notez qu'il est possible d'extraire des caractères tous les n caractères. Dans ce cas, veuillez spécifier un pas en troisième valeur d'un opérateur []. Voici encore quelques exemples d'utilisation.

>>> s = "Le langage Python est fantastique"
>>> s[1:-1:2]
'elnaePto s atsiu'
>>> s[1::2]
'elnaePto s atsiu'
>>> s[::2]
'L agg yhnetfnatqe'
>>> 

Fonctions et méthodes utilisables sur vos chaînes de caractères

Une difficulté, quand on apprend Python, c'est que pour manipuler certains types de données et notamment les chaînes de caractères, nous devons utiliser des fonctions dans certains cas et des méthodes dans d'autres. Certes une méthode est en quelque sorte une fonction, mais la syntaxe d'appel est quand même différente.

Pour appeler une fonction manipulant une chaîne on doit utiliser la syntaxe suivante (des paramètres supplémentaires peuvent être nécessaires) :

 1 
fonction(chaine[, paramètres...])
Syntaxe d'appel d'une fonction manipulant une chaîne

Par contre, pour appeler une méthode à partir d'une chaîne on doit utiliser cette syntaxe (des paramètres supplémentaires peuvent aussi être nécessaires) :

 1 
chaine.methode([paramètres...])
Syntaxe d'appel d'une méthode sur une chaîne

Quelques fonctions utiles pour la manipulation de vos chaînes de caractères

Bien entendu, la première fonction sur laquelle je souhaitais revenir est la fonction print. Elle vous permettra d'afficher vos chaînes de caractères, comme le rappel l'exemple ci-dessous.

>>> message = "Hello World"
>>> print(message)
Hello World
>>> 

Nous en avons déjà parlé, il y a aussi la fonction input qui permet de lire une chaîne de caractères à partir de la console. La valeur de retour sera obligatoirement de type str.

>>> first_name = input("Veuillez saisir votre prénom : ")
Veuillez saisir votre prénom : James
>>> print(first_name)
James
>>> 

Une autre fonction très utile est la fonction len : elle permet de calculer la longueur de vos chaînes. Voici un exemple d'utilisation.

>>> message = "Hello World"
>>> len(message)
11
>>> 

N'oubliez pas de demander l'aide en ligne sur les fonctions que vous utiliserez plus en apprendre un peu plus sur ces dernières. L'exemple ci-dessous laisse entendre que nous pouvons aussi utiliser la fonction len sur d'autres types d'objets que des chaînes.

>>> help(len)
Help on built-in function len in module builtins:

len(obj, /)
    Return the number of items in a container.
>>>

Quelques méthodes utiles pour la manipulation de vos chaînes de caractères

La classe str (dit autrement, le type str) expose un certain nombre de méthodes. Une méthode est, en quelque sorte, une fonction directement exposée par le type associé (ici, str).

Les plus curieux d'entre vous pourront tester la ligne de code suivante : elle affiche la liste des méthodes de la classe str.

>>> dir(str)
['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '_
_ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__init_s
ubclass__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__red
uce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__
subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find'
, 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifie
r', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'l
strip', 'maketrans', 'partition', 'removeprefix', 'removesuffix', 'replace', 'rfind', 'rindex', 'rjust',
'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'tr
anslate', 'upper', 'zfill']
>>> 
pour l'heure, je ne vous parlerais pas des méthodes qui commencent et se terminent pas __ (deux caractères underscore). Vous comprendrez mieux ces points quand nous parlerons de Programmation Orientée Objet (POO).

Voici quelques premières méthodes de la classe str :

Nom de la méthode Exemple d'utilisation Description
capitalize "toto".capitalize() Cette méthode produit une nouvelle chaîne de caractères dont la première lettre sera mise en majuscule et les autres en minuscules.
count "toto".count("o") Cette méthode calcule le nombre d'occurrences d'une sous-chaîne dans tout ou une partie de la chaîne caractères courante.
endswith "image.png".endswith(".png") Cette méthode permet de déterminer si une chaîne (ou une sous-chaîne) se termine par le suffixe spécifié.
index "Hello World".index("Wor") Renvoie la position dans la chaîne courante de la première occurrence de la chaîne passée en paramètre.
lower "HELLO".lower() Cette méthode produit une nouvelle chaîne de caractères dont l'ensemble des caractères seront mis en minuscules.
replace "toto".replace("o", "a") Produit une nouvelle chaîne en replaçant les occurrences d'une chaîne de caractères par une autre.
split "2021-06-20".split("-") Découpe une chaîne de caractères selon un séparateur donné.
startswith "Hello World".startswith("Hello") Cette méthode permet de déterminer si une chaîne (ou une sous-chaîne) commence par le préfixe spécifié.
strip " De La Vega ".strip() Renvoie une copie de la chaîne courante, dans laquelle les caractères d'espacement sont retirés en début et fin de chaîne.
upper "Hello World".upper() Cette méthode produit une nouvelle chaîne de caractères dont l'ensemble des caractères seront mis en majuscules.
veuillez activer ce lien pour obtenir une liste plus complète des méthodes disponibles sur la classe str.

Et voici quelques exemples d'utilisation de ces méthodes.

>>> file_name = input("Veuillez saisir le nom du fichier : ")
Veuillez saisir le nom du fichier : truc.png
>>> file_name.endswith(".png")
True
>>> file_name.endswith(".gif")
False
>>> file_name.capitalize()
'Truc.png'
>>> file_name.lower()
'truc.png'
>>> file_name.upper()
'TRUC.PNG'
>>> file_name.index(".png")
4
>>> file_name.index(".gif")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: substring not found
>>> file_name.count(".png")
1
>>> 

Pensez que vous pouvez aussi demander l'aide en ligne sur les méthodes de la classe str.

>>> help(str.capitalize)
Help on method_descriptor:

capitalize(self, /)
    Return a capitalized version of the string.
    
    More specifically, make the first character have upper case and the rest lower case.
>>> 

Travaux pratiques

Les énoncés

Exercice 1 : extraire le premier mot d'une chaîne de caractères et l'afficher de manière « capitalisée ».

Exercice 2 : déterminer le nombre de mots contenu dans une chaîne de caractères.

dans les deux cas, on considérera que les mots sont séparés par un espace (on ne gérera pas les caractères de ponctuation). Bien entendu, essayez de faire ces exercices sans regarder directement la correction ci-dessous. ;-)

Les corrections

Exercice 1 : pour répondre à cet exercice, le plus simple serait de déterminer la position du premier espace dans la chaîne. Une fois cette position déterminée, il ne restera plus qu'à extraire la chaîne et la capitaliser. Voici une correction possible.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
 14 
 15 
# La phrase à traiter (vous pourriez aussi la lire via un appel à input).
sentence = "python est un langage merveilleux"

# Calcul de la position du premier espace
pos = sentence.find(" ")

if pos == -1:
    # Dans ce cas, la variable sentence ne contient qu'un unique mot.
    word = sentence.capitalize()
    print(word)
else:
    # On extrait le premier mot (rappel : l'indice de fin est exclusif).
    word = sentence[0:pos]
    word = word.capitalize()
    print(word)
Extraction du premier mot d'une chaîne et affichage sous forme capitalisée

Et voici le résultat produit par cet exemple.

Python

Exercice 2 : le plus simple consiste à dire que le nombre de mots de la phrase correspond au nombre d'espaces plus 1. Voici une correction possible.

 1 
 2 
 3 
 4 
 5 
 6 
 7 
 8 
 9 
 10 
 11 
 12 
 13 
# La phrase à traiter (vous pourriez aussi la lire via un appel à input).
sentence = "python est un langage merveilleux"

# Calcul du nombre d'espaces
total = sentence.count(" ")

# Le nombre de mots correspond au nombre d'espaces + 1
total += 1

if total == 1:
    print('La phrase "', sentence, '" contient 1 mot')
else:
    print('La phrase "', sentence, '" contient', total, 'mots')
Calcul du nombre de mots contenu dans une phrase.

Et voici le résultat produit par cet exemple.

La phrase " python est un langage merveilleux " contient 5 mots


Manipulation de valeurs flottantes Les chaînes formatées