Python String Format ()

Die Methode string format () formatiert die angegebene Zeichenfolge in eine schönere Ausgabe in Python.

Die Syntax der format()Methode lautet:

 template.format (p0, p1,…, k0 = v0, k1 = v1,…)

Hier sind p0, p1, … Positionsargumente und k0, k1, … Schlüsselwortargumente mit den Werten v0, v1, ….

Die Vorlage ist eine Mischung aus Formatcodes mit Platzhaltern für die Argumente.

String format () Parameter

format()Methode akzeptiert eine beliebige Anzahl von Parametern. Ist jedoch in zwei Arten von Parametern unterteilt:

• Positionsparameter - Liste der Parameter, auf die mit dem Parameterindex in geschweiften Klammern zugegriffen werden kann(index)
• Schlüsselwortparameter - Liste der Parameter vom Typ key = value, auf die mit dem Parameterschlüssel in geschweiften Klammern zugegriffen werden kann(key)

Rückgabewert aus dem String-Format ()

Die format()Methode gibt die formatierte Zeichenfolge zurück.

Wie funktioniert das String-Format ()?

Der format()liest den Typ der an ihn übergebenen Argumente und formatiert ihn gemäß den in der Zeichenfolge definierten Formatcodes.

Für Positionsargumente

Hier ist Argument 0 eine Zeichenfolge "Adam" und Argument 1 ist eine schwebende Zahl 230.2346.

Hinweis: Die Argumentliste beginnt in Python bei 0.

Die Zeichenfolge "Hello (0), your balance is (1:9.3f)"ist die Vorlagenzeichenfolge. Dies enthält die Formatierungscodes für die Formatierung.

Die geschweiften Klammern sind nur Platzhalter für die zu platzierenden Argumente. Im obigen Beispiel ist (0) Platzhalter für "Adam" und (1: 9.3f) Platzhalter für 230.2346.

Da die Vorlagenzeichenfolge auf format()Argumente als (0)und verweist (1), sind die Argumente Positionsargumente. Beide können auch ohne die Nummern referenziert werden, da ()Python sie intern in Zahlen konvertiert.

Im Inneren,

• Seit „Adam“ die 0 - ^te Argument wird anstelle von platziert (0). Da (0)es keine anderen Formatcodes enthält, werden keine anderen Vorgänge ausgeführt.
• Es ist jedoch nicht der Fall für 1 ^st Argument 230,2346. Hier (1:9.3f)legt 230.2346 an seinem Platz und führt die Operation 9.3f.
• f gibt an, dass es sich bei dem Format um eine Gleitkommazahl handelt. Wenn nicht korrekt angegeben, wird ein Fehler ausgegeben.
• Der Teil vor dem "." (9) gibt die minimale Breite / Polsterung an, die die Nummer (230.2346) annehmen kann. In diesem Fall werden 230.2346 mindestens 9 Stellen einschließlich des "." Zugewiesen.
  Wenn keine Ausrichtungsoption angegeben ist, wird sie rechts von den verbleibenden Leerzeichen ausgerichtet. (Bei Zeichenfolgen wird es nach links ausgerichtet.)
• Der Teil nach dem "." (3) schneidet den Dezimalteil (2346) bis zur angegebenen Zahl ab. In diesem Fall wird 2346 nach 3 Stellen abgeschnitten.
  Die verbleibenden Zahlen (46) werden abgerundet, wenn 235 ausgegeben wird.

Für Schlüsselwortargumente

Wir haben dasselbe Beispiel von oben verwendet, um den Unterschied zwischen Schlüsselwort- und Positionsargumenten zu zeigen.

Hier haben wir anstelle nur der Parameter einen Schlüsselwert für die Parameter verwendet. Nämlich name = "Adam" und blc = 230.2346.

Da diese Parameter von ihren Schlüsseln als (Name) und (blc: 9.3f) bezeichnet werden, werden sie als Schlüsselwort oder benannte Argumente bezeichnet.

Im Inneren,

