Formatkonvertierung in Python, Format (Nullen, Exponentialschreibweise, Hexadezimal, usw.)

Geschäft

Um eine Zahl oder Zeichenkette in Python in verschiedene Formate umzuwandeln (zu formatieren), verwenden Sie die eingebaute Funktion format() oder die String-Methode str.format().

In diesem Abschnitt wird erklärt, wie Sie die folgenden Funktionen nutzen können.

  • eingebaute Funktion (z.B. in einer Programmiersprache)format()
  • String-Methodestr.format()

Darüber hinaus wird die Formatspezifikationszeichenfolge für die Konvertierung in das folgende Format mit Beispielcode erläutert.

  • Linksbündig, Mittig, Rechtsbündig
  • Nullfüllung
  • Vorzeichen (plus oder minus)
  • Zifferntrennzeichen (Komma, Unterstrich)
  • Binäre, oktale und hexadezimale Zahlen
  • Geben Sie die Anzahl der Stellen nach dem Dezimalpunkt an.
  • Signifikante Zahlen (Anzahl der signifikanten Stellen)
  • Exponentialschreibweise
  • Anzeige des Prozentsatzes

Beachten Sie, dass seit Python 3.6 die String-Methode str.format() um f-Strings (f-strings) erweitert wurde, um sie übersichtlicher zu gestalten.

Eingebaute Funktion: format()

format() wird als eingebaute Python-Standardfunktion bereitgestellt.

Die Gliederung ist wie folgt.

  • format(value, format_spec)
    • Das erste Argument: dievalue
      Der ursprüngliche Wert. String str, Zahl int, Float, etc.
    • Das zweite Argumentformat_spec
      Formatangabe String. String str
    • Rückgabewert: eine formatierte Zeichenkette str

Beispiele werden unten gezeigt. Die Arten von Formatstrings und wie man sie schreibt, werden später beschrieben.

In diesem Beispiel haben wir numerische Literale und String-Literale als erstes Argument verwendet, aber Sie können natürlich auch Variablen verwenden, die diese Werte enthalten.

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

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

String-Methode str.format()

Es gibt auch eine format()-Methode für den Stringtyp str.

Das {} in der Zeichenkette str, die die Methode format() aufruft, wird als Ersetzungsfeld bezeichnet und durch das Argument der Methode format() ersetzt.

Die Zeichenkette für die Formatspezifikation sollte in das Ersetzungsfeld {} geschrieben werden, gefolgt von “:”.

Der Rückgabewert ist eine formatierte Zeichenkette str.

Der äquivalente Prozess zu der oben beschriebenen eingebauten Funktion format() sieht folgendermaßen aus.

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

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

Auch hier verwenden wir numerische Literale und String-Literale als Argumente, aber natürlich sind auch Variablen akzeptabel.

Angabe von Argumenten für Substitutionsfelder

Argumente in der Reihenfolge angeben (Standard)

Es kann mehrere Ersetzungsfelder {} geben, und standardmäßig werden die Methodenargumente der Reihe nach verarbeitet. Wenn die Formatangabe in {} weggelassen wird, wird sie von str() einfach in eine Zeichenkette umgewandelt.

Nützlich zum Einfügen von Variablenwerten in eine Zeichenkette und zum Ausdrucken dieser Werte.

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

Geben Sie ein Positionsargument für Ganzzahlwerte an

Wenn in {} ein ganzzahliger Wert angegeben wird, z. B. {0} oder {1}, hängt die Ausgabe von der Reihenfolge der Argumente ab. Die gleiche Zahl kann wiederholt verwendet werden. Dies ist nützlich, wenn Sie denselben Wert in eine Zeichenkette einfügen wollen.

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

Angabe von Schlüsselwortargumenten für beliebige Namen (Zeichenketten)

Sie können auch einen beliebigen Namen in {} angeben und ihn als Schlüsselwortargument eingeben.

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

Geben Sie eine Liste oder ein Wörterbuch als Argument an

Listen und Wörterbücher können als Argumente angegeben werden.

Verwenden Sie [], um den Index einer Liste oder den Schlüssel eines Wörterbuchs in einem Ersetzungsfeld anzugeben. Beachten Sie, dass Anführungszeichen “'” und “” nicht verwendet werden, um Wörterbuchschlüssel anzugeben.

Wenn Sie dasselbe Argument wiederholt verwenden wollen, müssen Sie wie oben beschrieben einen Ganzzahlwert oder eine Zeichenkette (Name) angeben.

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.

Es kann als Positionsargument erweitert werden, indem man * an die Liste anhängt und es als Argument angibt, oder als Schlüsselwortargument, indem man ** an das Wörterbuch anhängt und es als Argument angibt.

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.

Beschreibung der geschweiften Klammern {}

