¿Cómo posponer / aplazar la evaluación de f-strings?

Estoy usando cadenas de plantilla para generar algunos archivos y me encanta la concisión de las nuevas cadenas f para este propósito, para reducir mi código de plantilla anterior de algo como esto:

template_a = "The current name is {name}"
names = ["foo", "bar"]
for name in names:
    print (template_a.format(**locals()))

Ahora puedo hacer esto, reemplazando directamente las variables:

names = ["foo", "bar"]
for name in names:
    print (f"The current name is {name}")

Sin embargo, a veces tiene sentido tener la plantilla definida en otro lugar, más arriba en el código, o importada de un archivo o algo. Esto significa que la plantilla es una cadena estática con etiquetas de formato. Algo tendría que sucederle a la cadena para decirle al intérprete que interprete la cadena como una nueva cadena f, pero no sé si existe tal cosa.

¿Hay alguna forma de introducir una cadena e interpretarla como una cadena f para evitar usar la .format(**locals())llamada?

Idealmente, quiero poder codificar así ... (donde magic_fstring_functiones donde entra la parte que no entiendo):

template_a = f"The current name is {name}"
# OR [Ideal2] template_a = magic_fstring_function(open('template.txt').read())
names = ["foo", "bar"]
for name in names:
    print (template_a)

... con esta salida deseada (sin leer el archivo dos veces):

The current name is foo
The current name is bar

... pero la salida real que obtengo es:

The current name is {name}
The current name is {name}

Aquí hay un "Ideal 2" completo.

No es una f-string, ni siquiera usa f-strings, pero hace lo solicitado. Sintaxis exactamente como se especifica. Sin dolores de cabeza de seguridad ya que no estamos usando eval().

Utiliza una pequeña clase e implementos __str__que se llama automáticamente por impresión. Para escapar del alcance limitado de la clase, usamos el inspectmódulo para saltar un fotograma y ver las variables a las que tiene acceso la persona que llama.

import inspect

class magic_fstring_function:
    def __init__(self, payload):
        self.payload = payload
    def __str__(self):
        vars = inspect.currentframe().f_back.f_globals.copy()
        vars.update(inspect.currentframe().f_back.f_locals)
        return self.payload.format(**vars)

template = "The current name is {name}"

template_a = magic_fstring_function(template)

# use it inside a function to demonstrate it gets the scoping right
def new_scope():
    names = ["foo", "bar"]
    for name in names:
        print(template_a)

new_scope()
# The current name is foo
# The current name is bar

Esto significa que la plantilla es una cadena estática con etiquetas de formato.

Sí, esa es exactamente la razón por la que tenemos literales con campos de reemplazo y .format, por lo tanto, podemos reemplazar los campos cuando queramos invocándolo format.

Algo tendría que sucederle a la cadena para decirle al intérprete que interprete la cadena como una nueva cadena f

Ese es el prefijo f/F. Puede envolverlo en una función y posponer la evaluación durante el tiempo de llamada, pero, por supuesto, eso genera una sobrecarga adicional:

template_a = lambda: f"The current name is {name}"
names = ["foo", "bar"]
for name in names:
    print (template_a())

Que imprime:

The current name is foo
The current name is bar

pero se siente mal y está limitado por el hecho de que solo puede echar un vistazo al espacio de nombres global en sus reemplazos. Intentar usarlo en una situación que requiere nombres locales fallará miserablemente a menos que se pase a la cadena como argumentos (lo que supera totalmente el punto).

¿Hay alguna forma de introducir una cadena e interpretarla como una cadena f para evitar usar la .format(**locals())llamada?

Aparte de una función (limitaciones incluidas), no, por lo que también podría seguir .format.

Una forma concisa de evaluar una cadena como una cadena f (con todas sus capacidades) es usar la siguiente función:

def fstr(template):
    return eval(f"f'{template}'")

Entonces puedes hacer:

template_a = "The current name is {name}"
names = ["foo", "bar"]
for name in names:
    print(fstr(template_a))
# The current name is foo
# The current name is bar

Y, a diferencia de muchas otras soluciones propuestas, también puede hacer:

template_b = "The current name is {name.upper() * 2}"
for name in names:
    print(fstr(template_b))
# The current name is FOOFOO
# The current name is BARBAR

Una cadena f es simplemente una forma más concisa de crear una cadena formateada, reemplazando .format(**names)por f. Si no desea que una cadena se evalúe inmediatamente de esa manera, no la convierta en una cadena f. Guárdelo como un literal de cadena ordinario y luego invocalo formatmás tarde cuando desee realizar la interpolación, como lo ha estado haciendo.

