Interpolation de chaînes en Python : Guide pour débutants

Supposons que vous vouliez afficher le nom et la profession d’une personne. Vous pourriez écrire un programme simple comme suit.

# Définir les variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Afficher les informations
output_string = ('My name is ' + name +
                ', I am ' + str(age) + ' years old ' +
                'and my profession is ' + profession + '.')
print(output_string)

   My name is Mark, I am 7 years old and my profession is Astronaut.

Cette approche manque de concision et de lisibilité. Heureusement, l’interpolation de chaînes offre une meilleure solution. Elle permet d’insérer directement dans une chaîne des variables, des expressions ou des sorties de fonctions, rendant la manipulation de chaînes dynamique et éliminant le besoin de concaténation manuelle.

En utilisant une approche d’interpolation de chaînes, nous pourrions réécrire le code comme suit.

# Définir les variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Afficher les informations
output_string = f'My name is {name}, I am {age} years old and my profession is {profession}.'
print(output_string)

   My name is Mark, I am 7 years old and my profession is Astronaut.

La version avec interpolation de chaînes permet d’incorporer des expressions directement à l’intérieur de la chaîne sans utiliser de concaténations désordonnées. Comme vous pouvez le constater, c’est une approche beaucoup plus propre.

Interpolation de Chaînes de Base en Python

Il existe plusieurs techniques d’interpolation de chaînes différentes en Python. La méthode la plus communément recommandée est celle des littéraux de chaînes formatés, également appelés f-strings, disponibles depuis Python 3.6.

Une autre méthode, couramment vue dans le code plus ancien que Python 3.6, est la méthode .format(). Bien que cette méthode soit plus verbeuse que les f-strings, elle présente parfois des avantages (détails ci-dessous).

Enfin, vous pouvez rencontrer %-style formatting dans les anciens codes.

En utilisant les f-strings (Python 3.6+)

Les f-strings (chaînes de caractères formatées) sont une manière puissante et concise de formater les chaînes de caractères en Python. Elles ont été introduites dans Python 3.6 et offrent un moyen lisible et efficace d’insérer directement des variables, des expressions et des appels de fonctions dans les chaînes de caractères.

Un exemple simple de la syntaxe de base d’une f-string est le suivant.

name = 'Mark'
output_string = f'My name is {name}.'
print(output_string)

   My name is Mark.

Dans ce code, la variable output_string est assignée une f-string. Le f préfixe avant l’ouverture des guillemets indique que la chaîne supporte des expressions intégrées. La variable name est évaluée et sa valeur est insérée dans la chaîne, ce qui donne en sortie : "Je m'appelle Mark."

Non seulement les valeurs des variables, mais aussi des calculs ou des expressions peuvent être insérés dans les f-strings. Considérez cet exemple.

import math


a = 3.0
b = 4.0


# Utilisez l'interpolation de chaîne pour la formule
print(f'The hypotenuse of a triangle with base {a} and side {b} is {math.sqrt(a ** 2 + b ** 2)}.')

   The hypotenuse of a triangle with base 3.0 and side 4.0 is 5.0.

L’expression math.sqrt(a ** 2 + b ** 2) est évaluée directement dans la chaîne, éliminant ainsi le besoin de calculer la valeur séparément avant de l’insérer dans la chaîne.

En utilisant la méthode .format()

Tout comme les f-strings, la .format() méthode permet d’insérer des variables et des expressions dans une chaîne. La syntaxe de base de la .format() méthode est la suivante.

name = 'Mark'
output_string = 'My name is {}.'.format(name)
print(output_string)

   My name is Mark.

Les crochets courbes {} servent de marqueur de position, indiquant qu’une valeur de variable sera insérée dans la chaîne à cette position. La valeur spécifique de la variable insérée dans le marqueur de position est déterminée par l’argument fourni à la méthode .format().

Arguments positionnels

Que se passe-t-il si vous avez besoin de plusieurs marqueurs de position pour plusieurs variables? Considérez le code suivant.

name = 'Mark'
age = 7


# Les marqueurs de position sont remplis dans l'ordre des arguments
output_string = 'My name is {} and I am {} years old.'.format(name, age)


print(output_string)

   My name is Mark and I am 7 years old.

