Bagaimana cara menunda / menunda evaluasi f-string?

Saya menggunakan string template untuk menghasilkan beberapa file dan saya menyukai keringkasan f-string baru untuk tujuan ini, untuk mengurangi kode template saya sebelumnya dari sesuatu seperti ini:

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

Sekarang saya bisa melakukan ini, langsung mengganti variabel:

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

Namun, terkadang masuk akal untuk menetapkan template di tempat lain - lebih tinggi dalam kode, atau diimpor dari file atau sesuatu. Artinya, template adalah string statis dengan tag pemformatan di dalamnya. Sesuatu harus terjadi pada string untuk memberi tahu penerjemah untuk menafsirkan string sebagai f-string baru, tetapi saya tidak tahu apakah ada hal seperti itu.

Apakah ada cara untuk memasukkan string dan menafsirkannya sebagai f-string untuk menghindari penggunaan .format(**locals())panggilan?

Idealnya saya ingin dapat membuat kode seperti ini ... (di magic_fstring_functionmana bagian yang tidak saya mengerti masuk):

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)

... dengan keluaran yang diinginkan ini (tanpa membaca file dua kali):

The current name is foo
The current name is bar

... tapi keluaran sebenarnya yang saya dapatkan adalah:

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

Berikut adalah "Ideal 2" yang lengkap.

Ini bukan f-string — bahkan tidak menggunakan f-string — tapi seperti yang diminta. Sintaks persis seperti yang ditentukan. Tidak ada sakit kepala keamanan karena kami tidak menggunakan eval().

Ini menggunakan kelas kecil dan implementasi __str__yang secara otomatis dipanggil dengan print. Untuk keluar dari ruang lingkup kelas yang terbatas, kita menggunakan inspectmodul untuk melompat satu frame ke atas dan melihat variabel yang dapat diakses pemanggil.

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

Artinya, template adalah string statis dengan tag pemformatan di dalamnya

Ya, itulah mengapa kami memiliki literal dengan bidang pengganti dan .format, sehingga kami dapat mengganti bidang kapan pun kami suka dengan memanggilnya format.

Sesuatu harus terjadi pada string untuk memberi tahu penerjemah untuk menafsirkan string sebagai f-string baru

Itu awalannya f/F. Anda dapat menggabungkannya dalam sebuah fungsi dan menunda evaluasi selama waktu panggilan, tetapi tentu saja itu menimbulkan overhead tambahan:

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

Yang mencetak:

The current name is foo
The current name is bar

tetapi terasa salah dan dibatasi oleh fakta bahwa Anda hanya dapat mengintip namespace global di pengganti Anda. Mencoba menggunakannya dalam situasi yang membutuhkan nama lokal akan gagal total kecuali diteruskan ke string sebagai argumen (yang benar-benar mengalahkan intinya).

Apakah ada cara untuk memasukkan string dan menafsirkannya sebagai f-string untuk menghindari penggunaan .format(**locals())panggilan?

Selain fungsi (termasuk batasan), tidak, jadi sebaiknya tetap gunakan .format.

Cara ringkas agar string dievaluasi sebagai f-string (dengan kemampuan penuhnya) adalah menggunakan fungsi berikut:

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

Kemudian Anda dapat melakukan:

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

Dan, berbeda dengan banyak solusi lain yang diusulkan, Anda juga dapat melakukan:

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 hanyalah cara yang lebih ringkas untuk membuat string berformat, menggantikan .format(**names)dengan f. Jika Anda tidak ingin string segera dievaluasi dengan cara seperti itu, jangan menjadikannya f-string. Simpan sebagai string literal biasa, dan kemudian panggil formatnanti ketika Anda ingin melakukan interpolasi, seperti yang telah Anda lakukan.

Tentu saja, ada alternatif lain dengan eval.

template.txt:

f'Nama saat ini adalah {name} '

Kode:

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

Tetapi yang berhasil Anda lakukan hanyalah mengganti str.formatdengan eval, yang tentunya tidak sepadan. Tetap gunakan string biasa dengan formatpanggilan.

Menggunakan .format bukanlah jawaban yang benar untuk pertanyaan ini. F-string Python sangat berbeda dari template str.format () ... mereka dapat berisi kode atau operasi mahal lainnya - oleh karena itu perlu penangguhan.

Berikut ini contoh logger yang ditangguhkan. Ini menggunakan pembukaan normal logging.getLogger, tetapi kemudian menambahkan fungsi baru yang menafsirkan f-string hanya jika level log sudah benar.

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)

Ini memiliki keuntungan karena dapat melakukan hal-hal seperti: log.fdebug("{obj.dump()}").... tanpa membuang objek kecuali proses debug diaktifkan.

IMHO: Ini seharusnya menjadi default operasi f-string, namun sekarang sudah terlambat . Evaluasi F-string dapat memiliki efek samping yang sangat besar dan tidak diinginkan, dan jika hal itu terjadi secara tertunda akan mengubah eksekusi program.

Untuk membuat f-string ditangguhkan dengan benar, python memerlukan beberapa cara untuk mengubah perilaku secara eksplisit. Mungkin menggunakan huruf 'g'? ;)

Telah ditunjukkan bahwa logging yang ditangguhkan seharusnya tidak macet jika ada bug di konverter string. Solusi di atas dapat melakukan ini juga, mengubah finally:menjadi except:, dan menempelkan a log.exceptiondi sana.

Apa yang Anda inginkan tampaknya dianggap sebagai peningkatan Python .

Sementara itu - dari diskusi yang ditautkan - berikut ini sepertinya merupakan solusi yang masuk akal yang tidak memerlukan penggunaan 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)

Keluaran:

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

terinspirasi oleh jawaban oleh kadee , berikut ini dapat digunakan untuk mendefinisikan kelas f-string yang ditangguhkan.

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)

itulah pertanyaan yang ditanyakan

Atau mungkin tidak menggunakan f-string, cukup format:

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

Dalam versi tanpa nama:

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

Bagaimana tentang:

s = 'Hi, {foo}!'

s
> 'Hi, {foo}!'

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

Saran yang menggunakan f-string. Lakukan evaluasi Anda pada tingkat logis di mana template terjadi dan berikan sebagai generator. Anda dapat melepasnya kapan saja, menggunakan 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