Interpolation de chaînes de caractères en Python : Guide du débutant

Supposons que vous souhaitiez éditer le nom et la profession d'une personne. Vous pouvez écrire un programme simple comme suit.

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output info
output_string = ('My name is ' + name +
                ', I am ' + str(age) + ' years old ' +
                'and my profession is ' + profession + '.')
print(output_string)Propulsé par

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

Cette approche manque de concision et de lisibilité. Heureusement, l'interpolation de chaînes de caractères offre une meilleure solution. Il permet d'insérer des variables, des expressions ou des sorties de fonctions directement dans une chaîne de caractères, ce qui rend la manipulation des chaînes de caractères dynamique et élimine la nécessité d'une concaténation manuelle.

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

# Define variables
name = 'Mark'
profession = 'Astronaut'
age = 7


# Output info
output_string = f'My name is {name}, I am {age} years old and my profession is {profession}.'
print(output_string)Propulsé par

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

La version avec interpolation de chaîne permet d'intégrer des expressions directement à l'intérieur de la chaîne sans avoir recours à des concaténations compliquées. Comme vous pouvez le constater, il s'agit d'une approche beaucoup plus propre.

Interpolation de chaînes de caractères de base en Python

Il existe plusieurs techniques d'interpolation de chaînes de caractères dans Python. La méthode la plus couramment recommandée est celle des littéraux de chaîne formatés, également connus sous le nom de f-strings, qui sont disponibles depuis Python 3.6.

Une autre méthode, couramment observée dans le code antérieur à Python 3.6, est la méthode .format(). Bien que cette méthode soit plus verbeuse que les chaînes de caractères, elle présente parfois des avantages (voir ci-dessous).

Enfin, vous pouvez rencontrer %-dans les codes hérités.

Utilisation des chaînes f (Python 3.6+)

f-chaînes (littérales de chaînes formatées) sont un moyen puissant et concis de formater les chaînes en Python. Ils ont été introduits dans Python 3.6 et fournissent un moyen lisible et efficace d'insérer des variables, des expressions et des appels de fonction directement dans des chaînes de caractères.

Voici un exemple simple de la syntaxe de base d'une chaîne f.

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

   My name is Mark.Propulsé par

Dans ce code, la variable output_string se voit attribuer une chaîne f. Le préfixe f précédant le guillemet ouvrant indique que la chaîne prend en charge les expressions intégrées. La variable name est évaluée et sa valeur est insérée dans la chaîne, ce qui donne la sortie : "My name is Mark."

Il est possible d'insérer dans les chaînes f non seulement des valeurs variables, mais aussi des calculs ou des expressions. Prenons l'exemple suivant.

import math


a = 3.0
b = 4.0


# Use string interpolation for the formula
print(f'The hypotenuse of a triangle with base {a} and side {b} is {math.sqrt(a ** 2 + b ** 2)}.')Propulsé par

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

L'expression math.sqrt(a ** 2 + b ** 2) est évaluée directement dans la chaîne, ce qui évite de calculer la valeur séparément avant de l'insérer dans la chaîne.

Utilisation de la méthode .format()

Comme les chaînes f, la méthode.format() permet d'insérer des variables et des expressions dans une chaîne. La syntaxe de base de la méthode .format() est la suivante.

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

   My name is Mark.Propulsé par

Les curly brackets {} servent de placeholder, signalant que la valeur d'une variable sera insérée dans la chaîne à cette position. La valeur spécifique de la variable insérée dans l'espace réservé est déterminée par l'argument fourni à la méthode .format().

Arguments de position

Que se passe-t-il si vous avez besoin de plusieurs espaces réservés pour plusieurs variables ? Considérez le code suivant.

name = 'Mark'
age = 7


# The placeholders are filled in order of the arguments
output_string = 'My name is {} and I am {} years old.'.format(name, age)


print(output_string)Propulsé par

   My name is Mark and I am 7 years old.Propulsé par

Dans cet exemple, deux variables, name et age, sont nécessaires. Par conséquent, la chaîne comprend deux espaces réservés et les variables sont insérées dans le même ordre que celui dans lequel elles apparaissent dans la méthode .format(). Ces arguments sont connus sous le nom de *positional* arguments car leur emplacement dans la chaîne est déterminé par leur position dans la liste d'arguments de la méthode.

