Maîtriser les chaînes Python : création, formatage et manipulation

Les chaînes Python

Dans ce tutoriel, vous apprendrez à créer, formater, modifier et supprimer des chaînes en Python. Vous découvrirez aussi diverses opérations et fonctions sur les chaînes.

Vidéo : Les chaînes Python

Qu'est-ce qu'une chaîne en Python ?

Une chaîne est une séquence de caractères.

Un caractère est simplement un symbole. Par exemple, la langue anglaise a 26 caractères.

Les ordinateurs ne traitent pas des caractères, ils traitent des nombres (binaire). Même si vous voyez des caractères à l'écran, en interne ils sont stockés et manipulés comme une combinaison de 0 et de 1.

Cette conversion de caractère en nombre s'appelle l'encodage, et le processus inverse est le décodage. ASCII et Unicode sont parmi les encodages populaires utilisés.

En Python, une chaîne est une séquence de caractères Unicode. Unicode a été introduit pour inclure chaque caractère de toutes les langues et apporter l'uniformité dans l'encodage. Vous pouvez en apprendre plus sur Unicode dans Python Unicode.

Comment créer une chaîne en Python ?

Les chaînes peuvent être créées en enfermant des caractères entre guillemets simples ou doubles. Les guillemets triples peuvent aussi être utilisés en Python, généralement pour représenter des chaînes multilignes et les docstrings.

# définition de chaînes en Python
# tous les suivants sont équivalents
my_string = 'Bonjour'
print(my_string)
my_string = "Bonjour"
print(my_string)
my_string = '''Bonjour'''
print(my_string)
# les guillemets triples peuvent s'étendre sur plusieurs lignes
my_string = """Bonjour, bienvenue dans le monde de Python"""
print(my_string)

Quand vous exécutez le programme, la sortie sera :

Bonjour Bonjour Bonjour Bonjour, bienvenue dans le monde de Python

Comment accéder aux caractères d'une chaîne ?

Nous pouvons accéder aux caractères individuels en utilisant l'indexation et une plage de caractères en utilisant le tranchage. L'index commence à 0. Tenter d'accéder à un caractère hors de l'index lève une IndexError. L'index doit être un entier. Nous ne pouvons pas utiliser des floats ou d'autres types, cela résulterait en TypeError.

Python permet l'indexation négative pour ses séquences.

L'index -1 fait référence au dernier élément, -2 à l'avant-dernier, etc. Nous pouvons accéder à une plage d'éléments dans une chaîne en utilisant l'opérateur de tranchage : (deux-points).

# Accès aux caractères de chaîne en Python
str = 'programiz'
print('str = ', str)
# premier caractère
print('str[0] = ', str[0])
# dernier caractère
print('str[-1] = ', str[-1])
# tranchage 2ème à 5ème caractère
print('str[1:5] = ', str[1:5])
# tranchage 6ème à 2ème depuis la fin
print('str[5:-2] = ', str[5:-2])

Quand nous exécutons le programme ci-dessus, nous obtenons la sortie suivante :

str = programiz str[0] = p str[-1] = z str[1:5] = rogr str[5:-2] = am

Si nous essayons d'accéder à un index hors limites ou utilisons autre chose qu'un entier, nous obtiendrons des erreurs.

# index doit être dans la plage
>>> my_string[15]
... IndexError: string index out of range
# index doit être un entier
>>> my_string[1.5]
... TypeError: string indices must be integers

Le tranchage peut être mieux visualisé en considérant l'index comme étant entre les éléments comme montré ci-dessous.

Si nous voulons accéder à une plage, nous avons besoin de l'index qui va trancher la portion de la chaîne.

Maîtriser les chaînes Python : création, formatage et manipulation

Comment modifier ou supprimer une chaîne ?

Les chaînes sont immuables. Cela signifie que les éléments d'une chaîne ne peuvent pas être changés une fois assignés. Nous pouvons simplement réassigner différentes chaînes au même nom.

>>> my_string = 'programiz'
>>> my_string[5] = 'a'
... TypeError: 'str' object does not support item assignment
>>> my_string = 'Python'
>>> my_string
'Python'

Nous ne pouvons pas supprimer ou retirer des caractères d'une chaîne. Mais supprimer la chaîne entièrement est possible avec le mot-clé del.

>>> del my_string[1]
... TypeError: 'str' object doesn't support item deletion
>>> del my_string
>>> my_string
... NameError: name 'my_string' is not defined

Opérations sur les chaînes Python

Il y a de nombreuses opérations qui peuvent être effectuées avec les chaînes, ce qui en fait l'un des types de données les plus utilisés en Python.

Pour en savoir plus sur les types de données disponibles en Python, visitez : Types de données Python

Concaténation de deux ou plusieurs chaînes