Dans cet exemple, deux variables, name et age, sont nécessaires. En conséquence, la chaîne inclut deux espaces réservés, et les variables sont insérées dans le même ordre qu’elles apparaissent dans la méthode .format(). Ces arguments sont appelés des arguments positionnels car leur emplacement dans la chaîne est déterminé par leur position dans la liste d’arguments de la méthode.

Emplacements indexés et nommés

En tant que variation de l’idée de l’espace réservé, considérez cet exemple.

name = 'Mark'
age = 7


# Imprimer l'âge deux fois
output_string = 'My name is {} and I am {} years old. My twin brother is also {} years old.'.format(name, age, age)
print(output_string)

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.

Ici, nous avons réutilisé la valeur de la variable age deux fois. Inclure la même variable plusieurs fois de cette manière est encombrant et nuit à la lisibilité. Existe-t-il un moyen de réutiliser une variable dans une chaîne formatée avec la méthode .format() sans la répéter ? Oui, il existe, en utilisant ce que l’on appelle des *espaces réservés indexés*.

name = 'Mark'
age = 7


# Utiliser des espaces réservés indexés
output_string = 'My name is {0} and I am {1} years old. My twin brother is also {1} years old.'.format(name, age)
print(output_string)

   My name is Mark and I am 7 years old. My twin brother is also 7 years old.

Dans cet exemple, nous avons explicitement défini l’ordre des variables dans les accolades, suivant l’indexation basée sur zéro de Python. De plus, nous avons réutilisé la variable à l’index 1 au lieu de la répéter.

En alternative à l’indexation positionnelle, vous pouvez également utiliser des arguments nommés, où chaque argument se voit attribuer un nom.

print('My name is {name} and I am {age} years old.'.format(name='Mark', age=7))

   My name is Mark and I am 7 years old.

L’argument nommé est évalué dans les accolades qui spécifient son nom. En conséquence, le {name} espace réservé est remplacé par la valeur "Mark", et le {age} espace réservé est remplacé par 30.

En utilisant l’opérateur %

La méthode finale pour l’interpolation de chaînes est l’opérateur %. Il fonctionne de manière similaire à la commande printf() en C. Son utilisation est obsolète et fortement déconseillée au profit des f-strings ou de la méthode .format(). Il est mentionné ici car vous pourriez le rencontrer dans des bases de code héritées.

Le format de base pour l’opérateur % est: "chaîne de format" % valeurs. La chaîne de format contient des espaces réservés, tels que %s pour les chaînes, qui sont remplacés par des valeurs. Par exemple, l’exemple suivant affiche « Bonjour, Mark. »

'Hello %s' % 'Mark'

   'Hello Mark'

D’autres spécificateurs de format courants sont présentés dans le tableau suivant.

L’opérateur % a de nombreuses limitations. D’une part, il est moins lisible que les f-strings. Considérons le code suivant.

name = "Alice"
age = 30
height = 5.6


# L'opérateur % est difficile à parcourir
message = "My name is %s, I am %d years old, and my height is %.1f feet." % (name, age, height)
print(message)

   My name is Alice, I am 30 years old, and my height is 5.6 feet.

Ce code est-il clair d’un seul coup d’œil ? Probablement pas. Il y a beaucoup de parsing visuel d’aller-retour entre le placeholder et les variables qui remplissent les blancs. Il est facile de se perdre (ou de tourner en rond) avec tout ce va-et-vient.

Maintenant, considérons un code équivalent utilisant des f-strings.

# C'est beaucoup plus propre
message = f"My name is {name}, I am {age} years old, and my height is {height:.1f} feet."
print(message)

   My name is Alice, I am 30 years old, and my height is 5.6 feet.

Aucun parcours et aucune chaîne de formatage obscure ne sont nécessaires. Le code est propre, facile à comprendre et facile à écrire. Vous pouvez apprendre d’autres astuces pour écrire un code clair et optimisé avec le parcours de compétences en Python Programming de DataCamp. 

Techniques avancées d’interpolation de chaînes en Python

Maintenant que nous avons compris les bases de l’interpolation de chaînes en Python, examinons quelques utilisations plus avancées. 

Interpolation de chaînes multilignes en Python

Les f-strings peuvent également être utilisées pour du contenu multilignes en utilisant le signifiant f avec des guillemets triples (qu’ils soient simples ou doubles). Le texte peut être écrit sur plusieurs lignes, et il apparaîtra dans la sortie exactement tel que formaté.