• Der Platzhalter (Name) wird durch den Wert des Namens "Adam" ersetzt. Da es keine anderen Formatcodes enthält, wird "Adam" platziert.
• Für das Argument blc = 230.2346 wird der Platzhalter (blc: 9.3f) durch den Wert 230.2346 ersetzt. Bevor es jedoch wie im vorherigen Beispiel ersetzt wird, führt es eine 9.3f-Operation aus.
  Dies gibt 230.235 aus. Der Dezimalteil wird nach 3 Stellen abgeschnitten und die verbleibenden Ziffern werden abgerundet. Ebenso wird der Gesamtbreite 9 zugewiesen, wobei zwei Leerzeichen links bleiben.

Grundformatierung mit format ()

Die format()Methode ermöglicht die Verwendung einfacher Platzhalter für die Formatierung.

Beispiel 1: Grundlegende Formatierung für Standard-, Positions- und Schlüsselwortargumente

 # default arguments print("Hello (), your balance is ().".format("Adam", 230.2346)) # positional arguments print("Hello (0), your balance is (1).".format("Adam", 230.2346)) # keyword arguments print("Hello (name), your balance is (blc).".format(name="Adam", blc=230.2346)) # mixed arguments print("Hello (0), your balance is (blc).".format("Adam", blc=230.2346))

Ausgabe

Hallo Adam, dein Guthaben ist 230.2346. Hallo Adam, dein Guthaben ist 230.2346. Hallo Adam, dein Guthaben ist 230.2346. Hallo Adam, dein Guthaben ist 230.2346.

Hinweis: Bei gemischten Argumenten müssen Schlüsselwortargumente immer Positionsargumenten folgen.

Zahlenformatierung mit format ()

Sie können Zahlen mit dem unten angegebenen Formatbezeichner formatieren:

Example 2: Simple number formatting

 # integer arguments print("The number is:(:d)".format(123)) # float arguments print("The float number is:(:f)".format(123.4567898)) # octal, binary and hexadecimal format print("bin: (0:b), oct: (0:o), hex: (0:x)".format(12))

Output

 The number is: 123 The number is:123.456790 bin: 1100, oct: 14, hex: c

Example 3: Number formatting with padding for int and floats

 # integer numbers with minimum width print("(:5d)".format(12)) # width doesn't work for numbers longer than padding print("(:2d)".format(1234)) # padding for float numbers print("(:8.3f)".format(12.2346)) # integer numbers with minimum width filled with zeros print("(:05d)".format(12)) # padding for float numbers filled with zeros print("(:08.3f)".format(12.2346))

Output

 1 2 1 2 3 4 1 2 . 2 3 5 0 0 0 1 2 0 0 1 2 . 2 3 5 

Here,

• in the first statement, (:5d) takes an integer argument and assigns a minimum width of 5. Since, no alignment is specified, it is aligned to the right.
• In the second statement, you can see the width (2) is less than the number (1234), so it doesn't take any space to the left but also doesn't truncate the number.
• Unlike integers, floats has both integer and decimal parts. And, the mininum width defined to the number is for both parts as a whole including ".".
• In the third statement, (:8.3f) truncates the decimal part into 3 places rounding off the last 2 digits. And, the number, now 12.235, takes a width of 8 as a whole leaving 2 places to the left.
• If you want to fill the remaining places with zero, placing a zero before the format specifier does this. It works both for integers and floats: (:05d) and (:08.3f).

Example 4: Number formatting for signed numbers

 # show the + sign print("(:+f) (:+f)".format(12.23, -12.23)) # show the - sign only print("(:-f) (:-f)".format(12.23, -12.23)) # show space for + sign print("(: f) (: f)".format(12.23, -12.23))

Output

+12.230000 -12.230000 12.230000 -12.230000 1 2. 2 3 0 0 0 0 - 1 2. 2 3 0 0 0 0

Zahlenformatierung mit Ausrichtung

Die Operatoren and =werden zur Ausrichtung verwendet, wenn den Zahlen eine bestimmte Breite zugewiesen wird.

