Conversion de format en Python, format (remplissage du zéro, notation exponentielle, hexadécimal, etc.)

Affaires

Pour convertir (formater) un nombre ou une chaîne dans différents formats en Python, utilisez la fonction intégrée format() ou la méthode str.format().

Dans cette section, nous allons expliquer comment utiliser les fonctions suivantes.

  • fonction intégrée (par exemple, dans un langage de programmation)format()
  • méthode des chaînesstr.format()

En outre, la chaîne de spécification de format pour la conversion au format suivant est expliquée avec un exemple de code.

  • Justifié à gauche, Justifié au centre, Justifié à droite
  • remplissage zéro
  • Signe (plus ou moins)
  • Séparateur de chiffres (virgule, trait de soulignement)
  • Nombres binaires, octaux et hexadécimaux
  • Indiquez le nombre de chiffres après le point décimal.
  • Chiffres significatifs (nombre de chiffres significatifs)
  • notation exponentielle
  • Affichage des pourcentages

Notez que depuis Python 3.6, les chaînes f (f-strings) ont été ajoutées à la méthode string str.format() pour la rendre plus concise.

Fonction intégrée : format()

format() est fourni comme une fonction intégrée standard de Python.

Le plan est le suivant.

  • format(value, format_spec)
    • Le premier argument : levalue
      La valeur originale. String str, number int, float, etc.
    • Le deuxième argumentformat_spec
      Chaîne de spécifications de format. Chaîne str
    • Valeur de retour : une chaîne de caractères formatée str

Des exemples sont présentés ci-dessous. Les types de chaînes de format et la manière de les écrire sont décrits plus loin.

Dans cet exemple, nous avons utilisé des littéraux numériques et des littéraux de chaînes de caractères comme premier argument, mais vous pouvez bien sûr utiliser des variables qui contiennent ces valeurs.

s = format(255, '04x')
print(s)
print(type(s))
# 00ff
# <class 'str'>

print(format('center', '*^16'))
# *****center*****

Méthode pour les chaînes de caractères str.format()

Il existe également une méthode format() pour le type string.

Le {} dans la chaîne de caractères str qui appelle la méthode format() est appelé le champ de substitution, et est remplacé par l'argument de la méthode format().

La chaîne de spécification du format doit être écrite dans le champ de substitution {} suivi de ” :”.

La valeur de retour est une chaîne de caractères formatée str.

Le processus équivalent à la fonction intégrée format() décrite ci-dessus est le suivant.

s = '{:04x}'.format(255)
print(s)
print(type(s))
# 00ff
# <class 'str'>

print('{:*^16}'.format('center'))
# *****center*****

Encore une fois, nous utilisons des littéraux numériques et des littéraux de chaînes de caractères comme arguments, mais bien sûr, les variables sont également acceptables.

Spécification des arguments pour les champs de substitution

Spécifier les arguments dans l'ordre (par défaut)

Il peut y avoir plusieurs champs de substitution {}, et par défaut, les arguments de la méthode sont traités dans l'ordre. Si la chaîne de spécification du format dans {} est omise, elle sera simplement convertie en chaîne par str().

Utile pour insérer des valeurs variables dans une chaîne de caractères et les imprimer.

print('{}-{}-{}'.format('100', '二百', 300))
# 100-二百-300

Spécifier un argument positionnel pour les valeurs entières

Si une valeur entière est spécifiée dans {}, comme {0} ou {1}, la sortie dépendra de l'ordre des arguments. Le même nombre peut être utilisé à plusieurs reprises. Ceci est utile lorsque vous souhaitez insérer la même valeur dans une chaîne de caractères.

print('{0}-{1}-{0}'.format('foo', 'bar'))
# foo-bar-foo

Spécifier des arguments de mots-clés pour des noms arbitraires (chaînes de caractères)

Vous pouvez également spécifier n'importe quel nom dans {} et le saisir comme argument de mot-clé.

print('{day}/{month}/{year}/'.format(day=11, month=1, year=2018))
# 11/1/2018

Spécifier une liste ou un dictionnaire comme argument

Les listes et les dictionnaires peuvent être spécifiés comme arguments.