La jonction de deux ou plusieurs chaînes en une seule est appelée concaténation.

L'opérateur + fait cela en Python. Écrire simplement deux littéraux de chaîne ensemble les concatène aussi.

L'opérateur * peut être utilisé pour répéter la chaîne un nombre donné de fois.

# Opérations sur les chaînes Python
str1 = 'Bonjour'
str2 = 'Monde!'
# utilisant +
print('str1 + str2 = ', str1 + str2)
# utilisant *
print('str1 * 3 =', str1 * 3)

Quand nous exécutons le programme ci-dessus, nous obtenons la sortie suivante :

str1 + str2 = BonjourMonde! str1 * 3 = BonjourBonjourBonjour

Écrire deux littéraux de chaîne ensemble les concatène aussi comme l'opérateur +.

Si nous voulons concaténer des chaînes sur différentes lignes, nous pouvons utiliser des parenthèses.

>>> # deux littéraux de chaîne ensemble
>>> 'Bonjour ''Monde!'
'Bonjour Monde!'
>>> # utilisant des parenthèses
>>> s = ('Bonjour '
... 'Monde')
>>> s
'Bonjour Monde'

Itérer sur une chaîne

Nous pouvons itérer sur une chaîne en utilisant une boucle for. Voici un exemple pour compter le nombre de 'l' dans une chaîne.

# Itération sur une chaîne
count = 0
for letter in 'Bonjour Monde':
    if(letter == 'l'):
        count += 1
print(count, 'lettres trouvées')

Quand nous exécutons le programme ci-dessus, nous obtenons la sortie suivante :

3 lettres trouvées

Test d'appartenance de chaîne

Nous pouvons tester si une sous-chaîne existe dans une chaîne ou non, en utilisant le mot-clé in.

>>> 'a' in 'program'
True
>>> 'at' not in 'bataille'
False

Fonctions intégrées pour travailler avec Python

Diverses fonctions intégrées qui fonctionnent avec les séquences fonctionnent aussi avec les chaînes.

Parmi les plus couramment utilisées, on trouve enumerate() et len(). La fonction enumerate() retourne un objet enumerate. Il contient l'index et la valeur de tous les éléments de la chaîne sous forme de paires. Cela peut être utile pour l'itération.

De même, len() retourne la longueur (nombre de caractères) de la chaîne.

str = 'froid'
# enumerate()
list_enumerate = list(enumerate(str))
print('list(enumerate(str)) = ', list_enumerate)
# comptage des caractères
print('len(str) = ', len(str))

Quand nous exécutons le programme ci-dessus, nous obtenons la sortie suivante :

list(enumerate(str)) = [(0, 'f'), (1, 'r'), (2, 'o'), (3, 'i'), (4, 'd')] len(str) = 4

Formatage de chaînes Python

Séquences d'échappement

Si nous voulons afficher un texte comme Il a dit, "Qu'y a-t-il ?", nous ne pouvons utiliser ni guillemets simples ni doubles. Cela résulterait en une SyntaxError car le texte contient à la fois des guillemets simples et doubles.

