String-Ersetzungen verwenden von Vorlagen in Python

Einführung

Dem string-Modul hat eine Vorlage-Klasse, ermöglicht Ihnen die Ersetzungen in einem string durch ein mapping-Objekt, zum Beispiel:

>>> string.Template('var is $var').substitute({'var': 1})
'var is 1'

Die Ersatz-Methode auslösen kann, eine KeyError-Ausnahme aus, wenn ein Versuch gemacht wird, zu ersetzen, ein element, das fehlt die Zuordnung, zum Beispiel

>>> string.Template('var is $var and foo is $foo').substitute({'var': 1})
KeyError: 'foo'

oder auslösen kann, einen ValueError, wenn die Vorlage-Zeichenfolge ist ungültig, z.B. enthält es eine $ - Zeichen, gefolgt von einem Leerzeichen:

>>> string.Template('$ var is $var').substitute({'var': 1})
ValueError: Invalid placeholder in string: line 1, col 1

Das Problem

Gegeben, eine Vorlage-Zeichenfolge und eine Zuordnung, die ich will, um festzustellen, ob alle Platzhalter in der Vorlage ersetzt werden würde. Für diese, würde ich versuchen um die substitution und fangen KeyError-Ausnahme:

def check_substitution(template, mapping):
    try:
        string.Template(template).substitute(mapping)
    except KeyError:
        return False
    except ValueError:
        pass
    return True

Aber das funktioniert nicht, weil wenn die Vorlage ungültig und ein ValueError ausgelöst, anschließende KeyErrors nicht gefangen:

>>> check_substitution('var is $var and foo is $foo', {'var': 1})
False
>>> check_substitution('$ var is $var and foo is $foo', {'var': 1})
True

aber ich egal über ValueErrors. Also, was wäre der richtige Ansatz für dieses problem?

Vorlagen haben eine safe_substitute Methode, ignoriert, dass jeder ValueError und geht auf die Substitutionen. Das problem ist, es ignoriert auch KeyErrors.
Die möglichen ValueError Fällen sind alle im Zusammenhang mit illegaler Nutzung der $ Charakter, richtig? Also warum nicht tun ein wenig die Vorverarbeitung der string zu entkommen illegalen Nutzungen von $?
Dies könnte funktionieren, würde aber erfordern, herauszufinden, alle Fälle, die trigger eine ValueError.

InformationsquelleAutor Ernest A | 2012-10-07

Die docs sagen , können Sie ersetzen Sie das Muster so lange, wie es enthält alle notwendigen benannte Gruppen:

import re
from string import Template


class TemplateIgnoreInvalid(Template):
    # override pattern to make sure `invalid` never matches
    pattern = r"""
    %(delim)s(?:
      (?P<escaped>%(delim)s) |   # Escape sequence of two delimiters
      (?P<named>%(id)s)      |   # delimiter and a Python identifier
      {(?P<braced>%(id)s)}   |   # delimiter and a braced identifier
      (?P<invalid>^$)            # never matches (the regex is not multilined)
    )
    """ % dict(delim=re.escape(Template.delimiter), id=Template.idpattern)


def check_substitution(template, **mapping):
    try:
        TemplateIgnoreInvalid(template).substitute(mapping)
    except KeyError:
        return False
    else:
        return True

Tests

f = check_substitution
assert f('var is $var', var=1)
assert f('$ var is $var', var=1)
assert     f('var is $var and foo is $foo', var=1, foo=2)
assert not f('var is $var and foo is $foo', var=1)
assert     f('$ var is $var and foo is $foo', var=1, foo=2)
assert not f('$ var is $var and foo is $foo', var=1)
# support all invalid patterns
assert f('var is $var and foo is ${foo', var=1)
assert f('var is $var and foo is ${foo', var=1, foo=2) #NOTE: problematic API
assert     f('var is $var and foo is ${foo and ${baz}', var=1, baz=3)
assert not f('var is $var and foo is ${foo and ${baz}', var=1)

Funktioniert es für alle ungültig vorkommen der delimiter ($).

Die Beispiele zeigen, dass das ignorieren Ungültiger Muster verbirgt einfachen Tippfehler in der Vorlage so ist es nicht eine gute API.

Perfekt! Ich werde darüber nachdenken, was Sie sagen, dass es eine schlechte Idee zu unterstützen ungültige Muster. Danke.

InformationsquelleAutor jfs

3

Dies ist ein Quick-Fix (Mit Rekursion):
```
def check_substitution(tem, m):
    try:
        string.Template(tem).substitute(m)
    except KeyError:
        return False
    except ValueError:
        return check_substitution(tem.replace('$ ', '$'), m) #strip spaces after $
    return True
```
Ich Weiß, dass das eine längere Zeit dauern, wenn es mehr als Ein Leerzeichen zwischen $ und var sind , so können Sie es verbessern, durch die Verwendung Regulärer Ausdruck.

BEARBEITEN

Flucht $ in $$ macht mehr Sinn [ Danke @Pedro ], so dass Sie fangen kann ValueError mit dieser Aussage:
```
return check_substitution(tem.replace('$ ', '$$ '), m) #escaping $ by $$
```
Diese Lösung ist nicht generisch. Es immer noch nicht, wenn das Zeichen nach dem Leerzeichen nicht einen Brief und meint, dass der Raum nach der $ vermeidbare und die ursprüngliche Absicht war, ein Platzhalter aus der $ und das Wort nach dem Leerzeichen. Die Flucht des einsamen $ durch die Verdoppelung es mehr Sinn machen würde.
Vielen Dank, ich werde mein edit beantworten.
Danke. Die Flucht würde erfordern mehr Arbeit, aber. Zum Beispiel, die Vorlage ${foo löst auch ein ValueError, wegen der unsymmetrischen {... das ist, warum ich vermeiden wollte Parsen der Vorlage selbst, aber vielleicht gibt es keine alternative.
href="http://stackoverflow.com/a/12769116/4279">meine Antwort behebt ${foo Problem.

InformationsquelleAutor MBarsi
-1

Python wird nicht eine Ersetzung von Strings über mehrere Zeilen

Wenn Sie diese Zeichenfolge
```
criterion = """
    <criteria>
    <order>{order}</order>
      <body><![CDATA[{code}]]></body>
    </criteria>
"""

criterion.format(dict(order="1",code="Hello")
```
Ergebnisse in:
```
KeyError: 'order'
```
Eine Lösung ist die Verwendung der string.Template-Modul
```
from string import Template

criterion = """
    <criteria>
    <order>$order</order>
      <body><![CDATA[$code]]></body>
    </criteria>
"""

Template(criterion).substitute(dict(order="1",code="hello")
```
HINWEIS: Sie müssen das Präfix der keywords mit einem $ nicht wickeln Sie Sie in {}

Ausgabe:
```
 <criteria>
    <order>1</order>
      <body><![CDATA[hello]]></body>
    </criteria>
```
Full docs sind: https://docs.python.org/2/library/string.html#template-strings

"Python wird nicht eine Ersetzung von Strings über mehrere Zeilen" - Falsch. Verwenden criterion.format(**dict(order="1", code="Hello") oder nur criterion.format(order="1", code="Hello")

InformationsquelleAutor knowingpark

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.