Utilisez [] pour spécifier l'index d'une liste ou la clé d'un dictionnaire dans un champ de substitution. Notez que les guillemets “'” et “” ne sont pas utilisés pour spécifier des clés de dictionnaire.

Si vous voulez utiliser le même argument à plusieurs reprises, vous devez spécifier une valeur entière ou une chaîne de caractères (nom) comme décrit ci-dessus.

l = ['one', 'two', 'three']
print('{0[0]}-{0[1]}-{0[2]}'.format(l))
# one-two-three

d1 = {'name': 'Alice', 'age': 20}
d2 = {'name': 'Bob', 'age': 30}
print('{0[name]} is {0[age]} years old.\n{1[name]} is {1[age]} years old.'.format(d1, d2))
# Alice is 20 years old.
# Bob is 30 years old.

Il peut être développé en tant qu'argument positionnel en ajoutant * à la liste et en le spécifiant comme argument, ou en tant qu'argument de mot-clé en ajoutant ** au dictionnaire et en le spécifiant comme argument.

l = ['one', 'two', 'three']
print('{}-{}-{}'.format(*l))
# one-two-three

d = {'name': 'Alice', 'age': 20}
print('{name} is {age} years old.'.format(**d))
# Alice is 20 years old.

Description des accolades {}

Si vous voulez écrire des accolades {,} dans la méthode format(), répétez-le deux fois comme {{,}}. Notez que les barres obliques inversées ne peuvent pas être échappées.

print('{{}}-{num}-{{{num}}}'.format(num=100))
# {}-100-{100}

chaîne formatée

Dans les deux cas, pour spécifier le format, écrivez “:chaîne de format” après la valeur entière ou la chaîne de nom dans {}.

print('{num:x}'.format(num=255))
# ff

print('{day}/{month:02}/{year:02}/'.format(day=11, month=1, year=2018))
# 11/01/2018

Dans ce qui suit, nous allons expliquer comment spécifier le format en utilisant une chaîne de format. L'exemple de code utilise la méthode str.format(), mais la même chaîne de format peut être utilisée avec la fonction intégrée format(). Dans la fonction intégrée format(), la chaîne de spécification du format est spécifiée comme deuxième argument.

Justifié à gauche, Justifié au centre, Justifié à droite

Vous pouvez aligner en bas à gauche, au centre, à droite, etc. Spécifiez le nombre total de caractères sous forme de nombre.

  • <
  • ^
  • >
print('left  : {:<10}'.format(100))
print('center: {:^10}'.format(100))
print('right : {:>10}'.format(100))
# left  : 100       
# center:    100    
# right :        100

Vous pouvez également spécifier un caractère à remplir. S'il est omis, comme dans l'exemple ci-dessus, il s'agit d'un espace.

Vous pouvez utiliser des caractères à deux octets, à condition qu'il s'agisse d'un seul caractère.

print('left  : {:*<10}'.format(100))
print('center: {:a^10}'.format(100))
print('right : {:鬼>10}'.format(100))
# left  : 100*******
# center: aaa100aaaa
# right : 鬼鬼鬼鬼鬼鬼鬼100

La justification à droite avec > ne tient pas compte du signe (-,+). Si vous utilisez =, le signe est suivi du caractère spécifié. Si vous voulez spécifier +, écrivez + après =. Les détails du traitement du signe sont décrits plus loin.

print('sign: {:0>10}'.format(-100))
print('sign: {:0=10}'.format(-100))
print('sign: {:0=+10}'.format(100))
# sign: 000000-100
# sign: -000000100
# sign: +000000100

<, ^ et > peuvent être spécifiés pour les chaînes de caractères, mais = entraînera une erreur ValueError. Si vous voulez utiliser = pour une chaîne de caractères, vous devez la convertir en un nombre à l'aide de int().

# print('sign: {:0=10}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

print('sign: {:0=10}'.format(int('-100')))
# sign: -000000100

Il en va de même pour les nombres à virgule flottante. Les points décimaux sont également comptés comme un caractère.

print('left  : {:*<10}'.format(1.23))
print('center: {:a^10}'.format(1.23))
print('right : {:鬼>10}'.format(1.23))
# left  : 1.23******
# center: aaa1.23aaa
# right : 鬼鬼鬼鬼鬼鬼1.23

