Tutoriel sur les chaînes de caractères en Python

Découpage (slicing) de chaînes en Python

Étant donné que les chaînes sont des séquences de caractères, vous pouvez y accéder par découpage (slicing) et indexation comme avec les listes ou tuples Python. Les chaînes sont indexées caractère par caractère, à partir de 0 :

Dans la chaîne ci-dessus, le premier caractère est C et son index est 0. Le dernier caractère est un point ., qui est le 16e caractère de la chaîne. Vous pouvez aussi accéder aux caractères dans le sens inverse en partant de -1 : utiliser -1 comme index permet d’accéder au .. Il y a également un espace entre Chocolate et cookie : c’est aussi un caractère de la chaîne, avec son propre index, le 9e ici. Vous pouvez le vérifier avec le slicing.

Comme chaque caractère d’une chaîne Python possède un index, vous pouvez accéder et manipuler les chaînes comme les autres types séquentiels. Le slicing permet de récupérer un élément précis ou un sous-ensemble d’éléments d’un objet contenant, à l’aide de leurs index. Le slicing vous évite d’écrire des boucles pour parcourir les index de votre chaîne afin de trouver ou d’accéder à certaines sous-chaînes.

snack = "Chocolate cookie."
print(snack[0])
print(snack[9])
print(snack[-1])

C

.

Supposons que vous souhaitiez extraire la sous-chaîne « cookie » de la chaîne ci-dessous. Comment faire ?

Dans ce cas, utilisez un slicing par plage.

La syntaxe du slicing par plage est la suivante : [index de début (inclus) : index de fin (exclu)]

snack = "Chocolate cookie."
print(snack[10:16])

cookie

Vous pouvez aussi utiliser une valeur négative pour l’index de fin :

print(snack[10:-1]) # -1 : l'index de fin est exclu dans le slicing.

cookie

Ne pas spécifier l’index de fin signifie que vous capturez les caractères depuis l’index de début jusqu’au dernier caractère de la chaîne. De même, omettre l’index de début signifie que vous partez du tout premier caractère jusqu’à l’index de fin :

# Valeur de fin non fournie
print(snack[0:]) 

# Valeur de début non fournie (la valeur de fin est exclue selon la syntaxe)
print(snack[:-1])

# Ceci est également autorisé
print(snack[:])

Chocolate cookie.
Chocolate cookie
Chocolate cookie.

Le slicing de chaînes accepte aussi un troisième paramètre, le stride (pas), qui indique de combien de caractères vous avancez après avoir récupéré le premier caractère. La valeur par défaut de stride est 1.

Voyons le stride en action pour mieux comprendre :

number_string = "1020304050"
print(number_string[0:-1:2])

12345

Astuce : avec le pas, vous pouvez faire quelque chose de très pratique : inverser une chaîne :

print(number_string[::-1]) #

0504030201

Une valeur de -1 pour le pas vous permet de partir du dernier caractère puis de reculer d’un caractère à la fois.

De même, si vous fournissez -2 comme valeur, vous partez du dernier caractère et reculez de deux caractères à la fois :

print(number_string[::-2]) #

00000

Opérations courantes sur les chaînes

Le slicing, qu’il soit simple ou par plage, fait partie des opérations les plus fréquentes sur les chaînes. Il y a aussi la concaténation, qui s’écrit aussi simplement qu’une addition :

string1 = 'Chocolate'
string2 = 'cookie'

snack = string1 + " " + string2
print(snack)

Chocolate cookie

Cependant, cela ne fonctionne pas si vous essayez de concaténer une chaîne avec un autre type de donnée.

cost = 15
string1 = "The total in Euro is: "

bill = string1 + cost
print(bill)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-218-7d5c5248b927> in <module>()
      2 string1 = "The total in Euro is: "
      3 
----> 4 bill = string1 + cost
      5 print(bill)


TypeError: Can't convert 'int' object to str implicitly

Ici, vous avez tenté de concaténer une chaîne avec un entier, ce qui n’est pas autorisé. L’interpréteur ne peut pas déduire implicitement si vous souhaitez effectuer une addition entière ou une concaténation de chaînes. En revanche, essayez ceci :