Wenn Sie geschweifte Klammern {,} in die format()-Methode schreiben wollen, wiederholen Sie sie zweimal wie {{,}}. Beachten Sie, dass Backslashes nicht escaped werden können.

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

formatierte Zeichenkette

In beiden Fällen schreiben Sie zur Angabe des Formats “:format string” hinter den Integer-Wert oder die Namenszeichenfolge in {}.

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

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

Im Folgenden wird erläutert, wie das Format mit Hilfe einer Formatzeichenkette angegeben wird. Der Beispielcode verwendet die String-Methode str.format(), aber die gleiche Formatzeichenkette kann auch mit der eingebauten Funktion format() verwendet werden. In der eingebauten Funktion format() wird die Zeichenkette für die Formatspezifikation als zweites Argument angegeben.

Linksbündig, Mittig, Rechtsbündig

Sie können unten linksbündig, zentriert, rechtsbündig usw. ausrichten. Geben Sie die Gesamtzahl der Zeichen als Zahl an.

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

Sie können auch ein Zeichen angeben, das ausgefüllt werden soll. Wird es weggelassen, wie im obigen Beispiel, ist es ein Leerzeichen.

Sie können Doppelbyte-Zeichen verwenden, solange es sich um ein einzelnes Zeichen handelt.

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

Bei der Rechtsbündigkeit mit > wird das Vorzeichen (-,+) nicht berücksichtigt. Wenn Sie = verwenden, wird das Vorzeichen von dem angegebenen Zeichen gefolgt. Wenn Sie + angeben wollen, schreiben Sie + nach =. Die Einzelheiten der Vorzeichenverarbeitung werden später beschrieben.

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

<, ^ und > können für Strings angegeben werden, aber = führt zu einem Fehler ValueError. Wenn Sie = für eine Zeichenkette verwenden wollen, müssen Sie sie mit int() in eine Zahl umwandeln.

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

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

Das Gleiche gilt für Gleitkommazahlen. Dezimalpunkte werden ebenfalls als ein Zeichen gezählt.

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

Listen, Tupel usw. führen zu einem Fehler, wenn sie so angegeben werden, wie sie sind, und können mit str() in Strings umgewandelt werden.

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]*****

Für linksbündig, zentriert und rechtsbündig gibt es auch eigene String-Methoden namens ljust(), center() und rjust().

0 füllen

Wenn Sie die Anzahl der Ziffern durch Auffüllen mit Nullen anpassen möchten, setzen Sie das aufzufüllende Zeichen auf 0 und richten es rechtsbündig aus.

Wenn das Ausrichtungssymbol bei der Nullausfüllung weggelassen wird, wird es so verarbeitet, als ob = angegeben wäre.

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

=Wenn Sie, wie oben beschrieben, eine Zeichenkette als Argument angeben, erhalten Sie eine Fehlermeldung. Wir sollten vorsichtig sein.

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

Für das Ausfüllen von Nullen gibt es auch eine eigene String-Methode namens zfill().

Vorzeichen (plus oder minus)

Standardmäßig werden nur negative Zahlen mit einem Vorzeichen (Minus-) versehen.

Wenn der Formatierungsangabe + hinzugefügt wird, wird bei positiven Zahlen auch ein Vorzeichen (Plus +) angezeigt. Wenn ein Leerzeichen hinzugefügt wird, wird am Anfang der positiven Zahl ein Leerzeichen angezeigt, und die Anzahl der Ziffern wird an der negativen Zahl ausgerichtet.

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

Seien Sie vorsichtig, wenn Sie mit beliebigen Zeichen auffüllen, wie z. B. bei der oben erwähnten Null-Auffüllung. Die Standardeinstellung ohne + und ohne Leerzeichen füllt positive Zahlen mit einem weiteren Zeichen auf.

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

Wenn ein Ausrichtungssymbol verwendet wird, sollte das Zeichenbezeichnungssymbol nach dem Ausrichtungssymbol geschrieben werden.

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

Zifferntrennzeichen (Komma, Unterstrich)

Fügen Sie alle drei Ziffern ein Komma oder einen Unterstrich _ als Trennzeichen ein. Dies macht große Zahlen leichter lesbar. Beachten Sie, dass underscore_ eine Option ist, die in Python 3.6 hinzugefügt wurde und daher nicht in früheren Versionen verwendet werden kann.

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

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

Bei Gleitkommazahlen wird nur der ganzzahlige Teil abgegrenzt.

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

Binäre, oktale und hexadezimale Zahlen

Konvertiert numerische Werte für die Ausgabe in binäre, oktale und hexadezimale Zahlen.

  • b: Binär
  • o: Oktal
  • d: Dezimal
  • x,X: Hexadezimal (Großbuchstaben werden großgeschrieben)
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