Les espaces réservés indexés et nommés

Voici une variante de l'idée de l'espace réservé.

name = 'Mark'
age = 7


# Print age twice
output_string = 'My name is {} and I am {} years old. My twin brother is also {} years old.'.format(name, age, age)
print(output_string)Propulsé par

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

Ici, nous avons réutilisé deux fois la valeur de la variable age. Le fait d'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, c'est possible, en utilisant ce que l'on appelle *indexed placeholders*.

name = 'Mark'
age = 7


# Use indexed placeholders
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)Propulsé par

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

Dans cet exemple, nous avons explicitement défini l'ordre des variables à l'intérieur des accolades, en suivant l'indexation à base zéro de Python. En outre, nous avons réutilisé la variable à l'index 1 au lieu de la répéter.

Comme alternative à l'indexation positionnelle, vous pouvez également utiliser des arguments nommés, où chaque argument reçoit un nom.

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

   My name is Mark and I am 7 years old.Propulsé par

L'argument nommé est évalué à l'intérieur des crochets qui spécifient son nom. Par conséquent, le caractère générique {name} est remplacé par la valeur "Mark", et le caractère générique {age} est remplacé par 30.

Utilisation de l'opérateur %

La dernière méthode d'interpolation des chaînes de caractères est l'opérateur%. Son fonctionnement est similaire à celui de la commande printf() en C. Son utilisation est dépréciée et fortement déconseillée au profit des chaînes f ou de la méthode.format(). Elle est mentionnée ici parce que vous pouvez la rencontrer dans les bases de code existantes.

Le format de base de l' opérateur % est le suivant : "format string" % values. 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 imprime "Hello, Mark".

'Hello %s' % 'Mark'Propulsé par

   'Hello Mark'Propulsé par

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

L'opérateur % a de nombreuses limites. D'une part, il est moins lisible que les chaînes de caractères f. D'autre part, il est moins lisible que les chaînes de caractères f. Considérez le code suivant.

name = "Alice"
age = 30
height = 5.6


# The % operator is hard to scan
message = "My name is %s, I am %d years old, and my height is %.1f feet." % (name, age, height)
print(message)Propulsé par

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

Ce code est-il clair au premier coup d'œil ? Probablement pas. Il y a beaucoup d'analyse visuelle entre l'espace réservé et les variables qui remplissent les blancs. Il est facile de s'y perdre (ou de s'étourdir) avec tout ce va-et-vient.

Considérons maintenant un code équivalent utilisant des chaînes f.

# This is much cleaner
message = f"My name is {name}, I am {age} years old, and my height is {height:.1f} feet."
print(message)Propulsé par

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

Aucun balayage ni aucune chaîne de formatage obscure n'est nécessaire. Le code est propre, facile à comprendre et à écrire. Vous pouvez apprendre d'autres astuces pour écrire un code clair et optimisé avec lecursus de compétences en programmation Python de DataCamp. 

Techniques avancées d'interpolation de chaînes de caractères en Python

Maintenant que nous avons compris les bases de l'interpolation de chaînes de caractères en Python, voyons quelques utilisations plus avancées. 

Interpolation de chaînes de caractères multilignes en Python

Les chaînes f peuvent également être utilisées pour un contenu multiligne en utilisant le signifiant f avec des guillemets triples (simples ou doubles). Le texte peut être écrit sur plusieurs lignes et il apparaîtra dans le résultat exactement tel qu'il a été formaté.

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


# This is an example of a multiline string
bio = f"""
Name: {name}
Profession: {profession}
Age: {age}
"""
print(bio)Propulsé par

   Name: Mark

   Profession: Astronaut

   Age: 7Propulsé par

 Les chaînes multilignes peuvent également être créées à l'aide de la méthode .format().

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


# This is a multiline string with .format()
bio = """
Name: {}
Profession: {}
Age: {}
""".format(name, profession, age)
print(bio)Propulsé par

   Name: Mark

   Profession: Astronaut

   Age: 7Propulsé par

Cas d'utilisation de l'interpolation de chaînes de caractères multilignes

Pourquoi voudriez-vous utiliser l'interpolation de chaînes de caractères multilignes ? L'interpolation de chaînes de caractères multilignes peut être utilisée à de nombreuses fins. Voici quelques exemples d'utilisation :

• Générer des courriels ou des messages multilignes
• Journalisation et débogage
• Générer dynamiquement des requêtes SQL

Générer des courriels ou des messages multilignes

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

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)Propulsé par

   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 TeamPropulsé par

