Les chaînes de caractères#

Nous nous intéressons maintenant à un autre type de données particulier du langage Python : les chaînes de caractères (type str). Pour créer une chaîne de caractères, il suffit d’utiliser des guillemets, simples ou doubles (les deux sont équivalents) :

s1 = "abc"
s2 = 'bde'

Comme pour les listes (et peut-être même plus encore), il est fortement conseillé de se reporter à l’aide en ligne dédiée lorsque vous avez des doutes sur la manipulation de chaînes de caractères : https://docs.python.org/3/library/stdtypes.html#string-methods

Conversion d’une chaîne en nombre#

Si une chaîne de caractères représente une valeur numérique (comme la chaîne "10.2" par exemple), on peut la transformer en un entier ou un nombre à virgule, afin de l’utiliser ensuite pour des opérations arithmétiques. On utilise pour cela les fonctions de conversion, respectivement int et float.

s = '10.2'
f = float(s)
print(f)

10.2

print(f == s)

False

print(f + 2)

12.2

s = '10'
i = int(s)
print(i)

10

print(i == s)

False

print(i - 1)

9

Analogie avec les listes#

Les chaînes de caractères se manipulent en partie comme des listes. On peut ainsi obtenir la taille d’une chaîne de caractères à l’aide de la fonction len, ou accéder à la \(i\)-ème lettre d’une chaîne de caractères avec la notation s[i]. Comme pour les listes, il est possible d’indicer une chaîne de caractères en partant de la fin, en utilisant des indices négatifs :

s = "abcdef"
print(len(s))

6

print(s[0])

a

print(s[-1])

f

De même, on peut sélectionner des sous-parties de chaînes de caractères à partir des indices de début et de fin de la sélection. Comme pour les listes, l’indice de fin correspond au premier élément exclu de la sélection :

s = "abcdef"
print(s[2:4])

cd

Comme pour les listes, on peut concaténer deux chaînes de caractères à l’aide de l’opérateur + ou répéter une chaîne de caractères avec l’opérateur * :

s = "ab" + ('cde' * 3)
print(s)

abcdecdecde

On peut également tester la présence d’une sous-chaîne de caractères dans une chaîne avec le mot-clé in :

s = "abcde"
print("a" in s)

True

print("bcd" in s)

True

print("bCd" in s)

False

Attention. Toutefois, l’analogie entre listes et chaînes de caractères est loin d’être parfaite. Par exemple, on peut accéder au \(i\)-ème élément d’une chaîne de caractères en lecture, mais pas en écriture. Si s est une chaîne de caractères, on ne peut pas exécuter s[2] = "c" par exemple.

Principales méthodes de la classe str#

La liste de méthodes de la classe str qui suit n’est pas exhaustive, il est conseillé de consulter l’aide en ligne de Python pour plus d’informations.

  • ch.count(sub): Retourne le nombre d’occurrences de sub dans ch

  • ch.endswith(suffix): Retourne True si ch se termine par suffix

  • ch.startswith(prefix): Retourne True si ch commence par prefix

  • ch.find(sub): Retourne l’indice du début de la première occurrence de sub dans ch

  • ch.rfind(sub): Retourne l’indice du début de la dernière occurrence de sub dans ch

  • ch.islower(): Retourne True si ch est constituée uniquement de caractères minuscules

  • ch.isupper(): Retourne True si ch est constituée uniquement de caractères majuscules

  • ch.isnumeric(): Retourne True si ch est constituée uniquement de chiffres

  • ch.lower(): Retourne la version minuscule de ch

  • ch.upper(): Retourne la version majuscule de ch

  • ch.replace(old, new): Retourne une copie de ch dans laquelle toutes les occurrences de old ont été remplacées par new

  • ch.split(sep=None): Retourne une liste contenant des morceaux de ch découpée à chaque occurrence de sep (par défaut, la chaîne est decoupée à chaque espace ou retour à la ligne)

  • ch.strip(): Retourne une version « nettoyée » de ch dans laquelle on a enlevé tous les espaces en début et en fin de chaîne

  • ch.format(...): Remplace les caractères {} dans la chaîne ch par le contenu des variables passées en argument

Formatage des chaînes de caractères#

Lorsque l’on souhaite ajouter, dans une chaîne de caractères, du contenu stocké dans une variable, on pourra utiliser la méthode format listée ci-dessus.

Commençons par un exemple :

age = 12
prenom = "Micheline"
s = "{} a {} ans".format(prenom, age)
print(s)

Micheline a 12 ans

Ainsi, la méthode .format() recherche dans la chaîne de caractères les {} et les remplace par les valeurs des variables fournies. Il est possible de maîtriser plus finement la mise en forme de ces variables, et même de les nommer (ce qui peut s’avérer très utile si la chaîne de caractères est longue et inclut de nombreuses variables).

Voici quelques exemples :

age_enfant = 12
prenom_enfant = "Micheline"
s = "{prenom} a {age} ans".format(prenom=prenom_enfant, age=age_enfant)
print(s)

Micheline a 12 ans

age_enfant = 12
prenom_enfant = "Micheline"
s = "{prenom} a {age:.3f} ans".format(prenom=prenom_enfant, age=age_enfant)
print(s)

Micheline a 12.000 ans