bill = string1 + str(cost)
print(bill)

The total in Euro is: 15

Cela fonctionne car vous avez explicitement converti l’entier en chaîne avant de concaténer. Pour en savoir plus sur les conversions de types, consultez ce tutoriel.

Pour répéter une chaîne, utilisez l’opérateur *.

single_word = 'hip '
line1 = single_word * 2 + 'hurray! '
print(line1 * 3)

hip hip hurray! hip hip hurray! hip hip hurray! 

Vous pouvez aussi tester l’appartenance d’une sous-chaîne avec in et not in :

sub_string1 = 'ice'
sub_string2 = 'glue'
string1 = 'ice cream'
if sub_string in string1:
    print("There is " + sub_string + " in " + string1)
if sub_string2 not in string1:
    print("Phew! No " + sub_string2 + " in " + string1)

There is ice in ice cream
Phew! No glue in ice cream

Python propose de nombreuses méthodes intégrées pour manipuler les chaînes. Remplacer une sous-chaîne, mettre en majuscule certains mots d’un paragraphe, trouver la position d’une chaîne dans une autre : autant d’opérations possibles avec ces méthodes.

Voyons-en quelques-unes de plus près :

• str.capitalize() : renvoie une copie de la chaîne avec son premier caractère en majuscule.

str.capitalize('cookie')

'Cookie'

• str.islower() : renvoie true si tous les caractères de la chaîne sont en minuscules, false sinon.

snack = 'cookie'
snack.islower()

True

• str.find(substring) : renvoie l’index le plus bas où la sous-chaîne est trouvée. Vous pouvez aussi préciser les index de début et de fin dans lesquels chercher. Renvoie -1 si la sous-chaîne n’est pas trouvée.

str1 = 'I got you a cookie'
str2 = 'cook'
str1.find(str2)

12

• str.count(substring) : compte le nombre d’occurrences d’une sous-chaîne. Vous pouvez aussi préciser des index de début et de fin.

str1 = 'I got you a cookie, do you like cookies?'
str2 = 'cookie'
str1.count(str2)

2

• str.isspace() : renvoie True s’il n’y a que des caractères d’espacement dans la chaîne, false sinon. Les caractères d’espacement incluent l’espace, la tabulation, le retour à la ligne, etc.

Cela peut être utile avec des jeux de données réels, qui n’encodent pas toujours correctement les espaces lors de conversions de format.

str_space = '   '
str_space.isspace()

True

str_tab = '\t'
str_tab.isspace()

True

str_nextline = '''\n'''
str_nextline.isspace()

True

Remarque : avez-vous remarqué \t et \n ci-dessus ? Ce sont des caractères d’échappement. Ils commencent par un \ (antislash). En interne, ils ne sont pas interprétés comme des chaînes normales, mais comme des caractères spéciaux représentant autre chose. Par exemple, \t représente une tabulation. Il en existe bien d’autres, que vous pouvez retrouver dans notre tutoriel Regex Python.

• str.lstrip() : supprime tous les espaces en début de chaîne. Une autre fonction pratique avec des données réelles.

str1 = " I can't hear you. Are you alright? "
str2 = " Yes, all is good."
str3 = str1.lstrip() + str2.lstrip()
print(str3)

I can't hear you. Are you alright? Yes, all is good.

• str.isdigit() : renvoie True si la chaîne ne contient que des chiffres et False sinon.

number_string = "1020304050"
number_string.isdigit()

True

• str.replace(substring, new) : remplace toutes les occurrences de la sous-chaîne par la nouvelle. Vous pouvez aussi définir un troisième argument max pour limiter le nombre de remplacements. Notez qu’il ne s’agit pas d’un remplacement en place : l’immuabilité s’applique toujours et une nouvelle chaîne est créée.

string1 = 'hip hip hurray! hip hip hurray! hip hip hurray!'
string2 = string1.replace('hip', 'Hip')
print(string1)
print(string2)

