Konwersja formatu w Pythonie, format (wypełnianie zera, notacja wykładnicza, szesnastkowa itd.)

Biznes

Aby przekonwertować (sformatować) liczbę lub ciąg znaków na różne formaty w Pythonie, użyj wbudowanej funkcji format() lub metody łańcuchowej str.format().

W tym rozdziale wyjaśnimy, jak korzystać z następujących funkcji.

  • funkcja wbudowana (np. w języku programowania)format()
  • metoda łańcuchowastr.format()

Dodatkowo wyjaśniony jest ciąg specyfikacji formatu do konwersji do następującego formatu wraz z przykładowym kodem.

  • Wyjustowane do lewej, Wyjustowane do środka, Wyjustowane do prawej
  • wypełnienie zerowe
  • Znak (plus lub minus)
  • Separator cyfr (przecinek, podkreślnik)
  • Liczby binarne, ósemkowe i szesnastkowe
  • Określenie liczby cyfr po przecinku dziesiętnym
  • Cyfry znaczące (liczba cyfr znaczących)
  • notacja wykładnicza
  • Wyświetlanie procentowe

Zauważ, że od Pythona 3.6 do metody łańcuchowej str.format() zostały dodane łańcuchy znaków (f-strings), aby uczynić ją bardziej zwięzłą.

Wbudowana funkcja: format()

format() jest dostarczana jako standardowa wbudowana funkcja Pythona.

Konspekt jest następujący.

  • format(value, format_spec)
    • Pierwszy argument:.value
      Oryginalna wartość. String str, number int, float, itd.
    • Drugi argumentformat_spec
      Specyfikacja formatu łańcucha. Łańcuch str
    • Wartość zwracana: sformatowany łańcuch str

Przykłady są pokazane poniżej. Typy łańcuchów formatujących i sposób ich zapisu opisane są w dalszej części instrukcji.

W tym przykładzie użyliśmy literałów numerycznych i literałów łańcuchowych jako pierwszego argumentu, ale oczywiście możesz użyć zmiennych, które zawierają te wartości.

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

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

Metoda łańcuchowa str.format()

Istnieje również metoda format() dla typu string str.

{} w łańcuchu str, który wywołuje metodę format() jest nazywane polem zastępczym i jest zastępowane przez argument metody format().

Łańcuch specyfikacji formatu powinien być zapisany w polu zastępczym {}, po którym następuje „:”.

Wartością zwrotną jest sformatowany łańcuch znaków str.

Proces równoważny do opisanej powyżej wbudowanej funkcji format() wygląda następująco.

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

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

Ponownie, używamy literałów numerycznych i literałów łańcuchowych jako argumentów, ale oczywiście zmienne są również akceptowalne.

Określanie argumentów dla pól substytucji

Określ argumenty w kolejności (domyślnie)

Może istnieć wiele pól zastępczych {}, a domyślnie, argumenty metody są przetwarzane w kolejności. Jeśli łańcuch specyfikacji formatu w {} jest pominięty, to zostanie on po prostu przekonwertowany na łańcuch przez str().

Użyteczne do wstawiania zmiennych wartości do łańcucha i ich drukowania.

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

Określenie argumentu pozycyjnego dla wartości całkowitych

Jeśli w {} podano wartość całkowitą, taką jak {0} lub {1}, to wynik będzie zależał od kolejności argumentów. Ta sama liczba może być użyta wielokrotnie. Jest to przydatne, gdy chcesz wstawić tę samą wartość do łańcucha.

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

Określenie argumentów słów kluczowych dla dowolnych nazw (łańcuchów)

Możesz także określić dowolną nazwę w {} i podać ją jako argument słowa kluczowego.

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

Podanie listy lub słownika jako argumentu

Listy i słowniki mogą być podawane jako argumenty.

Użyj [] by określić indeks listy lub klucz słownika w polu zastępczym. Zauważ, że cudzysłowy „'” i „” nie są używane do określania kluczy słownika.

Jeśli chcesz użyć tego samego argumentu wielokrotnie, musisz podać wartość całkowitą lub łańcuch (nazwę), jak opisano powyżej.

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.

Może być interpretowany jako argument pozycyjny przez dołączenie * do listy i podanie go jako argumentu, lub jako argument słowa kluczowego przez dołączenie ** do słownika i podanie go jako argumentu.

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.

