"string" --- Common string operations
*************************************

**Source code:** Lib/string.py

======================================================================

Siehe auch:

  Text Sequence Type --- str

  String Methods


String-Konstanten
=================

Die in diesem Modul definierten Konstanten sind:

string.ascii_letters

   Die Konkatenation der unten beschriebenen Konstanten
   "ascii_lowercase" und "ascii_uppercase". Dieser Wert ist nicht
   locale-abhängig.

string.ascii_lowercase

   Die Kleinbuchstaben "'abcdefghijklmnopqrstuvwxyz'". Dieser Wert ist
   nicht locale-abhängig und ändert sich nicht.

string.ascii_uppercase

   Die Großbuchstaben "'ABCDEFGHIJKLMNOPQRSTUVWXYZ'". Dieser Wert ist
   nicht locale-abhängig und ändert sich nicht.

string.digits

   Die Zeichenkette "'0123456789'".

string.hexdigits

   Die Zeichenkette "'0123456789abcdefABCDEF'".

string.octdigits

   Die Zeichenkette "'01234567'".

string.punctuation

   Zeichenkette von ASCII-Zeichen, die im "C"-locale als Satzzeichen
   gelten: "!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~".

string.printable

   String of ASCII characters which are considered printable.  This is
   a combination of "digits", "ascii_letters", "punctuation", and
   "whitespace".

string.whitespace

   Eine Zeichenkette, die alle ASCII-Zeichen enthält, die als
   Whitespace gelten. Dies umfasst die Zeichen Leerzeichen, Tabulator,
   Zeilenvorschub (linefeed), Zeilenrücklauf (return), Seitenvorschub
   (formfeed) und vertikaler Tabulator.


Custom String Formatting
========================

The built-in string class provides the ability to do complex variable
substitutions and value formatting via the "format()" method described
in **PEP 3101**.  The "Formatter" class in the "string" module allows
you to create and customize your own string formatting behaviors using
the same implementation as the built-in "format()" method.

class string.Formatter

   Die Klasse "Formatter" hat die folgenden öffentlichen Methoden:

   format(format_string, /, *args, **kwargs)

      Die Haupt-API-Methode. Sie nimmt einen Formatstring sowie eine
      beliebige Menge an Positions- und Schlüsselwort-Argumenten
      entgegen. Sie ist nur ein Wrapper, der "vformat()" aufruft.

      Geändert in Version 3.7: Ein Formatstring-Argument ist jetzt
      positional-only.

   vformat(format_string, args, kwargs)

      Diese Funktion führt die eigentliche Formatierungsarbeit durch.
      Sie ist als separate Funktion für Fälle verfügbar, in denen du
      ein vordefiniertes Dictionary von Argumenten übergeben möchtest,
      anstatt das Dictionary mit der Syntax "*args" und "**kwargs" als
      einzelne Argumente zu entpacken und neu zu verpacken.
      "vformat()" übernimmt das Aufteilen des Formatstrings in
      Zeichendaten und Ersetzungsfelder. Sie ruft die verschiedenen
      unten beschriebenen Methoden auf.

   Darüber hinaus definiert "Formatter" eine Reihe von Methoden, die
   dazu gedacht sind, von Unterklassen überschrieben zu werden:

   parse(format_string)

      Durchläuft den format_string und gibt ein Iterable aus Tupeln
      (*literal_text*, *field_name*, *format_spec*, *conversion*)
      zurück. Dies wird von "vformat()" verwendet, um die Zeichenkette
      entweder in Literaltext oder Ersetzungsfelder zu zerlegen.

      The values in the tuple conceptually represent a span of literal
      text followed by a single replacement field.  If there is no
      literal text (which can happen if two replacement fields occur
      consecutively), then *literal_text* will be a zero-length
      string.  If there is no replacement field, then the values of
      *field_name*, *format_spec* and *conversion* will be "None".

   get_field(field_name, args, kwargs)

      Given *field_name* as returned by "parse()" (see above), convert
      it to an object to be formatted.  Returns a tuple (obj,
      used_key).  The default version takes strings of the form
      defined in **PEP 3101**, such as "0[name]" or "label.title".
      *args* and *kwargs* are as passed in to "vformat()".  The return
      value *used_key* has the same meaning as the *key* parameter to
      "get_value()".

   get_value(key, args, kwargs)

      Ruft einen gegebenen Feldwert ab. Das Argument *key* ist
      entweder eine Ganzzahl oder eine Zeichenkette. Wenn es eine
      Ganzzahl ist, repräsentiert es den Index des Positionsarguments
      in *args*; wenn es eine Zeichenkette ist, repräsentiert es ein
      benanntes Argument in *kwargs*.

      Der Parameter *args* ist auf die Liste der Positionsargumente
      für "vformat()" gesetzt und der Parameter *kwargs* auf das
      Dictionary der Schlüsselwort-Argumente.

      Bei zusammengesetzten Feldnamen werden diese Funktionen nur für
      die erste Komponente des Feldnamens aufgerufen; nachfolgende
      Komponenten werden über normale Attribut- und
      Indizierungsoperationen verarbeitet.

      So würde beispielsweise der Feldausdruck '0.name' dazu führen,
      dass "get_value()" mit dem Argument *key* gleich 0 aufgerufen
      wird. Das Attribut "name" wird nach der Rückgabe von
      "get_value()" durch den Aufruf der eingebauten Funktion
      "getattr()" nachgeschlagen.

      Wenn sich der Index oder das Schlüsselwort auf ein Element
      bezieht, das nicht existiert, sollte ein "IndexError" oder
      "KeyError" ausgelöst werden.

   check_unused_args(used_args, args, kwargs)

      Implementiert bei Bedarf die Prüfung auf unbenutzte Argumente.
      Die Argumente dieser Funktion sind die Menge aller Argument-
      Schlüssel, auf die im Formatstring tatsächlich verwiesen wurde
      (Ganzzahlen für Positionsargumente und Zeichenketten für
      benannte Argumente), sowie eine Referenz auf *args* und
      *kwargs*, die an vformat übergeben wurden. Die Menge der
      unbenutzten Argumente kann aus diesen Parametern berechnet
      werden. Es wird davon ausgegangen, dass "check_unused_args()"
      eine Ausnahme auslöst, wenn die Prüfung fehlschlägt.

   format_field(value, format_spec)

      "format_field()" ruft einfach die globale eingebaute Funktion
      "format()" auf. Die Methode wird bereitgestellt, damit
      Unterklassen sie überschreiben können.

   convert_field(value, conversion)

      Konvertiert den Wert (der von "get_field()" zurückgegeben wird)
      anhand eines Konvertierungstyps (wie in dem von der Methode
      "parse()" zurückgegebenen Tupel). Die Standardversion
      unterstützt die Konvertierungstypen 's' (str), 'r' (repr) und
      'a' (ascii).