hip hip hurray! hip hip hurray! hip hip hurray!
Hip Hip hurray! Hip Hip hurray! Hip Hip hurray!

string1.replace('hip', 'Hip', 2)

'Hip Hip hurray! hip hip hurray! hip hip hurray!'

• str.split(delimiter="") : découpe la chaîne selon le délimiteur (espace par défaut) et renvoie une liste de sous-chaînes.

dessert = 'Cake, Cookie, Icecream'
list_dessert = string1.split(',')

Vous trouverez la liste exhaustive des méthodes de chaîne en Python ici.

Mise en forme des chaînes

Python propose plusieurs façons de formater une chaîne. Dans cette section, vous allez en découvrir davantage sur ces méthodes de formatage !

% Mise en forme

Le modulo % est une opération intégrée en Python, appelée opérateur d’interpolation. Vous devez fournir % suivi du type de donnée à formater ou convertir. L’opération % substitue ensuite l’expression « %datatype » par un ou plusieurs éléments du type spécifié :

print("I bought %d Euro worth of %s!" %(200, 'cookies'))

I bought 200 Euro worth of cookies!

Vous avez vu %d pour les entiers et %s pour les chaînes. Parmi les autres conversions disponibles : o pour l’octal, x pour l’hexadécimal, f pour les décimaux à virgule flottante, c pour un caractère unique (accepte un entier ou une chaîne d’un seul caractère).

La classe formatter

La classe formatter fait partie des classes de chaîne intégrées. Elle permet des substitutions de variables complexes et le formatage de valeurs via la méthode format(). Vous pouvez créer et personnaliser vos propres comportements de formatage en réécrivant ses méthodes publiques : format(), vformat(). Certaines méthodes sont destinées à être remplacées par des sous-classes : parse(), get_field(), get_value(), check_unused_args(), format_field() et convert_field(). Toutefois, pour rester simple, nous allons uniquement examiner la fonction la plus utilisée, format()…

print("I bought {0} Euro worth of {1}!".format(200,'cookies')) # Accès par position

I bought 200 Euro worth of cookies!

print("I bought {total} Euro worth of {item}!".format(total = 200, item = 'cookies')) # Accès par nom

I bought 200 Euro worth of cookies!

'{:#<10}'.format('Cake') # Alignement à gauche du mot 'Cake', espaces remplis avec '#'

'Cake######'

'{:#^10}'.format('Cake') # Alignement centré du mot 'Cake', espaces remplis avec '#'

'###Cake###'

'{:#>10}'.format('Cake') # Alignement à droite du mot 'Cake', espaces remplis avec '#'

'######Cake'

for num in range(1,10): 
        print('{0:{width}}'.format(num, width=5), end=' ')

    1     2     3     4     5     6     7     8     9 

Templates de chaînes

Plutôt que les substitutions basées sur %, les templates utilisent des substitutions basées sur $. L’introduction des templates dans Python 2.4 répondait au fait que, même si la mise en forme avec % est puissante et riche, elle est sujette aux erreurs et assez stricte quant aux formats suivant « % », ce qui la complexifie. Une erreur courante avec % est d’oublier le caractère de format final, par exemple : le e dans %(variabl)e.

Les templates exposent notamment deux méthodes : substitute() et safe_substitute(). Voici comment les utiliser :

from string import Template # First you will need to import 'Tempalte' class

money = dict(who = 'You', to_whom = 'baker')
Template('$who owe the $to_whom a total of $$100').substitute(money)

'You owe the baker a total of $100'

Vous avez remarqué le $$ dans l’exemple ci-dessus ?

C’est parce qu’avec les templates, $$ est un caractère d’échappement remplacé par un seul $. C’est l’une des règles des templates. Une autre règle concerne la façon de définir un identifiant dans votre template : la syntaxe habituelle $identifier, mais aussi ${identifier}.

Autrement dit, ${identifier} équivaut à $identifier, mais peut être utile dans des scénarios comme :

word = dict(noun = 'feed')
Template('Please don\'t stop ${noun}ing me').substitute(word)

"Please don't stop feeding me"

Voyons comment utiliser substitute() et safe_substitute().