Opis nawiasów klamrowych {}

Jeśli chcesz napisać nawiasy klamrowe {,} w metodzie format(), powtórz je dwa razy jak {{,}}}. Zauważ, że backslashe nie mogą być escape'owane.

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

sformatowany ciąg

W obu przypadkach, aby określić format, napisz „:łańcuch formatu” po wartości całkowitej lub łańcuchu nazwy w {}.

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

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

Poniżej wyjaśnimy, jak określić format za pomocą łańcucha formatu. Przykładowy kod używa metody łańcuchowej str.format(), ale ten sam łańcuch formatu może być użyty za pomocą wbudowanej funkcji format(). W wbudowanej funkcji format(), łańcuch specyfikacji formatu jest określany jako drugi argument.

Wyjustowane do lewej, Wyjustowane do środka, Wyjustowane do prawej

Możesz wyrównać do lewej, do środka, do prawej itd. poniżej. Określ całkowitą liczbę znaków jako liczbę.

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

Można również określić znak, który ma zostać wypełniony. Jeśli zostanie pominięty, jak w powyższym przykładzie, jest to spacja.

Można używać znaków dwubajtowych pod warunkiem, że jest to pojedynczy znak.

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

Wyrównanie do prawej za pomocą > nie uwzględnia znaku (-,+). Jeśli użyjesz =, to po znaku następuje podany znak. Jeżeli chcesz określić +, to napisz + po =. Szczegóły przetwarzania znaków są opisane później.

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

<, ^, i > mogą być określone dla łańcuchów, ale = spowoduje błąd ValueError. Jeśli chcesz użyć = dla łańcucha, musisz przekonwertować go na liczbę używając int().

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

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

To samo dotyczy liczb zmiennoprzecinkowych. Punkty dziesiętne są również liczone jako znak.

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

Listy, tuple, itp. spowodują błąd, jeśli zostaną podane jako takie, i mogą zostać przekonwertowane na łańcuchy przy użyciu funkcji 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]*****

Dla funkcji left-justified, center-justified i right-justified istnieją również dedykowane metody łańcuchowe o nazwach ljust(), center() i rjust().

0 wypełnienie

Jeśli chcesz dostosować liczbę cyfr przez wypełnianie zera, ustaw znak do wypełnienia na 0 i wyjustuj go do prawej.

W przypadku wypełniania zera, jeśli pominięto symbol wyrównania, jest ono przetwarzane tak, jakby podano =.

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

=Jeśli podasz ciąg znaków jako argument, jak opisano powyżej, otrzymasz błąd. Bądźmy ostrożni.

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

Do wypełniania zera istnieje również dedykowana metoda łańcuchowa o nazwie zfill().

Znak (plus lub minus)

Domyślnie tylko liczby ujemne są oznaczane znakiem (minus-).

Po dodaniu znaku + do łańcucha specyfikacji formatowania, znak (plus +) jest również wyświetlany dla liczb dodatnich. Jeżeli dodana jest spacja, to spacja jest wyświetlana na początku liczby dodatniej, a liczba cyfr jest wyrównywana do liczby ujemnej.

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

Należy uważać przy wypełnianiu arbitralnymi znakami, takimi jak wspomniane wyżej wypełnianie zerem. Domyślnie, bez + i bez spacji, wypełnia liczby dodatnie jeszcze jednym znakiem.

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

Jeżeli stosowany jest symbol wyrównania, to symbol oznaczenia znaku powinien być wpisany po symbolu wyrównania.

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

Separator cyfr (przecinek, podkreślnik)

Dodaj przecinek lub podkreślenie _ separator co trzy cyfry. Sprawia to, że duże liczby są łatwiejsze do odczytania. Zwróć uwagę, że underscore_ jest opcją dodaną w Pythonie 3.6, więc nie można jej używać we wcześniejszych wersjach.

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

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

W przypadku liczb zmiennoprzecinkowych typu float delimitowana jest tylko część całkowita.

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

Liczby binarne, ósemkowe i szesnastkowe

Konwertuje wartości liczbowe na liczby binarne, ósemkowe i szesnastkowe dla wyjścia.

  • b: Binary
  • o: Octal
  • d: Decimal
  • x,X: Hexadecimal (wielkie litery są kapitalizowane)
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

