Introduction détaillée au formatage de chaîne str.format en Python

Préface

Python a ajouté une nouvelle méthode de formatage de chaîne dans la version 2.6 : str.format() . Sa syntaxe de base consiste à remplacer le % précédent par {} et :.

Syntaxe des espaces réservés lors du formatage :

replacement_field ::= "{" [field_name] ["!" conversion] [":" format_spec] "}"

" mappage "Règle

peut accepter des paramètres illimités via la position

str.format() , et les positions peuvent être dans le désordre :

>>> "{0} {1}".format("hello", "world")
'hello world'
>>> "{} {}".format("hello", "world")
'hello world'
>>> "{1} {0} {1}".format("hello", "world")
'world hello world'

Par paramètres de mot-clé

Lors de l'utilisation de paramètres clés, le nom du paramètre doit être fourni dans la chaîne :

>>> "I am {name}, age is {age}".format(name="huoty", age=18)
'I am huoty, age is 18'
>>> user = {"name": "huoty", "age": 18}
>>> "I am {name}, age is {age}".format(**user)
'I am huoty, age is 18'

Les propriétés de l'utilisateur peuvent être lues directement via les propriétés de l'objet

str.format()  :

>>> class User(object):
...  def __init__(self, name, age):
...   self.name = name
...   self.age = age
...
...  def __str__(self):
...   return "{self.name}({self.age})".format(self=self)
...
...  def __repr__(self):
...   return self.__str__()
...
...
>>> user = User("huoty", 18)
>>> user
huoty(18)
>>> "I am {user.name}, age is {user.age}".format(user=user)
'I am huoty, age is 18'

Par indice

Les éléments sont accessibles en indice à l'intérieur de la chaîne qui doit être formatée :

>>> names, ages = ["huoty", "esenich", "anan"], [18, 16, 8]
>>> "I am {0[0]}, age is {1[2]}".format(names, ages)
'I am huoty, age is 8'
>>> users = {"names": ["huoty", "esenich", "anan"], "ages": [18, 16, 8]}
>>> "I am {names[0]}, age is {ages[0]}".format(**users)

Spécifier la conversion

Vous pouvez spécifier le type de conversion de la chaîne :

conversion ::= "r" | "s" | "a"

Où "!r" correspond à repr(); "!s" correspond à str(); "!a" correspond à ascii(). Exemple :

>>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')
"repr() shows quotes: 'test1'; str() doesn't: test2"

Qualificateurs de format

Remplissage et alignement

Le rembourrage est souvent utilisé avec l'alignement. ^, <, > sont respectivement centrés, alignés à gauche et alignés à droite, suivis de la largeur, et le caractère suivi de : est rempli d'un seul caractère. S'il n'est pas spécifié, il sera rempli d'espaces par défaut.

>>> "{:>8}".format("181716")
' 181716'
>>> "{:0>8}".format("181716")
'00181716'
>>> "{:->8}".format("181716")
'--181716'
>>> "{:-<8}".format("181716")
'181716--'
>>> "{:-^8}".format("181716")
'-181716-'
>>> "{:-<25}>".format("Here ")
'Here -------------------->'

Précision à virgule flottante

Utilisez f pour représenter le type à virgule flottante, et vous pouvez l'ajouter devant lui Contrôle de précision :

>>> "[ {:.2f} ]".format(321.33345)
'[ 321.33 ]'
>>> "[ {:.1f} ]".format(321.33345)
'[ 321.3 ]'
>>> "[ {:.4f} ]".format(321.33345)
'[ 321.3335 ]'
>>> "[ {:.4f} ]".format(321)
'[ 321.0000 ]'

Vous pouvez également spécifier un symbole pour les nombres à virgule flottante, ce qui signifie afficher avant les nombres positifs et - avant les nombres négatifs ; (espace) signifie afficher avant les nombres positifs Ajouter un espace avant un nombre, ajouter - avant un nombre négatif - est cohérent avec ne rien ajouter ({:f}):

>>> '{:+f}; {:+f}'.format(3.141592657, -3.141592657)
'+3.141593; -3.141593'
>>> '{: f}; {: f}'.format(3.141592657, -3.141592657)
' 3.141593; -3.141593'
>>> '{:f}; {:f}'.format(3.141592657, -3.141592657)
'3.141593; -3.141593'
>>> '{:-f}; {:-f}'.format(3.141592657, -3.141592657)
'3.141593; -3.141593'
>>> '{:+.4f}; {:+.4f}'.format(3.141592657, -3.141592657)
'+3.1416; -3.1416'

Spécifier la base

>>> "int: {0:d}; hex: {0:x}; oct: {0:o}; bin: {0:b}".format(18)
'int: 18; hex: 12; oct: 22; bin: 10010'
>>> "int: {0:d}; hex: {0:#x}; oct: {0:#o}; bin: {0:#b}".format(18)
'int: 18; hex: 0x12; oct: 0o22; bin: 0b10010'

Séparateur de milliers

Vous pouvez utiliser "," pour séparer les milliers :

>>> '{:,}'.format(1234567890)
'1,234,567,890'

Affichage du pourcentage

>>> "progress: {:.2%}".format(19.88/22)
'progress: 90.36%'

En fait, le format prend également en charge davantage de symboles de type :

type ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

Autre conseils

Imbrication d'espaces réservés

Parfois, l'imbrication d'espaces réservés est toujours utile :

>>> '{0:{fill}{align}16}'.format("hello", fill='*', align='^')
'*****hello******'
>>>
>>> for num in range(5,12):
...  for base in "dXob":
...   print("{0:{width}{base}}".format(num, base=base, width=5), end=' ')
...  print()
...
...
 5  5  5 101
 6  6  6 110
 7  7  7 111
 8  8 10 1000
 9  9 11 1001
 10  A 12 1010
 11  B 13 1011

Utilisé comme fonction

Vous ne pouvez pas spécifier les paramètres de format en premier, mais l'appeler comme fonction à un endroit inutile :

>>> email_f = "Your email address was {email}".format
>>> print(email_f(email="suodhuoty@gmail.com"))
Your email address was sudohuoty@gmail.com

Accolades d'échappement

Lorsque vous devez utiliser des accolades dans une chaîne, vous pouvez utiliser des accolades pour échapper :

>>> " The {} set is often represented as { {0} } ".format("empty")
' The empty set is often represented as {0} '

Pour une introduction plus détaillée au formatage de chaîne str.format en Python et aux articles connexes, veuillez faire attention au site Web PHP chinois !