F-dizgilerinin değerlendirilmesi nasıl ertelenir / ertelenir?

Bazı dosyalar oluşturmak için şablon dizeleri kullanıyorum ve bu amaç için yeni f-dizelerinin kısa olmasını seviyorum, önceki şablon kodumu şunun gibi bir şeyden azaltmak için:

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

Şimdi bunu doğrudan değişkenleri değiştirerek yapabilirim:

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

Bununla birlikte, bazen şablonun başka bir yerde tanımlanması mantıklıdır - kodda daha yukarıda veya bir dosyadan veya başka bir şeyden içe aktarılmış. Bu, şablonun, içinde biçimlendirme etiketleri bulunan statik bir dize olduğu anlamına gelir. Yorumlayıcıya dizeyi yeni bir f-dizesi olarak yorumlamasını söylemek için dizeye bir şey olması gerekir, ancak böyle bir şey olup olmadığını bilmiyorum.

.format(**locals())Çağrıyı kullanmaktan kaçınmak için bir dizge getirmenin ve onu bir f-dizesi olarak yorumlamanın bir yolu var mı ?

İdeal olarak, böyle kodlayabilmeyi istiyorum ... ( magic_fstring_functionanlamadığım kısım nereden geliyor):

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)

... bu istenen çıktıyla (dosyayı iki kez okumadan):

The current name is foo
The current name is bar

... ancak aldığım gerçek çıktı:

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

İşte tam bir "İdeal 2".

Bu bir f-stringi değil - f-stringlerini bile kullanmıyor - ama istendiği gibi yapıyor. Sözdizimi tam olarak belirtildiği gibi. Kullanmadığımız için güvenlik sorunu yok eval().

Küçük bir sınıf kullanır ve __str__otomatik olarak baskı tarafından çağrılan uygular . Sınıfın sınırlı kapsamından kaçmak için inspectmodülü bir çerçeve yukarı atlamak ve çağıranın erişebildiği değişkenleri görmek için kullanırız.

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

Bu, şablonun içinde biçimlendirme etiketleri bulunan statik bir dize olduğu anlamına gelir

Evet, tam da bu yüzden değiştirme alanlarına sahip değişmez değerlere sahibiz ve .formatböylece alanları istediğimiz zaman çağırarak değiştirebiliriz format.

Yorumlayıcıya dizeyi yeni bir f-string olarak yorumlamasını söylemek için dizeye bir şey olması gerekir.

Bu önek f/F. Bunu bir işleve sarabilir ve görüşme sırasında değerlendirmeyi erteleyebilirsiniz, ancak elbette bu fazladan ek yüke neden olur:

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

Hangi çıktı:

The current name is foo
The current name is bar

ancak yanlış hissediyor ve değiştirmelerinizde yalnızca genel ad alanına göz atabileceğiniz gerçeğiyle sınırlı. Yerel isimler gerektiren bir durumda onu kullanmaya çalışmak, dizgeye argümanlar olarak geçmedikçe sefil bir şekilde başarısız olacaktır (noktayı tamamen yener).

.format(**locals())Çağrıyı kullanmaktan kaçınmak için bir dizge getirmenin ve onu bir f-dizesi olarak yorumlamanın bir yolu var mı ?

Bir işlev dışında (sınırlamalar dahil), hayır, bu yüzden de bağlı kalabilir .format.

Bir dizenin bir f-dizesi olarak değerlendirilmesini sağlamanın özlü bir yolu (tüm yetenekleriyle) aşağıdaki işlevi kullanmaktır:

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

O zaman şunları yapabilirsiniz:

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

Ve diğer birçok önerilen çözümün aksine, şunları da yapabilirsiniz:

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

Bir f-string basitçe yerine bir biçimlendirilmiş dize oluşturmanın daha özlü bir yoldur .format(**names)ile f. Bir dizgenin hemen bu şekilde değerlendirilmesini istemiyorsanız, onu bir f-dizesi haline getirmeyin. Sıradan bir dizge olarak kaydedin ve daha formatsonra yaptığınız gibi, enterpolasyonu gerçekleştirmek istediğinizde onu çağırın .

Tabii ki ile bir alternatif var eval.

template.txt:

f'Şu andaki ad {name} '

Kod:

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

Ama sonra bütün Değiştirmek yapmanız başardınız str.formatile evalmutlaka buna değmez, hangi. Bir formatçağrı ile normal dizeleri kullanmaya devam edin .

.Format kullanmak bu sorunun doğru cevabı değildir. Python f dizeleri str.format () şablonlarından çok farklıdır ... kod veya diğer pahalı işlemleri içerebilirler - dolayısıyla erteleme ihtiyacı doğar.

Aşağıda bir ertelenmiş günlük kaydedici örneği verilmiştir. Bu, logging.getLogger'ın normal başlangıcını kullanır, ancak daha sonra f-dizesini yalnızca günlük düzeyi doğruysa yorumlayan yeni işlevler ekler.

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)

Bu, aşağıdaki gibi şeyler yapabilme avantajına sahiptir: log.fdebug("{obj.dump()}").... hata ayıklama etkinleştirilmedikçe nesneyi dökmeden.

IMHO: Bu , f dizelerinin varsayılan işlemi olmalıydı , ancak artık çok geç . F-string değerlendirmesinin büyük ve istenmeyen yan etkileri olabilir ve bunun ertelenmiş bir şekilde gerçekleşmesi programın yürütülmesini değiştirecektir.

F dizelerini düzgün bir şekilde ertelemek için, python'un açıkça davranışı değiştirmenin bir yoluna ihtiyacı olacaktır. Belki 'g' harfini kullanırsınız? ;)

Dize dönüştürücüsünde bir hata varsa, ertelenmiş günlüğün çökmemesi gerektiği belirtildi. Yukarıdaki çözüm, hem de bunu değiştirebilir finally:için except:ve bir sopa log.exceptioniçeride.

İstediğiniz şey bir Python geliştirmesi olarak görülüyor .

Bu arada - bağlantılı tartışmadan - aşağıdakiler, kullanımı gerektirmeyen makul bir geçici çözüm gibi görünüyor 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)

Çıktı:

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

kadee'nin yanıtından esinlenerek , ertelenmiş-f-string sınıfını tanımlamak için aşağıdakiler kullanılabilir.

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)

tam olarak sorulan soru buydu

Ya da belki f dizeleri kullanmayın, sadece biçimlendirin:

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

İsimsiz versiyonda:

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

Peki ya:

s = 'Hi, {foo}!'

s
> 'Hi, {foo}!'

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

F dizelerini kullanan bir öneri. Değerlendirmenizi şablonlamanın gerçekleştiği mantıksal seviyede yapın ve onu bir jeneratör olarak geçirin. F dizelerini kullanarak, seçtiğiniz herhangi bir noktada gevşetebilirsiniz.

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