Format String Syntax
====================

The "str.format()" method and the "Formatter" class share the same
syntax for format strings (although in the case of "Formatter",
subclasses can define their own format string syntax).  The syntax is
related to that of formatted string literals, but it is less
sophisticated and, in particular, does not support arbitrary
expressions.

Formatstrings enthalten „Ersetzungsfelder“, die von geschweiften
Klammern "{}" umgeben sind. Alles, was nicht in Klammern steht, wird
als Literaltext betrachtet und unverändert in die Ausgabe kopiert.
Wenn ein Klammerzeichen im Literatext enthalten sein muss, kann es
durch Verdopplung maskiert werden: "{{" und "}}".

Die Grammatik für ein Ersetzungsfeld lautet wie folgt:

   replacement_field ::= "{" [field_name] ["!" conversion] [":" format_spec] "}"
   field_name        ::= arg_name ("." attribute_name | "[" element_index "]")*
   arg_name          ::= [identifier | digit+]
   attribute_name    ::= identifier
   element_index     ::= digit+ | index_string
   index_string      ::= <any source character except "]"> +
   conversion        ::= "r" | "s" | "a"
   format_spec       ::= format-spec:format_spec

Einfacher ausgedrückt kann das Ersetzungsfeld mit einem *field_name*
beginnen, der das Objekt angibt, dessen Wert formatiert und anstelle
des Ersetzungsfeldes in die Ausgabe eingefügt werden soll. Auf den
*field_name* folgt optional ein *conversion*-Feld, dem ein
Ausrufezeichen "'!'" vorangestellt ist, und eine *format_spec*, der
ein Doppelpunkt "':'" vorangestellt ist. Diese geben ein vom Standard
abweichendes Format für den Ersetzungswert an.

Siehe auch den Abschnitt Format Specification Mini-Language.

The *field_name* itself begins with an *arg_name* that is either a
number or a keyword.  If it's a number, it refers to a positional
argument, and if it's a keyword, it refers to a named keyword
argument. An *arg_name* is treated as a number if a call to
"str.isdecimal()" on the string would return true. If the numerical
arg_names in a format string are 0, 1, 2, ... in sequence, they can
all be omitted (not just some) and the numbers 0, 1, 2, ... will be
automatically inserted in that order. Because *arg_name* is not quote-
delimited, it is not possible to specify arbitrary dictionary keys
(e.g., the strings "'10'" or "':-]'") within a format string. The
*arg_name* can be followed by any number of index or attribute
expressions. An expression of the form "'.name'" selects the named
attribute using "getattr()", while an expression of the form
"'[index]'" does an index lookup using "__getitem__()".

Geändert in Version 3.1: Die Positionsargument-Spezifikatoren können
für "str.format()" weggelassen werden, sodass "'{} {}'.format(a, b)"
äquivalent zu "'{0} {1}'.format(a, b)" ist.

Geändert in Version 3.4: Die Positionsargument-Spezifikatoren können
für "Formatter" weggelassen werden.

Einige einfache Beispiele für Formatstrings:

   "First, thou shalt count to {0}"  # References first positional argument
   "Bring me a {}"                   # Implicitly references the first positional argument
   "From {} to {}"                   # Same as "From {0} to {1}"
   "My quest is {name}"              # References keyword argument 'name'
   "Weight in tons {0.weight}"       # 'weight' attribute of first positional arg
   "Units destroyed: {players[0]}"   # First element of keyword argument 'players'.

The *conversion* field causes a type coercion before formatting.
Normally, the job of formatting a value is done by the "__format__()"
method of the value itself.  However, in some cases it is desirable to
force a type to be formatted as a string, overriding its own
definition of formatting.  By converting the value to a string before
calling "__format__()", the normal formatting logic is bypassed.

Drei Konvertierungsflags werden derzeit unterstützt: "'!s'", das
"str()" für den Wert aufruft, "'!r'", das "repr()" aufruft, und
"'!a'", das "ascii()" aufruft.