fact = Template('$alter_ego is weak but wait till he transforms to $superhero!')
fact.substitute(alter_ego='Bruce Banner', superhero='Hulk')

'Bruce Banner is weak but wait till he transforms to Hulk!'

hero = dict(alter_ego='Peter Parker')
fact.substitute(hero)

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-244-c82f6a2ebc02> in <module>()
      1 hero = dict(alter_ego='Peter Parker')
----> 2 fact.substitute(hero)


~/anaconda3/envs/tensorflow/lib/python3.5/string.py in substitute(*args, **kws)
    127             raise ValueError('Unrecognized named group in pattern',
    128                              self.pattern)
--> 129         return self.pattern.sub(convert, self.template)
    130 
    131     def safe_substitute(*args, **kws):


~/anaconda3/envs/tensorflow/lib/python3.5/string.py in convert(mo)
    117             named = mo.group('named') or mo.group('braced')
    118             if named is not None:
--> 119                 val = mapping[named]
    120                 # We use this idiom instead of str() because the latter will
    121                 # fail if val is a Unicode containing non-ASCII characters.


KeyError: 'superhero'

L’exemple ci-dessus lève une erreur, car superhero n’est pas défini. En revanche, essayez ceci…

fact.safe_substitute(hero)

'Peter Parker is weak but wait till he transforms to $superhero!'

safe_substitute() est l’un des avantages des templates.

Pourquoi autant d’options de mise en forme, vous demandez-vous ?

Essentiellement pour des préférences de syntaxe. C’est souvent un compromis entre simplicité et verbosité, et cela dépend aussi de votre familiarité avec certaines syntaxes. Par exemple, l’opérateur % semblera naturel aux personnes issues du C. Les templates en Python sont simples à écrire, tandis que format() peut être plus verbeux mais offre plus de fonctionnalités.

Littéraux de chaîne formatés (f-strings)

Voici une autre méthode de formatage ajoutée avec Python 3.6. Un littéral de chaîne formaté, ou f-string, est une chaîne préfixée par « f » ou « F ». Vous pouvez définir des identifiants à utiliser dans votre chaîne entre accolades { }.

Pourquoi encore une nouvelle option ? Parce que le pragmatisme et la simplicité, c’est ce qu’il y a de mieux !

Consultez les exemples ci-dessous pour voir pourquoi les f-strings sont souvent la manière la plus simple et la plus pratique de formater des chaînes en Python.

alter_ego = 'Peter Parker' superhero = 'spiderman' f'{alter_ego} is weak but wait till he transforms to {superhero}!'

Remarque : le code ci-dessus ne fonctionne qu’avec Python 3.6 et versions ultérieures. Pour vérifier votre version de Python, tapez : python -V dans le terminal. Vous pouvez aussi utiliser le module sys dans Python :

import sys
sys.version

Les f-strings sont en réalité des expressions évaluées à l’exécution, ce qui signifie que vous pouvez utiliser n’importe quelle expression Python entre les accolades, autre avantage majeur.

f'{alter_ego} is weak but wait till he transforms to {superhero.capitalize()}!'

Les f-strings ne sont-elles pas déjà géniales ? Et ce n’est pas tout… elles sont aussi plus rapides que les trois autres méthodes vues précédemment, car elles sont pré-analysées et stockées en bytecode efficace pour une exécution plus rapide.

Tirez les bonnes ficelles !

Vous êtes arrivé au bout du tutoriel, bravo ! Vous avez vu ce que sont les chaînes, appris le slicing et quelques opérations courantes. Vous avez également découvert plusieurs façons de formater des chaînes. Mais souvenez-vous : la clé pour maîtriser une technique, c’est la pratique !

Les chaînes ne sont qu’un des nombreux types de données en Python. Découvrez le cours DataCamp Data Types for Data Science pour en savoir plus sur les listes, dictionnaires, tuples et ensembles. Dans ce cours, vous mettrez à profit votre connaissance des types de données. Vous travaillerez avec des données de transport de la région métropolitaine de Chicago pour des usages data science. Allez voir par vous-même…