Преобразование форматов в Python, формат (заполнение нулями, экспоненциальная нотация, шестнадцатеричная и т.д.)

Бизнес

Чтобы преобразовать (отформатировать) число или строку в различные форматы в Python, используйте встроенную функцию format() или строковый метод str.format().

В этом разделе мы объясним, как использовать следующие функции.

  • встроенная функция (например, в языке программирования)format()
  • строковый методstr.format()

Кроме того, строка спецификации формата для преобразования в следующий формат объясняется с помощью примера кода.

  • Выравнивание по левому краю, Выравнивание по центру, Выравнивание по правому краю
  • нулевое заполнение
  • Знак (плюс или минус)
  • Разделитель цифр (запятая, знак подчеркивания)
  • Двоичные, восьмеричные и шестнадцатеричные числа
  • Укажите количество цифр после десятичной точки
  • Значимые цифры (количество значащих цифр)
  • экспоненциальная нотация
  • Отображение в процентах

Обратите внимание, что начиная с Python 3.6 в строковый метод str.format() были добавлены f-строки (f-строки), чтобы сделать его более лаконичным.

Встроенная функция: format()

format() предоставляется как стандартная встроенная функция Python.

В общих чертах это выглядит следующим образом.

  • format(value, format_spec)
    • Первый аргумент:value
      Исходное значение. Строка str, число int, float и т.д.
    • Второй аргументformat_spec
      Строка спецификации формата. Строка str
    • Возвращаемое значение: форматированная строка str

Примеры показаны ниже. Типы форматных строк и способы их записи описаны далее.

В этом примере в качестве первого аргумента мы использовали числовые литералы и строковые литералы, но, конечно, вы можете использовать переменные, содержащие эти значения.

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

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

Метод строк str.format()

Существует также метод format() для типа string str.

Поле {} в строке str, вызывающей метод format(), называется полем подстановки и заменяется аргументом метода format().

Строка спецификации формата должна быть записана в поле подстановки {}, за которым следует «:».

Возвращаемое значение — отформатированная строка str.

Процесс, эквивалентный описанной выше встроенной функции format(), выглядит следующим образом.

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

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

Опять же, в качестве аргументов мы используем числовые литералы и строковые литералы, но, конечно, переменные также допустимы.

Указание аргументов для полей подстановки

Укажите аргументы по порядку (по умолчанию)

Полей подстановки {} может быть несколько, и по умолчанию аргументы метода обрабатываются по порядку. Если строка спецификации формата в {} опущена, она будет просто преобразована в строку с помощью функции str().

Используется для вставки значений переменных в строку и их печати.

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

Укажите позиционный аргумент для целочисленных значений

Если в {} указано целочисленное значение, например {0} или {1}, вывод будет зависеть от порядка аргументов. Одно и то же число можно использовать многократно. Это полезно, когда вы хотите вставить одно и то же значение в строку.

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

Укажите аргументы ключевых слов для произвольных имен (строк)

Вы также можете указать любое имя в {} и ввести его в качестве аргумента ключевого слова.

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

Укажите список или словарь в качестве аргумента

В качестве аргументов могут быть указаны списки и словари.

Используйте [], чтобы указать индекс списка или ключ словаря в поле подстановки. Обратите внимание, что кавычки «'» и «» не используются для указания ключей словаря.

Если вы хотите использовать один и тот же аргумент многократно, вам необходимо указать целочисленное значение или строку (имя), как описано выше.

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.

Его можно расширить как позиционный аргумент, добавив * к списку и указав его в качестве аргумента, или как аргумент ключевого слова, добавив ** к словарю и указав его в качестве аргумента.

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.

Описание фигурных скобок {}

Если вы хотите написать фигурные скобки {,} в методе format(), повторите его дважды, как {{,}}. Обратите внимание, что обратные косые черты не могут быть экранированы.

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

форматированная строка

В обоих случаях, чтобы указать формат, напишите «:строка формата» после целочисленного значения или строки имени в {}.

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

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

Далее мы расскажем, как задать формат с помощью строки формата. В коде примера используется строковый метод str.format(), но ту же строку формата можно использовать со встроенной функцией format(). Во встроенной функции format() строка спецификации формата указывается в качестве второго аргумента.

Выравнивание по левому краю, Выравнивание по центру, Выравнивание по правому краю

Вы можете выравнивать по левому краю, по центру, по правому краю и т.д. ниже. Укажите общее количество символов в виде числа.

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

Вы также можете указать символ, который будет заполнен. Если он опущен, как в примере выше, то это пробел.

Вы можете использовать двухбайтовые символы, если это один символ.

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

Правое выравнивание с помощью > не учитывает знак (-,+). Если вы используете =, за знаком следует указанный символ. Если вы хотите указать +, напишите + после =. Подробности обработки знаков описаны далее.

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

<, ^ и > могут быть указаны для строк, но = приведет к ошибке ValueError. Если вы хотите использовать = для строки, вам необходимо преобразовать ее в число с помощью функции int().

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

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

То же самое относится к числам с плавающей точкой. Десятичные точки также считаются за символ.

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

Списки, кортежи и т.д. вызовут ошибку, если будут указаны как есть, и могут быть преобразованы в строки с помощью функции 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]*****