Einige Beispiele:

   "Harold's a clever {0!s}"        # Calls str() on the argument first
   "Bring out the holy {name!r}"    # Calls repr() on the argument first
   "More {!a}"                      # Calls ascii() on the argument first

Das Feld *format_spec* enthält eine Spezifikation darüber, wie der
Wert dargestellt werden soll, einschließlich Details wie Feldbreite,
Ausrichtung, Auffüllung, Dezimalpräzision und so weiter. Jeder Werttyp
kann seine eigene „Formatierungs-Minisprache“ oder Interpretation der
*format_spec* definieren.

Die meisten eingebauten Typen unterstützen eine gemeinsame
Formatierungs-Mini-Sprache, die im nächsten Abschnitt beschrieben
wird.

Ein *format_spec*-Feld kann auch verschachtelte Ersetzungsfelder
enthalten. Diese verschachtelten Ersetzungsfelder können einen
Feldnamen, ein Konvertierungskennzeichen und eine Formatangabe
enthalten, eine tiefere Verschachtelung ist jedoch nicht zulässig. Die
Ersetzungsfelder innerhalb von *format_spec* werden ersetzt, bevor die
*format_spec*-Zeichenkette interpretiert wird. Dies ermöglicht es dir,
die Formatierung eines Werts dynamisch anzugeben.

Siehe den Abschnitt Formatierungsbeispiele für einige Beispiele.


Format Specification Mini-Language
----------------------------------

"Format specifications" are used within replacement fields contained
within a format string to define how individual values are presented
(see Format String Syntax and f-Strings). They can also be passed
directly to the built-in "format()" function.  Each formattable type
may define how the format specification is to be interpreted.

Die meisten eingebauten Typen implementieren die folgenden Optionen
für Formatspezifikationen, obwohl einige der Formatierungsoptionen nur
von den numerischen Typen unterstützt werden.

Eine allgemeine Konvention besagt, dass eine leere Formatspezifikation
dasselbe Ergebnis erzeugt, wie wenn du "str()" für den Wert aufgerufen
hättest. Eine nicht leere Formatspezifikation verändert in der Regel
das Ergebnis.

Die allgemeine Form einer *Standard-Formatspezifikation* ist:

   format_spec     ::= [[fill]align][sign]["z"]["#"]["0"][width][grouping_option]["." precision][type]
   fill            ::= <any character>
   align           ::= "<" | ">" | "=" | "^"
   sign            ::= "+" | "-" | " "
   width           ::= digit+
   grouping_option ::= "_" | ","
   precision       ::= digit+
   type            ::= "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "s" | "x" | "X" | "%"

Wenn ein gültiger *align*-Wert angegeben ist, kann ihm ein
*fill*-Zeichen vorangestellt werden, das ein beliebiges Zeichen sein
kann und standardmäßig ein Leerzeichen ist, wenn es weggelassen wird.
Es ist nicht möglich, eine geschweifte Klammer (""{"" oder ""}"") als
*fill*-Zeichen in einem formatted string literal oder bei der
Verwendung der "str.format()" Methode zu verwenden. Es ist jedoch
möglich, eine geschweifte Klammer mit einem verschachtelten
Ersetzungsfeld einzufügen. Diese Einschränkung betrifft die
"format()"-Funktion nicht.

Die Bedeutung der verschiedenen Ausrichtungsoptionen ist wie folgt:

+-----------+------------------------------------------------------------+
| Option    | Bedeutung                                                  |
|===========|============================================================|
| "'<'"     | Erzwingt, dass das Feld innerhalb des verfügbaren Platzes  |
|           | linksbündig ausgerichtet wird (dies ist der Standardwert   |
|           | für die meisten Objekte).                                  |
+-----------+------------------------------------------------------------+
| "'>'"     | Erzwingt, dass das Feld innerhalb des verfügbaren Platzes  |
|           | rechtsbündig ausgerichtet wird (dies ist der Standard für  |
|           | Zahlen).                                                   |
+-----------+------------------------------------------------------------+
| "'='"     | Forces the padding to be placed after the sign (if any)    |
|           | but before the digits.  This is used for printing fields   |
|           | in the form '+000000120'. This alignment option is only    |
|           | valid for numeric types.  It becomes the default for       |
|           | numbers when '0' immediately precedes the field width.     |
+-----------+------------------------------------------------------------+
| "'^'"     | Erzwingt, dass das Feld innerhalb des verfügbaren Platzes  |
|           | zentriert ausgerichtet wird.                               |
+-----------+------------------------------------------------------------+

Beachte, dass die Feldbreite, sofern keine Mindestfeldbreite definiert
ist, immer dieselbe Größe wie die darin enthaltenen Daten hat, sodass
die Ausrichtungsoption in diesem Fall keine Bedeutung hat.

Die Option *sign* ist nur für numerische Typen gültig und kann eine
der folgenden sein:

+-----------+------------------------------------------------------------+
| Option    | Bedeutung                                                  |
|===========|============================================================|
| "'+'"     | indicates that a sign should be used for both positive as  |
|           | well as negative numbers.                                  |
+-----------+------------------------------------------------------------+
| "'-'"     | indicates that a sign should be used only for negative     |
|           | numbers (this is the default behavior).                    |
+-----------+------------------------------------------------------------+
| Leerzeic  | indicates that a leading space should be used on positive  |
| hen       | numbers, and a minus sign on negative numbers.             |
+-----------+------------------------------------------------------------+