print('sign: {:0>10}'.format(-1.23))
print('sign: {:0=10}'.format(-1.23))
print('sign: {:0=+10}'.format(1.23))
# sign: 00000-1.23
# sign: -000001.23
# sign: +000001.23

Les listes, les tuples, etc. provoqueront une erreur s'ils sont spécifiés tels quels, et peuvent être convertis en chaînes de caractères en utilisant str().

l = [0, 1]
print(type(l))
# <class 'list'>

# print('{:*^16}'.format(l))
# TypeError: unsupported format string passed to list.__format__

print(type(str(l)))
# <class 'str'>

print('{:*^16}'.format(str(l)))
# *****[0, 1]*****

Pour l'ajustement à gauche, l'ajustement au centre et l'ajustement à droite, il existe également des méthodes dédiées aux chaînes de caractères appelées ljust(), center() et rjust().

0 remplissage

Si vous voulez ajuster le nombre de chiffres en remplissant le zéro, mettez le caractère à remplir à 0 et justifiez-le à droite.

Dans le cas du remplissage du zéro, si le symbole d'alignement est omis, il est traité comme si = était spécifié.

print('zero padding: {:0=10}'.format(100))
print('zero padding: {:010}'.format(100))
# zero padding: 0000000100
# zero padding: 0000000100

print('zero padding: {:0=10}'.format(-100))
print('zero padding: {:010}'.format(-100))
# zero padding: -000000100
# zero padding: -000000100

=Si vous spécifiez une chaîne de caractères comme argument, comme décrit ci-dessus, vous obtiendrez une erreur. Soyons prudents.

# print('zero padding: {:010}'.format('-100'))
# ValueError: '=' alignment not allowed in string format specifier

Pour le remplissage du zéro, il existe également une méthode dédiée aux chaînes de caractères appelée zfill().

Signe (plus ou moins)

Par défaut, seuls les nombres négatifs sont marqués d'un signe (moins-).

Lorsque + est ajouté à la chaîne de spécification de formatage, un signe (plus +) est également affiché pour les nombres positifs. Si un espace est ajouté, un espace est affiché au début du nombre positif, et le nombre de chiffres est aligné sur le nombre négatif.

print('sign: {}'.format(100))
print('sign: {}'.format(-100))
# sign: 100
# sign: -100

print('sign: {:+}'.format(100))
print('sign: {:+}'.format(-100))
# sign: +100
# sign: -100

print('sign: {: }'.format(100))
print('sign: {: }'.format(-100))
# sign:  100
# sign: -100

Soyez prudent lorsque vous remplissez avec des caractères arbitraires, comme le remplissage de zéro mentionné ci-dessus. La valeur par défaut, sans + et sans espace, remplit les nombres positifs avec un caractère supplémentaire.

print('sign: {:06}'.format(100))
print('sign: {:06}'.format(-100))
# sign: 000100
# sign: -00100

print('sign: {:+06}'.format(100))
print('sign: {:+06}'.format(-100))
# sign: +00100
# sign: -00100

print('sign: {: 06}'.format(100))
print('sign: {: 06}'.format(-100))
# sign:  00100
# sign: -00100

Si un symbole d'alignement est utilisé, le symbole de désignation du signe doit être écrit après le symbole d'alignement.

print('sign: {:_>6}'.format(100))
print('sign: {:_>6}'.format(-100))
# sign: ___100
# sign: __-100

print('sign: {:_>+6}'.format(100))
print('sign: {:_>+6}'.format(-100))
# sign: __+100
# sign: __-100

print('sign: {:_> 6}'.format(100))
print('sign: {:_> 6}'.format(-100))
# sign: __ 100
# sign: __-100

Séparateur de chiffres (virgule, trait de soulignement)

Ajoutez une virgule ou un trait de soulignement _ comme séparateur tous les trois chiffres. Cela rend les grands nombres plus faciles à lire. Notez que underscore_ est une option ajoutée dans Python 3.6, elle ne peut donc pas être utilisée dans les versions antérieures.

print('{:,}'.format(100000000))
# 100,000,000

print('{:_}'.format(100000000))
# 100_000_000

Dans le cas des nombres à virgule flottante de type float, seule la partie entière est délimitée.

print('{:,}'.format(1234.56789))
# 1,234.56789

