एफ-स्ट्रिंग्स के मूल्यांकन को स्थगित / स्थगित कैसे करें?

Question 1

मैं कुछ फ़ाइलों को उत्पन्न करने के लिए टेम्प्लेट स्ट्रिंग का उपयोग कर रहा हूं और मुझे इस उद्देश्य के लिए नए एफ-स्ट्रिंग्स की संक्षिप्तता पसंद है, मेरे पिछले टेम्पलेट कोड को कुछ इस तरह से कम करने के लिए:

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

हालांकि, कभी-कभी यह समझ में आता है कि टेम्पलेट को कहीं और परिभाषित किया गया है - कोड में उच्चतर, या फ़ाइल या किसी चीज़ से आयात किया गया। इसका मतलब यह है कि टेम्प्लेट एक स्थिर स्ट्रिंग है जिसमें इसमें टैगिंग प्रारूपित हैं। नए एफ-स्ट्रिंग के रूप में स्ट्रिंग की व्याख्या करने के लिए दुभाषिया को बताने के लिए स्ट्रिंग के साथ कुछ होना होगा, लेकिन मुझे नहीं पता कि क्या ऐसी कोई चीज है।

क्या किसी स्ट्रिंग में लाने का कोई तरीका है और क्या उसने .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}

Question 2

यहाँ एक पूर्ण "आदर्श 2" है।

यह एफ-स्ट्रिंग नहीं है - यह एफ-स्ट्रिंग्स का भी उपयोग नहीं करता है - लेकिन यह अनुरोध के अनुसार करता है। सिंटैक्स बिल्कुल निर्दिष्ट के रूप में। कोई सुरक्षा सिरदर्द नहीं है क्योंकि हम उपयोग नहीं कर रहे हैं 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

Question 3

इसका मतलब यह है कि टेम्प्लेट एक स्थिर स्ट्रिंग है जिसमें इसमें टैगिंग स्वरूपण हैं

हां, यही कारण है कि हमारे पास प्रतिस्थापन फ़ील्ड के साथ शाब्दिक हैं और .formatइसलिए, जब भी हम formatइसे पसंद करते हैं, तब हम फ़ील्ड को प्रतिस्थापित कर सकते हैं ।

स्ट्रिंग को नए एफ-स्ट्रिंग के रूप में व्याख्या करने के लिए दुभाषिया को बताने के लिए स्ट्रिंग के साथ कुछ करना होगा

यही उपसर्ग है 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

लेकिन गलत लगता है और इस तथ्य से सीमित है कि आप अपने प्रतिस्थापन में केवल वैश्विक नाम स्थान पर झांक सकते हैं। इसे ऐसी स्थिति में उपयोग करने की कोशिश की जा रही है जिसके लिए स्थानीय नामों की आवश्यकता बुरी तरह से विफल हो जाएगी जब तक कि इसे तर्कों के रूप में पारित नहीं किया जाता है (जो बिंदु को पूरी तरह से हरा देता है)।

क्या किसी स्ट्रिंग में लाने का कोई तरीका है और क्या उसने .format(**locals())कॉल का उपयोग करने से बचने के लिए एक एफ-स्ट्रिंग के रूप में व्याख्या की है ?

एक फ़ंक्शन (सीमाएं शामिल) के अलावा, नहीं, तो साथ ही साथ छड़ी हो सकती है .format।

Question 4

निम्नलिखित कार्य का उपयोग करते हुए एक स्ट्रिंग का मूल्यांकन एक एफ-स्ट्रिंग (अपनी पूर्ण क्षमताओं के साथ) के रूप में किया जाता है:

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

Question 5

एक एफ-स्ट्रिंग केवल एक स्वरूपित स्ट्रिंग बनाने का एक अधिक संक्षिप्त तरीका है, .format(**names)जिसके साथ प्रतिस्थापित किया जाता है f। यदि आप नहीं चाहते कि एक स्ट्रिंग का तुरंत इस तरह से मूल्यांकन किया जाए, तो इसे F-string न बनाएं। इसे एक साधारण स्ट्रिंग शाब्दिक के रूप में सहेजें, और फिर बाद में कॉल करें 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कॉल के साथ नियमित स्ट्रिंग्स का उपयोग करते रहें ।

Question 6

.Format का उपयोग करना इस प्रश्न का सही उत्तर नहीं है। पायथन एफ-स्ट्रिंग्स 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()}") .... जब तक डिबगिंग सक्षम नहीं होती तब तक वस्तु को डंप किए बिना।

IMHO: यह एफ-स्ट्रिंग्स का डिफ़ॉल्ट संचालन होना चाहिए था , हालांकि अब बहुत देर हो चुकी है । एफ-स्ट्रिंग मूल्यांकन में बड़े पैमाने पर और अनपेक्षित दुष्परिणाम हो सकते हैं, और ऐसा होने पर आस्थगित तरीके से कार्यक्रम निष्पादन बदल जाएगा।

एफ-स्ट्रिंग्स को ठीक से स्थगित करने के लिए, अजगर को स्पष्ट रूप से स्विचिंग व्यवहार के कुछ तरीके की आवश्यकता होगी। शायद 'जी' अक्षर का उपयोग करें? ;)

Question 7

आप जो चाहते हैं वह एक पायथन वृद्धि के रूप में माना जा रहा है ।

इस बीच, लिंक की गई चर्चा से - निम्नलिखित ऐसा लगता है कि यह एक उचित समाधान होगा जिसका उपयोग करने की आवश्यकता नहीं है 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

Question 8

से प्रेरित Kadee द्वारा जवाब , निम्नलिखित एक आस्थगित-च-स्ट्रिंग वर्ग को परिभाषित करने के लिए इस्तेमाल किया जा सकता।

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)

जो वास्तव में क्या सवाल के लिए पूछा है

Question 9

या शायद एफ-स्ट्रिंग्स का उपयोग न करें, बस प्रारूप:

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

Question 10

कैसा रहेगा:

s = 'Hi, {foo}!'

s
> 'Hi, {foo}!'

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

Question 11

एक सुझाव जो एफ-स्ट्रिंग्स का उपयोग करता है। अपने मूल्यांकन को उस तार्किक स्तर पर करें जहाँ टेम्प्लेटिंग हो रही है और इसे जनरेटर के रूप में पास करें। आप एफ-स्ट्रिंग्स का उपयोग करके, जो भी आप चुनते हैं, उसे खोल सकते हैं

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