วิธีการเลื่อน / เลื่อนการประเมิน f-strings?

ฉันใช้สตริงเทมเพลตเพื่อสร้างไฟล์บางไฟล์และฉันชอบความกระชับของ f-strings ใหม่เพื่อจุดประสงค์นี้เพื่อลดรหัสเทมเพลตก่อนหน้าของฉันจากสิ่งนี้:

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-string เพื่อหลีกเลี่ยงการใช้การ.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}

นี่คือ "อุดมคติ 2" ฉบับสมบูรณ์

ไม่ใช่ f-string - ไม่ใช้ 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

ซึ่งหมายความว่าเทมเพลตเป็นสตริงแบบคงที่ที่มีแท็กการจัดรูปแบบอยู่ในนั้น

ใช่นั่นเป็นเหตุผลที่เรามีตัวอักษรพร้อมฟิลด์ทดแทน.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-string เพื่อหลีกเลี่ยงการใช้การ.format(**locals())โทร?

นอกเหนือจากฟังก์ชั่น (รวมข้อ จำกัด ) ไม่ดังนั้นอาจติดด้วย.formatเช่นกัน

วิธีที่กระชับในการประเมินสตริงเป็น f-string (พร้อมความสามารถเต็มรูปแบบ) คือการใช้ฟังก์ชันต่อไปนี้:

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

f-string เป็นเพียงวิธีที่กระชับมากขึ้นในการสร้างสตริงที่จัดรูปแบบโดยแทนที่.format(**names)ด้วยf. หากคุณไม่ต้องการให้สตริงถูกประเมินทันทีในลักษณะดังกล่าวอย่ากำหนดให้เป็นสตริง f บันทึกเป็นสตริงลิเทอรัลธรรมดาแล้วเรียกใช้formatในภายหลังเมื่อคุณต้องการดำเนินการแก้ไขตามที่คุณเคยทำ

แน่นอนว่ามีอีกทางเลือกหนึ่ง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ซึ่งแน่นอนไม่คุ้มค่า เพียงแค่ใช้สายปกติกับการformatโทร

การใช้. format ไม่ใช่คำตอบที่ถูกต้องสำหรับคำถามนี้ Python f-strings แตกต่างจากเทมเพลต str.format () อย่างมาก ... สามารถมีโค้ดหรือการดำเนินการอื่น ๆ ที่มีราคาแพงได้ดังนั้นจึงจำเป็นต้องมีการเลื่อนออกไป

นี่คือตัวอย่างของคนตัดไม้รอการตัดบัญชี สิ่งนี้ใช้คำนำหน้าปกติของ logging.getLogger แต่จะเพิ่มฟังก์ชันใหม่ที่แปลความหมายของ f-string ก็ต่อเมื่อระดับการบันทึกถูกต้อง

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-สตริง แต่ตอนนี้มันสายเกินไป การประเมิน F-string อาจมีผลข้างเคียงจำนวนมากและไม่ได้ตั้งใจและการที่สิ่งนั้นเกิดขึ้นในลักษณะที่รอการตัดบัญชีจะเปลี่ยนการทำงานของโปรแกรม

ในการสร้าง f-strings ให้ถูกเลื่อนออกไปอย่างถูกต้อง python จำเป็นต้องมีวิธีการเปลี่ยนพฤติกรรมอย่างชัดเจน อาจจะใช้ตัวอักษร 'g'? ;)

มีการชี้ให้เห็นว่าการบันทึกที่รอการตัดบัญชีไม่ควรผิดพลาดหากมีข้อบกพร่องในตัวแปลงสตริง การแก้ปัญหาดังกล่าวข้างต้นสามารถทำเช่นนี้ได้เป็นอย่างดีเปลี่ยนfinally:ไปexcept:และติดlog.exceptionอยู่ในนั้น

สิ่งที่คุณต้องการดูเหมือนจะถือว่าเป็นการเพิ่มประสิทธิภาพของ 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สิ่งต่อไปนี้สามารถใช้เพื่อกำหนดคลาส 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)

ซึ่งตรงกับคำถามที่ถาม

หรืออาจจะไม่ใช้ f-strings เพียงแค่จัดรูปแบบ:

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

เกี่ยวกับ:

s = 'Hi, {foo}!'

s
> 'Hi, {foo}!'

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

คำแนะนำที่ใช้ f-strings ทำการประเมินผลของคุณในระดับตรรกะที่เกิดเทมเพลตและส่งต่อเป็นตัวสร้าง คุณสามารถผ่อนคลายได้ทุกเมื่อโดยใช้ 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