Avec les chaînes f, la création d'une lettre type est simple et efficace. Pour modifier 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)Propulsé par

   [ERROR 404]

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

   URL: /missing-page

 

   The requested page could not be found.Propulsé par

Cette méthode permet de conserver des messages structurés et facilite le débogage grâce à des journaux correctement formatés.

Générer dynamiquement des requêtes SQL

Les requêtes SQL peuvent être construites dynamiquement à l'aide de chaînes de caractères multilignes.

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


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


print(query)Propulsé par

   SELECT *

   FROM users

   WHERE email = '[email protected]';Propulsé par

Cette méthode rend les requêtes SQL lisibles et maintient l'indentation. En outre, il n'est pas nécessaire d'utiliser + pour la concaténation des chaînes de caractères.

Parmi les autres cas d'utilisation, on peut citer

• Rédiger des contrats formatés
• Création de Markdown ou de $\LaTeX$ documents
• Modèles HTML/XML multilignes
• Générer des réponses API ou du texte de type JSON

Avantages de l'interpolation de chaînes de caractères multilignes

Comme nous pouvons le constater, l'interpolation de chaînes de caractères multilignes présente plusieurs avantages.

• L'interpolation de chaînes de caractères préserve le formatage sans avoir recours au caractère d'échappement \n.
• L'interpolation des chaînes de caractères améliore la lisibilité par rapport au formatage sur une seule ligne. 
• L'interpolation de chaînes de caractères réduit l'encombrement lorsque vous travaillez avec du texte structuré (par exemple, des journaux, des requêtes, des rapports). 
• L'interpolation des chaînes de caractères permet de générer du texte dynamique sans interrompre l'indentation. 

Formatage des nombres et des valeurs spéciales

Pour contrôler le nombre de décimales affichées à l'aide d'une chaîne f, utilisez la syntaxe suivante : f'{value:.nf}', où value est le nombre à virgule flottante, n est le nombre de décimales, et f (celui qui suit le .) représente le formatage de la virgule flottante.

Pour illustrer, le code suivant produit $\pià différentes 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}')Propulsé par

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

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))Propulsé par

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

Vous pouvez utiliser une chaîne f 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%}")Propulsé par

   Success rate: 87.50%Propulsé par

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

amount = 98765.4321


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

   USD: $98,765.43

   EUR: €98,765.43

   GBP: £98,765.43Propulsé par

Utilisation de chaînes f avec des dictionnaires et des listes

Pour utiliser les chaînes f avec un dictionnaire en Python, accédez aux valeurs du dictionnaire à l'intérieur des crochets en utilisant la notation des crochets (dict['key']) ou en décompressant 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']}.")Propulsé par

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

Au lieu d'accéder à chaque clé manuellement, vous pouvez décomposer le dictionnaire en une chaîne f comme suit.

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


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

   My name is Alice and I am 7 years old.Propulsé par

Pour éviter une erreur en cas de clés manquantes, utilisez get() pour l'accès au dictionnaire.

person = {"name": "Alice"}


# Error: key 'city' is missing
print(f"City: {person['city']}") Propulsé par

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




   KeyError                                  Traceback (most recent call last)




   Cell In[87], line 4

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

         3 # Error: key 'city' is missing

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







   KeyError: 'city'Propulsé par

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

   City: Not specifiedPropulsé par

Avantages et inconvénients des méthodes d'interpolation des chaînes de caractères

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

Quand devez-vous utiliser .format() sur les chaînes f ?

Pièges courants et meilleures pratiques

Vous trouverez ci-dessous des méthodes de dépannage et des conseils pour utiliser l'interpolation de chaînes de caractères en Python. 

Éviter les erreurs de syntaxe avec les accolades bouclées

De nombreuses erreurs de syntaxe peuvent être commises lors de l'utilisation de l'interpolation de chaînes de caractères impliquant des accolades.

• Assurez-vous que chaque { a une correspondance }

print('Hello, my name is {name!'}Propulsé par

     Cell In[96], line 1

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

Heureusement, l'erreur est simple et la solution facile.

• Utilisez {{ et }} pour afficher les {} littéraux.

