Почему литеральные отформатированные строки (f-строки) были такими медленными в альфа-версии Python 3.6? (теперь исправлено в стабильной версии 3.6)

Примечание. Этот ответ был написан для альфа-версий Python 3.6. новый код операции, добавленный в 3.6.0b1, значительно улучшил производительность f-строки.

Синтаксис f"..." эффективно преобразуется в операцию str.join() над литеральными частями строки вокруг выражений {...}, а результаты самих выражений проходят через метод object.__format__() (передавая любую спецификацию формата :..). Это можно увидеть при разборке:

>>> import dis
>>> dis.dis(compile('f"X is {x}"', '', 'exec'))
  1           0 LOAD_CONST               0 ('')
              3 LOAD_ATTR                0 (join)
              6 LOAD_CONST               1 ('X is ')
              9 LOAD_NAME                1 (x)
             12 FORMAT_VALUE             0
             15 BUILD_LIST               2
             18 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             21 POP_TOP
             22 LOAD_CONST               2 (None)
             25 RETURN_VALUE
>>> dis.dis(compile('"X is {}".format(x)', '', 'exec'))
  1           0 LOAD_CONST               0 ('X is {}')
              3 LOAD_ATTR                0 (format)
              6 LOAD_NAME                1 (x)
              9 CALL_FUNCTION            1 (1 positional, 0 keyword pair)
             12 POP_TOP
             13 LOAD_CONST               1 (None)
             16 RETURN_VALUE

Обратите внимание на коды операций BUILD_LIST и LOAD_ATTR .. (join) в этом результате. Новый FORMAT_VALUE берет вершину стека плюс значение формата (проанализированное во время компиляции), чтобы объединить их в вызове object.__format__().

Итак, ваш пример, f"X is {x}", переводится как:

''.join(["X is ", x.__format__('')])

Обратите внимание, что для этого требуется, чтобы Python создал объект списка и вызвал метод str.join().

Вызов str.format() также является вызовом метода, и после синтаксического анализа по-прежнему задействован вызов x.__format__(''), но, что особенно важно, здесь не задействовано создание списка. Именно эта разница делает метод str.format() быстрее.

Обратите внимание, что Python 3.6 был выпущен только в виде альфа-сборки; эта реализация все еще может быть легко изменена. См. PEP 494 — Расписание выпуска Python 3.6. расписание, а также Python issue #27078 (открыт в ответ на этот вопрос) для обсуждения как еще больше повысить производительность форматированных строковых литералов.

До версии 3.6 beta 1 строка формата f'x is {x}' была скомпилирована в эквивалент ''.join(['x is ', x.__format__('')]). Полученный байт-код оказался неэффективным по нескольким причинам:

1. он построил последовательность фрагментов строки...
2. ... и эта последовательность была списком, а не кортежем! (создавать кортежи немного быстрее, чем списки).
3. он поместил пустую строку в стек
4. он искал метод join в пустой строке
5. он вызывал __format__ даже для голых объектов Unicode, для которых __format__('') всегда возвращал self, или целочисленных объектов, для которых __format__('') в качестве аргумента возвращал str(self).
6. __format__ метод не имеет слотов.

Однако для более сложной и длинной строки литеральные отформатированные строки все же были бы быстрее, чем соответствующий вызов '...'.format(...), потому что для последнего строка интерпретируется каждый раз, когда строка форматируется.

Именно этот вопрос был главным мотиватором для ошибки 27078 с запросом нового кода операции байт-кода Python для фрагментов строки в строку. (опкод получает один операнд - количество фрагментов в стеке; фрагменты помещаются в стек в порядке появления, т.е. последняя часть является самым верхним элементом). Сергей Сторчака реализовал этот новый код операции и объединил его с CPython, так что он был доступен в Python 3.6 начиная с бета-версии 1 (и, следовательно, в финальной версии Python 3.6.0).

В результате строки с литеральным форматированием будут намного быстрее, чем string.format. Они также часто намного быстрее, чем форматирование в старом стиле в Python 3.6, если вы просто интерполируете объекты str или int:

>>> timeit.timeit("x = 2; 'X is {}'.format(x)")
0.32464265200542286
>>> timeit.timeit("x = 2; 'X is %s' % x")
0.2260766440012958
>>> timeit.timeit("x = 2; f'X is {x}'")
0.14437875000294298

f'X is {x}' теперь компилируется в

>>> dis.dis("f'X is {x}'")
  1           0 LOAD_CONST               0 ('X is ')
              2 LOAD_NAME                0 (x)
              4 FORMAT_VALUE             0
              6 BUILD_STRING             2
              8 RETURN_VALUE

Новый BUILD_STRING вместе с оптимизацией кода FORMAT_VALUE полностью устраняет первые 5 из 6 источников неэффективности. Метод __format__ по-прежнему не имеет слотов, поэтому он требует поиска по словарю в классе, поэтому его вызов обязательно медленнее, чем вызов __str__, но теперь можно полностью избежать вызова в обычных случаях форматирования экземпляров int или str (не подклассов). !) без спецификаторов форматирования.