name = 'Mark'
profession = 'Astronaut'
age = 7


# Ceci est un exemple d'une chaîne multilignes
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

Les chaînes multilignes peuvent également être créées en utilisant la méthode .format().

name = 'Mark'
profession = 'Astronaut'
age = 7


# Ceci est une chaîne multilignes avec .format()
bio = """
Name: {}
Profession: {}
Age: {}
""".format(name, profession, age)
print(bio)

   Name: Mark

   Profession: Astronaut

   Age: 7

Cas d’utilisation pour l’interpolation de chaînes multilignes

Pourquoi voudriez-vous utiliser l’interpolation de chaînes multilignes ? Il existe de nombreuses utilisations pour l’interpolation de chaînes multilignes. Voici quelques cas d’utilisation :

• Génération d’e-mails ou de messages multilignes
• Journalisation et débogage
• Génération de requêtes SQL dynamiques

Génération d’e-mails ou de messages multilignes

Supposons que vous envoyiez une lettre type à de nombreux invités à une conférence technologique.

name = "Alice"
event = "Annual Tech Conference"
date = "March 15, 2025"


email = """Dear {name},


We are pleased to invite you to the {event} taking place on {date}.
We hope you can join us for an exciting experience.


Best regards, 
The Event Team""".format(name=name, event=event, date=date)


print(email)

   Dear Alice,

  

   We are pleased to invite you to the Annual Tech Conference taking place on March 15, 2025.

   We hope you can join us for an exciting experience.

  

   Best regards, 

   The Event Team

Avec les f-strings, créer une lettre type est simple et efficace. Pour changer le nom, l’événement ou la date, il suffit de les modifier dans les variables et la chaîne change automatiquement.

Journalisation et débogage

Les chaînes multilignes sont utiles pour imprimer des messages d’erreur dans les journaux.

error_code = 404
url = '/missing-page'
timestamp = '2025-02-05 12:30:00'
error_message = 'The requested page could not be found.'


log_message = f"""[ERROR {error_code}]
Time: {timestamp}
URL: {url}


{error_message}"""


print(log_message)

   [ERROR 404]

   Time: 2025-02-05 12:30:00

   URL: /missing-page

 

   The requested page could not be found.

Cette méthode garde les messages de journal bien structurés et facilite le débogage avec des journaux correctement formatés.

Génération de requêtes SQL dynamiques

Les requêtes SQL peuvent être construites dynamiquement en utilisant des chaînes multilignes.

table = 'users'
column = 'email'
value = '[email protected]'


query = f"""SELECT *
FROM {table}
WHERE {column} = '{value}';"""


print(query)

   SELECT *

   FROM users

   WHERE email = '[email protected]';

Cette méthode rend les requêtes SQL lisibles et maintient l’indentation. De plus, elle élimine le besoin d’utiliser + pour la concaténation de chaînes.

D’autres cas d’utilisation comprennent:

• Rédaction de contrats formatés
• Création de documents Markdown ou $\LaTeX$
• Modèles HTML/XML multi-lignes
• Génération de réponses API ou de texte au format JSON

Avantages de l’interpolation de chaînes multilignes

Comme nous pouvons le voir, il y a plusieurs avantages à l’interpolation de chaînes multilignes.

• L’interpolation de chaînes préserve le formatage sans avoir besoin du caractère d’échappement \n. 
• L’interpolation de chaînes améliore la lisibilité par rapport au formatage sur une seule ligne. 
• L’interpolation de chaînes réduit le désordre lors de la manipulation de texte structuré (par exemple, les journaux, les requêtes, les rapports). 
• L’interpolation de chaînes permet la génération dynamique de texte sans rompre l’indentation.

Formatage des nombres et des valeurs spéciales

Pour contrôler le nombre de décimales affichées en utilisant une f-string, utilisez la syntaxe : f'{value:.nf}', où value est le nombre à virgule flottante, n est le nombre de décimales, et f (celui après le .) représente le formatage en virgule flottante.

Pour illustrer, le code suivant affiche $\pi$ avec différents nombres de décimales.

pi = 3.1415926535


print(f'Pi rounded to 2 decimal places: {pi:.2f}')
print(f'Pi rounded to 4 decimal places: {pi:.4f}')
print(f'Pi rounded to 0 decimal places: {pi:.0f}')

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3

