Python Language
String-Formatierung

Einführung

Syntax

• "{}". format (42) ==> "42"
• "{0}". Format (42) ==> "42"
• "{0: .2f}". Format (42) ==> "42.00"
• "{0: .0f}". Format (42.1234) ==> "42"
• "{answer}". format (no_answer = 41, antwort = 42) ==> "42"
• "{answer: .2f}". format (no_answer = 41, antwort = 42) ==> "42.00"
• "{[key]}". format ({'key': 'value'}) ==> "value"
• "{[1]}". Format (['null', 'eins', 'zwei']) ==> "eins"
• "{Antwort} = {Antwort}". Format (Antwort = 42) ==> "42 = 42"
• '' .join (['stack', 'overflow']) ==> "stack overflow"

Bemerkungen

Grundlagen der String-Formatierung

foo = 1
bar = 'bar'
baz = 3.14

Sie können str.format um die Ausgabe zu formatieren. Klammerpaare werden in der Reihenfolge, in der die Argumente übergeben werden, durch Argumente ersetzt:

print('{}, {} and {}'.format(foo, bar, baz))
# Out: "1, bar and 3.14"

In den Klammern können auch Indizes angegeben werden. Die Zahlen entsprechen den Indizes der Argumente, die an die Funktion str.format (0-basiert) übergeben wurden.

print('{0}, {1}, {2}, and {1}'.format(foo, bar, baz))
# Out: "1, bar, 3.14, and bar"
print('{0}, {1}, {2}, and {3}'.format(foo, bar, baz))
# Out: index out of range error

Benannte Argumente können auch verwendet werden:

print("X value is: {x_val}. Y value is: {y_val}.".format(x_val=2, y_val=3))
# Out: "X value is: 2. Y value is: 3."

str.format können bei der str.format an str.format :

class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('My value is: {0.value}'.format(my_value))  # "0" is optional
# Out: "My value is: 6"

Wörterbuchschlüssel können ebenfalls verwendet werden:

my_dict = {'key': 6, 'other_key': 7}
print("My other key is: {0[other_key]}".format(my_dict))  # "0" is optional
# Out: "My other key is: 7"

Gleiches gilt für Listen- und Tupelindizes:

my_list = ['zero', 'one', 'two']
print("2nd element is: {0[2]}".format(my_list))  # "0" is optional
# Out: "2nd element is: two"

Hinweis: Zusätzlich zu str.format bietet Python den Modulo-Operator % - auch als String-Formatierungs- oder Interpolationsoperator (siehe PEP 3101 ) - zum Formatieren von Strings an. str.format ist ein Nachfolger von % und bietet mehr Flexibilität, beispielsweise durch die Erleichterung mehrerer Substitutionen.

Neben den Argumentindizes können Sie auch eine Formatangabe in die geschweiften Klammern einfügen. Dies ist ein Ausdruck, die besonderen Regeln folgt und muss einen Doppelpunkt vorangestellt werden ( : ). Eine vollständige Beschreibung der Formatangaben finden Sie in den Dokumenten . Ein Beispiel für eine Formatspezifikation ist die Ausrichtungsanweisung :~^20 ( ^ steht für Zentrumsausrichtung, Gesamtbreite 20, mit ~ Zeichen füllen):

'{:~^20}'.format('centered')
# Out: '~~~~~~centered~~~~~~'

format erlaubt Verhalten, das mit % nicht möglich ist, z. B. Wiederholung von Argumenten:

t = (12, 45, 22222, 103, 6)
print '{0} {2} {1} {2} {3} {2} {4} {2}'.format(*t)    
# Out: 12 22222 45 22222 103 22222 6 22222

Da format eine Funktion ist, kann es als Argument in anderen Funktionen verwendet werden:

number_list = [12,45,78]
print map('the number is {}'.format, number_list)
# Out: ['the number is 12', 'the number is 45', 'the number is 78']   
    

from datetime import datetime,timedelta
    
