Utilisation et exemples de la méthode format() de la chaîne Python

Python string methods

La méthode format() de la chaîne formatte les valeurs spécifiées et les insère dans les placeholders de la chaîne.
Les placeholders sont définis par des accolades {} (gousses). Consultez la section "Placeholders" ci-dessous pour plus d'informations sur les placeholders.
La méthode format() de la chaîne Python retourne une chaîne formatée.

La syntaxe de la méthode format() est la suivante :

template.format(p0,　p1,　...,　k0=v0,　k1=v1,　...)

Ici, p0, p1,... sont des paramètres positionnels et k0, k1,... ont des valeurs de paramètres nommés v0, v1,...。

Et, le template est un mélange de codes de formatage et de placeholders de paramètres.

paramètres de format() pour les chaînes de caractères

La méthode format() prend un nombre illimité de paramètres. Mais, ils sont divisés en deux types :

• paramètres positionnels -Liste des paramètres accessible via l'index de paramètre dans les accolades {index}

• paramètres nommés -La liste des paramètres de type clé=valeur, accessible via la clé de paramètre dans les accolades {key}

La valeur retournée par format() pour les chaînes de caractères

La méthode format() retourne une chaîne de caractères formatée.

Comment fonctionne format() pour les chaînes de caractères ?

format()lit le type des paramètres passés à celui-ci et les formate en fonction des codes de format définis dans la chaîne.

Pour les paramètres positionnels

Ici, le paramètre 0 est la chaîne de caractères "Adam", le paramètre1est un nombre à virgule flottante230.2346。

Attention :　Dans Python, la liste des paramètres commence à 0.

La chaîne de caractères "Hello {0}, votre solde est {1:9.3f}" est une chaîne de caractères de modèle. Il contient des codes de formatage utilisés pour le formatage.

les accolades sont simplement des placeholders pour les paramètres à placer. Dans l'exemple ci-dessus, {0} est le placeholder pour "Adam", {1:9.3f} est230.2346des placeholders.

Comme les chaînes de caractères de modèle引用format()paramètres comme {0} et {1}, ces paramètres sont des paramètres positionnels. Ils peuvent également être mentionnés sans numéro, car {} et Python les convertissent en numéros internes.

f} fait référence à

• Comme "Adam" est le 0 ^unparamètre, donc il est placé à la position {0}. Comme {0} ne contient aucune autre code de format, il ne fait aucune autre opération.

• Cependant, le premier paramètre230.2346Ce n'est pas le cas. Ici, {1:9.3f} mettra230.2346placez-le à son emplacement et exécutez9.3Avant de le remplacer, comme dans les exemples précédents, il l'exécute

• f spécifie le format en cours de traitement des nombres à virgule flottante. S'il n'est pas spécifié correctement, il émettra une erreur.

• La partie avant "." (9) spécifiez le nombre (230.2346) peut être utilisé comme largeur minimale/remplissage. Dans ce cas,230.2346au moins est alloué9emplacement, y compris ".".
  Si l'option d'alignement n'est pas spécifiée, elle sera alignée à droite des autres espaces. (Pour les chaînes de caractères, elle est alignée à gauche.)

