Capturing **vars() pattern in string formatting

Question

I frequently find myself using the following pattern for string formatting.

a = 3
b = 'foo'
c = dict(mykey='myval')

#prints a is 3, b is foo, mykey is myval
print('a is {a}, b is {b}, mykey is {c[mykey]}'.format(**vars()))

That is, I often have the values I need to print in the local namespace, represented by a call to vars(). As I look over my code, however, it seems awfully unpythonic to be constantly repeating the .format(**vars()) pattern.

I'd like to create a function that will capture this pattern. It would be something like the following.

# doesn't work
def lfmt(s):
    """
    lfmt (local format) will format the string using variables
    in the caller's local namespace.
    """
    return s.format(**vars())

Except that by the time I'm in the lfmt namespace, vars() is no longer what I want.

How can I write lfmt so that it executes vars() in the caller's namespace such that the following code would work as the example above?

print(lfmt('a is {a}, b is {b}, mykey is {c[mykey]}'))

Your request would seem to go against the Python spirit of "Explicit is better than implicit." I no longer quite have the Python chops I once did, but I can't think of any way to accomplish what you want. — Sean, Feb 04 '10 at 17:57

unutbu · Accepted Answer · 2010-02-04T18:47:45.013

2

Edit: In order for lfmt to work when called from different namespaces, you'll need the inspect module. Note, as the documentation warns, the inspect module may not be suitable for production code since it may not work with all implementations of Python

import inspect
def lfmt(s):
    caller = inspect.currentframe().f_back
    return s.format(**caller.f_locals)

a = 3
b = 'foo'
c = dict(mykey='myval')

print(lfmt('a is {a}, b is {b}, mykey is {c[mykey]}'))
# a is 3, b is foo, mykey is myval

edited Feb 04 '10 at 18:47

answered Feb 04 '10 at 18:22

unutbu

842,883
184
1,785
1,677

Thanks. That works when the caller is in the global namespace, but not when the caller is in some other scope. – Jason R. Coombs Feb 04 '10 at 18:23
1

@Jason: Yes, you are right. I've edited my answer to make lfmt work across namespaces. – unutbu Feb 04 '10 at 18:33
Excellent. That's almost it. Change f_globals to f_locals and it's exactly what I'm looking for. – Jason R. Coombs Feb 04 '10 at 18:35

score 1 · Answer 2 · answered Feb 04 '10 at 18:07

You have to inspect the variables from the calling frames.

This will get you started:

import inspect
import pprint

def lfmt(s):
    for frame in inspect.getouterframes(inspect.currentframe()):
        f = frame[0]
        print pprint.pformat(f.f_locals)
    return '???'

if __name__ == '__main__':
    a = 10
    b = 20
    c = 30
    lfmt('test')

score 0 · Answer 3 · edited May 23 '17 at 12:11

0

You could also use sys instead of inspect, but I don't know if it has the same problem with different implementations as inspect has.

import sys

def lfmt(s):
    caller = sys._getframe(1)
    return s.format(**caller.f_locals)

This is as far as I got: Python string interpolation implementation

edited May 23 '17 at 12:11

Community

1
1

answered May 16 '13 at 04:05

HarmonicaMuse

7,633
37
52

score 0 · Answer 4 · answered Feb 04 '10 at 18:16

Here you are:

import sys

def lfmt(s):
    """
    lfmt (local format) will format the string using variables
    in the caller's local namespace.
    """

    if hasattr(sys, "tracebacklimit") and sys.tracebacklimit == 0:
        raise Exception, "failfailfail"

    try:
        raise ZeroDivisionError
    except ZeroDivisionError:
        f = sys.exc_info()[2].tb_frame.f_back

    return s.format(**f.f_locals)

a = 5
somestring = "text"
print lfmt("{a} {somestring}")

The fact that it works doesn't mean you should use it. This is what developers call "major hack", usually shipped with a comment "XXX fix me XXX".

This is good. And I think there's a cleaner solution that involves the inspect module that lost-theory pointed out. — Jason R. Coombs, Feb 04 '10 at 18:24

score 0 · Answer 5 · answered Feb 04 '10 at 19:10

0

Is it so bad to type ,vars each time you call the function?

def lfmt(s,v):
    """
    lfmt (local format) will format the string using variables
    from the dict returned by calling v()"""
    return s.format(**v())

print(lfmt('a is {a}, b is {b}, mykey is {c[mykey]}',vars))

answered Feb 04 '10 at 19:10

John La Rooy

295,403
53
369
502

It's not _so_ bad, but if I'm going to go through the trouble of creating a function, I'm not going to ask the caller to pass the same thing every time, especially if there's a better way. – Jason R. Coombs Feb 04 '10 at 20:43

Capturing **vars() pattern in string formatting

5 Answers5

Linked