# Les bases des f-strings en Python

Avec les chaînes de caractères f, ou *f-strings* en Python, vous pouvez **insérer des expressions et des variables complexes** directement dans une chaîne, sans avoir à effectuer de conversions ou de formatages supplémentaires.

## f-strings Python : qu’est-ce que c’est ?

Les f-strings Python sont un format de chaîne de caractères Python introduit avec Python 3.6. Elles sont également appelées **chaînes littérales formatées**. À l’intérieur des strings, vous pouvez évaluer des calculs en les intégrant dans des accolades. Elles permettent une écriture plus compacte par rapport à d’autres méthodes de formatage de chaînes comme `str.format()` ou la concaténation avec `+`. Il en résulte un code plus clair et plus concis.

Les f-strings sont extrêmement flexibles et permettent d’insérer des variables et des expressions dans différents types de données comme **les entiers, les floats, les listes** ou même des expressions et des fonctions sans conversion préalable ou formatage spécial. En règle générale, les f-strings Python sont plus rapides que les autres méthodes de formatage de chaînes en Python.

## La syntaxe générale des f-strings

La structure de base d’une chaîne de caractères f est constituée du **préfixe** `f` ou `F`, suivi d’une chaîne de caractères identifiée par des guillemets (“ ou ’). À l’intérieur de cette chaîne, des accolades `{}` peuvent être utilisées pour intégrer des variables ou des expressions.

```python
nom = "Pierre"
age = 25
formatted_string = f"Mon nom est {nom} et j’ai {age} ans".
print(formatted_string) # Sortie : Mon nom est Pierre et j’ai 25 ans.
```

Dans notre exemple, nous remplaçons la variable `nom` par `{nom}` et la variable `age` par `{age}` dans la chaîne de caractères f pour produire la chaîne de caractères finale.

## Utilisations des f-strings Python

Les chaînes de caractères f peuvent être utilisées et spécifiées de plusieurs manières.

### Effectuer des calculs à l’intérieur d’une chaîne de caractères.

Les f-strings Python sont particulièrement pratiques pour effectuer des **opérations arithmétiques** à l’intérieur d’une chaîne de caractères. Vous pouvez ainsi définir une expression complexe en une seule ligne.

```python
nombre1 = 10
nombre2 = 5
resultat = f"La somme de {nombre1} et {nombre2} est {nombre1 + nombre2}"
print(resultat) # Sortie : La somme de 10 et 5 est 15
```

Ici, l’addition de `nombre1` et `nombre2` est effectuée à l’intérieur de la chaîne de caractères f, et le résultat est inséré directement dans la chaîne de caractères finale.

### Python f-strings et raw strings

La combinaison de `r` (pour les chaînes brutes) et de `f` (pour les chaînes formatées ou chaînes f) produit un type spécial de chaîne en Python, connu sous le nom de *rf-string* (ou chaîne rf). La chaîne rf combine la fonctionnalité des chaînes brutes, qui **traitent littéralement les séquences d’échappement**, avec la flexibilité et la puissance des chaînes f, qui permettent d’incorporer directement des variables et des expressions dans une chaîne.

```python
nom = "User"
chemin = rf'C:\Users\Username\Documents\{nom}\file.txt'
print(chemin) # Output: C:\Users\Username\Documents\User\file.txt
```

Dans le code, nous utilisons la chaîne rf pour définir un chemin. L’utilisation de `{nom}` à l’intérieur de la chaîne rf entraîne l’insertion directe de la variable `nom`, tandis que le `r` placé avant la chaîne garantit que la **barre oblique inversée** `\` est traité comme un caractère littéral et non comme une partie d’une séquence d’échappement.

### Précision des nombres à virgule flottante

Des instructions spéciales de **formatage** permettent de définir le nombre de décimales d’un nombre à virgule flottante dans la chaîne formatée.

```python
valeur = 3.14159265359  
valeur_formatee = f"Valeur arrondie = {valeur:.3f}"
print(valeur_formatee)  # Sortie : Valeur arrondie = 3.142
```

Ici, l’instruction de formatage `:.3f` indique que la variable `valeur` doit être arrondie à trois décimales et insérée dans la chaîne formatée.

### Largeur et alignement

Pour les f-strings Python, la largeur et l’alignement permettent de contrôler la **représentation des valeurs insérées** dans un champ défini. Cela est utile pour placer du texte ou des chiffres dans une zone donnée et les aligner soit à gauche, soit à droite, soit au centre.

Supposons que nous ayons le nom `__Alice__` et que nous voulions l’aligner à droite dans un champ de dix caractères de large :

```python
nom = "Alice"
nom_formate = f"Bonjour, {nom:>10}"
print(nom_formate)  # Sortie : Bonjour,      Alice
```

Comme la valeur fait moins de dix caractères, la spécification `{nom:>10}` l’aligne à droite.

### Remplissage avec des zéros ou d’autres caractères

Le remplissage avec des zéros ou d’autres caractères influence l’alignement des nombres dans un champ. Cela est utile lorsque les nombres doivent être affichés dans un format fixe, par exemple pour **afficher des heures ou des valeurs numériques**.

```python
nombre = 42
nombre_formate = f"Nombre : {nombre:06}"
print(nombre_formate)  # Sortie : Nombre : 000042
```

Ici, `:06` indique que le nombre `nombre` est saisi dans un champ de six chiffres, et que nous remplissons les chiffres manquants avec des zéros non significatifs.

Il est également possible de spécifier d’autres caractères que des zéros pour le remplissage :

```python
mot = "Python"
mot_formate = f"Mot : {mot:_<10}"
print(mot_formate)  # Sortie : Mot : Python____
```


This is a markdown version of: [https://www.ionos.com/fr-ch/digitalguide/sites-internet/developpement-web/python-f-strings/](https://www.ionos.com/fr-ch/digitalguide/sites-internet/developpement-web/python-f-strings/) for AI/LLM consumption.