Sie kann auch mit der 0-Füllung kombiniert werden und wird häufig verwendet, um Ziffern in binärer und hexadezimaler Notation auszurichten.

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

Beachten Sie, dass die Anzahl der Null-Füllzeichen unter Berücksichtigung des Präfixes angegeben werden muss.

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

Bei binären und hexadezimalen Zahlen kann nur der Unterstrich _ als Zifferntrennzeichen eingefügt werden (Python 3.6 oder höher). Es wird ein vierstelliges Trennzeichen verwendet; die Anzahl der mit Nullen gefüllten Zeichen muss auch die Anzahl der Unterstriche berücksichtigen.

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

Nur der Ganzzahltyp int kann das Format in binär oder hexadezimal umwandeln. Sie können int() verwenden, um es in eine Zahl zu konvertieren.

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

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

Geben Sie die Anzahl der Stellen nach dem Dezimalpunkt an.

Um die Anzahl der Nachkommastellen anzugeben, gehen Sie wie folgt vor: n ist die Anzahl der Ziffern. Die Anzahl der Ziffern nach dem Dezimalpunkt wird unabhängig von der Anzahl der Ziffern im ganzzahligen Teil zu der angegebenen Anzahl von Ziffern.
.[n]f

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

Die linke Seite des Dezimalpunkts kann wie oben beschrieben linksbündig, zentriert, rechtsbündig oder mit Nullen gefüllt angegeben werden. Ist die Anzahl der Ziffern des Zielwerts größer als die angegebene Anzahl, wird nichts unternommen. Wenn die Anzahl der Ziffern des Zielwerts größer ist als die angegebene Anzahl, wird nichts unternommen.

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

Wenn Sie eine Anzahl von Stellen angeben, die kleiner ist als die ursprüngliche Anzahl von Stellen nach dem Dezimalpunkt, wird der Wert gerundet. Beachten Sie, dass dabei nicht auf die nächste ganze Zahl gerundet wird, sondern auf eine gerade Zahl, z. B. wird 0,5 auf 0 gerundet.

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

Wenn Sie eine allgemeine Rundung verwenden möchten, können Sie die quantize()-Methode der Standardbibliothek decimal verwenden.

Exponentialschreibweise

Wenn eine Fließkommazahl in eine Zeichenkette str umgewandelt wird, wird sie automatisch in exponentieller Schreibweise geschrieben, abhängig von der Anzahl der Ziffern. Der Ganzzahltyp int tut dies nicht.

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

Wenn Sie e oder E in der Formatierungszeichenfolge angeben, können Sie immer in die Exponentialschreibweise konvertieren. Die in der Ausgabe verwendeten Zeichen sind dann e bzw. E.

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

Es ist auch möglich, die Anzahl der Ziffern nach dem Dezimalpunkt anzugeben. Der ganzzahlige Teil besteht immer aus einer Ziffer und der Dezimalpunkt aus der angegebenen Anzahl von Ziffern.

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

Beachten Sie, dass, wenn Sie linksbündig, zentriert, rechtsbündig oder mit Nullen gefüllt angeben, auch e-, E+ usw. als Ziffern (Zeichen) gezählt werden.

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

Signifikante Zahlen (Anzahl der signifikanten Stellen)

Sie können die Gesamtzahl der Ziffern wie folgt festlegen Je nach Ergebnis wird automatisch die Exponentialschreibweise verwendet. Beachten Sie, dass die Nullen nach dem Dezimalpunkt weggelassen werden.
.[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

Wenn Sie g weglassen, ist die Ausgabe keine Ganzzahl. g ist in den meisten Fällen gleich, aber nur in den Fällen, in denen die Ausgabe eine Ganzzahl ist.

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

Wenn wir denselben Wert verarbeiten, erhalten wir jeweils das folgende Ergebnis.

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

Wenn Sie also die gleiche Anzahl signifikanter Ziffern (Anzahl signifikanter Stellen) ausgeben möchten, verwenden Sie die Exponentialschreibweise von e oder E. Der ganzzahlige Teil ist immer eine Ziffer und der Dezimalpunkt ist die angegebene Anzahl von Ziffern, wenn Sie also n signifikante Ziffern ausgeben möchten, geben Sie einfach n-1 an.

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

Anzeige des Prozentsatzes

Wenn % in der Formatierungsangabe angegeben ist, wird der Wert des numerischen float oder int mit 100 multipliziert und mit % in eine Zeichenkette umgewandelt.

Es ist auch möglich, die Anzahl der Stellen nach dem Dezimalpunkt anzugeben. Die Standardeinstellung sind sechs Nachkommastellen. Linksbündig, zentriert, rechtsbündig und Null-Füllung sind ebenfalls verfügbar. Das % wird ebenfalls als ein Zeichen gezählt.

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%