Convertir, ou unformat, une chaîne de variables (comme le format(), mais en sens inverse) en Python

Fait le Python ordinaire de l'expression de la bibliothèque déjà fournit la fonctionnalité que vous demandez. Vous avez juste à modifier la syntaxe du modèle légèrement

>>> import re
>>> from operator import itemgetter
>>> mystr='Version 1.15.6\n'
>>> m = re.match('Version (?P<_0>.+)\.(?P<_1>.+)\.(?P<_2>.+)', mystr)
>>> map(itemgetter(1), sorted(m.groupdict().items()))
['1', '15', '6']

Comme vous pouvez le voir, vous avez à changer la (des nations unies)les chaînes de format à partir de {0} à (?P<_0>.+). Vous pourriez même avoir besoin d'un décimal par (?P<_0>\d+). En outre, vous avez à s'échapper certains caractères pour les empêcher d'être interprétée comme l'expression rationnelle des caractères spéciaux. Mais cette turm peut être automatisé à nouveau par ex. avec

>>> re.sub(r'\\{(\d+)\\}', r'(?P<_>.+)', re.escape('Version {0}.{1}.{2}'))
'Version\\ (?P<_0>.+)\\.(?P<_1>.+)\\.(?P<_2>.+)'

Il suffit de construire sur Uche réponse, je cherchais un moyen pour inverser une chaîne de caractères via un modèle avec kwargs. J'ai donc monté la fonction suivante:

def string_to_dict(string, pattern):
    regex = re.sub(r'{(.+?)}', r'(?P<_>.+)', pattern)
    values = list(re.search(regex, string).groups())
    keys = re.findall(r'{(.+?)}', pattern)
    _dict = dict(zip(keys, values))
    return _dict

Qui fonctionne comme par:

>>> p = 'hello, my name is {name} and I am a {age} year old {what}'

>>> s = p.format(name='dan', age=33, what='developer')
>>> s
'hello, my name is dan and I am a 33 year old developer'
>>> string_to_dict(s, p)
{'age': '33', 'name': 'dan', 'what': 'developer'}

>>> s = p.format(name='cody', age=18, what='quarterback')
>>> s
'hello, my name is cody and I am a 18 year old quarterback'
>>> string_to_dict(s, p)
{'age': '18', 'name': 'cody', 'what': 'quarterback'}

EDIT: voir Aussi cette réponse pour un peu plus d'informations sur parse et parmatter.

La pypi paquet parse sert ce but bien:

pip install parse

Peut être utilisée comme ceci:

>>> import parse
>>> result=parse.parse('Version {0}.{1}.{2}\n', 'Version 1.15.6\n')
<Result ('1', '15', '6') {}>
>>> values=list(result)
>>> print(values)
['1', '15', '6']

Noter que les docs disent la parse paquet ne correspond pas EXACTEMENT à émuler les spécification du format mini-langue par défaut; il utilise aussi certains type d'indicateurs spécifiés par re. De la note spéciale est que s signifie "espace" par défaut, plutôt que de str. Ceci peut être facilement modifié pour être compatible avec la spécification de format en changeant le type par défaut pour s à str (à l'aide de extra_types):

result = parse.parse(format_str, string, extra_types=dict(s=str))

Ici est une idée conceptuelle pour une modification de la string.Formatter intégré en classe à l'aide de la parse package à ajouter unformat capacité que j'ai moi-même utilisé:

import parse
from string import Formatter
class Unformatter(Formatter):
'''A parsable formatter.'''
def unformat(self, format, string, extra_types=dict(s=str), evaluate_result=True):
return parse.parse(format, string, extra_types, evaluate_result)
unformat.__doc__ = parse.Parser.parse.__doc__

IMPORTANT: le nom de la méthode parse est déjà en cours d'utilisation par le Formatter classe, j'ai donc choisi unformat à la place pour éviter les conflits.

Mise à JOUR: Vous pouvez l'utiliser comme cette - très semblable à la string.Formateur classe.

Mise en forme (identique à '{:d} {:d}'.format(1, 2)):

>>> formatter = Unformatter() 
>>> s = formatter.format('{:d} {:d}', 1, 2)
>>> s
'1 2' 

Unformatting:

>>> result = formatter.unformat('{:d} {:d}', s)
>>> result
<Result (1, 2) {}>
>>> tuple(result)
(1, 2)

C'est bien sûr une utilisation très limitée comme indiqué ci-dessus. Cependant, j'ai mis en place un pypi paquet (parmatter - un projet à l'origine pour mon propre usage, mais peut-être que d'autres pourront trouver utile) qui explore quelques idées sur la façon de mettre cette idée à plus de travail utile. Le paquet dépend fortement de ladite parse paquet.

Voici une solution dans le cas où vous ne souhaitez pas utiliser l'analyse du module. Il convertit les chaînes de format en expressions régulières avec des groupes nommés. On fait quelques hypothèses (décrit dans la docstring) qui n'avaient pas de problème dans mon cas, mais peut ne pas être d'accord dans le vôtre.

def match_format_string(format_str, s):
"""Match s against the given format string, return dict of matches.
We assume all of the arguments in format string are named keyword arguments (i.e. no {} or
{:0.2f}). We also assume that all chars are allowed in each keyword argument, so separators
need to be present which aren't present in the keyword arguments (i.e. '{one}{two}' won't work
reliably as a format string but '{one}-{two}' will if the hyphen isn't used in {one} or {two}).
We raise if the format string does not match s.
Example:
fs = '{test}-{flight}-{go}'
s = fs.format('first', 'second', 'third')
match_format_string(fs, s) -> {'test': 'first', 'flight': 'second', 'go': 'third'}
"""
# First split on any keyword arguments, note that the names of keyword arguments will be in the
# 1st, 3rd, ... positions in this list
tokens = re.split(r'\{(.*?)\}', format_str)
keywords = tokens[1::2]
# Now replace keyword arguments with named groups matching them. We also escape between keyword
# arguments so we support meta-characters there. Re-join tokens to form our regexp pattern
tokens[1::2] = map(u'(?P<{}>.*)'.format, keywords)
tokens[0::2] = map(re.escape, tokens[0::2])
pattern = ''.join(tokens)
# Use our pattern to match the given string, raise if it doesn't match
matches = re.match(pattern, s)
if not matches:
raise Exception("Format string did not match")
# Return a dict with all of our keywords and their values
return {x: matches.group(x) for x in keywords}