Le formatage avec la méthode .format() est similaire.

print('Pi rounded to 2 decimal places: {:.2f}'.format(pi))
print('Pi rounded to 4 decimal places: {:.4f}'.format(pi))
print('Pi rounded to 0 decimal places: {:.0f}'.format(pi))

   Pi rounded to 2 decimal places: 3.14
   Pi rounded to 4 decimal places: 3.1416
   Pi rounded to 0 decimal places: 3

Vous pouvez utiliser une f-string pour formater des pourcentages en utilisant la syntaxe :.nf combinée avec %, où n est le nombre de décimales.

score = 0.875
print(f"Success rate: {score:.2%}")

   Success rate: 87.50%

Vous pouvez utiliser une f-string pour formater des devises en utilisant le :, pour les séparateurs de milliers et .nf pour contrôler les décimales. Vous pouvez également inclure un symbole de devise comme $, €, ou £ directement dans la chaîne.

amount = 98765.4321


print(f"USD: ${amount:,.2f}")
print(f"EUR: €{amount:,.2f}")
print(f"GBP: £{amount:,.2f}")

   USD: $98,765.43

   EUR: €98,765.43

   GBP: £98,765.43

Utiliser des f-strings avec des dictionnaires et des listes

Pour utiliser des f-strings avec un dictionnaire en Python, accédez aux valeurs du dictionnaire à l’intérieur des accolades en utilisant la notation des crochets (dict[‘clé’]) ou en déballant le dictionnaire avec **.

person = {
   'name': 'Alice',
   'age': 30,
   'city': 'New York'
}


print(f"My name is {person['name']}, I am {person['age']} years old, and I live in {person['city']}.")

   My name is Alice, I am 30 years old, and I live in New York.

Au lieu d’accéder manuellement à chaque clé, vous pouvez déballer le dictionnaire dans une f-string comme suit.

person = {
   'name': 'Alice',
   'age': 30,
}


print(f'My name is {name} and I am {age} years old.'.format(**person))

   My name is Alice and I am 7 years old.

Pour éviter une erreur due à des clés manquantes, utilisez get() pour accéder au dictionnaire.

person = {"name": "Alice"}


# Erreur : la clé 'ville' est manquante
print(f"City: {person['city']}") 

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




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

         1 person = {"name": "Alice"}

         3 # Erreur : la clé 'ville' est manquante

   ----> 4 print(f"City: {person['city']}")







   KeyError: 'city'

print(f"City: {person.get('city', 'Not specified')}")

   City: Not specified

Avantages et inconvénients des méthodes d’interpolation de chaînes

Comme nous l’avons vu, les f-strings et la méthode .format() sont toutes deux des méthodes utiles pour l’interpolation de chaînes. Examinons une comparaison des avantages et des inconvénients de chaque méthode.

Quand devriez-vous utiliser .format() au lieu des f-strings?

Erreurs courantes et meilleures pratiques

Vous trouverez ci-dessous quelques méthodes de dépannage et les meilleures astuces pour utiliser l’interpolation de chaîne en Python.

Éviter les erreurs de syntaxe avec les accolades.

Il existe de nombreuses erreurs de syntaxe que l’on peut commettre lors de l’utilisation de l’interpolation de chaînes avec des accolades.

• Assurez-vous que chaque { ait une correspondance }

print('Hello, my name is {name!'}

     Cell In[96], line 1

       print('Hello, my name is {name!'}
                                       ^
   SyntaxError: closing parenthesis '}' does not match opening parenthesis '('

Heureusement, l’erreur est simple et la correction est facile.

• Utilisez {{ et }} pour afficher des accolades littérales {}

Que se passe-t-il si vous souhaitez imprimer des accolades dans une chaîne interpolée ? Tout ce qui se trouve entre les accolades sera (tenté d’être) évalué.

print(f'Set notation: {a, b, c}')

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

   NameError                                 Traceback (most recent call last)

   Cell In[101], line 1

   ----> 1 print(f'Set notation: {a, b, c}')

   NameError: name 'c' is not defined

Python interprète a, b, c à l’intérieur des accolades comme un tuple, tentant de trouver une valeur associée à a. Comme aucune telle variable n’existe, une KeyError est levée. La solution est d’utiliser des doubles accolades {{}}.

