Come posticipare / differire la valutazione delle stringhe f?

Sto usando stringhe modello per generare alcuni file e adoro la concisione delle nuove stringhe f per questo scopo, per ridurre il mio codice modello precedente da qualcosa di simile:

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

Ora posso farlo, sostituendo direttamente le variabili:

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

Tuttavia, a volte ha senso avere il modello definito altrove, più in alto nel codice o importato da un file o qualcosa del genere. Ciò significa che il modello è una stringa statica con tag di formattazione al suo interno. Dovrebbe accadere qualcosa alla stringa per dire all'interprete di interpretare la stringa come una nuova stringa f, ma non so se esiste una cosa del genere.

C'è un modo per inserire una stringa e interpretarla come una stringa f per evitare di usare la .format(**locals())chiamata?

Idealmente voglio essere in grado di codificare in questo modo ... (dov'è magic_fstring_functiondove entra la parte che non capisco):

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 questo output desiderato (senza leggere il file due volte):

The current name is foo
The current name is bar

... ma l'output effettivo che ottengo è:

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

Ecco un "Ideal 2" completo.

Non è una stringa f — non usa nemmeno le stringhe f — ma fa come richiesto. Sintassi esattamente come specificato. Nessun problema di sicurezza poiché non stiamo utilizzando eval().

Usa una piccola classe e implementa __str__che viene chiamata automaticamente da print. Per sfuggire all'ambito limitato della classe, utilizziamo il inspectmodulo per saltare di un frame e vedere le variabili a cui il chiamante ha accesso.

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

Ciò significa che il modello è una stringa statica con tag di formattazione al suo interno

Sì, questo è esattamente il motivo per cui abbiamo letterali con campi sostitutivi e .format, quindi possiamo sostituire i campi ogni volta che vogliamo richiamandoli format.

Qualcosa dovrebbe accadere alla stringa per dire all'interprete di interpretare la stringa come una nuova stringa f

Questo è il prefisso f/F. Potresti racchiuderlo in una funzione e posticipare la valutazione durante il tempo di chiamata, ma ovviamente ciò comporta un sovraccarico aggiuntivo:

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

Che stampa:

The current name is foo
The current name is bar

ma sembra sbagliato ed è limitato dal fatto che puoi solo dare un'occhiata allo spazio dei nomi globale nelle tue sostituzioni. Cercare di usarlo in una situazione che richiede nomi locali fallirà miseramente a meno che non venga passato alla stringa come argomento (che batte totalmente il punto).

C'è un modo per inserire una stringa e interpretarla come una stringa f per evitare di usare la .format(**locals())chiamata?

A parte una funzione (limitazioni incluse), no, quindi potrebbe anche restare .format.

Un modo conciso per far valutare una stringa come una stringa f (con tutte le sue capacità) è usare la seguente funzione:

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

Quindi puoi fare:

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

E, a differenza di tante altre soluzioni proposte, puoi anche fare:

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 stringa f è semplicemente un modo più conciso di creare una stringa formattata, sostituendola .format(**names)con f. Se non vuoi che una stringa venga valutata immediatamente in questo modo, non renderla una stringa f. Salvalo come una stringa letterale ordinaria e quindi chiamaformat più tardi quando vuoi eseguire l'interpolazione, come hai fatto.

Ovviamente c'è un'alternativa con eval.

template.txt:

f "Il nome attuale è {name}"

Codice:

>>> 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

Ma poi tutto quello che sei riuscito a fare è sostituire str.formatcon eval, che non è sicuramente la pena. Continua a usare stringhe normali con una formatchiamata.

L'utilizzo di .format non è una risposta corretta a questa domanda. Le f-string di Python sono molto diverse dai modelli str.format () ... possono contenere codice o altre operazioni costose - da qui la necessità di differimento.

Ecco un esempio di logger differito. Questo utilizza il normale preambolo di logging.getLogger, ma poi aggiunge nuove funzioni che interpretano la stringa f solo se il livello di log è corretto.

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)

Questo ha il vantaggio di poter fare cose come: log.fdebug("{obj.dump()}").... senza scaricare l'oggetto a meno che il debug non sia abilitato.

IMHO: Questa avrebbe dovuto essere l' operazione predefinita di f-strings, tuttavia ora è troppo tardi . La valutazione della stringa F può avere effetti collaterali enormi e non intenzionali e il fatto che ciò avvenga in modo differito cambierà l'esecuzione del programma.

Per rendere le stringhe f correttamente differite, python avrebbe bisogno di un modo per cambiare esplicitamente il comportamento. Forse usare la lettera "g"? ;)

È stato sottolineato che la registrazione differita non dovrebbe bloccarsi se c'è un bug nel convertitore di stringhe. La soluzione di cui sopra può fare anche questo, cambiare il finally:a except:e inserire un log.exceptionlì.

Quello che vuoi sembra essere considerato come un miglioramento di Python .

Nel frattempo, dalla discussione collegata, quanto segue sembra essere una soluzione alternativa ragionevole che non richiede l'utilizzo 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)

Produzione:

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

ispirato dalla risposta di kadee , quanto segue può essere utilizzato per definire una classe deferred-f-string.

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)

che è esattamente ciò che chiedeva la domanda

O forse non utilizzare stringhe f, basta formattare:

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

Nella versione senza nomi:

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

Che ne dite di:

s = 'Hi, {foo}!'

s
> 'Hi, {foo}!'

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

Un suggerimento che utilizza stringhe f. Esegui la tua valutazione sul livello logico in cui si sta verificando il modello e passalo come generatore. Puoi rilassarlo in qualsiasi punto tu scelga, usando le stringhe f

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