once_upon_a_time = datetime(2010, 7, 1, 12, 0, 0)
delta = timedelta(days=13, hours=8,  minutes=20)
    
gen = (once_upon_a_time + x * delta for x in xrange(5))
    
print '\n'.join(map('{:%Y-%m-%d %H:%M:%S}'.format, gen))
#Out: 2010-07-01 12:00:00
#     2010-07-14 20:20:00
#     2010-07-28 04:40:00
#     2010-08-10 13:00:00
#     2010-08-23 21:20:00

Ausrichtung und Polsterung

'{:~<9s}, World'.format('Hello')
# 'Hello~~~~, World'

'{:~>9s}, World'.format('Hello')
# '~~~~Hello, World'

'{:~^9s}'.format('Hello')
# '~~Hello~~'

'{:0=6d}'.format(-123)
# '-00123'

Anmerkung: Sie können die gleichen Ergebnisse mit den String-Funktionen ljust() , rjust() , center() , zfill() Diese Funktionen werden jedoch seit Version 2.5 nicht mehr unterstützt.

Format Literale (F-String)

Zeichenketten im Literalformat wurden in PEP 498 (Python3.6 und höher) eingeführt, sodass Sie f am Anfang eines Zeichenfolgenlitals voranstellen können, um das .format effektiv auf alle Variablen im aktuellen Gültigkeitsbereich anzuwenden.

>>> foo = 'bar'
>>> f'Foo is {foo}'
'Foo is bar'

Dies funktioniert auch mit erweiterten Formatzeichenfolgen, einschließlich Ausrichtung und Punktnotation.

>>> f'{foo:^7s}'
'  bar  '

Hinweis: Das f'' bezeichnet keinen bestimmten Typ wie b'' für bytes oder u'' für unicode in Python2. Die Formatierung wird sofort angewendet, was zu einer normalen Stabilisierung führt.

Die Formatstrings können auch geschachtelt sein :

>>> price = 478.23
>>> f"{f'${price:0.2f}':*>20s}"
'*************$478.23'

Die Ausdrücke in einem F-String werden in der Reihenfolge von links nach rechts ausgewertet. Dies ist nur erkennbar, wenn die Ausdrücke Nebenwirkungen haben:

>>> def fn(l, incr):
...    result = l[0]
...    l[0] += incr
...    return result
...
>>> lst = [0]
>>> f'{fn(lst,2)} {fn(lst,3)}'
'0 2'
>>> f'{fn(lst,2)} {fn(lst,3)}'
'5 7'
>>> lst
[10]

String-Formatierung mit datetime

Jede Klasse kann ihre eigene String-Formatierungssyntax mit der __format__ Methode __format__ . Ein Typ in der Python-Standardbibliothek, der dies praktisch nutzt, ist der datetime Typ, bei dem datetime strftime Formatierungscodes direkt in str.format :

>>> from datetime import datetime
>>> 'North America: {dt:%m/%d/%Y}.  ISO: {dt:%Y-%m-%d}.'.format(dt=datetime.now())
'North America: 07/21/2016.  ISO: 2016-07-21.'

Eine vollständige Liste der Liste der Datumsformatierungsformate finden Sie in der offiziellen Dokumentation .

Formatieren Sie mit Getitem und Getattr

Für jede Datenstruktur, die __getitem__ unterstützt, kann die verschachtelte Struktur formatiert werden:

person = {'first': 'Arthur', 'last': 'Dent'} 
'{p[first]} {p[last]}'.format(p=person) 
# 'Arthur Dent'

Auf getattr() kann mit getattr() zugegriffen werden:

class Person(object):
    first = 'Zaphod'
    last = 'Beeblebrox'

'{p.first} {p.last}'.format(p=Person())
# 'Zaphod Beeblebrox'

Float-Formatierung

>>> '{0:.0f}'.format(42.12345)
'42'

>>> '{0:.1f}'.format(42.12345)
'42.1'

>>> '{0:.3f}'.format(42.12345)
'42.123'

>>> '{0:.5f}'.format(42.12345)
'42.12345'

