[Python 2/3] Analysiert die Formatzeichenfolge

Derzeit gibt es in Python drei Arten von Funktionen, die dem Sprintf von C entsprechen. (F-String wird ausgeschlossen, da kein Format-String verwendet wird)

In diesem Artikel wird zusammengefasst, wie Sie herausfinden können, wie viele Tapple-Elemente im Abschnitt "values" der obigen Tabelle oder in den Schlüsseln im Wörterbuch erforderlich sind. Um ehrlich zu sein, denke ich, dass es ein ziemlich selten verwendetes Wissen ist, aber es kann nützlich sein, wenn Sie Ihren eigenen Formatierer erstellen, indem Sie "logging.Formatter" erben.

Überblick

--% -Formatierung → Fehlerformat und Ausnahme anzeigen.

• str.format → string.Formatter().parser(fmt)
• Template string → string.Template.pattern.finditer(fmt)

%-formatting (printf style formatting) Im Gegensatz zu den beiden anderen kann ich im Standardpaket keine dedizierte Funktion zum Parsen finden, daher werde ich mein Bestes geben. Dieses Mal habe ich eine Funktion zum Entschlüsseln basierend auf der zurückgeworfenen Ausnahme erstellt. Wenn der im values-Teil von fmt% values angeforderte Typ ein Taple ist, wird seine Länge zurückgegeben, und wenn es sich um ein Wörterbuch handelt, wird sein Schlüssel zurückgegeben.

def parse_printf_style_format(fmt):
    if not isinstance(fmt, (bytes, str)):
        raise TypeError('got ' + type(fmt).__name__)
        
    try:
        fmt % ()
    except TypeError as e:
        if e.args[0] == 'not enough arguments for format string':
            values = ()
        elif e.args[0] == 'format requires a mapping':
            values = {}
        else:
            raise
    else:
        return None
    
    if isinstance(values, tuple):
        while True:
            try:
                fmt % values
            except TypeError as e:
                if e.args[0] == 'not enough arguments for format string':
                    values += (0,)
                else:
                    raise ValueError('invalid format: ' + repr(fmt))
            else:
                return len(values)
    elif isinstance(values, dict):
        while True:
            try:
                fmt % values
            except TypeError as e:
                if e.args[0] == 'not enough arguments for format string':
                    raise ValueError('invalid format: ' + repr(fmt))
                else:
                    raise
            except KeyError as e:
                values[e.args[0]] = 0
            else:
                return tuple(values.keys())
    else:
        assert False

Anwendungsbeispiel

>>> parse_printf_style_format('%d %s %x')
3
>>> parse_printf_style_format('%(foo)s, %(bar)d')
('foo', 'bar')

str.format()

Es ist ein Schlag mit string.Formatter (). Parse (fmt). Weitere Informationen finden Sie unter Offizielles Dokument.

>>> import string
>>> fmt = '{foo:s}, {{bar:d}}, and {:f}'
>>> list(string.Formatter().parse(fmt))
[('', 'foo', 's', None),
 (', {', None, None, None),
 ('bar:d}', None, None, None),
 (', and ', '', 'f', None)]

Template strings

Es ist ein Schlag mit "string.Template.pattern.finditer (fmt)". Der reguläre Ausdruck, der dem Platzhalter entspricht, wird im Attribut pattern gespeichert.

>>> import string
>>> fmt = '${this_is_braced} $$this_is_escaped $@this_is_invalid $this_is_named'
>>> print(string.Template.pattern.pattern)

    \$(?:
      (?P<escaped>\$) |   # Escape sequence of two delimiters
      (?P<named>[_a-z][_a-z0-9]*)      |   # delimiter and a Python identifier
      {(?P<braced>[_a-z][_a-z0-9]*)}   |   # delimiter and a braced identifier
      (?P<invalid>)              # Other ill-formed delimiter exprs
    )

>>> [match.groupdict() for match in string.Template.pattern.finditer(fmt)]

[{'braced': 'this_is_braced', 'escaped': None, 'invalid': None, 'named': None},
 {'braced': None, 'escaped': '$', 'invalid': None, 'named': None},
 {'braced': None, 'escaped': None, 'invalid': '', 'named': None},
 {'braced': None, 'escaped': None, 'invalid': None, 'named': 'this_is_named'}]

Impressionen

Die Kältebehandlung der% -Formatierung ist schrecklich.