print("Set notation: {{a, b, c}}")

Notation ensembliste : {{a, b, c}}

Comparaison des performances : f-strings vs .format()

Comparons les performances des f-strings et de .format().

import timeit


name = "Alice"
age = 30
pi = 3.1415926535


# Mesurer les performances des f-strings
f_string_time = timeit.timeit('f"My name is {name} and I am {age} years old."', globals=globals(), number=1000000)


# Mesurer les performances de .format()
format_time = timeit.timeit('"My name is {} and I am {} years old.".format(name, age)', globals=globals(), number=1000000)


# Mesurer les performances des f-strings avec des expressions
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# Mesurer les performances de .format() avec des expressions
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# Afficher les résultats
print(f"f-string (simple): {f_string_time:.6f} seconds")
print(f".format() (simple): {format_time:.6f} seconds")
print(f"f-string (with expression): {f_string_expr_time:.6f} seconds")
print(f".format() (with expression): {format_expr_time:.6f} seconds")

   f-string (simple): 0.080447 seconds

   .format() (simple): 0.129860 seconds

   f-string (with expression): 0.123171 seconds

   .format() (with expression): 0.146242 seconds

Comme vous pouvez le constater, d’un point de vue d’efficacité, il est préférable d’utiliser les f-strings plutôt que .format().

Meilleures pratiques pour une interpolation de chaînes propre et lisible

Pour garantir que votre formatage de chaîne soit clair, efficace et maintenable, suivez ces meilleures pratiques lors de l’utilisation de chaînes interpolées.

• Privilégiez les f-strings pour la lisibilité (Python 3.6+)

# Recommandé
name = "Alice"
age = 30
print(f"My name is {name} and I am {age} years old.")


# Non recommandé (Moins lisible)
print("My name is {} and I am {} years old.".format(name, age))


# Évitez d'utiliser le formatage avec % (Obsolète)
print("My name is %s and I am %d years old." % (name, age))

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

• Utilisez des espaces réservés nommés pour plus de clarté

# Espaces réservés nommés (lisibles)
user = {"name": "Alice", "age": 30}
print(f"My name is {user['name']} and I am {user['age']} years old.")


# Utilisation d'index dans .format() (moins lisible)
print("My name is {0} and I am {1} years old.".format("Alice", 30))

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.

• Conservez les chaînes multilignes lisibles.

name = "Alice"
age = 30


message = f"""Hello, {name}!


We are happy to invite you to our event.
At {age} years old, you are eligible for the VIP pass.


Best regards,
Event Team
"""
print(message)

   Hello, Alice!


   We are happy to invite you to our event.

   At 30 years old, you are eligible for the VIP pass.


   Best regards,

   Event Team  

• Utilisez des f-strings dans le logging pour un meilleur débogage

Python 3.8 et versions ultérieures prennent en charge = pour le débogage dans les f-strings.

value = 42


# Output: value = 42
print(f"{value = }") 

   value = 42

Conclusion

L’interpolation de chaînes est une fonctionnalité puissante en Python qui rend le formatage des chaînes plus propre, plus lisible et plus efficace. Parmi les méthodes disponibles, les f-strings sont l’approche la plus moderne et recommandée, offrant de meilleures performances, clarté et flexibilité par rapport aux anciennes méthodes comme .format() et % le formatage. 

En suivant les meilleures pratiques, telles que l’utilisation de marqueurs de position nommés, le contrôle de la précision décimale, l’alignement du texte pour une meilleure lisibilité et la gestion élégante des clés manquantes du dictionnaire, vous pouvez écrire un formatage de chaîne propre, professionnel et maintenable en Python.

Que vous génériez des rapports formatés, des messages multilignes ou des sorties de données structurées, les f-strings offrent un moyen simple mais puissant d’intégrer des variables et des expressions de manière transparente. Adopter les f-strings améliorera non seulement la qualité de votre code, mais renforcera également son efficacité.

Pour plus d’informations sur l’interpolation de chaîne Python, consultez les ressources de DataCamp :

• Formatage f-string en Python tutoriel
• Ajout de chaîne Python : 6 techniques essentielles de concaténation
• Programmation Python parcours de compétences
• Fondamentaux de Python parcours de compétences
• Introduction à la science des données en Python cours