>>> print("Il a dit, "Qu'y a-t-il ?"")
... SyntaxError: invalid syntax
>>> print('Il a dit, "Qu\'y a-t-il ?"')
... SyntaxError: invalid syntax

Une façon de contourner ce problème est d'utiliser des guillemets triples. Alternativement, nous pouvons utiliser des séquences d'échappement.

Une séquence d'échappement commence par une barre oblique inverse et est interprétée différemment. Si nous utilisons un guillemet simple pour représenter une chaîne, tous les guillemets simples à l'intérieur doivent être échappés. Il en va de même pour les guillemets doubles. Voici comment faire pour représenter le texte ci-dessus.

# utilisant des guillemets triples
print('''Il a dit, "Qu'y a-t-il ?"''')
# échappement des guillemets simples
print('Il a dit, "Qu\'y a-t-il ?"')
# échappement des guillemets doubles
print("Il a dit, \"Qu'y a-t-il ?\"")

Quand nous exécutons le programme ci-dessus, nous obtenons la sortie suivante :

Il a dit, "Qu'y a-t-il ?" Il a dit, "Qu'y a-t-il ?" Il a dit, "Qu'y a-t-il ?"

Voici la liste de toutes les séquences d'échappement supportées par Python.

Séquence d'échappement	Description
\newline	Barre oblique inverse et nouvelle ligne ignorées
\\	Barre oblique inverse
\'	Guillemet simple
\"	Guillemet double
\a	ASCII Bell
\b	ASCII Backspace
\f	ASCII Formfeed
\n	ASCII Linefeed
\r	ASCII Carriage Return
\t	ASCII Horizontal Tab
\v	ASCII Vertical Tab
\ooo	Caractère avec valeur octale ooo
\xHH	Caractère avec valeur hexadécimale HH

Voici quelques exemples :

>>> print("C:\\Python32\\Lib")
C:\Python32\Lib
>>> print("Ceci est imprimé\nsur deux lignes")
Ceci est imprimé
sur deux lignes
>>> print("Ceci est \x48\x45\x58 représentation")
Ceci est HEX représentation

Chaîne brute (raw string) pour ignorer les séquences d'échappement

Parfois, nous souhaitons ignorer les séquences d'échappement à l'intérieur d'une chaîne. Pour ce faire, nous pouvons placer r ou R devant la chaîne. Cela implique qu'il s'agit d'une chaîne brute et toute séquence d'échappement à l'intérieur sera ignorée.

>>> print("Ceci est \x61 \nbon exemple")
Ceci est a
bon exemple
>>> print(r"Ceci est \x61 \nbon exemple")
Ceci est \x61 \nbon exemple

La méthode format() pour formater les chaînes

La méthode format() disponible avec l'objet chaîne est très versatile et puissante pour formater les chaînes. Les chaînes de format contiennent des accolades {} comme espaces réservés ou champs de remplacement qui sont remplacés.

Nous pouvons utiliser des arguments positionnels ou nommés pour spécifier l'ordre.

# Méthode format() de chaîne Python
# ordre par défaut (implicite)
default_order = "{}, {} et {}".format('Jean','Pierre','Paul')
print('\n--- Ordre par défaut ---')
print(default_order)
# ordre utilisant argument positionnel
positional_order = "{1}, {0} et {2}".format('Jean','Pierre','Paul')
print('\n--- Ordre positionnel ---')
print(positional_order)
# ordre utilisant argument nommé
keyword_order = "{p}, {p2} et {j}".format(j='Jean',p2='Pierre',p='Paul')
print('\n--- Ordre nommé ---')
print(keyword_order)

Quand nous exécutons le programme ci-dessus, nous obtenons la sortie suivante :

--- Ordre par défaut --- Paul, Pierre et Jean --- Ordre positionnel --- Pierre, Jean et Paul --- Ordre nommé --- Paul, Pierre et Jean

La méthode format() peut avoir des spécifications de format optionnelles. Elles sont séparées du nom du champ par deux-points. Par exemple, nous pouvons aligner à gauche <, à droite > ou centrer ^ une chaîne dans l'espace donné.

Nous pouvons aussi formater des entiers en binaire, hexadécimal, etc. et les floats peuvent être arrondis ou affichés en format exposant. Il y a des tonnes de formatages que vous pouvez utiliser. Visitez ici pour tous les formatages de chaîne disponibles avec la méthode format().

>>> # formatage d'entiers
>>> "Représentation binaire de {0} est {0:b}".format(12)
'Représentation binaire de 12 est 1100'
>>> # formatage de floats
>>> "Représentation exposant : {0:e}".format(1566.345)
'Exposant representation: 1.566345e+03'
>>> # arrondi
>>> "Un tiers est : {0:.3f}".format(1/3)
'Un tiers est : 0.333'
>>> # alignement de chaîne
>>> "|{:<10}|{:^10}|{:>10}|".format('beurre','pain','jambon')
'|beurre     |  pain    |     jambon|'

Ancien style de formatage

Nous pouvons même formater les chaînes comme l'ancien style sprintf() utilisé en langage C. Nous utilisons l'opérateur % pour accomplir cela.

>>> x = 12.3456789
>>> print('La valeur de x est %3.2f' %x)
La valeur de x est 12.35
>>> print('La valeur de x est %3.4f' %x)
La valeur de x est 12.3457

Méthodes courantes des chaînes Python

Il y a de nombreuses méthodes disponibles avec l'objet chaîne. La méthode format() mentionnée ci-dessus en est une. Certaines des méthodes couramment utilisées sont lower(), upper(), join(), split(), find(), replace(), etc. Voici une liste complète de toutes les méthodes intégrées pour travailler avec les chaînes en Python.

>>> "PrOgRaMiZ".lower()
'programiz'
>>> "PrOgRaMiZ".upper()
'PROGRAMIZ'
>>> "Ceci va diviser tous les mots en une liste".split()
['Ceci', 'va', 'diviser', 'tous', 'les', 'mots', 'en', 'une', 'liste']
>>> ' '.join(['Ceci', 'va', 'rejoindre', 'tous', 'les', 'mots', 'en', 'une', 'chaîne'])
'Ceci va rejoindre tous les mots en une chaîne'
>>> 'Bonne Année'.find('nn')
7
>>> 'Bonne Année'.replace('Bonne','Excellente')
'Excellente Année'

Maîtriser les tuples Python : création, accès et opérations avancées Maîtriser les ensembles Python : création, manipulation et opérations

Python