Làm thế nào để hoãn / trì hoãn việc đánh giá chuỗi f?

Tôi đang sử dụng chuỗi mẫu để tạo một số tệp và tôi thích sự ngắn gọn của chuỗi f mới cho mục đích này, để giảm mã mẫu trước đó của tôi khỏi một cái gì đó như thế này:

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

Bây giờ tôi có thể làm điều này, trực tiếp thay thế các biến:

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

Tuy nhiên, đôi khi có ý nghĩa nếu mẫu được xác định ở nơi khác - cao hơn trong mã hoặc được nhập từ tệp hoặc thứ gì đó. Điều này có nghĩa là mẫu là một chuỗi tĩnh có các thẻ định dạng trong đó. Điều gì đó sẽ xảy ra với chuỗi để yêu cầu trình thông dịch giải thích chuỗi đó là một chuỗi f mới, nhưng tôi không biết liệu có điều đó xảy ra hay không.

Có cách nào để đưa vào một chuỗi và nó được hiểu là chuỗi f để tránh sử dụng .format(**locals())cuộc gọi không?

Lý tưởng nhất là tôi muốn có thể viết mã như thế này ... ( magic_fstring_functionphần tôi không hiểu nằm ở đâu):

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)

... với đầu ra mong muốn này (mà không cần đọc tệp hai lần):

The current name is foo
The current name is bar

... nhưng sản lượng thực tế tôi nhận được là:

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

Đây là một "Lý tưởng 2" hoàn chỉnh.

Nó không phải là chuỗi f — thậm chí không sử dụng chuỗi f — nhưng nó thực hiện theo yêu cầu. Cú pháp chính xác như được chỉ định. Không phải đau đầu về bảo mật vì chúng tôi không sử dụng eval().

Nó sử dụng một lớp nhỏ và thực hiện __str__được tự động gọi bằng print. Để thoát khỏi phạm vi giới hạn của lớp, chúng tôi sử dụng inspectmô-đun để nhảy một khung lên và xem các biến mà người gọi có quyền truy cập.

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

Điều này có nghĩa là mẫu là một chuỗi tĩnh có các thẻ định dạng trong đó

Vâng, đó chính xác là lý do tại sao chúng ta có các ký tự với các trường thay thế và .format, vì vậy chúng tôi có thể thay thế các trường bất cứ khi nào chúng tôi muốn bằng cách gọi formatnó.

Điều gì đó sẽ xảy ra với chuỗi để yêu cầu trình thông dịch giải thích chuỗi đó là một chuỗi f mới

Đó là tiền tố f/F. Bạn có thể gói nó trong một chức năng và hoãn đánh giá trong thời gian gọi nhưng tất nhiên điều đó sẽ phát sinh thêm chi phí:

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

Cái nào in ra:

The current name is foo
The current name is bar

nhưng cảm thấy sai và bị hạn chế bởi thực tế là bạn chỉ có thể xem qua không gian tên chung trong phần thay thế của mình. Cố gắng sử dụng nó trong tình huống yêu cầu tên cục bộ sẽ thất bại thảm hại trừ khi được chuyển đến chuỗi dưới dạng đối số (hoàn toàn đánh bại điểm).

Có cách nào để đưa vào một chuỗi và nó được hiểu là chuỗi f để tránh sử dụng .format(**locals())cuộc gọi không?

Ngoài một chức năng (bao gồm các giới hạn), nope, do đó cũng có thể gắn bó với .format.

Một cách ngắn gọn để có một chuỗi được đánh giá là một chuỗi f (với đầy đủ các tính năng của nó) là sử dụng hàm sau:

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

Sau đó, bạn có thể làm:

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

Và, ngược lại với nhiều giải pháp được đề xuất khác, bạn cũng có thể làm:

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

Chuỗi f chỉ đơn giản là một cách ngắn gọn hơn để tạo một chuỗi được định dạng, thay thế .format(**names)bằng f. Nếu bạn không muốn một chuỗi được đánh giá ngay lập tức theo cách như vậy, đừng đặt nó thành chuỗi f. Lưu nó dưới dạng một chuỗi ký tự thông thường, và sau đó gọi formatnó sau khi bạn muốn thực hiện nội suy, như bạn đã làm.

Tất nhiên, có một thay thế với eval.

template.txt:

f'Tên hiện tại là {name} '

Mã:

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

Nhưng sau đó tất cả những gì bạn phải làm là thay thế str.formatbằng eval, điều này chắc chắn không đáng. Chỉ cần tiếp tục sử dụng các chuỗi thông thường với một formatcuộc gọi.

Sử dụng .format không phải là một câu trả lời chính xác cho câu hỏi này. Chuỗi f trong Python rất khác với các mẫu str.format () ... chúng có thể chứa mã hoặc các hoạt động đắt tiền khác - do đó cần phải hoãn lại.

Đây là một ví dụ về trình ghi nhật ký trả chậm. Điều này sử dụng phần mở đầu bình thường của logging.getLogger, nhưng sau đó thêm các hàm mới chỉ diễn giải chuỗi f nếu mức nhật ký là chính xác.

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)

Điều này có lợi thế là có thể làm những việc như: log.fdebug("{obj.dump()}").... mà không cần kết xuất đối tượng trừ khi gỡ lỗi được bật.

IMHO: Đây lẽ ra là hoạt động mặc định của f-string, tuy nhiên bây giờ đã quá muộn . Đánh giá chuỗi F có thể có các tác dụng phụ lớn và không mong muốn, và nếu điều đó xảy ra một cách trì hoãn sẽ thay đổi việc thực thi chương trình.

Để làm cho chuỗi f bị trì hoãn đúng cách, python sẽ cần một số cách chuyển đổi hành vi rõ ràng. Có thể sử dụng chữ cái 'g'? ;)

Nó đã được chỉ ra rằng ghi nhật ký hoãn lại sẽ không bị lỗi nếu có lỗi trong trình chuyển đổi chuỗi. Giải pháp trên cũng có thể làm điều này, thay đổi finally:thành except:, và gắn log.exceptionvào đó.

Những gì bạn muốn dường như được coi là một cải tiến của Python .

Trong khi đó - từ cuộc thảo luận được liên kết - thì điều sau có vẻ như đó sẽ là một cách giải quyết hợp lý mà không yêu cầu sử dụng 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)

Đầu ra:

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

lấy cảm hứng từ câu trả lời của kadee , phần sau có thể được sử dụng để xác định một lớp f-string hoãn lại.

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)

đó chính xác là những gì câu hỏi yêu cầu

Hoặc có thể không sử dụng f-string, chỉ định dạng:

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

Trong phiên bản không có tên:

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

Làm thế nào về:

s = 'Hi, {foo}!'

s
> 'Hi, {foo}!'

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

Một gợi ý sử dụng chuỗi f. Thực hiện đánh giá của bạn ở cấp độ logic nơi diễn ra quá trình tạo khuôn mẫu và chuyển nó như một bộ tạo. Bạn có thể thư giãn nó bất cứ lúc nào bạn chọn, sử dụng f-string

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