>>> '{0:.7f}'.format(42.12345)
'42.1234500'

Gleiches gilt für andere Verweise:

>>> '{:.3f}'.format(42.12345)
'42.123'

>>> '{answer:.3f}'.format(answer=42.12345)
'42.123'

Fließkommazahlen können auch in wissenschaftlicher Notation oder als Prozentsatz formatiert werden:

>>> '{0:.3e}'.format(42.12345)
'4.212e+01'

>>> '{0:.0%}'.format(42.12345)
'4212%'

Sie können auch die Notizen {0} und {name} kombinieren. Dies ist besonders nützlich, wenn Sie alle Variablen mit einer Deklaration auf eine vordefinierte Anzahl von Dezimalstellen runden möchten:

>>> s = 'Hello'
>>> a, b, c = 1.12345, 2.34567, 34.5678
>>> digits = 2

>>> '{0}! {1:.{n}f}, {2:.{n}f}, {3:.{n}f}'.format(s, a, b, c, n=digits)
'Hello! 1.12, 2.35, 34.57'

Numerische Werte formatieren

Die .format() -Methode kann eine Zahl in verschiedenen Formaten interpretieren, z.

>>> '{:c}'.format(65)    # Unicode character
'A'

>>> '{:d}'.format(0x0a)  # base 10
'10'

>>> '{:n}'.format(0x0a)  # base 10 using current locale for separators
'10'

Formatieren von Ganzzahlen auf verschiedene Basen (Hex, Okt, Binär)

>>> '{0:x}'.format(10) # base 16, lowercase - Hexadecimal
'a'

>>> '{0:X}'.format(10) # base 16, uppercase - Hexadecimal
'A'

>>> '{:o}'.format(10) # base 8 - Octal
'12'

>>> '{:b}'.format(10) # base 2 - Binary
'1010'

>>> '{0:#b}, {0:#o}, {0:#x}'.format(42) # With prefix
'0b101010, 0o52, 0x2a'

>>> '8 bit: {0:08b}; Three bytes: {0:06x}'.format(42) # Add zero padding
'8 bit: 00101010; Three bytes: 00002a'

Verwenden Sie die Formatierung, um ein RGB-Float-Tupel in einen Farb-Hex-String zu konvertieren:

>>> r, g, b = (1.0, 0.4, 0.0)
>>> '#{:02X}{:02X}{:02X}'.format(int(255 * r), int(255 * g), int(255 * b))
'#FF6600'

Nur ganze Zahlen können konvertiert werden:

>>> '{:x}'.format(42.0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: Unknown format code 'x' for object of type 'float'

Benutzerdefinierte Formatierung für eine Klasse

Hinweis:

Alles gilt unten an der str.format Methode sowie die format - Funktion. Im folgenden Text sind die beiden austauschbar.

Für jeden Wert, der den übergeben format Funktion sucht Python für eine __format__ Methode für dieses Argument. Ihre eigene benutzerdefinierte Klasse kann daher ihre eigene hat __format__ Methode , um zu bestimmen , wie die format - Funktion wird angezeigt und Ihre Klasse formatiert und es ist Attribut.

Dies unterscheidet sich von der __str__ Methode, da Sie bei der __format__ Methode die Formatierungssprache, einschließlich Ausrichtung, __format__ usw., berücksichtigen können und sogar (wenn Sie möchten) eigene Formatbezeichner und Ihre eigenen Formatierungssprachenerweiterungen implementieren. 1

object.__format__(self, format_spec)

Zum Beispiel :

# Example in Python 2 - but can be easily applied to Python 3

class Example(object):
    def __init__(self,a,b,c):
        self.a, self.b, self.c = a,b,c

    def __format__(self, format_spec):
        """ Implement special semantics for the 's' format specifier """
        # Reject anything that isn't an s
        if format_spec[-1] != 's':
            raise ValueError('{} format specifier not understood for this object', format_spec[:-1])

        # Output in this example will be (<a>,<b>,<c>)
        raw = "(" + ",".join([str(self.a), str(self.b), str(self.c)]) + ")"
        # Honor the format language by using the inbuilt string format
        # Since we know the original format_spec ends in an 's' 
        # we can take advantage of the str.format method with a 
        # string argument we constructed above
        return "{r:{f}}".format( r=raw, f=format_spec )

inst = Example(1,2,3)
print "{0:>20s}".format( inst )
# out :              (1,2,3)
# Note how the right align and field width of 20 has been honored.

Hinweis:

Wenn Ihre benutzerdefinierte Klasse nicht über eine benutzerdefinierte __format__ Methode verfügt und eine Instanz der Klasse an die format Funktion übergeben wird, verwendet Python2 immer den Rückgabewert der __str__ Methode oder der __str__ __repr__ Methode, um zu bestimmen, was gedruckt werden soll Standard repr verwendet), und Sie werden das verwenden müssen s Formatbezeichner formatiert werden diese. Mit Python3, Ihre benutzerdefinierten Klasse zur passieren format - Funktion, müssen Sie definieren __format__ Methode auf Ihrer benutzerdefinierte Klasse.