Die Option "'z'" wandelt negative Null-Gleitkommawerte nach dem Runden
auf die Formatpräzision in eine positive Null um. Diese Option ist nur
für Gleitkomma-Darstellungstypen gültig.

Geändert in Version 3.11: Die Option "'z'" wurde hinzugefügt (siehe
auch **PEP 682**).

Die Option "'#'" bewirkt, dass die "alternative Form" für die
Umwandlung verwendet wird. Die alternative Form ist für verschiedene
Typen unterschiedlich definiert. Diese Option ist nur für die Typen
Integer, Float und Complex gültig. Wenn bei Integern eine Binär-,
Oktal- oder Hexadezimalausgabe verwendet wird, fügt diese Option dem
Ausgabewert das entsprechende Präfix "'0b'", "'0o'", "'0x'" oder
"'0X'" hinzu. Bei Float und Complex führt die alternative Form dazu,
dass das Ergebnis der Umwandlung immer ein Dezimalpunkt-Zeichen
enthält, selbst wenn keine Ziffern folgen. Normalerweise erscheint ein
Dezimalpunkt-Zeichen im Ergebnis dieser Umwandlungen nur, wenn eine
Ziffer folgt. Zudem werden bei "'g'"- und "'G'"- Umwandlungen
nachstehende Nullen nicht aus dem Ergebnis entfernt.

The "','" option signals the use of a comma for a thousands separator.
For a locale aware separator, use the "'n'" integer presentation type
instead.

Geändert in Version 3.1: Die Option "','" wurde hinzugefügt (siehe
auch **PEP 378**).

The "'_'" option signals the use of an underscore for a thousands
separator for floating point presentation types and for integer
presentation type "'d'".  For integer presentation types "'b'", "'o'",
"'x'", and "'X'", underscores will be inserted every 4 digits.  For
other presentation types, specifying this option is an error.

Geändert in Version 3.6: Die Option "'_'" wurde hinzugefügt (siehe
auch **PEP 515**).

*width* is a decimal integer defining the minimum total field width,
including any prefixes, separators, and other formatting characters.
If not specified, then the field width will be determined by the
content.

When no explicit alignment is given, preceding the *width* field by a
zero ("'0'") character enables sign-aware zero-padding for numeric
types.  This is equivalent to a *fill* character of "'0'" with an
*alignment* type of "'='".

Geändert in Version 3.10: Eine vorangestellte "'0'" vor dem Feld
*width* hat keinen Einfluss mehr auf die Standardausrichtung von
Zeichenketten.

Die Präzision (*precision*) ist eine dezimale Ganzzahl, die angibt,
wie viele Stellen nach dem Dezimalpunkt bei den Darstellungstypen
"'f'" und "'F'" oder vor und nach dem Dezimalpunkt bei den
Darstellungstypen "'g'" oder "'G'" angezeigt werden sollen. Bei
Zeichenketten-Darstellungstypen gibt das Feld die maximale Feldgröße
an – mit anderen Worten, wie viele Zeichen aus dem Feldinhalt
verwendet werden. Die *precision* ist für Ganzzahl-Darstellungstypen
nicht zulässig.

Schließlich bestimmt der Typ (*type*), wie die Daten dargestellt
werden sollen.

Die verfügbaren Zeichenketten-Darstellungstypen sind:

   +-----------+------------------------------------------------------------+
   | Typ       | Bedeutung                                                  |
   |===========|============================================================|
   | "'s'"     | Zeichenkettenformat. Dies ist der Standardtyp für          |
   |           | Zeichenketten und kann weggelassen werden.                 |
   +-----------+------------------------------------------------------------+
   | None      | Gleichbedeutend mit "'s'".                                 |
   +-----------+------------------------------------------------------------+

Die verfügbaren Ganzzahl-Darstellungstypen sind:

   +-----------+------------------------------------------------------------+
   | Typ       | Bedeutung                                                  |
   |===========|============================================================|
   | "'b'"     | Binärformat. Gibt die Zahl zur Basis 2 aus.                |
   +-----------+------------------------------------------------------------+
   | "'c'"     | Zeichen. Konvertiert die Ganzzahl vor der Ausgabe in das   |
   |           | entsprechende Unicode-Zeichen.                             |
   +-----------+------------------------------------------------------------+
   | "'d'"     | Dezimalzahl. Gibt die Zahl zur Basis 10 aus.               |
   +-----------+------------------------------------------------------------+
   | "'o'"     | Oktalformat. Gibt die Zahl zur Basis 8 aus.                |
   +-----------+------------------------------------------------------------+
   | "'x'"     | Hexadezimalformat. Gibt die Zahl zur Basis 16 aus und      |
   |           | verwendet dabei Kleinbuchstaben für die Ziffern über 9.    |
   +-----------+------------------------------------------------------------+
   | "'X'"     | Hexadezimalformat. Gibt die Zahl zur Basis 16 aus und      |
   |           | verwendet dabei Großbuchstaben für die Ziffern über 9.     |
   |           | Falls "'#'" angegeben ist, wird auch der Präfix "'0x'" zu  |
   |           | "'0X'" großgeschrieben.                                    |
   +-----------+------------------------------------------------------------+
   | "'n'"     | Number. This is the same as "'d'", except that it uses the |
   |           | current locale setting to insert the appropriate number    |
   |           | separator characters.                                      |
   +-----------+------------------------------------------------------------+
   | None      | Gleichbedeutend mit "'d'".                                 |
   +-----------+------------------------------------------------------------+

