Как отложить/отложить оценку f-строк?

Вот и полный "Идеал 2".

Это не f-строка — она даже не использует f-строки, — но она делает то, что требуется. Синтаксис точно такой, как указано. Никаких проблем с безопасностью, так как мы не используем eval().

Он использует небольшой класс и реализует __str__, который автоматически вызывается печатью. Чтобы избежать ограниченной области действия класса, мы используем модуль inspect для перехода на один кадр вверх и просмотра переменных, к которым у вызывающей стороны есть доступ.

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

Это означает, что шаблон представляет собой статическую строку с тегами форматирования.

Да, именно поэтому у нас есть литералы с замещающими полями и .format, поэтому мы можем заменять поля, когда захотим, вызывая для них format.

Что-то должно произойти со строкой, чтобы интерпретатор интерпретировал строку как новую f-строку.

Это префикс f/F. Вы можете обернуть его в функцию и отложить оценку во время вызова, но, конечно, это влечет за собой дополнительные накладные расходы:

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

Что распечатывает:

The current name is foo
The current name is bar

но кажется неправильным и ограничен тем фактом, что вы можете заглянуть только в глобальное пространство имен в своих заменах. Попытка использовать его в ситуации, когда требуются локальные имена, потерпит неудачу, если только не будет передана в строку в качестве аргументов (что совершенно не соответствует действительности).

Есть ли способ ввести строку и интерпретировать ее как f-строку, чтобы избежать использования вызова .format(**locals())?

Кроме функции (с ограничениями), нет, так что лучше придерживаться .format.

Краткий способ оценить строку как f-строку (с ее всеми возможностями) — использовать следующую функцию:

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

Затем вы можете сделать:

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

И, в отличие от многих других предлагаемых решений, вы также можете сделать:

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

Использование .format не является правильным ответом на этот вопрос. F-строки Python сильно отличаются от шаблонов str.format()... они могут содержать код или другие дорогостоящие операции — отсюда и необходимость отсрочки.

Вот пример отложенного логгера. Здесь используется обычная преамбула logging.getLogger, но затем добавляются новые функции, которые интерпретируют f-строку только в том случае, если уровень журнала правильный.

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)

Преимущество этого заключается в возможности делать такие вещи, как: log.fdebug("{obj.dump()}") .... без дампа объекта, если не включена отладка.

ИМХО: это должно было быть по умолчанию операцией f-строки, однако слишком поздно. Вычисление F-строки может иметь серьезные и непреднамеренные побочные эффекты, и если это произойдет отложенным образом, это изменит выполнение программы.

Чтобы правильно отложить f-строки, python потребуется какой-то способ явного переключения поведения. Может быть, использовать букву «г»? ;)

Было указано, что отложенное ведение журнала не должно давать сбоев, если в преобразователе строк есть ошибка. Приведенное выше решение также может сделать это, измените finally: на except: и вставьте туда log.exception.

F-строка — это просто более краткий способ создания форматированной строки, заменяющий .format(**names) на f. Если вы не хотите, чтобы строка оценивалась таким образом немедленно, не делайте ее f-строкой. Сохраните его как обычный строковый литерал, а затем вызовите для него format позже, когда захотите выполнить интерполяцию, как вы это делали.

Конечно, есть альтернатива с eval.

template.txt:

f'Текущее имя {имя}'

Код:

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

Но тогда все, что вам удалось сделать, это заменить str.format на eval, что, конечно, того не стоит. Просто продолжайте использовать обычные строки с вызовом format.

То, что вы хотите, похоже, рассматривается как улучшение Python.

Между тем — из связанного обсуждения — следующее кажется разумным обходным путем, который не требует использования 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)

Вывод:

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

вдохновленный ответом kadee, для определения класса 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)

именно к этому и был задан вопрос

Как насчет:

s = 'Hi, {foo}!'

s
> 'Hi, {foo}!'

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

Или, может быть, не используйте f-строки, просто отформатируйте:

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

В версии без названий:

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

Большинство из этих ответов дадут вам что-то, что иногда ведет себя как f-строки, но в некоторых случаях все они будут неправильными. На pypi есть пакет f-yeah, который делает все это, но стоит вам всего два дополнительных символа! (полное раскрытие, я автор)

from fyeah import f

print(f("""'{'"all" the quotes'}'"""))

Есть много различий между f-строками и вызовами формата, вот, вероятно, неполный список.

• f-строки позволяют произвольно оценивать код Python
• f-строки не могут содержать обратную косую черту в выражении (поскольку форматированные строки не имеют выражения, поэтому я полагаю, вы могли бы сказать, что это не разница, но это отличается от того, что может сделать необработанный eval())
• поиск dict в отформатированных строках не должен заключаться в кавычки. Поиск dict в f-строках можно заключать в кавычки, поэтому также можно искать нестроковые ключи.
• f-строки имеют формат отладки, которого нет у format(): f"The argument is {spam=}"
• выражения f-строки не могут быть пустыми

Предложения по использованию eval обеспечат вам полную поддержку формата f-строки, но они не работают со всеми типами строк.

def f_template(the_string):
    return eval(f"f'{the_string}'")

print(f_template('some "quoted" string'))
print(f_template("some 'quoted' string"))

some "quoted" string
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 2, in f_template
  File "<string>", line 1
    f'some 'quoted' string'
            ^
SyntaxError: invalid syntax

В этом примере также в некоторых случаях будет неправильно определена область видимости переменных.

Предложение, использующее f-строки. Сделайте свою оценку на логическом уровне, где происходит шаблонизация, и передайте ее как генератор. Вы можете раскрутить его в любой точке, которую вы выберете, используя 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