Python Language
Formatage de chaîne

Introduction

Syntaxe

• "{}". format (42) ==> "42"
• "{0}". Format (42) ==> "42"
• "{0: .2f}". Format (42) ==> "42.00"
• "{0: .0f}". Format (42.1234) ==> "42"
• "{réponse}". format (no_answer = 41, réponse = 42) ==> "42"
• "{answer: .2f}". format (no_answer = 41, réponse = 42) ==> "42.00"
• "{[clé]}". format ({'clé': 'valeur'}) ==> "valeur"
• "{[1]}". Format (['zéro', 'un', 'deux']) ==> "un"
• "{réponse} = {réponse}". format (réponse = 42) ==> "42 = 42"
• '' .join (['stack', 'overflow']) ==> "débordement de pile"

Remarques

Bases du formatage de chaînes

foo = 1
bar = 'bar'
baz = 3.14

Vous pouvez utiliser str.format pour formater la sortie. Les paires de crochets sont remplacées par des arguments dans l'ordre dans lequel les arguments sont transmis:

print('{}, {} and {}'.format(foo, bar, baz))
# Out: "1, bar and 3.14"

Les index peuvent également être spécifiés entre crochets. Les nombres correspondent aux index des arguments passés à la fonction str.format (basée sur 0).

print('{0}, {1}, {2}, and {1}'.format(foo, bar, baz))
# Out: "1, bar, 3.14, and bar"
print('{0}, {1}, {2}, and {3}'.format(foo, bar, baz))
# Out: index out of range error

Les arguments nommés peuvent également être utilisés:

print("X value is: {x_val}. Y value is: {y_val}.".format(x_val=2, y_val=3))
# Out: "X value is: 2. Y value is: 3."

Les attributs d'objet peuvent être référencés lorsqu'ils sont passés dans str.format :

class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('My value is: {0.value}'.format(my_value))  # "0" is optional
# Out: "My value is: 6"

Les clés de dictionnaire peuvent également être utilisées:

my_dict = {'key': 6, 'other_key': 7}
print("My other key is: {0[other_key]}".format(my_dict))  # "0" is optional
# Out: "My other key is: 7"

La même chose s'applique aux index de liste et de tuple:

my_list = ['zero', 'one', 'two']
print("2nd element is: {0[2]}".format(my_list))  # "0" is optional
# Out: "2nd element is: two"

Remarque: en plus de str.format , Python fournit également l'opérateur modulo % également connu sous le nom d' opérateur de formatage ou d' interpolation de chaîne (voir PEP 3101 ) - pour le formatage des chaînes. str.format est un successeur de % et offre une plus grande flexibilité, par exemple en facilitant l'exécution de multiples substitutions.

Outre les index d’argument, vous pouvez également inclure une spécification de format dans les accolades. Ceci est une expression qui suit des règles particulières et doit être précédée par deux points ( : ). Consultez la documentation pour une description complète de la spécification de format. Un exemple de spécification de format est la directive d'alignement :~^20 ( ^ représente l'alignement central, largeur totale 20, remplissage avec ~ caractère):

'{:~^20}'.format('centered')
# Out: '~~~~~~centered~~~~~~'

format permet un comportement impossible avec % , par exemple la répétition des arguments:

t = (12, 45, 22222, 103, 6)
print '{0} {2} {1} {2} {3} {2} {4} {2}'.format(*t)    
# Out: 12 22222 45 22222 103 22222 6 22222

Le format étant une fonction, il peut être utilisé comme argument dans d'autres fonctions:

number_list = [12,45,78]
print map('the number is {}'.format, number_list)
# Out: ['the number is 12', 'the number is 45', 'the number is 78']   
    

from datetime import datetime,timedelta
    
once_upon_a_time = datetime(2010, 7, 1, 12, 0, 0)
delta = timedelta(days=13, hours=8,  minutes=20)
    
gen = (once_upon_a_time + x * delta for x in xrange(5))
    
print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))
#Out: 2010-07-01 12:00:00
#     2010-07-14 20:20:00
#     2010-07-28 04:40:00
#     2010-08-10 13:00:00
#     2010-08-23 21:20:00

Alignement et remplissage

'{:~<9s}, World'.format('Hello')
# 'Hello~~~~, World'

'{:~>9s}, World'.format('Hello')
# '~~~~Hello, World'

'{:~^9s}'.format('Hello')
# '~~Hello~~'

'{:0=6d}'.format(-123)
# '-00123'

Remarque: vous pouvez obtenir les mêmes résultats en utilisant les fonctions de chaîne ljust() , rjust() , center() , zfill() , mais ces fonctions sont obsolètes depuis la version 2.5.

Format littéraux (f-string)

Chaînes de format littérales ont été introduits dans PEP 498 (Python3.6 et vers le haut), vous permettant de préfixer f au début d'une chaîne littérale pour appliquer efficacement .format à avec toutes les variables du périmètre actuel.

>>> foo = 'bar'
>>> f'Foo is {foo}'
'Foo is bar'