In addition to the above presentation types, integers can be formatted
with the floating point presentation types listed below (except "'n'"
and "None"). When doing so, "float()" is used to convert the integer
to a floating point number before formatting.

Die verfügbaren Darstellungstypen für "float" und "Decimal" Werte
sind:

   +-----------+------------------------------------------------------------+
   | Typ       | Bedeutung                                                  |
   |===========|============================================================|
   | "'e'"     | Scientific notation. For a given precision "p", formats    |
   |           | the number in scientific notation with the letter 'e'      |
   |           | separating the coefficient from the exponent. The          |
   |           | coefficient has one digit before and "p" digits after the  |
   |           | decimal point, for a total of "p + 1" significant digits.  |
   |           | With no precision given, uses a precision of "6" digits    |
   |           | after the decimal point for "float", and shows all         |
   |           | coefficient digits for "Decimal". If no digits follow the  |
   |           | decimal point, the decimal point is also removed unless    |
   |           | the "#" option is used.                                    |
   +-----------+------------------------------------------------------------+
   | "'E'"     | Wissenschaftliche Notation. Entspricht "'e'", verwendet    |
   |           | jedoch ein großes 'E' als Trennzeichen.                    |
   +-----------+------------------------------------------------------------+
   | "'f'"     | Fixed-point notation. For a given precision "p", formats   |
   |           | the number as a decimal number with exactly "p" digits     |
   |           | following the decimal point. With no precision given, uses |
   |           | a precision of "6" digits after the decimal point for      |
   |           | "float", and uses a precision large enough to show all     |
   |           | coefficient digits for "Decimal". If no digits follow the  |
   |           | decimal point, the decimal point is also removed unless    |
   |           | the "#" option is used.                                    |
   +-----------+------------------------------------------------------------+
   | "'F'"     | Festkommanotation. Entspricht "'f'", wandelt jedoch "nan"  |
   |           | in "NAN" und "inf" in "INF" um.                            |
   +-----------+------------------------------------------------------------+
   | "'g'"     | Allgemeines Format. Für eine gegebene Präzision "p >= 1"   |
   |           | rundet dies die Zahl auf "p" signifikante Stellen und      |
   |           | formatiert das Ergebnis je nach seiner Größenordnung       |
   |           | entweder in Festkommanotation oder in wissenschaftlicher   |
   |           | Notation. Eine Präzision von "0" wird wie eine Präzision   |
   |           | von "1" behandelt.  Die genauen Regeln lauten wie folgt:   |
   |           | Angenommen, das mit dem Darstellungstyp "'e'" und der      |
   |           | Präzision "p-1" formatierte Ergebnis hätte den Exponenten  |
   |           | "exp". Wenn dann "m <= exp < p" gilt, wobei "m" für Floats |
   |           | -4 und für "Decimals" -6 ist, wird die Zahl mit dem        |
   |           | Darstellungstyp "'f'" und der Präzision "p-1-exp"          |
   |           | formatiert. Andernfalls wird die Zahl mit dem              |
   |           | Darstellungstyp "'e'" und der Präzision "p-1" formatiert.  |
   |           | In beiden Fällen werden irrelavante nachstehende Nullen    |
   |           | aus der Mantisse entfernt, und auch der Dezimalpunkt wird  |
   |           | entfernt, wenn keine weiteren Ziffern folgen, es sei denn, |
   |           | die Option "'#'" wird verwendet.  Wenn keine Präzision     |
   |           | angegeben ist, wird für "float" eine Präzision von "6"     |
   |           | signifikanten Stellen verwendet. Für "Decimal" wird der    |
   |           | Koeffizient des Ergebnisses aus den Koeffizientenziffern   |
   |           | des Werts gebildet; wissenschaftliche Notation wird für    |
   |           | Werte verwendet, deren Absolutwert kleiner als "1e-6" ist  |
   |           | sowie für Werte, bei denen der Stellenwert der             |
   |           | niederwertigsten Ziffer größer als 1 ist, andernfalls wird |
   |           | Festkommanotation verwendet.  Positives und negatives      |
   |           | Unendlich, positive und negative Null sowie NaNs werden    |
   |           | unabhängig von der Präzision als "inf", "-inf", "0", "-0"  |
   |           | bzw. "nan" formatiert.                                     |
   +-----------+------------------------------------------------------------+
   | "'G'"     | Allgemeines Format. Entspricht "'g'", wechselt jedoch zu   |
   |           | "'E'", wenn die Zahl zu groß wird. Die Darstellungen von   |
   |           | Unendlich und NaN werden ebenfalls in Großbuchstaben       |
   |           | ausgegeben.                                                |
   +-----------+------------------------------------------------------------+
   | "'n'"     | Number. This is the same as "'g'", except that it uses the |
   |           | current locale setting to insert the appropriate number    |
   |           | separator characters.                                      |
   +-----------+------------------------------------------------------------+
   | "'%'"     | Prozentsatz. Multipliziert die Zahl mit 100 und zeigt sie  |
   |           | im Festkomma-Format ("'f'") an, gefolgt von einem          |
   |           | Prozentzeichen.                                            |
   +-----------+------------------------------------------------------------+
   | None      | For "float" this is the same as "'g'", except that when    |
   |           | fixed-point notation is used to format the result, it      |
   |           | always includes at least one digit past the decimal point. |
   |           | The precision used is as large as needed to represent the  |
   |           | given value faithfully.  Für "Decimal" entspricht dies     |
   |           | entweder "'g'" oder "'G'", abhängig vom Wert von           |
   |           | "context.capitals" des aktuellen Decimal-Kontexts.  Der    |
   |           | Gesamteffekt besteht darin, der Ausgabe von "str()" zu     |
   |           | entsprechen, wie sie durch die anderen Formatmodifikatoren |
   |           | geändert wird.                                             |
   +-----------+------------------------------------------------------------+


