如何推迟/推迟对F线的评估？

Question

我正在使用模板字符串生成一些文件，并且我喜欢为此目的而使用的新 f 字符串的简洁性，以减少我以前的模板代码，如下所示：

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

现在我可以这样做，直接替换变量：

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

但是，有时它会使在其他地方定义模板是有意义的——在代码的更高处，或者从文件或其他东西导入。这意味着模板是一个静态字符串，其中包含格式化标签。字符串必须发生一些事情才能告诉解释器将该字符串解释为新的 f 字符串，但我不知道是否存在这样的事情。

有什么方法可以引入字符串并将其解释为 f 字符串以避免使用 .format(**locals()) 调用？

理想情况下我想要能够像这样编码...（其中 magic_fstring_function 是我不理解的部分所在）：

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)

...具有所需的输出（无需读取文件两次）：

The current name is foo
The current name is bar

.. .但我得到的实际输出是：

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

---

_{另请参阅：如何将 f-string 与变量一起使用，而不是与字符串文字一起使用？}

Answer 1

将字符串评估为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

Answer 2

这是一个完整的“理想2”。

它不是F弦，甚至都不使用F-strings，而是根据要求进行的。符合指定的语法。没有安全性头痛，因为我们不使用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

Answer 3

这意味着模板是一个静态字符串，其中包含格式化标签

是的，这正是我们使用带有替换字段和 .format 的文字的原因，因此我们可以随时通过调用 format 来替换字段就可以了。

字符串必须发生一些事情才能告诉解释器将该字符串解释为新的 f 字符串

，即前缀 f/F。您可以将其包装在一个函数中并在调用时推迟评估，但这当然会产生额外的开销：

def template_a():
    return 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。

Answer 4

怎么样：

s = 'Hi, {foo}!'

s
> 'Hi, {foo}!'

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

Answer 5

使用.format不是此问题的正确答案。 python f -string与str.format（）模板非常不同...它们可以包含代码或其他昂贵的操作 - 因此需要延期。

这是延期记录器的示例。这使用了日志记录的正常序言，但然后添加新功能，仅当日志级别正确时，才能解释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（）}”）。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。

IMHO：这应该是f-strings的默认操作，但是现在为时已晚。 F弦弦评估可以具有巨大的意外副作用，并且以递延方式发生这种情况将改变程序执行。

为了使F-string适当推迟，Python需要某种明确切换行为的方法。也许使用字母“ G”？ ;）

已经指出，如果字符串转换器中有一个错误，则延期记录不应崩溃。以上解决方案也可以执行此操作，最后将更改为 以外：，然后在其中粘贴log.exception。

Answer 6

F-string只是创建格式化字符串的一种更简洁的方法，用.format（**名称）用f替换。如果您不希望以这样的方式对字符串进行评估，请不要使其成为F串。将其保存为普通字符串文字，然后在您要执行插值时，请在其稍后拨打格式。

当然，有一个eval的替代方案。

template.txt：

f'当前名称{name}'

代码：

>>> 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，这肯定不值得。只需继续使用格式调用常规字符串即可。

Answer 7

您想要的似乎被视为 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

Answer 8

或者也许不使用 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))

Answer 9

灵感来自 kadee的答案，可以使用以下来定义延迟的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)

这正是问题所要求的

Answer 10

这些答案中的大多数有时会给你一些行为类似于 f 字符串的东西，但在某些情况下它们都会出错。
pypi 上有一个包 f-yeah 可以完成这一切，只需要花费两个额外的字符！ （完全披露，我是作者）

from fyeah import f

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

f 字符串和格式调用之间有很多差异，这里是一个可能不完整的列表

• f 字符串允许任意评估 python 代码
• f 字符串不能在表达式中包含反斜杠（由于格式化字符串没有表达式，所以我想您可以说这没有区别，但它确实与原始 eval() 可以做的不同）
• 格式化字符串中的字典查找不得被引用。 f 字符串中的 dict 查找可以被引用，因此也可以查找非字符串键
• 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

在某些情况下，此示例还会出现变量作用域错误。

Answer 11

为此，我更喜欢在lambda功能中使用FSTRING，例如：

s = lambda x: f'this is your string template to embed {x} in it.'
n = ['a' , 'b' , 'c']
for i in n:
   print( s(i) )

Answer 12

关于使用str.format（）的讨论很多，但是如前所述，它不允许在诸如算术或切片之类的F弦乐中允许的大多数表达式。使用eval（）显然也有缺点。

我建议您研究一种模板语言，例如Jinja。对于我的用例，它运行良好。请参阅下面的示例，其中我已经用单个卷曲支撑覆盖了变量注释语法，以匹配F弦语法。我没有完全回顾F-strings和Jinja之间的差异。

from jinja2 import Environment, BaseLoader

a, b, c = 1, 2, "345"
templ = "{a or b}{c[1:]}"

env = Environment(loader=BaseLoader, variable_start_string="{", variable_end_string="}")
env.from_string(templ).render(**locals())

结果

'145'

Answer 13

我发现这个问题很有趣，并写了我自己的 library 实现懒惰的F-strings。

安装它：

pip install fazy

并使用：

import f

number = 33
print(f('{number} kittens drink milk'))

此解决方案非常适合用于记录。阅读有关链接中文档中的功能和限制的更多信息。

Answer 14

使用 f 字符串的建议。做出您的评价
模板发生的逻辑级别并将其作为生成器传递。
您可以使用 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  

Answer 15

您可以使用.format样式替换，并明确定义替换的变量名称：

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

输出

The current name is foo
The current name is bar

Answer 16

我遇到了这个问题，这与我要做的事情类似，唯一的区别是我需要提早评估的F弦乐的变量的某些，然后将其他F串变量推迟到以后确定。

因此，要从原始示例中借用，这就是我将其删除的方式：

from datetime import date
now = date.today()
names = ["foo", "bar"]

# double bracket allows `name` to be evaluated by the next format() call
template_a = f"The current name is {{name}} and the current date is {now}."

for name in names:
    print (template_a.format(name=name))