• La partie après "." (3) tronquera la partie décimale (2346) tronqué au nombre donné. Dans ce cas,3346Après cela, il sera tronqué2346。
  Reste des nombres (46sera arrondi, et affiché235。

Pour les paramètres nommés

Nous avons utilisé le même exemple ci-dessus pour illustrer la différence entre les paramètres nommés et les paramètres positionnels.

Ici, nous utilisons non seulement les paramètres, mais aussi les valeurs clé-valeur en tant que paramètres. C'est-à-dire name="Adam" et blc=230.2346。

Ces paramètres sont définis par leurs clés sous la forme {name} et {blc:9.3parce qu'elles sont appelées paramètres nommés ou paramètres par nom.

f} fait référence à

• En interne,-Le substitut {name} remplace la valeur de name

• « Adam ». Comme il ne contient aucune autre code de formatage, il a été placé « Adam ». 230.2346Pour le paramètre blc =9.3，le substitut {blc:230.2346f} sera remplacé par la valeur9.3Avant de le remplacer, comme dans les exemples précédents, il l'exécute
  Opération f.230.235。La partie décimale est3est tronqué, et les autres nombres sont arrondis. De même, la largeur totale est répartie9，en laissant deux espaces de côté à gauche.

Format de base d'utilisation de format()

La méthode format() permet d'utiliser des substituts simples pour le formatage.

Example1：Format par défaut, position et paramètres nommés

#　Paramètres par défaut
print("Bonjour {}, votre solde est {}.".format("Adam",　230.2346))
#　Paramètres positionnés
print("Bonjour {0}, votre solde est {1}.".format("Adam",　230.2346))
#　Paramètres nommés
print("Bonjour {name}, votre solde est {blc}.".format(name="Adam", blc=230.2346))
#　Paramètres mélangés
print("Bonjour {0}, votre solde est {blc}.".format("Adam", blc=230.2346))

Lors de l'exécution du programme, toutes les sorties seront identiques :

Bonjour Adam, votre solde est　230.2346.
Bonjour Adam, votre solde est　230.2346.
Bonjour Adam, votre solde est　230.2346.
Bonjour Adam, votre solde est　230.2346.

Attention :Pour les paramètres mélangés, les paramètres nommés doivent toujours suivre les paramètres positionnés.

Formater les nombres avec format()

Vous pouvez utiliser les indicateurs de format ci-dessous pour définir le format de nombre :

Example2：Simple format de nombre

#　Entier
print("Nombre:{:d}".format(123))
# Paramètres flottants
print("Nombre à virgule flottante:{:f}".format(123.4567898))
# Formatage en octal, binaire et hexadécimal
print("bin:　{0:b},　oct:　{0:o},　hex:　{0:x}".format(12))

Lorsque vous exécutez ce programme, la sortie sera :

Nombre :　123
Nombre à virgule flottante :123.456790
bin:　1100,　oct:　14,　hex:　c

Example3：Remplissage des nombres avec int et float

# Entier avec largeur minimale
print("{:5d}".format(12))
# La largeur n'a pas d'effet sur les nombres plus longs que le remplissage
print("{:2d}".format(1234))
# Remplissage des nombres à virgule flottante
print("{:8.3f}".format(12.2346))
# Entier avec largeur minimale de 0
print("{:=05d}".format(12))
# Alignement des nombres à virgule flottante avec remplissage par zéro
print("{:=08.3f}".format(12.2346))

Lorsque vous exécutez ce programme, la sortie sera :

　　　121234　　12.235000120012.235

Here,

• Dans la première instruction, {:5d} prend des paramètres entiers et spécifie la largeur minimale5。En l'absence de spécification de l'alignement, il est aligné à droite.

• Dans la deuxième instruction, vous pouvez voir la largeur (2）inférieur au nombre (1234），par conséquent, il n'a pas besoin de laisser d'espaces à gauche et ne tronque pas ce nombre.

• Les nombres à virgule flottante, contrairement aux entiers, ont une partie entière et une partie décimale. Et, la largeur minimale définie pour ce nombre est l'ensemble des deux parties, y compris le point.

• Dans la troisième instruction, {:8.3f} tronque la partie décimale à3digits, arrondi aux deux derniers digits. Et, le nombre est maintenant12.235，largeur totale8，garder à gauche2emplacement.

• Si vous devez remplir le reste avec des zéros, placez un zéro avant le marqueur de format. Il convient aux entiers et aux nombres à virgule flottante :{:05d} et {:08.3f}。

Example4：Formatage des nombres signés

# Affichage+signe
print("{:+f}　{:+f}".format(12.23,　-12.23))
# Affichage simple-signe
print("{:-f}　{:-f}".format(12.23,　-12.23))
# Affichage+espaces avant le signe
print("{:=f}　{:=f}".format(12.23,　-12.23))

Lorsque vous exécutez ce programme, la sortie sera :

+12.230000　-12.230000
12.230000　-12.230000　12.230000　-12.230000

Formatage des nombres avec alignement

Lorsque vous spécifiez une largeur pour un nombre, les opérateurs < et = sont utilisés pour l'alignement.^>=

Example5：Formatage des nombres à gauche, à droite et au centre

# Entier à droite
print("{:5d}".format(12))
# Nombre à virgule flottante avec alignement central
print("{:^10.3f}".format(12.2346))
# Alignement à gauche des entiers avec remplissage par zéro
print("{:<05d}".format(12))
# Alignement central du nombre à virgule flottante
print("{:=8.3f}".format(-12.2346))

Lorsque vous exécutez ce programme, la sortie sera :

　　　12　　12.235　　12000-　12.235

Attention :Pour le troisième exemple, l'alignement à gauche avec le remplissage par zéro peut poser des problèmes, cet exemple renvoie12000 au lieu de12。

Formatage de la chaîne de caractères avec format()

En tant que nombre, vous pouvez formater la chaîne de manière similaire à l'aide de format()

Example6：Formatage du texte avec remplissage et alignement

# Alignement à gauche du texte avec remplissage
print("{:5}".format("cat")).
# Alignement à droite du texte avec remplissage
print("{>}}5}".format("cat")).
# Remplissage centralisé des chaînes de caractères
print("{:^5}".format("cat")).
# Remplissage centralisé des chaînes de caractères
# Et*' caractères de remplissage
print("{:*^5}".format("cat")).

Lorsque vous exécutez ce programme, la sortie sera :

cat cat cat　*cat*

Example7：Utilisation de format() pour tronquer la chaîne de caractères

# Tronquer la chaîne de caractères en3lettres
print("{:.3}".format("caterpillar")).
# Tronquer la chaîne de caractères en3lettres
# Et remplissage
print("{:5.3}".format("caterpillar")).
# Tronquer la chaîne de caractères en3lettres,
# Remplissage et alignement central
print("{:^5.3}".format("caterpillar")).

Lorsque vous exécutez ce programme, la sortie sera :

catcat cat

Utilisation de format() pour formater les membres de la classe et du dictionnaire

Python utilise interne getattr() sous forme de " .age" pour les membres de la classe. Et il utilise __getitem__() pour trouver les membres de dictionnaire sous forme de "[index]".

Example8：Utilisation de format() pour formater les membres de la classe

# Définir la classe Person
class Person:
　　　　age =　23
　　　　name = "Adam"
# Formatage de age
print("{p.name}年龄是 : {p.age}".format(p=Person()))

Lorsque vous exécutez ce programme, la sortie sera :

Adam's 年龄是 :　23

Dans ce cas, l'objet Person est passé en tant que paramètre de mot-clé p.

Dans la chaîne de modèle, utilisez .name et .age respectivement pour accéder aux noms et âges de Person.

Example9：Utilisation de format() pour formater les membres du dictionnaire

# Définir le dictionnaire Person
person = {'age':　23, 'name': 'Adam'}
# Formatage de age
print("{p[name]}'s age is: {p[age]}".format(p=person))

Lorsque vous exécutez ce programme, la sortie sera :

Adam's age is:　23

Comme pour class, le dictionnaire person est passé en tant que paramètre de mot-clé p.

Dans la chaîne de modèle, utilisez [name] et [age] respectivement pour accéder au nom et à l'âge de la personne.

Il y a une méthode plus simple d'utiliser str.format() en Python pour formater un dictionnaire**mapping).

# Définir le dictionnaire Person
person = {'age':　23, 'name': 'Adam'}
# Formatage de age
print("{name}'s age is: {age}".format(**person))

** Est un paramètre de format (largeur minimale du champ).

Utilisation de format() comme paramètre de code de formatage

Vous pouvez également transmettre dynamiquement les codes de formatage, par exemple l'exactitude, l'alignement, le caractère de remplissage comme paramètres de position ou de mot-clé.

Example10：Utilisation de format() pour le formatage dynamique

# Dynamique chaîne de formatage
string = "{:{fill}{align}{width}}"
# Passer les codes de format en tant que paramètres
print(string.format('cat', fill='*, align='^', width=5))
# Modèle de formatage flottant dynamique
num = "\{:{align}{width}.{precision}f}"
# Passer les codes de format en tant que paramètres
print(num.format("123.236, align='<', width=8, précision=2))

When running the program, the output is:

**cat**123.24

Here,

• Dans le premier exemple, "cat" est le paramètre positionnel à formatter. De même, fill='*」，align='^' et width=5Sont les paramètres nommés.

• Dans les chaînes de caractères de modèle, ces paramètres nommés ne sont pas passés comme des chaînes de caractères normales à imprimer, mais comme des codes de format réels recherchés par fill, align et width.
  les paramètres remplacent les placeholders nommés correspondants, et la chaîne "cat" est formatée en conséquence.

• De même, dans le second exemple,123.236Sont les paramètres positionnels, et align, width et precision sont passés en tant que codes de format au chaîne de caractères de modèle.

Autres options de formatage avec format()

format() prend également en charge des options de formatage spécifiques au type, telles que le formatage des dates et des nombres complexes.

format() appelle __format__() à partir de datetime, tandis que format() accède aux propriétés du nombre complexe.

Vous pouvez facilement redéfinir la méthode __format__() de tout objet pour le formatage personnalisé.

Example11：Utiliser format() et redéfinir __format__() pour le formatage spécifique au type

import datetime
# Format de date et d'heure
date = datetime.datetime.now()
print("Heure actuelle: \{:%Y/\%m/\{%d \%H:\%M:\%S\}".format(date))
# Format des nombres complexes
complexNumber =　1+2j
print("Partie réelle: \{0.real} et partie imaginaire: \{0.imag}".format(complexNumber))
# Définir la méthode __format__ personnalisée
class Person:
　　　　def __format__(self, format):
　　　　　　　　if(format == "age"):
　　　　　　　　　　　　return ""23"
　　　　　　　　return "None"
print("L'âge d'Adam est: \{age}\".format(Person()))

When running the program, the output is:

Current time:　2020/04/17　14:33:02
Real part:　1Real part: .0 and Imaginary part:　2.0
Adam's age is:　23

Here,

• For datetime:
  The current date and time are passed as positional arguments to the format() method.
  And internally using the __format__() method, format() can access year, month, day, hour, minute, and second.

• For complex numbers:
  1 + 2j is internally converted to a ComplexNumber object.
  Then access its properties real and imag, the number is formatted.

• Rewrite __format__():
  Like datetime, you can overwrite your own __format__() method for custom formatting, which will return the age when accessed with {age}.

You can also use the __str__() and __repr__() functions of the object by using the abbreviated notation of format().

Like __format__(), you can easily rewrite the __str__() and __repr__() methods of the object.

Example12: Use the abbreviated __str__() and __repr__() of format() as !r and !s

# __str__() and __repr__() can be abbreviated as !r and !s
print("Quotes: {0!r}, Without Quotes: {0!s}".format("cat"))
# __str__() and __repr__() implementation of the class
class Person:
　　　　def __str__(self):
　　　　　　　　return "STR"
　　　　def __repr__(self):
　　　　　　　　return "REPR"
print("repr: {p!r}, str: {p!s}".format(p=Person()))

When running the program, the output is:

Quotes: 'cat', Without Quotes: cat
repr: REPR, str: STR

Python string methods