Nombres binaires, octaux et hexadécimaux

Convertit les valeurs numériques en nombres binaires, octaux et hexadécimaux pour la sortie.

  • b: Binaire
  • o: Octal
  • d: Décimal
  • x,X: Hexadécimal (les lettres majuscules sont en majuscules)
print('bin: {:b}'.format(255))
print('oct: {:o}'.format(255))
print('dec: {:d}'.format(255))
print('hex: {:x}'.format(255))
print('HEX: {:X}'.format(255))
# bin: 11111111
# oct: 377
# dec: 255
# hex: ff
# HEX: FF

Il peut également être combiné avec le remplissage 0, et est souvent utilisé pour aligner les chiffres en notation binaire et hexadécimale.

print('bin: {:08b}'.format(255))
print('oct: {:08o}'.format(255))
print('dec: {:08d}'.format(255))
print('hex: {:08x}'.format(255))
print('HEX: {:08X}'.format(255))
# bin: 11111111
# oct: 00000377
# dec: 00000255
# hex: 000000ff
# HEX: 000000FF

Notez que le nombre de caractères de remplissage doit être spécifié en tenant compte du préfixe.

print('bin: {:#010b}'.format(255))
print('oct: {:#010o}'.format(255))
print('dec: {:#010d}'.format(255))
print('hex: {:#010x}'.format(255))
print('HEX: {:#010X}'.format(255))
# bin: 0b11111111
# oct: 0o00000377
# dec: 0000000255
# hex: 0x000000ff
# HEX: 0X000000FF

Pour les nombres binaires et hexadécimaux, seul le séparateur de chiffres underscore _ peut être inséré (Python 3.6 ou ultérieur). Le séparateur à 4 chiffres est utilisé ; le nombre de caractères remplis de zéros doit également tenir compte du nombre de traits de soulignement.

print('hex: {:08x}'.format(255))
print('hex: {:09_x}'.format(255))
print('hex: {:#011_x}'.format(255))
# hex: 000000ff
# hex: 0000_00ff
# hex: 0x0000_00ff

Seul le type int peut convertir le format en binaire ou en hexadécimal. Vous pouvez utiliser int() pour le convertir en un nombre.

# print('hex: {:08x}'.format('255'))
# ValueError: Unknown format code 'X' for object of type 'str'

print('hex: {:08x}'.format(int('255')))
# hex: 000000ff

Indiquez le nombre de chiffres après le point décimal.

Pour spécifier le nombre de chiffres après la virgule, procédez comme suit : n est le nombre de chiffres. Le nombre de chiffres après la virgule devient le nombre de chiffres spécifié, quel que soit le nombre de chiffres de la partie entière.
.[n]f

print('{:.2f}'.format(123.456))
print('{:.5f}'.format(123.456))
print('{:.3f}'.format(0.0001234))
# 123.46
# 123.45600
# 0.000

Le côté gauche du point décimal peut être spécifié comme étant justifié à gauche, justifié au centre, justifié à droite ou rempli de zéro, comme décrit ci-dessus. Si le nombre de chiffres de la valeur cible est supérieur au nombre spécifié, rien n'est fait. Si le nombre de chiffres de la valeur cible est supérieur au nombre de chiffres spécifié, rien n'est fait.

print('{:>12.5f}'.format(123.456))
print('{:012.5f}'.format(123.456))
print('{:06.5f}'.format(123.456))
#    123.45600
# 000123.45600
# 123.45600

Si vous spécifiez un nombre de chiffres inférieur au nombre original de chiffres après la virgule, la valeur sera arrondie. Notez qu'il ne s'agit pas d'un arrondi au nombre entier le plus proche, mais à un nombre pair, par exemple, 0,5 est arrondi à 0.

print('{:.0f}'.format(0.4))
print('{:.0f}'.format(0.5))
print('{:.0f}'.format(0.6))
# 0
# 0
# 1

Si vous souhaitez utiliser un arrondi général, vous pouvez utiliser la méthode quantize() de la bibliothèque standard decimal.

notation exponentielle

Lorsqu'un nombre flottant de type float est converti en une chaîne de caractères str, il est automatiquement écrit en notation exponentielle en fonction du nombre de chiffres. Ce n'est pas le cas pour les nombres entiers de type int.