Que se passe-t-il si vous souhaitez imprimer des accolades à l'intérieur d'une chaîne interpolée ? Tout ce qui se trouve à l'intérieur des crochets sera (ou tentera d'être) évalué.

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

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

   NameError                                 Traceback (most recent call last)

   Cell In[101], line 1

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

   NameError: name 'c' is not definedPropulsé par

Python interprète a, b, c à l'intérieur des crochets comme un tuple, en essayant de trouver une valeur associée à a. Étant donné qu'une telle variable n'existe pas, il y a une KeyError. La solution consiste à utiliser des doubles parenthèses curvilignes {{}}.

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

   Notation de l'ensemble : {{a, b, c}}

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

Comparons les performances des cordes f et de .format().

import timeit


name = "Alice"
age = 30
pi = 3.1415926535


# Measure f-string performance
f_string_time = timeit.timeit('f"My name is {name} and I am {age} years old."', globals=globals(), number=1000000)


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


# Measure f-string performance with expressions
f_string_expr_time = timeit.timeit('f"Pi rounded to 2 decimal places: {pi:.2f}"', globals=globals(), number=1000000)


# Measure .format() performance with expressions
format_expr_time = timeit.timeit('"Pi rounded to 2 decimal places: {:.2f}".format(pi)', globals=globals(), number=1000000)


# Print results
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")Propulsé par

   f-string (simple): 0.080447 seconds

   .format() (simple): 0.129860 seconds

   f-string (with expression): 0.123171 seconds

   .format() (with expression): 0.146242 secondsPropulsé par

Comme vous pouvez le constater, du point de vue de l'efficacité, il est préférable de préférer les cordes f à .format().

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

Pour vous assurer que le formatage de vos chaînes est clair, efficace et facile à maintenir, suivez ces bonnes pratiques lorsque vous utilisez des chaînes interpolées.

• Préférer les chaînes f pour plus de lisibilité (Python 3.6+)

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


# Not Recommended (Less readable)
print("My name is {} and I am {} years old.".format(name, age))


# Avoid using % formatting (Outdated)
print("My name is %s and I am %d years old." % (name, age))Propulsé par

   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.Propulsé par

• Pour plus de clarté, utilisez des espaces réservés nommés

# Named placeholders (readable)
user = {"name": "Alice", "age": 30}
print(f"My name is {user['name']} and I am {user['age']} years old.")


# Using indexes in .format() (not as readable)
print("My name is {0} and I am {1} years old.".format("Alice", 30))Propulsé par

   My name is Alice and I am 30 years old.

   My name is Alice and I am 30 years old.Propulsé par

• Les chaînes de caractères multilignes restent 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)Propulsé par

   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  Propulsé par

• Utilisez les chaînes f dans la journalisation pour un meilleur débogage

Python 3.8 et les versions ultérieures prennent en charge = pour le débogage dans les chaînes f.

value = 42


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

   value = 42Propulsé par

Conclusion

L'interpolation de chaînes est une fonctionnalité puissante de Python qui rend le formatage de chaînes plus propre, plus lisible et plus efficace. Parmi les méthodes disponibles, les chaînes f constituent l'approche la plus moderne et la plus recommandée, car elles offrent de meilleures performances, une plus grande clarté et une plus grande souplesse que les méthodes plus anciennes telles que le formatage .format() et %.

En suivant les meilleures pratiques, telles que l'utilisation de caractères de remplacement nommés, le contrôle de la précision décimale, l'alignement du texte pour une meilleure lisibilité et la gestion des clés de dictionnaire manquantes, vous pouvez écrire un formatage de chaîne propre, professionnel et facile à maintenir en Python. 

Que vous produisiez des rapports formatés, des messages multilignes ou des sorties de données structurées, les chaînes f constituent un moyen simple et puissant d'intégrer des variables et des expressions de manière transparente. L'adoption des chaînes f améliorera non seulement la qualité de votre code, mais aussi son efficacité. 

Pour plus d'informations sur l'interpolation de chaînes de caractères en Python, consultez les ressources de DataCamp :

• Formatage de chaînes de caractères en Python tutoriel
• Chaîne d'appendice Python : 6 techniques essentielles de concaténation
• Programmation Python cursus de compétences
• Principes de base de Python cursus de compétences
• Introduction à la science des données en Python cours