Chaînes de formatage Python – PEP 498 – Interpolation de chaîne littérale

Les f-strings Python ou les chaînes formatées sont la nouvelle façon de formater les chaînes. Cette fonctionnalité a été introduite en Python 3.6 dans le cadre de PEP-498. On les appelle aussi l’interpolation de chaînes littérales.

Pourquoi avons-nous besoin des f-strings?

Python propose différentes façons de formater une chaîne. Examinons-les rapidement et quels sont les problèmes qu’elles posent.

• Formatage % – idéal pour un formatage simple mais un support limité pour les chaînes, les entiers, les doubles uniquement. On ne peut pas l’utiliser avec des objets.

• Chaînes de modèle – c’est très basique. Les chaînes de modèle fonctionnent uniquement avec des arguments par mot-clé comme un dictionnaire. Nous ne sommes pas autorisés à appeler une fonction et les arguments doivent être des chaînes.

• Formatage de chaîne() – La fonction de formatage de chaîne Python a été introduite pour surmonter les problèmes et les fonctionnalités limitées du formatage avec % et des chaînes de modèle. Cependant, elle est trop verbeuse. Regardons sa verborréité avec un exemple simple.

  >>> age = 4 * 10
  >>> 'Mon âge est {age}.'.format(age=age)
  'Mon âge est 40.'
  

Les f-strings Python fonctionnent presque de la même manière que la fonction format() mais suppriment toute la verborréité que la fonction format() comporte. Voyons comment nous pouvons formater facilement la chaîne ci-dessus à l’aide des f-strings.

>>> f'My age is {age}'
'My age is 40.'

Les f-strings Python ont été introduites pour avoir une syntaxe minimale pour le formatage de chaînes. Les expressions sont évaluées à l’exécution. Si vous utilisez Python 3.6 ou une version ultérieure, vous devriez utiliser les f-strings pour tous vos besoins de formatage de chaînes.

Exemples d’expressions f-strings Python

Jetons un coup d’œil à un exemple simple d’expressions f-strings.

name = 'Pankaj'
age = 34

f_string = f'My Name is {name} and my age is {age}'

print(f_string)
print(F'My Name is {name} and my age is {age}')  # f and F are same

name = 'David'
age = 40

# La chaîne f est déjà évaluée et ne changera pas maintenant
print(f_string)

Sortie :

My Name is Pankaj and my age is 34
My Name is Pankaj and my age is 34
My Name is Pankaj and my age is 34

Python exécute les instructions une par une et une fois que les expressions f-strings sont évaluées, elles ne changent pas même si la valeur de l’expression change. C’est pourquoi dans les extraits de code ci-dessus, la valeur de la chaîne f reste la même même après que les variables ‘nom’ et ‘âge’ aient changé dans la partie ultérieure du programme.

1. Expressions f-strings avec conversions

Nous pouvons utiliser des expressions f-strings pour convertir datetime dans un format spécifique. Nous pouvons également exécuter des expressions mathématiques dans les f-strings.

from datetime import datetime

name = 'David'
age = 40
d = datetime.now()

print(f'Age after five years will be {age+5}')  # age = 40
print(f'Name with quotes = {name!r}')  # name = David
print(f'Default Formatted Date = {d}')
print(f'Custom Formatted Date = {d:%m/%d/%Y}')

Sortie :

Age after five years will be 45
Name with quotes = 'David'
Default Formatted Date = 2018-10-10 11:47:12.818831
Custom Formatted Date = 10/10/2018

2. Les f-strings prennent en charge les chaînes brutes

Nous pouvons également créer des chaînes brutes en utilisant les f-strings.

print(f'Default Formatted Date:\n{d}')
print(fr'Default Formatted Date:\n {d}')

Sortie :

Default Formatted Date:
2018-10-10 11:47:12.818831
Default Formatted Date:\n 2018-10-10 11:47:12.818831

3. f-strings avec des objets et des attributs

Nous pouvons également accéder aux attributs des objets dans les f-strings.

class Employee:
    id = 0
    name = ''

    def __init__(self, i, n):
        self.id = i
        self.name = n

    def __str__(self):
        return f'E[id={self.id}, name={self.name}]'


emp = Employee(10, 'Pankaj')
print(emp)

print(f'Employee: {emp}\nName is {emp.name} and id is {emp.id}')

Sortie :

E[id=10, name=Pankaj]
Employee: E[id=10, name=Pankaj]
Name is Pankaj and id is 10

4. f-strings appelant des fonctions

Nous pouvons également appeler des fonctions dans le formatage des f-strings.

def add(x, y):
    return x + y


print(f'Sum(10,20) = {add(10, 20)}')

Sortie : Sum(10,20) = 30

5. f-string avec des espaces blancs

Si des espaces blancs sont présents au début ou à la fin de l’expression, ils sont ignorés. Si la partie de chaîne littérale contient des espaces blancs, alors ils sont préservés.

>>> age = 4 * 20
>>> f'   Age = {  age   }  '
'   Age = 80  '

6. Expressions lambda avec des f-strings

Nous pouvons également utiliser des expressions lambda à l’intérieur des expressions f-string.

x = -20.45
print(f'Lambda Example: {(lambda x: abs(x)) (x)}')

print(f'Lambda Square Example: {(lambda x: pow(x, 2)) (5)}')

Sortie :

Lambda Example: 20.45
Lambda Square Example: 25

7. Exemples divers d’utilisations des f-strings

Jetons un coup d’œil à quelques exemples divers des f-strings en Python.

print(f'{"quoted string"}')
print(f'{{ {4*10} }}')
print(f'{{{4*10}}}')

Sortie:

quoted string
{ 40 }
{40}

C’est tout pour les chaînes formatées en Python, également appelées f-strings.

Vous pouvez consulter le script Python complet et plus d’exemples en Python depuis notre Dépôt GitHub.

Référence: PEP-498, Documentation officielle