如何获取格式化字符串中使用的名称列表？

Question

Given a formatting string:

x = "hello %(foo)s  there %(bar)s"

Is there a way to get the names of the formatting variables? (Without directly parsing them myself).

Using a Regex wouldn't be too tough but I was wondering if there was a more direct way to get these.

Answer 1

Use a dict subclass with overridden __missing__ method and from there you can collect all the missing format variables:

class StringFormatVarsCollector(dict):
    def __init__(self, *args, **kwargs):
        self.format_vars = []

    def __missing__(self, k):
        self.format_vars.append(k)
...         
def get_format_vars(s):
    d = StringFormatVarsCollector()     
    s % d                    
    return d.format_vars
... 
>>> get_format_vars("hello %(foo)s  there %(bar)s")
['foo', 'bar']

Answer 2

If you don't want to parse the string, you can use this little function:

def find_format_vars(string):
    vars= {}
    while True:
        try:
            string%vars
            break
        except KeyError as e:
            vars[e.message]= ''
    return vars.keys()

>>> print find_format_vars("hello %(foo)s there %(bar)s") ['foo', 'bar']

Answer 3

The format fields are only significant to the % operator, not the string itself. So, there is no attribute like str.__format_fields__ which you can access in order to get the field names.

I'd say that using Regex is actually the correct approach in this case. You can easily use re.findall to extract the names:

>>> import re
>>> x = "hello %(foo)s  there %(bar)s"
>>> re.findall('(?<!%)%\(([^)]+)\)[diouxXeEfFgGcrs]', x)
['foo', 'bar']
>>>

Below is an explanation of the pattern:

(?<!%)             # Negated look-behind to make sure that we do not match %% 
%                  # Matches %
\(                 # Matches (
(                  # Starts a capture group
[^)]+              # Matches one or more characters that are not )
)                  # Closes the capture group
\)                 # Matches )
[diouxXeEfFgGcrs]  # Matches one of the characters in the square brackets

Answer 4

New style string formatting has this ability.

from string import Formatter

f = Formatter()
x = "hello {foo}s  there {bar}s"
parsed = f.parse(x)

The results of parsed will be an iterable of tuples with this format:
(literal_text, field_name, format_spec, conversion)

So it's simple enough to pull out the field_name section of the tuple:

field_names = [tup[1] for tup in parsed]

Here's the documentation if you would like more in-depth information https://docs.python.org/2/library/string.html#string.Formatter

Single list-comprehension version:

[tup[1] for tup in "hello {foo}s  there {bar}s"._formatter_parser()]