Recherche de site Web

F-strings en Python - PEP 498 - Interpolation de chaînes littérales

Les f-strings ou chaînes formatées en Python sont la nouvelle façon de formater des chaînes. Cette fonctionnalité a été introduite dans Python 3.6 sous PEP-498. On l'appelle aussi interpolation de chaîne littérale.

Pourquoi avons-nous besoin des f-strings ?

Python offre plusieurs façons de formater une chaîne. Jetons un coup d'œil rapide à celles-ci et aux problèmes qu'elles présentent.

  • % formatage - excellent pour un formatage simple mais prise en charge limitée aux chaînes, entiers, doubles uniquement. Nous ne pouvons pas l'utiliser avec des objets.

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

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

    >>> age = 4 * 10
>>> 'My age is {age}.'.format(age=age)
'My age is 40.'

Les f-strings en Python fonctionnent presque de la même manière que la fonction format(), mais éliminent toute la verbosité que possède la fonction format(). Voyons combien il est facile de formater la chaîne ci-dessus en utilisant des f-strings.

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

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

Exemples de f-strings en Python

Regardons un exemple simple de 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

f_string is already evaluated and won't change now
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-string 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 f_string reste la même même après que les variables 'name' et 'age' aient changé dans la dernière partie du programme.

1. f-strings avec des expressions et des conversions

Nous pouvons utiliser des f-strings pour convertir des objets datetime en un format spécifique. Nous pouvons également exécuter des expressions mathématiques dans des 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

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

Nous pouvons également créer des chaînes brutes en utilisant des 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 d'objet 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 : Somme(10,20)=30

5. f-string avec des espaces blancs

S'il y a des espaces vides en début ou en fin de l'expression, ils sont ignorés. Si la partie chaîne littérale contient des espaces vides, 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'f-strings

Examinons quelques exemples divers de 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 Python, également appelées f-strings.

Vous pouvez consulter le script Python complet et d'autres exemples de Python sur notre dépôt GitHub.

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