Formatierungsbeispiele
----------------------

Dieser Abschnitt enthält Beispiele für die "str.format()"-Syntax und
einen Vergleich mit der alten "%"-Formatierung.

In den meisten Fällen ähnelt die Syntax der alten "%"-Formatierung,
mit der Ergänzung von "{}" und der Verwendung von ":" anstelle von
"%". Beispielsweise kann "'%03.2f'" in "'{:03.2f}'" übersetzt werden.

Die neue Format-Syntax unterstützt auch neue und andere Optionen, die
in den folgenden Beispielen gezeigt werden.

Zugriff auf Argumente über die Position:

   >>> '{0}, {1}, {2}'.format('a', 'b', 'c')
   'a, b, c'
   >>> '{}, {}, {}'.format('a', 'b', 'c')  # 3.1+ only
   'a, b, c'
   >>> '{2}, {1}, {0}'.format('a', 'b', 'c')
   'c, b, a'
   >>> '{2}, {1}, {0}'.format(*'abc')      # unpacking argument sequence
   'c, b, a'
   >>> '{0}{1}{0}'.format('abra', 'cad')   # arguments' indices can be repeated
   'abracadabra'

Zugriff auf Argumente über den Namen:

   >>> 'Coordinates: {latitude}, {longitude}'.format(latitude='37.24N', longitude='-115.81W')
   'Coordinates: 37.24N, -115.81W'
   >>> coord = {'latitude': '37.24N', 'longitude': '-115.81W'}
   >>> 'Coordinates: {latitude}, {longitude}'.format(**coord)
   'Coordinates: 37.24N, -115.81W'

Zugriff auf Attribute von Argumenten:

   >>> c = 3-5j
   >>> ('The complex number {0} is formed from the real part {0.real} '
   ...  'and the imaginary part {0.imag}.').format(c)
   'The complex number (3-5j) is formed from the real part 3.0 and the imaginary part -5.0.'
   >>> class Point:
   ...     def __init__(self, x, y):
   ...         self.x, self.y = x, y
   ...     def __str__(self):
   ...         return 'Point({self.x}, {self.y})'.format(self=self)
   ...
   >>> str(Point(4, 2))
   'Point(4, 2)'

Zugriff auf Elemente von Argumenten:

   >>> coord = (3, 5)
   >>> 'X: {0[0]};  Y: {0[1]}'.format(coord)
   'X: 3;  Y: 5'

Ersetzen von "%s" und "%r":

   >>> "repr() shows quotes: {!r}; str() doesn't: {!s}".format('test1', 'test2')
   "repr() shows quotes: 'test1'; str() doesn't: test2"

Ausrichten von Text und Angeben einer Breite:

   >>> '{:<30}'.format('left aligned')
   'left aligned                  '
   >>> '{:>30}'.format('right aligned')
   '                 right aligned'
   >>> '{:^30}'.format('centered')
   '           centered           '
   >>> '{:*^30}'.format('centered')  # use '*' as a fill char
   '***********centered***********'

Ersetzen von "%+f", "%-f" und "% f" sowie Angeben eines Vorzeichens:

   >>> '{:+f}; {:+f}'.format(3.14, -3.14)  # show it always
   '+3.140000; -3.140000'
   >>> '{: f}; {: f}'.format(3.14, -3.14)  # show a space for positive numbers
   ' 3.140000; -3.140000'
   >>> '{:-f}; {:-f}'.format(3.14, -3.14)  # show only the minus -- same as '{:f}; {:f}'
   '3.140000; -3.140000'

Ersetzen von "%x" und "%o" und Umwandeln des Werts in verschiedene
Basen:

   >>> # format also supports binary numbers
   >>> "int: {0:d};  hex: {0:x};  oct: {0:o};  bin: {0:b}".format(42)
   'int: 42;  hex: 2a;  oct: 52;  bin: 101010'
   >>> # with 0x, 0o, or 0b as prefix:
   >>> "int: {0:d};  hex: {0:#x};  oct: {0:#o};  bin: {0:#b}".format(42)
   'int: 42;  hex: 0x2a;  oct: 0o52;  bin: 0b101010'

Using the comma as a thousands separator:

   >>> '{:,}'.format(1234567890)
   '1,234,567,890'

Angabe eines Prozentsatzes:

   >>> points = 19
   >>> total = 22
   >>> 'Correct answers: {:.2%}'.format(points/total)
   'Correct answers: 86.36%'

Verwendung typspezifischer Formatierung:

   >>> import datetime
   >>> d = datetime.datetime(2010, 7, 4, 12, 15, 58)
   >>> '{:%Y-%m-%d %H:%M:%S}'.format(d)
   '2010-07-04 12:15:58'