Verschachtelte Formatierung

Einige Formate können zusätzliche Parameter enthalten, z. B. die Breite der formatierten Zeichenfolge oder die Ausrichtung:

>>> '{:.>10}'.format('foo')
'.......foo'

Diese können auch als Parameter zum format bereitgestellt werden, indem Sie mehr {} in {} verschachteln:

>>> '{:.>{}}'.format('foo', 10)
'.......foo'
'{:{}{}{}}'.format('foo', '*', '^', 15)
'******foo******'

Im letzteren Beispiel wird die Formatzeichenfolge '{:{}{}{}}' in '{:*^15}' (dh "center und pad mit * bis Gesamtlänge 15") geändert, bevor sie auf das Format angewendet wird tatsächliche Zeichenfolge 'foo' , um auf diese Weise formatiert zu werden.

Dies kann nützlich sein, wenn Parameter vorher nicht bekannt sind, z. B. beim Ausrichten von Tabellendaten:

>>> data = ["a", "bbbbbbb", "ccc"]
>>> m = max(map(len, data))
>>> for d in data:
...     print('{:>{}}'.format(d, m))
      a
bbbbbbb
    ccc

Saiten auffüllen und abschneiden, kombiniert

Angenommen, Sie möchten Variablen in einer Spalte mit 3 Zeichen drucken.

Hinweis: Das Verdoppeln { und } entgeht ihnen.

s = """

pad
{{:3}}             :{a:3}:

truncate
{{:.3}}            :{e:.3}:

combined
{{:>3.3}}          :{a:>3.3}:
{{:3.3}}           :{a:3.3}:
{{:3.3}}           :{c:3.3}:
{{:3.3}}           :{e:3.3}:
"""

print (s.format(a="1"*1, c="3"*3, e="5"*5))

Ausgabe:

pad
{:3}             :1  :

truncate
{:.3}            :555:

combined
{:>3.3}          :  1:
{:3.3}           :1  :
{:3.3}           :333:
{:3.3}           :555:

Benannte Platzhalter

Formatstrings können benannte Platzhalter enthalten, die zum format mit Schlüsselwortargumenten interpoliert werden.

Wörterbuch verwenden (Python 2.x)

>>> data = {'first': 'Hodor', 'last': 'Hodor!'}
>>> '{first} {last}'.format(**data)
'Hodor Hodor!'

Wörterbuch verwenden (Python 3.2+)

>>> '{first} {last}'.format_map(data)
'Hodor Hodor!'

str.format_map können Wörterbücher verwendet werden, ohne sie vorher entpacken zu müssen. Anstelle eines neu gefüllten dict auch die data (möglicherweise ein benutzerdefinierter Typ) verwendet.

Ohne Wörterbuch:

>>> '{first} {last}'.format(first='Hodor', last='Hodor!')
'Hodor Hodor!'