Beispiel 5: Zahlenformatierung mit Links-, Rechts- und Mittelausrichtung

 # integer numbers with right alignment print("(:5d)".format(12)) # float numbers with center alignment print("(:^10.3f)".format(12.2346)) # integer left alignment filled with zeros print("(:<05d)".format(12)) # float numbers with center alignment print("(:=8.3f)".format(-12.2346))

Ausgabe

1 2 1 2. 2 3 5 1 2 0 0 0 - 1 2. 2 3 5

Hinweis: Die mit Nullen für Ganzzahlen gefüllte linke Ausrichtung kann Probleme verursachen, da das dritte Beispiel 12000 anstelle von 12 zurückgibt.

String-Formatierung mit format ()

Als Zahlen kann eine Zeichenfolge auf ähnliche Weise mit formatiert werden format().

Example 6: String formatting with padding and alignment

 # string padding with left alignment print("(:5)".format("cat")) # string padding with right alignment print("(:>5)".format("cat")) # string padding with center alignment print("(:^5)".format("cat")) # string padding with center alignment # and '*' padding character print("(:*^5)".format("cat"))

Output

 c a t c a t c a t * c a t * 

Example 7: Truncating strings with format()

 # truncating strings to 3 letters print("(:.3)".format("caterpillar")) # truncating strings to 3 letters # and padding print("(:5.3)".format("caterpillar")) # truncating strings to 3 letters, # padding and center alignment print("(:^5.3)".format("caterpillar"))

Output

 c a t c a t c a t 

Formatting class and dictionary members using format()

Python internally uses getattr() for class members in the form ".age". And, it uses __getitem__() lookup for dictionary members in the form "(index)".

Example 8: Formatting class members using format()

 # define Person class class Person: age = 23 name = "Adam" # format age print("(p.name)'s age is: (p.age)".format(p=Person()))

Output

 Adam's age is: 23 

Here, Person object is passed as a keyword argument p.

Inside the template string, Person's name and age are accessed using .name and .age respectively.

Example 9: Formatting dictionary members using format()

 # define Person dictionary person = ('age': 23, 'name': 'Adam') # format age print("(p(name))'s age is: (p(age))".format(p=person))

Output

 Adam's age is: 23 

Similar to class, person dictionary is passed as a keyword argument p.

Inside the template string, person's name and age are accessed using (name) and (age) respectively.

There's an easier way to format dictionaries in Python using str.format(**mapping).

 # define Person dictionary person = ('age': 23, 'name': 'Adam') # format age print("(name)'s age is: (age)".format(**person))

** is a format parameter (minimum field width).

Arguments as format codes using format()

You can also pass format codes like precision, alignment, fill character as positional or keyword arguments dynamically.

Example 10: Dynamic formatting using format()

 # dynamic string format template string = "(:(fill)(align)(width))" # passing format codes as arguments print(string.format('cat', fill='*', # dynamic float format template num = "(:(align)(width).(precision)f)" # passing format codes as arguments print(num.format(123.236,>

 * * c a t * * 1 2 3 . 2 4 

 import datetime # datetime formatting date = datetime.datetime.now() print("It's now: (:%Y/%m/%d %H:%M:%S)".format(date)) # complex number formatting complexNumber = 1+2j print("Real part: (0.real) and Imaginary part: (0.imag)".format(complexNumber)) # custom __format__() method class Person: def __format__(self, format): if(format == 'age'): return '23' return 'None' print("Adam's age is: (:age)".format(Person()))

 It's now: 2016/12/02 04:16:28 Real part: 1.0 and Imaginary part: 2.0 Adam's age is: 23 

 # __str__() and __repr__() shorthand !r and !s print("Quotes: (0!r), Without Quotes: (0!s)".format("cat")) # __str__() and __repr__() implementation for class class Person: def __str__(self): return "STR" def __repr__(self): return "REPR" print("repr: (p!r), str: (p!s)".format(p=Person()))

 Zitate: 'Katze', Ohne Zitate: Katze Repr: REPR, Str: STR