Перетворення формату в Python, формат (заповнення нуля, експоненційне позначення, шістнадцятковий тощо)

Бізнес

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

У цьому розділі ми пояснимо, як використовувати наступні функції.

  • вбудована функція (наприклад, на мові програмування)format()
  • метод рядкаstr.format()

Крім того, у прикладі коду пояснюється рядок специфікації формату для перетворення в наступний формат.

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

Зауважте, що з Python 3.6 до методу str.format() було додано f-рядки (f-strings), щоб зробити його більш лаконічним.

Вбудована функція: format()

format() надається як стандартна вбудована функція Python.

Схема виглядає наступним чином.

  • format(value, format_spec)
    • Перший аргумент: стvalue
      Початкове значення. Рядок str, число int, float тощо.
    • Другий аргументformat_spec
      Рядок специфікації формату. Струна вул
    • Повертається значення: відформатований рядок str

Нижче наведено приклади. Типи рядків форматування та способи їх написання описані далі.

У цьому прикладі ми використали числові та рядкові літерали як перший аргумент, але, звичайно, ви можете використовувати змінні, які містять ці значення.

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

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

Рядковий метод str.format()

Існує також метод format() для типу string string.

{} у рядку 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}

форматований рядок

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

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

Роздільник цифр (кома, підкреслення)

Додайте кому або символ підкреслення _ кожні три цифри. Це полегшує читання великих чисел. Зауважте, що підкреслення_ є опцією, доданою в Python 3.6, тому її не можна використовувати в попередніх версіях.

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

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

У випадку числових типів з плаваючою комою розділяється лише ціла частина.

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

Двійкові, вісімкові та шістнадцяткові числа

Перетворює числові значення в двійкові, вісімкові та шістнадцяткові числа для виведення.

  • b: двійковий
  • o: вісімковий
  • 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() стандартної бібліотеки десяткового дробу.

експоненційне позначення

Коли число з плаваючою комою перетворюється в рядок 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%