Verschachteln von Argumenten und komplexere Beispiele:

   >>> for align, text in zip('<^>', ['left', 'center', 'right']):
   ...     '{0:{fill}{align}16}'.format(text, fill=align, align=align)
   ...
   'left<<<<<<<<<<<<'
   '^^^^^center^^^^^'
   '>>>>>>>>>>>right'
   >>>
   >>> octets = [192, 168, 0, 1]
   >>> '{:02X}{:02X}{:02X}{:02X}'.format(*octets)
   'C0A80001'
   >>> int(_, 16)
   3232235521
   >>>
   >>> width = 5
   >>> for num in range(5,12): 
   ...     for base in 'dXob':
   ...         print('{0:{width}{base}}'.format(num, base=base, width=width), end=' ')
   ...     print()
   ...
       5     5     5   101
       6     6     6   110
       7     7     7   111
       8     8    10  1000
       9     9    11  1001
      10     A    12  1010
      11     B    13  1011


Template strings
================

Vorlage-Zeichenketten bieten einfachere Ersetzungen von Zeichenketten,
wie in **PEP 292** beschrieben. Ein Hauptanwendungsfall für Vorlage-
Zeichenketten ist die Internationalisierung (i18n), da die einfachere
Syntax und Funktionalität in diesem Kontext die Übersetzung im
Vergleich zu anderen eingebauten Zeichenketten-
Formatierungsmöglichkeiten in Python erleichtert. Ein Beispiel für
eine auf Vorlage-Zeichenketten aufbauende Bibliothek für i18n ist das
Paket flufl.i18n.

Vorlage-Zeichenketten unterstützen "$"-basierte Ersetzungen nach den
folgenden Regeln:

* "$$" ist ein Maskierungszeichen; es wird durch ein einzelnes "$"
  ersetzt.

* "$identifier" benennt einen Ersetzungs-Platzhalter, der einem
  Mapping-Schlüssel von "\"identifier\"" entspricht. Standardmäßig ist
  "\"identifier\"" auf jede ASCII-alphanumerische Zeichenkette
  (einschließlich Unterstrichen) ohne Berücksichtigung von
  Groß-/Kleinschreibung beschränkt, die mit einem Unterstrich oder
  einem ASCII-Buchstaben beginnt. Das erste Nicht-Bezeichner-Zeichen
  nach dem "$"-Zeichen beendet diese Platzhalter-Spezifikation.

* "${identifier}" ist äquivalent zu "$identifier". Es ist
  erforderlich, wenn gültige Bezeichner-Zeichen auf den Platzhalter
  folgen, aber nicht Teil des Platzhalters sind, wie etwa
  "\"${noun}ification\"".

Jedes andere Vorkommen von "$" in der Zeichenkette führt dazu, dass
ein "ValueError" ausgelöst wird.

The "string" module provides a "Template" class that implements these
rules.  The methods of "Template" are:

class string.Template(template)

   Der Konstruktor nimmt ein einzelnes Argument entgegen, welches die
   Vorlage-Zeichenkette ist.

   substitute(mapping={}, /, **kwds)

      Führt die Ersetzung der Vorlage durch und gibt eine neue
      Zeichenkette zurück. *mapping* ist ein beliebiges Dictionary-
      ähnliches Objekt mit Schlüsseln, die den Platzhaltern in der
      Vorlage entsprechen. Alternativ können Sie
      Schlüsselwort-"Argumente angeben, wobei die Schlüsselwörter die
      Platzhalter sind. Wenn sowohl *mapping* als auch *kwds*
      angegeben sind und es Überschneidungen gibt, haben die
      Platzhalter aus *kwds* Vorrang.

   safe_substitute(mapping={}, /, **kwds)

      Wie "substitute()", außer dass, wenn Platzhalter in *mapping*
      und *kwds* fehlen, anstelle des Auslösens einer
      "KeyError"-Ausnahme der originale Platzhalter unverändert in der
      resultierenden Zeichenkette erscheint. Auch werden im Gegensatz
      zu "substitute()" alle anderen Vorkommen von "$" einfach als "$"
      zurückgegeben, anstatt einen "ValueError" auszulösen.

      Während weiterhin andere Ausnahmen auftreten können, wird diese
      Methode "safe" genannt, da sie immer versucht, eine brauchbare
      Zeichenkette zurückzugeben, anstatt eine Ausnahme auszulösen. In
      einem anderen Sinne ist "safe_substitute()" möglicherweise alles
      andere als sicher, da sie stillschweigend fehlerhafte Vorlagen
      ignoriert, die unvollständige Trennzeichen, unpaarige Klammern
      oder Platzhalter enthalten, welche keine gültigen Python-
      Bezeichner sind.

   is_valid()

      Returns false if the template has invalid placeholders that will
      cause "substitute()" to raise "ValueError".

      Neu in Version 3.11.

   get_identifiers()

      Gibt eine Liste der gültigen Bezeichner in der Vorlage in der
      Reihenfolge ihres ersten Auftretens zurück und ignoriert dabei
      ungültige Bezeichner.

      Neu in Version 3.11.

   "Template"-Instanzen stellen außerdem ein öffentliches
   Datenattribut bereit:

   template

      Dies ist das Objekt, das an das *template*-Argument des
      Konstruktors übergeben wird. Im Allgemeinen sollten Sie es nicht
      ändern, allerdings wird ein schreibgeschützter Zugriff nicht
      erzwungen.