Cela fonctionne avec des chaînes de format plus avancées, y compris l'alignement et la notation par points.

>>> f'{foo:^7s}'
'  bar  '

Note: Le f'' ne désigne pas un type particulier comme b'' pour les bytes ou u'' pour unicode dans python2. Le formage est immédiatement appliqué, entraînant un brassage normal.

Les chaînes de format peuvent également être imbriquées :

>>> price = 478.23
>>> f"{f'${price:0.2f}':*>20s}"
'*************$478.23'

Les expressions d'une chaîne de caractères sont évaluées dans l'ordre de gauche à droite. Ceci est détectable uniquement si les expressions ont des effets secondaires:

>>> def fn(l, incr):
...    result = l[0]
...    l[0] += incr
...    return result
...
>>> lst = [0]
>>> f'{fn(lst,2)} {fn(lst,3)}'
'0 2'
>>> f'{fn(lst,2)} {fn(lst,3)}'
'5 7'
>>> lst
[10]

Formatage de chaîne avec datetime

Toute classe peut configurer sa propre syntaxe de formatage de chaîne via la méthode __format__ . Un type dans la bibliothèque Python standard qui en fait une utilisation pratique est le type datetime , où l'on peut utiliser des codes de mise en forme semblables à strftime directement dans str.format :

>>> from datetime import datetime
>>> 'North America: {dt:%m/%d/%Y}.  ISO: {dt:%Y-%m-%d}.'.format(dt=datetime.now())
'North America: 07/21/2016.  ISO: 2016-07-21.'

Une liste complète de la liste des formateurs datetime peut être trouvée dans la documentation officielle .

Format utilisant Getitem et Getattr

Toute structure de données qui prend en charge __getitem__ peut avoir sa structure imbriquée formatée:

person = {'first': 'Arthur', 'last': 'Dent'} 
'{p[first]} {p[last]}'.format(p=person) 
# 'Arthur Dent'

Les attributs d'objet sont accessibles via getattr() :

class Person(object):
    first = 'Zaphod'
    last = 'Beeblebrox'

'{p.first} {p.last}'.format(p=Person())
# 'Zaphod Beeblebrox'

Formatage flottant

>>> '{0:.0f}'.format(42.12345)
'42'

>>> '{0:.1f}'.format(42.12345)
'42.1'

>>> '{0:.3f}'.format(42.12345)
'42.123'

>>> '{0:.5f}'.format(42.12345)
'42.12345'

>>> '{0:.7f}'.format(42.12345)
'42.1234500'

Même attente pour une autre manière de référencer:

>>> '{:.3f}'.format(42.12345)
'42.123'

>>> '{answer:.3f}'.format(answer=42.12345)
'42.123'

Les nombres à virgule flottante peuvent également être formatés en notation scientifique ou en pourcentage:

>>> '{0:.3e}'.format(42.12345)
'4.212e+01'

>>> '{0:.0%}'.format(42.12345)
'4212%'

Vous pouvez également combiner les notations {0} et {name} . Ceci est particulièrement utile lorsque vous souhaitez arrondir toutes les variables à un nombre prédéfini de décimales avec une déclaration :

>>> s = 'Hello'
>>> a, b, c = 1.12345, 2.34567, 34.5678
>>> digits = 2

>>> '{0}! {1:.{n}f}, {2:.{n}f}, {3:.{n}f}'.format(s, a, b, c, n=digits)
'Hello! 1.12, 2.35, 34.57'

Formatage des valeurs numériques

La méthode .format() peut interpréter un nombre sous différents formats, tels que:

>>> '{:c}'.format(65)    # Unicode character
'A'

>>> '{:d}'.format(0x0a)  # base 10
'10'

>>> '{:n}'.format(0x0a)  # base 10 using current locale for separators
'10'

Formater les entiers en différentes bases (hexadécimal, oct, binaire)

>>> '{0:x}'.format(10) # base 16, lowercase - Hexadecimal
'a'

>>> '{0:X}'.format(10) # base 16, uppercase - Hexadecimal
'A'

>>> '{:o}'.format(10) # base 8 - Octal
'12'

>>> '{:b}'.format(10) # base 2 - Binary
'1010'

>>> '{0:#b}, {0:#o}, {0:#x}'.format(42) # With prefix
'0b101010, 0o52, 0x2a'

>>> '8 bit: {0:08b}; Three bytes: {0:06x}'.format(42) # Add zero padding
'8 bit: 00101010; Three bytes: 00002a'

Utilisez le formatage pour convertir un tuple flottant RVB en une chaîne hexadécimale couleur:

>>> r, g, b = (1.0, 0.4, 0.0)
>>> '#{:02X}{:02X}{:02X}'.format(int(255 * r), int(255 * g), int(255 * b))
'#FF6600'

Seuls les entiers peuvent être convertis:

>>> '{:x}'.format(42.0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Unknown format code 'x' for object of type 'float'

Formatage personnalisé pour une classe

Remarque:

Tout ce qui suit s'applique à la méthode str.format , ainsi qu'à la fonction de format . Dans le texte ci-dessous, les deux sont interchangeables.

Pour chaque valeur transmise à la fonction format , Python recherche une méthode __format__ pour cet argument. Votre propre classe personnalisée peut donc avoir sa propre méthode __format__ pour déterminer comment la fonction de format affichera et formatera votre classe et ses attributs.

Ceci est différent de la méthode __str__ , car dans la méthode __format__ , vous pouvez prendre en compte le langage de formatage, y compris l'alignement, la largeur des champs, et même (si vous le souhaitez) implémenter vos propres spécificateurs de format et vos propres extensions de langage de formatage. 1

object.__format__(self, format_spec)

Par exemple :

# Example in Python 2 - but can be easily applied to Python 3

class Example(object):
    def __init__(self,a,b,c):
        self.a, self.b, self.c = a,b,c

    def __format__(self, format_spec):
        """ Implement special semantics for the 's' format specifier """
        # Reject anything that isn't an s
        if format_spec[-1] != 's':
            raise ValueError('{} format specifier not understood for this object', format_spec[:-1])

        # Output in this example will be (<a>,<b>,<c>)
        raw = "(" + ",".join([str(self.a), str(self.b), str(self.c)]) + ")"
        # Honor the format language by using the inbuilt string format
        # Since we know the original format_spec ends in an 's' 
        # we can take advantage of the str.format method with a 
        # string argument we constructed above
        return "{r:{f}}".format( r=raw, f=format_spec )

inst = Example(1,2,3)
print "{0:>20s}".format( inst )
# out :              (1,2,3)
# Note how the right align and field width of 20 has been honored.

Remarque:

Si votre classe personnalisée n'a pas une coutume __format__ méthode et une instance de la classe est passée à la format fonction, python2 utilisera toujours la valeur de retour de la __str__ méthode ou __repr__ méthode pour déterminer ce qu'il faut imprimer (et si elles existent ni alors la default repr sera utilisé), et vous devrez utiliser le spécificateur de format s pour le formater. Avec Python3 , pour passer votre classe personnalisée à la fonction format , vous aurez besoin de définir la méthode __format__ sur votre classe personnalisée.

Format imbriqué

Certains formats peuvent prendre des paramètres supplémentaires, tels que la largeur de la chaîne formatée ou l'alignement:

>>> '{:.>10}'.format('foo')
'.......foo'

Ceux-ci peuvent également être fournis en tant que paramètres à format en imbriquant plus {} dans le {} :

>>> '{:.>{}}'.format('foo', 10)
'.......foo'
'{:{}{}{}}'.format('foo', '*', '^', 15)
'******foo******'

Dans ce dernier exemple, la chaîne de format '{:{}{}{}}' est modifiée en '{:*^15}' (c.-à-d. Centre et pavé avec * pour une longueur totale de 15 ") avant de l'appliquer au chaîne réelle 'foo' à formater de cette façon.

Cela peut être utile dans les cas où les paramètres ne sont pas connus à l'avance, pour les instances lors de l'alignement des données tabulaires:

>>> data = ["a", "bbbbbbb", "ccc"]
>>> m = max(map(len, data))
>>> for d in data:
...     print('{:>{}}'.format(d, m))
      a
bbbbbbb
    ccc

Cordes de rembourrage et de troncature, combinées

Supposons que vous souhaitiez imprimer des variables dans une colonne de 3 caractères.

Note: doubler { et } leur échappe.

s = """

pad
{{:3}}             :{a:3}:

truncate
{{:.3}}            :{e:.3}:

combined
{{:>3.3}}          :{a:>3.3}:
{{:3.3}}           :{a:3.3}:
{{:3.3}}           :{c:3.3}:
{{:3.3}}           :{e:3.3}:
"""

print (s.format(a="1"*1, c="3"*3, e="5"*5))

Sortie:

pad
{:3}             :1  :

truncate
{:.3}            :555:

combined
{:>3.3}          :  1:
{:3.3}           :1  :
{:3.3}           :333:
{:3.3}           :555:

Espaces réservés nommés

Les chaînes de format peuvent contenir des marqueurs nommés qui sont interpolées en utilisant des arguments de mots clés pour le format .

Utiliser un dictionnaire (Python 2.x)

>>> data = {'first': 'Hodor', 'last': 'Hodor!'}
>>> '{first} {last}'.format(**data)
'Hodor Hodor!'

Utiliser un dictionnaire (Python 3.2+)

>>> '{first} {last}'.format_map(data)
'Hodor Hodor!'

str.format_map permet d'utiliser des dictionnaires sans avoir à les déballer en premier. De plus, la classe de data (qui peut être un type personnalisé) est utilisée à la place d'un dict nouvellement rempli.

Sans dictionnaire:

>>> '{first} {last}'.format(first='Hodor', last='Hodor!')
'Hodor Hodor!'