Por supuesto, existe una alternativa con eval.

template.txt:

f'El nombre actual es {nombre} '

Código:

>>> template_a = open('template.txt').read()
>>> names = 'foo', 'bar'
>>> for name in names:
...     print(eval(template_a))
...
The current name is foo
The current name is bar

Pero todo lo que ha logrado hacer es reemplazar str.formatcon eval, lo que seguramente no vale la pena. Simplemente siga usando cadenas regulares con una formatllamada.

Usar .format no es una respuesta correcta a esta pregunta. Las cadenas f de Python son muy diferentes de las plantillas str.format () ... pueden contener código u otras operaciones costosas, de ahí la necesidad de aplazamiento.

A continuación, se muestra un ejemplo de registrador diferido. Esto usa el preámbulo normal de logging.getLogger, pero luego agrega nuevas funciones que interpretan la cadena f solo si el nivel de registro es correcto.

log = logging.getLogger(__name__)

def __deferred_flog(log, fstr, level, *args):
    if log.isEnabledFor(level):
        import inspect
        frame = inspect.currentframe().f_back.f_back
        try:
            fstr = 'f"' + fstr + '"'
            log.log(level, eval(fstr, frame.f_globals, frame.f_locals))
        finally:
            del frame
log.fdebug = lambda fstr, *args: __deferred_flog(log, fstr, logging.DEBUG, *args)
log.finfo = lambda fstr, *args: __deferred_flog(log, fstr, logging.INFO, *args)

Esto tiene la ventaja de poder hacer cosas como: log.fdebug("{obj.dump()}").... sin volcar el objeto a menos que la depuración esté habilitada.

En mi humilde opinión: esta debería haber sido la operación predeterminada de f-strings, sin embargo, ahora es demasiado tarde . La evaluación de F-string puede tener efectos secundarios masivos y no deseados, y si eso sucede de manera diferida cambiará la ejecución del programa.

Para hacer que las f-strings se difieran correctamente, Python necesitaría alguna forma de cambiar explícitamente el comportamiento. ¿Quizás usar la letra 'g'? ;)

Se ha señalado que el registro diferido no debería fallar si hay un error en el convertidor de cadenas. La solución anterior también puede hacer esto, cambiar finally:a except:y pegar log.exceptionallí.

Lo que desea parece estar considerado como una mejora de Python .

Mientras tanto, a partir de la discusión vinculada, lo siguiente parece ser una solución alternativa razonable que no requiere el uso eval():

class FL:
    def __init__(self, func):
        self.func = func
    def __str__(self):
        return self.func()


template_a = FL(lambda: f"The current name, number is {name!r}, {number+1}")
names = "foo", "bar"
numbers = 40, 41
for name, number in zip(names, numbers):
    print(template_a)

Salida:

The current name, number is 'foo', 41
The current name, number is 'bar', 42

inspirado en la respuesta de kadee , lo siguiente se puede usar para definir una clase de cadena f diferida.

class FStr:
    def __init__(self, s):
        self._s = s
    def __repr__(self):
        return eval(f"f'{self._s}'")

...

template_a = FStr('The current name is {name}')

names = ["foo", "bar"]
for name in names:
    print (template_a)

que es exactamente lo que pedía la pregunta

O tal vez no use f-strings, solo formatee:

fun = "The curent name is {name}".format
names = ["foo", "bar"]
for name in names:
    print(fun(name=name))

En versión sin nombres:

fun = "The curent name is {}".format
names = ["foo", "bar"]
for name in names:
    print(fun(name))

Qué tal si:

s = 'Hi, {foo}!'

s
> 'Hi, {foo}!'

s.format(foo='Bar')
> 'Hi, Bar!'

Una sugerencia que usa f-strings. Haga su evaluación en el nivel lógico donde se está produciendo la plantilla y páselo como un generador. Puede desenrollarlo en cualquier punto que elija, utilizando f-strings

In [46]: names = (i for i in ('The CIO, Reed', 'The homeless guy, Arnot', 'The security guard Spencer'))

In [47]: po = (f'Strangely, {next(names)} has a nice {i}' for i in (" nice house", " fast car", " big boat"))

In [48]: while True:  
...:     try:  
...:         print(next(po))  
...:     except StopIteration:  
...:         break  
...:       
Strangely, The CIO, Reed has a nice  nice house  
Strangely, The homeless guy, Arnot has a nice  fast car  
Strangely, The security guard Spencer has a nice  big boat