Substitutions de chaînes à l'aide de modèles en Python

Introduction

La chaîne de module a une classe de Modèle, qui vous permet de faire des substitutions dans une chaîne de caractères à l'aide d'une cartographie de l'objet, par exemple:

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

La méthode de substitution peut soulever une KeyError exception, si une tentative est faite pour remplacer un élément qui manque à la cartographie, par exemple

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

ou peut soulever une ValueError, si le modèle de chaîne n'est pas valide, par exemple, il contient un $ caractère, suivi par un espace:

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

Le Problème

Donné une chaîne de modèle et d'une cartographie, je veux déterminer si tous les place de titulaires de droits dans le modèle doit être remplacé. Pour cela, je voudrais essayer de faire de la substitution et de l'attraper tout KeyError exception:

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

Mais cela ne fonctionne pas, parce que si le modèle n'est pas valide et un ValueError est soulevée, à la suite KeyErrors ne sont pas pris:

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

mais je n'avez pas de soins sur ValueErrors. Alors, quelle serait la bonne façon d'aborder ce problème?

source d'informationauteur Ernest A

  1. 5

    Les docs disent que vous pouvez remplacer le modèle, tant qu'il contient tout le nécessaire groupes nommés:

    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)

    Il fonctionne pour tous les invalides occurences de la délimiteur ($).

    Les exemples montrent que le fait d'ignorer invalide modèles de cache de simples fautes de frappe dans le modèle de sorte qu'il n'est pas une bonne API.

  2. 3

    C'est une solution Rapide (en Utilisant la récursivité):

    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

    Je Sais que sa prend plus de temps si il n'y a plus d'Un Espace entre $ et var , de sorte que vous pouvez l'améliorer en utilisant des expressions Régulières.

    MODIFIER

    échapper $ en $$ plus de sens [ Merci @Pedro ] de sorte que vous pouvez attraper ValueError par cette déclaration:

    return check_substitution(tem.replace('$ ', '$$ '), m) #escaping $ by $$
  3. -1

    Python ne va pas faire de remplacement de chaîne de caractères sur plusieurs lignes

    Si vous avez cette chaîne

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

criterion.format(dict(order="1",code="Hello")

    résultats dans: 

    KeyError: 'order'

    Une solution est d'utiliser la chaîne de caractères.Modèle de module

    from string import Template

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

Template(criterion).substitute(dict(order="1",code="hello")

    REMARQUE: vous devez préfixer les mots-clés avec un $ emballez pas dans {}

    de sortie est: 

     <criteria>
    <order>1</order>
      <body><![CDATA[hello]]></body>
    </criteria>

    Plein de docs sont: https://docs.python.org/2/library/string.html#template-strings