Wie kann die Bewertung von F-Strings verschoben / verschoben werden?

Ich verwende Vorlagenzeichenfolgen, um einige Dateien zu generieren, und ich liebe die Prägnanz der neuen F-Zeichenfolgen für diesen Zweck, um meinen vorherigen Vorlagencode von so etwas zu reduzieren:

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

Jetzt kann ich dies tun und Variablen direkt ersetzen:

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

Manchmal ist es jedoch sinnvoll, die Vorlage an einer anderen Stelle zu definieren - weiter oben im Code oder aus einer Datei oder etwas anderem importiert. Dies bedeutet, dass die Vorlage eine statische Zeichenfolge mit Formatierungs-Tags ist. Es müsste etwas mit der Zeichenfolge passieren, um den Interpreter anzuweisen, die Zeichenfolge als neue F-Zeichenfolge zu interpretieren, aber ich weiß nicht, ob es so etwas gibt.

Gibt es eine Möglichkeit, eine Zeichenfolge einzubringen und als F-Zeichenfolge zu interpretieren, um die Verwendung des .format(**locals())Aufrufs zu vermeiden ?

Idealerweise möchte ich in der Lage sein, so zu codieren ... (wo magic_fstring_functionkommt der Teil ins Spiel, den ich nicht verstehe):

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)

... mit dieser gewünschten Ausgabe (ohne die Datei zweimal zu lesen):

The current name is foo
The current name is bar

... aber die tatsächliche Ausgabe, die ich bekomme, ist:

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

Hier ist ein komplettes "Ideal 2".

Es ist kein F-String - es werden nicht einmal F-Strings verwendet - aber es funktioniert wie gewünscht. Syntax genau wie angegeben. Keine Sicherheitskopfschmerzen, da wir nicht verwenden eval().

Es verwendet eine kleine Klasse und implementiert, __str__die automatisch von print aufgerufen wird. Um dem begrenzten Umfang der Klasse zu entgehen, verwenden wir das inspectModul, um einen Frame nach oben zu springen und die Variablen anzuzeigen, auf die der Aufrufer Zugriff hat.

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

Dies bedeutet, dass die Vorlage eine statische Zeichenfolge mit Formatierungs-Tags ist

Ja, genau deshalb haben wir Literale mit Ersatzfeldern und .formatkönnen die Felder jederzeit ersetzen, indem wir sie aufrufen format.

Mit dem String müsste etwas passieren, um den Interpreter anzuweisen, den String als neuen F-String zu interpretieren

Das ist das Präfix f/F. Sie könnten es in eine Funktion einbinden und die Auswertung während der Anrufzeit verschieben, aber das verursacht natürlich zusätzlichen Aufwand:

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

Welches druckt aus:

The current name is foo
The current name is bar

fühlt sich aber falsch an und wird durch die Tatsache eingeschränkt, dass Sie nur einen Blick auf den globalen Namespace in Ihren Ersetzungen werfen können. Der Versuch, es in einer Situation zu verwenden, in der lokale Namen erforderlich sind, schlägt kläglich fehl, es sei denn, es wird als Argument an die Zeichenfolge übergeben (was den Punkt völlig übertrifft).

Gibt es eine Möglichkeit, eine Zeichenfolge einzubringen und als F-Zeichenfolge zu interpretieren, um die Verwendung des .format(**locals())Aufrufs zu vermeiden ?

Anders als eine Funktion (einschließlich Einschränkungen), nein, könnte genauso gut bei bleiben .format.

Eine prägnante Möglichkeit, eine Zeichenfolge als F-Zeichenfolge (mit ihren vollen Funktionen) auszuwerten, besteht in der Verwendung der folgenden Funktion:

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

Dann können Sie tun:

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

Und im Gegensatz zu vielen anderen Lösungsvorschlägen können Sie auch Folgendes tun:

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

Eine F-Zeichenfolge ist einfach eine präzisere Methode zum Erstellen einer formatierten Zeichenfolge, die .format(**names)durch ersetzt wird f. Wenn Sie nicht möchten, dass eine Zeichenfolge sofort auf diese Weise ausgewertet wird, machen Sie sie nicht zu einer F-Zeichenfolge. Speichern Sie es als gewöhnliches Zeichenfolgenliteral und rufen Sie formates später auf, wenn Sie die Interpolation wie bisher ausführen möchten.

Natürlich gibt es eine Alternative mit eval.

template.txt::

f'Der aktuelle Name ist {name} '

Code:

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

Aber dann haben Sie es geschafft , zu tun ist , zu ersetzen str.formatmit eval, das ist sicherlich nicht wert. Verwenden Sie bei einem formatAufruf einfach weiterhin normale Zeichenfolgen .

Die Verwendung von .format ist keine korrekte Antwort auf diese Frage. Python-F-Strings unterscheiden sich stark von str.format () -Vorlagen. Sie können Code oder andere teure Operationen enthalten - daher ist eine Verschiebung erforderlich.

Hier ist ein Beispiel für einen verzögerten Logger. Dies verwendet die normale Präambel von logging.getLogger, fügt dann aber neue Funktionen hinzu, die den f-String nur interpretieren, wenn die Protokollstufe korrekt ist.

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)

Dies hat den Vorteil, dass Sie Folgendes tun können: log.fdebug("{obj.dump()}").... ohne das Objekt zu sichern, es sei denn, das Debuggen ist aktiviert.

IMHO: Dies hätte die Standardoperation von F-Strings sein sollen, aber jetzt ist es zu spät . Die Auswertung von F-Strings kann massive und unbeabsichtigte Nebenwirkungen haben, und wenn dies auf verzögerte Weise geschieht, ändert sich die Programmausführung.

Um F-Strings richtig zu verschieben, würde Python eine Möglichkeit benötigen, das Verhalten explizit zu ändern. Vielleicht den Buchstaben 'g' verwenden? ;)

Was Sie wollen, scheint als Python- Erweiterung betrachtet zu werden .

In der verknüpften Diskussion scheint Folgendes eine vernünftige Problemumgehung zu sein, für die keine Verwendung erforderlich ist 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)

Ausgabe:

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

Inspiriert von der Antwort von Kadee kann das Folgende verwendet werden, um eine verzögerte F-String-Klasse zu definieren.

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)

Das ist genau das, wonach die Frage gestellt wurde

Oder verwenden Sie keine F-Strings, sondern formatieren Sie einfach:

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

In Version ohne Namen:

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

Ein Vorschlag, der F-Strings verwendet. Führen Sie Ihre Bewertung auf der logischen Ebene durch, auf der das Templating stattfindet, und übergeben Sie es als Generator. Sie können es an jedem beliebigen Punkt mit F-Strings abwickeln

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  

Wie wäre es mit:

s = 'Hi, {foo}!'

s
> 'Hi, {foo}!'

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