Vous trouverez une présentation plus exhaustive de ces questions dans la documentation Python sur ce point.

Pour aller plus loin : les f-strings#

Il existe une autre façon de mettre en forme les chaînes de caractères, qui consiste en l’utilisation de f-strings. Pour définir une f-string, il suffit d’ajouter un f avant la chaîne de caractères :

s = f"Ceci est une f-string"
print(s)

Ceci est une f-string

Jusqu’ici, rien de bien révolutionnaire. Mais ces f-strings deviennent fort pratiques dès lors que l’on souhaite ajouter des données issues de variables précédemment définies :

age = 12
prenom = "Micheline"
s = f"{prenom} a {age} ans"
print(s)

Micheline a 12 ans

Cette syntaxe est beaucoup plus concise que ce que l’on pouvait avoir en utilisant la méthode .format(). On peut même effectuer des calculs à la volée dans les f-strings :

age_chat = 12
s = f"Ce chat a {age_chat} ans, ce qui lui fait {age_chat * 6} ans en âge équivalent humain"
print(s)

Ce chat a 12 ans, ce qui lui fait 72 ans en âge équivalent humain

En utilisant f-strings et options de formatage, on peut obtenir des sorties alignées avec un code relativement succinct comme dans les exemples suivants :

# Exemple 1 : alignement
# Syntaxe : {variable : alignement largeur}
# Alignement < gauche | > droite | ^ centré|
ville = "Rennes"
print(f"La ville de {ville:<10} est en Bretagne.")
print(f"La ville de {ville:>10} est en Bretagne.")
print(f"La ville de {ville:^10} est en Bretagne.")

La ville de Rennes     est en Bretagne.
La ville de     Rennes est en Bretagne.
La ville de   Rennes   est en Bretagne.

# Exemple 2 : Affichage des entiers
# Syntaxe : {variable : largeur symbole}
# le symbole d (digit) ou n (numeric) représente un entier
vils = ["Rennes", "Chantepie", "Noyal-sur-Vilaine"]
pops = [215346, 10445, 5820 ]
for v, p in zip(vils, pops):
    print(f"A {v:<17} : il y a {p:7n} habitants." )

A Rennes            : il y a  215346 habitants.
A Chantepie         : il y a   10445 habitants.
A Noyal-sur-Vilaine : il y a    5820 habitants.

# Exemple 3 : Affichage des nombres ayant une partie décimale
# Syntaxe : {variable : longtotale.longdeci f}
# Remarque le nombre affiché est arrondi (et non tronqué)
x, y =10/3, 25/7
for longdeci in range(5):
    print(f"Avec {longdeci} décimales, le 1er nombre est |{x:7.{longdeci}f}| le second est|{y:7.{longdeci}f}|")

Avec 0 décimales, le 1er nombre est |      3| le second est|      4|
Avec 1 décimales, le 1er nombre est |    3.3| le second est|    3.6|
Avec 2 décimales, le 1er nombre est |   3.33| le second est|   3.57|
Avec 3 décimales, le 1er nombre est |  3.333| le second est|  3.571|
Avec 4 décimales, le 1er nombre est | 3.3333| le second est| 3.5714|

Exercices#

Exercice 5.1

Écrivez une fonction qui prenne en argument deux chaînes de caractères s et prefix et retourne le nombre de mots de la chaîne s qui débutent par la chaîne prefix.

Solution

def compte_prefix(s, prefix):
    compteur = 0
    for mot in s.split():
        if mot.startswith(prefix):
            compteur += 1
    return compteur

print(compte_prefix("la vie est belle au bord du lac", "la"))

Exercice 5.2

Écrivez une fonction qui prenne en argument deux chaînes de caractères s et mot_cible et retourne le nombre d’occurrences du mot mot_cible dans la chaîne s en ne tenant pas compte de la casse.

Solution

def compte_sans_casse(s, mot_cible):
    compteur = 0
    mot_cible_minuscules = mot_cible.lower()
    for mot in s.split():
        if mot.lower() == mot_cible_minuscules:
            compteur += 1
    return compteur

print(compte_sans_casse("la vie est LA aussi", "la"))

Exercice 5.3

Écrivez une fonction qui prenne en argument une liste d’entiers et l’affiche sous le format suivant :

L'entier d'indice  0 est |           1|
L'entier d'indice  1 est |          12|
L'entier d'indice  2 est |         123|
L'entier d'indice  3 est |        1234|
L'entier d'indice  4 est |       12345|
L'entier d'indice  5 est |      123456|
L'entier d'indice  6 est |     1234567|
L'entier d'indice  7 est |    12345678|
L'entier d'indice  8 est |   123456789|
L'entier d'indice  9 est |  1234567890|
L'entier d'indice 10 est | 12345678901|

Cet affichage correspond à la liste [1, 12, 123, 1234, 12345, 123456, 1234567, 12345678, 123456789, 1234567890, 12345678901]

Solution

def affiche_liste(liste):
    for i, elt in enumerate(listent):
        print(f"L'entier d'indice {i:2n} est |{elt:12n}|")

listent = [1, 12, 123, 1234, 12345, 123456, 1234567, 12345678, 123456789, 1234567890, 12345678901]
affiche_liste(listent)