Для выравнивания по левому краю, по центру и по правому краю также существуют специальные строковые методы ljust(), center() и rjust().

0 заполнение

Если вы хотите настроить количество цифр путем заполнения нулями, установите символ, который будет заполнен, на 0 и выровняйте его вправо.

В случае нулевого заполнения, если символ выравнивания опущен, он обрабатывается, как если бы было указано =.

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

=Если в качестве аргумента указать строку, как описано выше, вы получите ошибку. Давайте будем осторожны.

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

Для заполнения нуля также существует специальный строковый метод zfill().

Знак (плюс или минус)

По умолчанию только отрицательные числа помечаются знаком (минус -).

При добавлении + к строке спецификации форматирования для положительных чисел также отображается знак (плюс +). Если добавляется пробел, то в начале положительного числа отображается пробел, а количество цифр выравнивается с отрицательным числом.

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

Будьте осторожны при заполнении произвольными символами, например, при заполнении нулями, о котором говорилось выше. По умолчанию, без + и без пробелов, положительные числа заполняются еще одним символом.

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

Если используется символ выравнивания, то символ обозначения знака следует писать после символа выравнивания.

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

Разделитель цифр (запятая, знак подчеркивания)

Добавьте запятую или разделитель _ через каждые три цифры. Это облегчает чтение больших чисел. Обратите внимание, что underscore_ — это опция, добавленная в Python 3.6, поэтому ее нельзя использовать в более ранних версиях.

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

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

В случае плавающих типов чисел с плавающей точкой разграничивается только целочисленная часть.

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

Двоичные, восьмеричные и шестнадцатеричные числа

Преобразует числовые значения в двоичные, восьмеричные и шестнадцатеричные числа для вывода.

  • b: Бинарный
  • o: Octal
  • d: Десятичная дробь
  • x,X: Шестнадцатеричная (заглавные буквы пишутся прописными)
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

Он также может сочетаться с 0-заполнением и часто используется для выравнивания цифр в двоичной и шестнадцатеричной системе счисления.

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

Обратите внимание, что количество символов нулевого заполнения должно быть указано с учетом префикса.

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

Для двоичных и шестнадцатеричных чисел можно вставить только разделитель знаков подчеркивания _ (Python 3.6 или более поздняя версия). Используется 4-значный разделитель; количество заполненных нулями символов должно учитывать и количество знаков подчеркивания.

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

Только целочисленный тип int может преобразовать формат в двоичный или шестнадцатеричный. Вы можете использовать int() для преобразования в число.

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

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

Укажите количество цифр после десятичной точки

Чтобы указать количество цифр после десятичной точки, сделайте следующее: n — количество цифр. Количество цифр после десятичной точки становится указанным числом цифр независимо от количества цифр в целой части.
.[n]f

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

Левая часть десятичной точки может быть задана как выровненная по левому краю, выровненная по центру, выровненная по правому краю или заполненная нулями, как описано выше. Если количество цифр в целевом значении больше указанного числа, то ничего не делается. Если количество цифр в целевом значении больше указанного числа, ничего не делается.

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

Если вы укажете число цифр меньше, чем исходное число цифр после десятичной точки, значение будет округлено. Обратите внимание, что округляется не до ближайшего целого числа, а до четного, например, 0,5 округляется до 0.

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

Если вы хотите использовать общее округление, вы можете использовать метод quantize() стандартной библиотеки decimal.

экспоненциальная нотация

Когда число с плавающей точкой преобразуется в строку str, оно автоматически записывается в экспоненциальной нотации в зависимости от количества цифр. Целочисленный тип 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

Если в строке спецификации форматирования указать e или E, то всегда можно преобразовать в экспоненциальную нотацию. Символы, используемые в выводе, будут e и E, соответственно.

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

Также можно указать количество цифр после десятичной точки. Целая часть всегда будет состоять из одной цифры, а десятичная точка будет состоять из указанного количества цифр.

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

Обратите внимание, что если вы укажете выравнивание по левому краю, выравнивание по центру, выравнивание по правому краю или нулевое заполнение, то e-, E+ и т.д. также будут считаться цифрами (символами).

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

Значимые цифры (количество значащих цифр)

Вы можете указать общее количество цифр, выполнив следующие действия В зависимости от результата, экспоненциальная нотация будет использоваться автоматически. Обратите внимание, что нули после десятичной точки будут опущены.
.[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

Если вы опустите g, выходной результат не будет целым числом. g — то же самое в большинстве случаев, но только в тех случаях, когда выходной результат является целым числом.

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

Если мы обработаем одно и то же значение, то получим соответственно следующее.

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

В случае с g или если оно опущено, то опущены нули после десятичной точки, поэтому если вы хотите вывести такое же количество значащих цифр (количество значащих цифр), используйте экспоненциальную нотацию e или E. Целая часть всегда равна одной цифре, а десятичная точка — указанному количеству цифр, поэтому если вы хотите вывести n значащих цифр, просто укажите 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

Отображение в процентах

Если в строке спецификации форматирования указан %, значение числового float или int умножается на 100 и преобразуется в строку с %.

Также можно указать количество цифр после десятичной точки. По умолчанию используется шесть цифр после десятичной точки. Также доступны функции выравнивания влево, выравнивания по центру, выравнивания вправо и нулевого заполнения. Знак % также учитывается как символ.

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%