Może być również połączony z wypełnieniem 0 i jest często używany do wyrównywania cyfr w notacji binarnej i szesnastkowej.

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

Należy zwrócić uwagę, że liczba znaków wypełnienia zerowego musi być określona z uwzględnieniem prefiksu.

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

W przypadku liczb binarnych i szesnastkowych można wstawić tylko separator cyfr podkreślenie _ (Python 3.6 lub nowszy). Używany jest separator 4-cyfrowy; liczba znaków wypełnionych zerem musi uwzględniać także liczbę podkreśleń.

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

Tylko typ całkowity int może przekonwertować format na binarny lub szesnastkowy. Możesz użyć int(), aby przekonwertować go na liczbę.

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

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

Określenie liczby cyfr po przecinku dziesiętnym

Aby określić liczbę cyfr po przecinku, wykonaj następujące czynności: n jest liczbą cyfr. Liczba cyfr po przecinku jest równa podanej liczbie cyfr, niezależnie od liczby cyfr w części całkowitej.
.[n]f

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

Lewa strona kropki dziesiętnej może zostać określona jako wyrównana do lewej, wyrównana do środka, wyrównana do prawej lub wypełniona zerem, jak opisano powyżej. Jeśli liczba cyfr wartości docelowej jest większa niż podana, nic nie jest wykonywane. Jeśli liczba cyfr w wartości docelowej jest większa niż podana, nic nie jest wykonywane.

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

Jeśli podasz liczbę cyfr mniejszą niż oryginalna liczba cyfr po przecinku, wartość zostanie zaokrąglona. Zauważ, że nie jest to zaokrąglanie do najbliższej liczby całkowitej, ale do liczby parzystej, np. 0.5 jest zaokrąglane do 0.

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

Jeśli chcesz użyć ogólnego zaokrąglenia, możesz użyć metody quantize() biblioteki standardowej decimal.

notacja wykładnicza

Kiedy liczba zmiennoprzecinkowa float jest konwertowana na łańcuch str, zostanie ona automatycznie zapisana w notacji wykładniczej w zależności od liczby cyfr. Typ całkowity int tego nie robi.

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

Jeśli w łańcuchu specyfikacji formatowania określisz e lub E, zawsze możesz dokonać konwersji na notację wykładniczą. Znakami użytymi na wyjściu będą odpowiednio e i E.

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

Możliwe jest również określenie liczby cyfr po przecinku. Część całkowita zawsze będzie miała jedną cyfrę, a po przecinku będzie podana liczba cyfr.

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

Należy pamiętać, że w przypadku wybrania opcji wyrównania do lewej, wyrównania do środka, wyrównania do prawej lub wypełnienia do zera, znaki e-, E+ itd. będą również liczone jako cyfry (znaki).

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

Cyfry znaczące (liczba cyfr znaczących)

Możesz określić całkowitą liczbę cyfr, wykonując następujące czynności W zależności od wyniku, notacja wykładnicza zostanie użyta automatycznie. Zwróć uwagę, że końcowe zera po przecinku dziesiętnym zostaną pominięte.
.[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

Jeśli pominiesz g, to wynik nie będzie liczbą całkowitą. g jest takie samo w większości przypadków, ale tylko w tych, w których wynik jest liczbą całkowitą.

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

Jeśli przetworzymy tę samą wartość, otrzymamy odpowiednio następujące wyniki.

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

W przypadku g lub jeśli jest ono pominięte, pomijane są końcowe zera po przecinku, więc jeśli chcesz uzyskać tę samą liczbę cyfr znaczących (liczbę cyfr znaczących), użyj notacji wykładniczej e lub E. Część całkowita jest zawsze jedną cyfrą, a przecinek dziesiętny określoną liczbą cyfr, więc jeśli chcesz uzyskać n cyfr znaczących, podaj po prostu 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

Wyświetlanie procentowe

Jeżeli % jest określone w łańcuchu specyfikacji formatowania, to wartość liczbowa float lub int jest mnożona przez 100 i konwertowana na łańcuch z %.

Możliwe jest również określenie liczby cyfr po przecinku dziesiętnym. Domyślnie jest to sześć cyfr po przecinku. Dostępne są również opcje wyrównania do lewej, wyrównania do środka, wyrównania do prawej oraz wypełnienia do zera. Znak % jest również liczony jako znak.

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%