print('{}'.format(0.0001234))
print('{}'.format(0.00001234))
# 0.0001234
# 1.234e-05

print('{}'.format(1234000000000000.0))
print('{}'.format(12340000000000000.0))
print('{}'.format(12340000000000000000000000))
# 1234000000000000.0
# 1.234e+16
# 12340000000000000000000000

Si vous spécifiez e ou E dans la chaîne de spécification de formatage, vous pouvez toujours convertir en notation exponentielle. Les caractères utilisés dans la sortie seront e et E, respectivement.

print('{:e}'.format(0.0001234))
print('{:E}'.format(0.0001234))
# 1.234000e-04
# 1.234000E-04

Il est également possible de spécifier le nombre de chiffres après le point décimal. La partie entière sera toujours à un chiffre et le point décimal sera le nombre de chiffres spécifié.

print('{:.5e}'.format(0.0001234))
print('{:.2E}'.format(0.0001234))
# 1.23400e-04
# 1.23E-04

print('{:.5e}'.format(987.65))
print('{:.2E}'.format(987.65))
# 9.87650e+02
# 9.88E+02

Notez que si vous spécifiez justifié à gauche, justifié au centre, justifié à droite ou rempli de zéro, e-, E+, etc. seront également comptés comme des chiffres (caractères).

print('{:>12.5e}'.format(987.65))
print('{:012.2E}'.format(987.65))
#  9.87650e+02
# 00009.88E+02

Chiffres significatifs (nombre de chiffres significatifs)

Vous pouvez spécifier le nombre total de chiffres en procédant comme suit Selon le résultat, la notation exponentielle sera utilisée automatiquement. Notez que les zéros de queue après le point décimal seront omis.
.[n]g

print('{:.2g}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.3g}'.format(0.0001234))
# 1.2e+02
# 123
# 123.456
# 0.000123

Si vous omettez g, la sortie ne sera pas un nombre entier. g est le même dans la plupart des cas, mais seulement dans les cas où la sortie est un nombre entier.

print('{:.2}'.format(123.456))
print('{:.3}'.format(123.456))
print('{:.8}'.format(123.456))
print('{:.3}'.format(0.0001234))
# 1.2e+02
# 1.23e+02
# 123.456
# 0.000123

Si nous traitons la même valeur, nous obtenons respectivement les résultats suivants.

print('{:.3f}'.format(123.456))
print('{:.3e}'.format(123.456))
print('{:.3g}'.format(123.456))
print('{:.3}'.format(123.456))
# 123.456
# 1.235e+02
# 123
# 1.23e+02

print('{:.8f}'.format(123.456))
print('{:.8e}'.format(123.456))
print('{:.8g}'.format(123.456))
print('{:.8}'.format(123.456))
# 123.45600000
# 1.23456000e+02
# 123.456
# 123.456

Dans le cas de g ou s'il est omis, les zéros de queue après le point décimal sont omis, donc si vous voulez produire le même nombre de chiffres significatifs (nombre de chiffres significatifs), utilisez la notation exponentielle de e ou E. La partie entière est toujours un chiffre et le point décimal est le nombre de chiffres spécifié, donc si vous voulez produire n chiffres significatifs, spécifiez simplement n-1.

print('{:.4e}'.format(123.456))
print('{:.4e}'.format(0.000012345))
print('{:.4e}'.format(12))
# 1.2346e+02
# 1.2345e-05
# 1.2000e+01

Affichage des pourcentages

Si % est spécifié dans la chaîne de spécification de formatage, la valeur du flottant numérique ou de l'int est multipliée par 100 et convertie en chaîne avec %.

Il est également possible de spécifier le nombre de chiffres après la virgule. La valeur par défaut est de six chiffres après la virgule. Les options suivantes sont également disponibles : left-justify, center-justify, right-justify et zero-fill. Le % est également compté comme un caractère.

print('{:%}'.format(0.12345))
print('{:.2%}'.format(0.12345))
# 12.345000%
# 12.35%

print('{:%}'.format(10))
print('{:.2%}'.format(10))
# 1000.000000%
# 1000.00%

print('{:>7.2%}'.format(0.12345))
print('{:07.2%}'.format(0.12345))
#  12.35%
# 012.35%