Hier ist ein Beispiel für die Verwendung von Template:

   >>> from string import Template
   >>> s = Template('$who likes $what')
   >>> s.substitute(who='tim', what='kung pao')
   'tim likes kung pao'
   >>> d = dict(who='tim')
   >>> Template('Give $who $100').substitute(d)
   Traceback (most recent call last):
   ...
   ValueError: Invalid placeholder in string: line 1, col 11
   >>> Template('$who likes $what').substitute(d)
   Traceback (most recent call last):
   ...
   KeyError: 'what'
   >>> Template('$who likes $what').safe_substitute(d)
   'tim likes $what'

Fortgeschrittene Nutzung: Sie können Unterklassen von "Template"
ableiten, um die Platzhalter-Syntax, das Trennzeichen oder den
gesamten regulären Ausdruck zum Parsen von Vorlage-Zeichenketten
anzupassen. Dazu kannst du diese Klassenattribute überschreiben:

* *delimiter* -- Dies ist die Zeichenkette, die das einleitende
  Trennzeichen eines Platzhalters beschreibt. Der Standardwert ist
  "$". Beachte, dass dies *kein* regulärer Ausdruck sein sollte, da
  die Implementierung bei Bedarf "re.escape()" auf diese Zeichenkette
  anwendet. Beachte weiterhin, dass du das Trennzeichen nach der
  Klassenerstellung nicht mehr ändern kannst (d. h. ein anderes
  Trennzeichen muss im Klassennamensraum der Unterklasse gesetzt
  werden).

* *idpattern* -- Dies ist der reguläre Ausdruck, der das Muster für
  Platzhalter ohne geschweifte Klammern beschreibt. Der Standardwert
  ist der reguläre Ausdruck "(?a:[_a-z][_a-z0-9]*)". Wenn dieser
  angegeben ist und *braceidpattern* "None" ist, gilt dieses Muster
  auch für Platzhalter mit geschweiften Klammern.

  Bemerkung:

    Da standardmäßig *flags* auf "re.IGNORECASE" gesetzt ist, kann das
    Muster "[a-z]" auch auf einige Nicht-ASCII-Zeichen passen. Aus
    diesem Grund wird hier das lokale Flag "a" verwendet.

  Geändert in Version 3.7: *braceidpattern* kann verwendet werden, um
  unterschiedliche Muster für die Verwendung innerhalb und außerhalb
  der geschweiften Klammern zu definieren.

* *braceidpattern* -- Dies ist wie *idpattern*, beschreibt jedoch das
  Muster für Platzhalter mit geschweiften Klammern. Der Standardwert
  ist "None", was bedeutet, dass auf *idpattern* zurückgegriffen wird
  (d. h. dasselbe Muster wird sowohl innerhalb als auch außerhalb von
  Klammern verwendet). Falls angegeben, ermöglicht dies die Definition
  unterschiedlicher Muster für Platzhalter mit und ohne geschweifte
  Klammern.

  Neu in Version 3.7.

* *flags* -- Die Flags für reguläre Ausdrücke, die beim Kompilieren
  des regulären Ausdrucks zur Erkennung von Ersetzungen angewendet
  werden. Der Standardwert ist "re.IGNORECASE". Beachte, dass
  "re.VERBOSE" den Flags immer hinzugefügt wird, weshalb
  benutzerdefinierte *idpattern* den Konventionen für ausführliche
  reguläre Ausdrücke entsprechen müssen.

  Neu in Version 3.2.

Alternatively, you can provide the entire regular expression pattern
by overriding the class attribute *pattern*.  If you do this, the
value must be a regular expression object with four named capturing
groups.  The capturing groups correspond to the rules given above,
along with the invalid placeholder rule:

* *escaped* -- Diese Gruppe passt auf die Escapesequenz, z.B. "$$", im
  Standardmuster.

* *named* -- Diese Gruppe passt auf den Namen des Platzhalters ohne
  geschweifte Klammern; sie sollte das Trennzeichen nicht in der
  Erfassungsgruppe enthalten.

* *braced* -- Diese Gruppe passt auf den in geschweifte Klammern
  eingeschlossenen Namen des Platzhalters; sie sollte weder das
  Trennzeichen noch die Klammern in der Erfassungsgruppe enthalten.

* *invalid* -- Diese Gruppe passt auf jedes andere Trennzeichenmuster
  (normalerweise ein einzelnes Trennzeichen) und sollte als Letztes im
  regulären Ausdruck stehen.

Die Methoden dieser Klasse lösen "ValueError" aus, wenn das Muster auf
die Vorlage passt, ohne dass eine dieser benannten Gruppen
übereinstimmt.


Hilfsfunktionen
===============

string.capwords(s, sep=None)

   Teilt das Argument mithilfe von "str.split()" in Wörter auf,
   schreibt jedes Wort mithilfe von "str.capitalize()" groß und fügt
   die großgeschriebenen Wörter mit "str.join()" wieder zusammen. Wenn
   das optionale zweite Argument *sep* fehlt oder "None" ist, werden
   Abfolgen von Whitespace-Zeichen durch ein einzelnes Leerzeichen
   ersetzt und führende sowie abschließende Whitespaces entfernt;
   andernfalls wird *sep* zum Aufteilen und Zusammenfügen der Wörter
   verwendet.
