За преобразуване (форматиране) на число или низ в различни формати в Python използвайте вградената функция format() или метода за форматиране на низове str.format().
В този раздел ще обясним как да използвате следните функции.
- вградена функция (напр. в език за програмиране)
format() - низ метод
str.format()
Освен това с примерен код е обяснен низът за спецификация на формата за преобразуване в следния формат.
- Ляво изравнено, Централно изравнено, Дясно изравнено
- нулево запълване
- Знак (плюс или минус)
- Разделител на цифри (запетая, долна черта)
- Двоични, осмични и шестнадесетични числа
- Определяне на броя на цифрите след десетичната запетая
- Значещи цифри (брой значещи цифри)
- експоненциално записване
- Показване на проценти
Обърнете внимание, че от версия 3.6 на Python към метода за символни низове str.format() са добавени символни низове (f-strings), за да бъде той по-кратък.
- Вградена функция: format()
- Метод на символите str.format()
- Ляво изравнено, Централно изравнено, Дясно изравнено
- 0 запълване
- Знак (плюс или минус)
- Разделител на цифри (запетая, долна черта)
- Двоични, осмични и шестнадесетични числа
- Определяне на броя на цифрите след десетичната запетая
- експоненциално записване
- Значещи цифри (брой значещи цифри)
- Показване на проценти
Вградена функция: format()
Format() се предоставя като стандартна вградена функция на Python.
Схемата е следната.
format(value, format_spec)- Първият аргумент:
value
Първоначалната стойност. String 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}
форматиран низ
И в двата случая, за да зададете формата, напишете „: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
Разделител на цифри (запетая, долна черта)
На всеки три цифри добавете запетая или разделител _. Това улеснява четенето на големи числа. Имайте предвид, че underscore_ е опция, добавена в Python 3.6, така че не може да се използва в по-ранни версии.
print('{:,}'.format(100000000))
# 100,000,000
print('{:_}'.format(100000000))
# 100_000_000
При типовете числа с плаваща запетая float се обособява само целочислената част.
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-fill и често се използва за подравняване на цифри в двоичен и шестнадесетичен запис.
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
Имайте предвид, че ако посочите left-justified (изравнено вляво), center-justified (изравнено в средата), right-justified (изравнено вдясно) или zero-filled (попълнено с нула), 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%