2. Лексический анализ

Программа на языке Python читается парсером. На вход парсеру подается поток токенов, сгенерированный лексическим анализатором. В этой главе описывается, как лексический анализатор разбивает файл на лексемы.

Python считывает текст программы в виде кодовых точек Юникода; кодировка исходного файла может быть задана объявлением кодировки и по умолчанию равна UTF-8, подробнее см. в PEP 3120. Если исходный файл не может быть декодирован, выдается сообщение SyntaxError.

2.1. Структура линии

Программа на Python состоит из нескольких логических строк.

2.1.1. Логические линии

Конец логической строки представляется маркером NEWLINE. Высказывания не могут пересекать границы логических строк, за исключением случаев, когда NEWLINE разрешен синтаксисом (например, между высказываниями в составных высказываниях). Логическая строка строится из одной или нескольких физических строк, следуя явным или неявным правилам соединения строк.

2.1.2. Физические линии

Физическая строка - это последовательность символов, завершаемая последовательностью конца строки. В исходных файлах и строках может использоваться любая из стандартных последовательности завершения строк платформы - форма Unix, использующая ASCII LF (перевод строки), форма Windows, использующая ASCII-последовательность CR LF (возврат с последующим переводом строки), или старая форма Macintosh, использующая символ ASCII CR (возврат). Все эти формы могут использоваться одинаково, независимо от платформы. Конец ввода также служит неявным терминатором для последней физической строки.

При встраивании Python строки исходного кода должны передаваться в API Python с использованием стандартных соглашений C для символов новой строки (символ \n, представляющий ASCII LF, является терминатором строки).

2.1.3. Комментарии

Комментарий начинается с хэш-символа (#), который не является частью строкового литерала, и заканчивается в конце физической строки. Комментарий означает конец логической строки, если не задействованы правила неявного объединения строк. Комментарии игнорируются синтаксисом.

2.1.4. Объявления о кодировке

Если комментарий в первой или второй строке сценария Python соответствует регулярному выражению coding[=:]\s*([-\w.]+), этот комментарий обрабатывается как объявление кодировки; первая группа этого выражения называет кодировку файла исходного кода. Объявление кодировки должно располагаться в отдельной строке. Если это вторая строка, то первая строка также должна быть строкой, содержащей только комментарий. Рекомендуемые формы выражения кодировки

# -*- coding: <encoding-name> -*-

который также распознается GNU Emacs, и

# vim:fileencoding=<encoding-name>

который признан VIM Брэма Муленаара.

Если объявление кодировки не найдено, по умолчанию используется кодировка UTF-8. Если неявная или явная кодировка файла - UTF-8, то начальная метка порядка байтов UTF-8 (b“xefxbbxbf“) игнорируется, а не является синтаксической ошибкой.

Если объявлена кодировка, имя кодировки должно быть распознано Python (см. Стандартные кодировки). Кодировка используется для всего лексического анализа, включая строковые литералы, комментарии и идентификаторы.

2.1.5. Явное соединение линий

Две или более физических строк могут быть объединены в логические строки с помощью символов обратной косой черты (\) следующим образом: если физическая строка заканчивается обратной косой чертой, которая не является частью строкового литерала или комментария, она объединяется со следующей, образуя одну логическую строку, удаляя обратную косую черту и следующий символ конца строки. Например:

if 1900 < year < 2100 and 1 <= month <= 12 \
   and 1 <= day <= 31 and 0 <= hour < 24 \
   and 0 <= minute < 60 and 0 <= second < 60:   # Looks like a valid date
        return 1

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

2.1.6. Неявное соединение линий

Выражения в круглых скобках, квадратных скобках или фигурных скобках могут быть разбиты более чем на одну физическую строку без использования обратных косых черточек. Например:

month_names = ['Januari', 'Februari', 'Maart',      # These are the
               'April',   'Mei',      'Juni',       # Dutch names
               'Juli',    'Augustus', 'September',  # for the months
               'Oktober', 'November', 'December']   # of the year

Неявно продолженные строки могут содержать комментарии. Отступы линий продолжения не важны. Допускаются пустые строки продолжения. Между неявными продолженными строками не ставится лексема NEWLINE. Неявные продолженные строки могут также встречаться в строках, заключенных в тройные кавычки (см. ниже); в этом случае они не могут содержать комментариев.

2.1.7. Пустые строки

Логическая строка, содержащая только пробелы, табуляции, форм-фиды и, возможно, комментарий, игнорируется (т. е. не генерируется маркер NEWLINE). При интерактивном вводе операторов обработка пустой строки может отличаться в зависимости от реализации цикла read-eval-print. В стандартном интерактивном интерпретаторе полностью пустая логическая строка (т. е. не содержащая даже пробельных символов или комментария) завершает многострочный оператор.

2.1.8. Вдавливание

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

Табуляции заменяются (слева направо) от одного до восьми пробелов таким образом, чтобы общее количество символов до замены включительно было кратно восьми (это правило используется в Unix). Общее количество пробелов, предшествующих первому непустому символу, определяет отступ строки. Отступ не может быть разделен на несколько физических строк с помощью обратных косых черточек; отступ определяется пробелами до первой обратной косой черты.

Отступы отклоняются как непоследовательные, если в исходном файле смешаны табуляции и пробелы таким образом, что смысл зависит от наличия табуляции в пробелах; в этом случае выставляется TabError.

Примечание о кросс-платформенной совместимости: из-за особенностей текстовых редакторов на платформах, отличных от UNIX, нежелательно использовать смесь пробелов и табуляций для отступов в одном исходном файле. Следует также отметить, что различные платформы могут явно ограничивать максимальный уровень отступа.

В начале строки может присутствовать символ форм-фида; он будет игнорироваться при вычислениях отступа, приведенных выше. Символы форматирования, встречающиеся в других местах ведущего пробельного символа, имеют неопределенный эффект (например, они могут обнулить счетчик пробелов).

Уровни отступа последовательных строк используются для создания лексем INDENT и DEDENT с помощью стека следующим образом.

Перед чтением первой строки файла в стек заносится один ноль, который больше никогда не будет снят. Числа, помещенные в стек, всегда будут строго возрастать снизу вверх. В начале каждой логической строки уровень отступа строки сравнивается с вершиной стека. Если он равен, то ничего не происходит. Если больше, то он задвигается в стек и генерируется одна лексема INDENT. Если меньше, то это должно быть одно из чисел, находящихся в стеке; все числа в стеке, которые больше, отбрасываются, и для каждого отброшенного числа генерируется маркер DEDENT. В конце файла для каждого оставшегося в стеке числа, которое больше нуля, генерируется маркер DEDENT.

Вот пример правильного (хотя и запутанного) отступа в коде Python:

def perm(l):
        # Compute the list of all permutations of l
    if len(l) <= 1:
                  return [l]
    r = []
    for i in range(len(l)):
             s = l[:i] + l[i+1:]
             p = perm(s)
             for x in p:
              r.append(l[i:i+1] + x)
    return r

В следующем примере показаны различные ошибки отступов:

 def perm(l):                       # error: first line indented
for i in range(len(l)):             # error: not indented
    s = l[:i] + l[i+1:]
        p = perm(l[:i] + l[i+1:])   # error: unexpected indent
        for x in p:
                r.append(l[i:i+1] + x)
            return r                # error: inconsistent dedent

(На самом деле, первые три ошибки обнаруживаются синтаксическим анализатором; только последняя ошибка обнаруживается лексическим анализатором - отступ return r не соответствует уровню, выгруженному из стека).

2.1.9. Пробелы между лексемами

За исключением начала логической строки или строковых литералов, пробельные символы пробел, табуляция и форм-фид могут использоваться как взаимозаменяемые для разделения лексем. Пробел необходим между двумя лексемами только в том случае, если их объединение иначе можно интерпретировать как разные лексемы (например, ab - одна лексема, а a b - две лексемы).

2.2. Другие жетоны

Помимо NEWLINE, INDENT и DEDENT, существуют следующие категории лексем: идентификаторы, ключевые слова, литералы, операторы и разделители. Пробельные символы (кроме терминаторов строк, о которых говорилось ранее) не являются лексемами, но служат для разграничения лексем. Если существует двусмысленность, токен включает в себя самую длинную возможную строку, которая образует законный токен при чтении слева направо.

2.3. Идентификаторы и ключевые слова

Идентификаторы (также называемые именами) описываются следующими лексическими определениями.

Синтаксис идентификаторов в Python основан на приложении UAX-31 к стандарту Unicode, с уточнениями и изменениями, описанными ниже; см. также PEP 3131 для более подробной информации.

В диапазоне ASCII (U+0001…U+007F) допустимыми символами для идентификаторов являются те же, что и в Python 2.x: заглавные и строчные буквы A - Z, знак подчеркивания _ и, кроме первого символа, цифры 0 - 9.

В Python 3.0 появились дополнительные символы, не входящие в диапазон ASCII (см. PEP 3131). Для этих символов в классификации используется версия базы данных символов Unicode, включенная в модуль unicodedata.

Длина идентификаторов не ограничена. Случай имеет значение.

identifier   ::=  xid_start xid_continue*
id_start     ::=  <all characters in general categories Lu, Ll, Lt, Lm, Lo, Nl, the underscore, and characters with the Other_ID_Start property>
id_continue  ::=  <all characters in id_start, plus characters in the categories Mn, Mc, Nd, Pc and others with the Other_ID_Continue property>
xid_start    ::=  <all characters in id_start whose NFKC normalization is in "id_start xid_continue*">
xid_continue ::=  <all characters in id_continue whose NFKC normalization is in "id_continue*">

Упомянутые выше коды категорий Unicode означают:

  • Lu - заглавные буквы

  • Ll - строчные буквы

  • Lt - заглавные буквы

  • Lm - буквы-модификаторы

  • Lo - другие буквы

  • Nl - номера букв

  • Mn - знаки без пробелов

  • Mc - интервальные комбинированные знаки

  • Nd - десятичные числа

  • Pc - соединительные пунктуации

  • Other_ID_Start - явный список символов в PropList.txt для поддержки обратной совместимости

  • Other_ID_Continue - аналогично

При разборе все идентификаторы преобразуются в нормальную форму NFKC; сравнение идентификаторов осуществляется на основе NFKC.

Ненормативный HTML-файл с перечнем всех допустимых символов идентификатора для Unicode 15.1.0 можно найти по адресу https://www.unicode.org/Public/15.1.0/ucd/DerivedCoreProperties.txt.

2.3.1. Ключевые слова

Следующие идентификаторы используются как зарезервированные слова, или ключевые слова языка, и не могут быть использованы в качестве обычных идентификаторов. Они должны быть написаны именно так, как написано здесь:

False      await      else       import     pass
None       break      except     in         raise
True       class      finally    is         return
and        continue   for        lambda     try
as         def        from       nonlocal   while
assert     del        global     not        with
async      elif       if         or         yield

2.3.2. Мягкие ключевые слова

Added in version 3.10.

Некоторые идентификаторы зарезервированы только в определенных контекстах. Они известны как мягкие ключевые слова. Идентификаторы match, case, type и _ могут синтаксически выступать в качестве ключевых слов в определенных контекстах, но это различие делается на уровне синтаксического анализатора, а не при токенизации.

Как мягкие ключевые слова, их использование в грамматике возможно при сохранении совместимости с существующим кодом, который использует эти имена в качестве имен идентификаторов.

match, case и _ используются в утверждении match. type используется в утверждении type.

Изменено в версии 3.12: type теперь является мягким ключевым словом.

2.3.3. Зарезервированные классы идентификаторов

Некоторые классы идентификаторов (помимо ключевых слов) имеют особые значения. Эти классы идентифицируются по шаблонам ведущих и завершающих символов подчеркивания:

_*

Не импортируется from module import *.

_

В шаблоне case внутри высказывания match, _ - это soft keyword, который обозначает wildcard.

Отдельно интерактивный интерпретатор делает результат последней оценки доступным в переменной _. (Он хранится в модуле builtins, наряду со встроенными функциями, такими как print).

В других местах _ - это обычный идентификатор. Он часто используется для именования «особых» элементов, но для самого Python он не является особым.

Примечание

Имя _ часто используется в связи с интернационализацией; обратитесь к документации по модулю gettext для получения дополнительной информации об этом соглашении.

Он также часто используется для неиспользуемых переменных.

__*__

Системно-определенные имена, неофициально называемые «дундерскими». Эти имена определяются интерпретатором и его реализацией (включая стандартную библиотеку). Текущие системные имена обсуждаются в разделе Специальные имена методов и в других разделах. В будущих версиях Python, вероятно, будет определено больше. Любое использование имен __*__ в любом контексте, не соответствующее явно документированному использованию, может быть нарушено без предупреждения.

__*

Частные имена класса. Имена этой категории, используемые в контексте определения класса, переписываются в искаженном виде, чтобы помочь избежать столкновений имен между «приватными» атрибутами базовых и производных классов. См. раздел Идентификаторы (имена).

2.4. Литература

Литералы - это обозначения для постоянных значений некоторых встроенных типов.

2.4.1. Литералы строк и байтов

Строковые литералы описываются следующими лексическими определениями:

stringliteral   ::=  [stringprefix](shortstring | longstring)
stringprefix    ::=  "r" | "u" | "R" | "U" | "f" | "F"
                     | "fr" | "Fr" | "fR" | "FR" | "rf" | "rF" | "Rf" | "RF"
shortstring     ::=  "'" shortstringitem* "'" | '"' shortstringitem* '"'
longstring      ::=  "'''" longstringitem* "'''" | '"""' longstringitem* '"""'
shortstringitem ::=  shortstringchar | stringescapeseq
longstringitem  ::=  longstringchar | stringescapeseq
shortstringchar ::=  <any source character except "\" or newline or the quote>
longstringchar  ::=  <any source character except "\">
stringescapeseq ::=  "\" <any source character>

bytesliteral   ::=  bytesprefix(shortbytes | longbytes)
bytesprefix    ::=  "b" | "B" | "br" | "Br" | "bR" | "BR" | "rb" | "rB" | "Rb" | "RB"
shortbytes     ::=  "'" shortbytesitem* "'" | '"' shortbytesitem* '"'
longbytes      ::=  "'''" longbytesitem* "'''" | '"""' longbytesitem* '"""'
shortbytesitem ::=  shortbyteschar | bytesescapeseq
longbytesitem  ::=  longbyteschar | bytesescapeseq
shortbyteschar ::=  <any ASCII character except "\" or newline or the quote>
longbyteschar  ::=  <any ASCII character except "\">
bytesescapeseq ::=  "\" <any ASCII character>

Одно синтаксическое ограничение, не указанное в этих продукциях, заключается в том, что между stringprefix или bytesprefix и остальной частью литерала не допускаются пробельные символы. Набор символов источника определяется объявлением кодировки; если в исходном файле нет объявления кодировки, то это UTF-8; см. раздел Объявления о кодировке.

Если говорить простым языком: Оба типа литералов могут быть заключены в соответствующие одинарные кавычки (') или двойные кавычки ("). Они также могут быть заключены в совпадающие группы из трех одинарных или двойных кавычек (такие строки обычно называют строками в тройных кавычках). Символ обратной косой черты (\) используется для придания специального значения обычным символам, таким как n, который означает «новую строку» в экранированном виде (\n). Он также может использоваться для экранирования символов, которые в противном случае имеют специальное значение, таких как новая строка, обратная косая черта или символ кавычек. Примеры см. в разделе escape sequences ниже.

Литералы байтов всегда имеют префикс 'b' или 'B'; они создают экземпляр типа bytes вместо типа str. Они могут содержать только символы ASCII; байты с числовым значением 128 или больше должны выражаться с помощью эскейпов.

Как строковые, так и байтовые литералы могут иметь префикс в виде буквы 'r' или 'R'; такие строки называются raw strings и рассматривают обратные слеши как литеральные символы. В результате в строковых литералах эскейпы '\U' и '\u' в необработанных строках не обрабатываются специальным образом. Учитывая, что необработанные литералы юникода в Python 2.x ведут себя иначе, чем в Python 3.x, синтаксис 'ur' не поддерживается.

Added in version 3.3: Префикс 'rb' для необработанных байтовых литералов был добавлен в качестве синонима 'br'.

Поддержка унаследованного литерала юникода (u'value') была восстановлена, чтобы упростить сопровождение двух кодовых баз Python 2.x и 3.x. Более подробную информацию см. в разделе PEP 414.

Строковый литерал с 'f' или 'F' в префиксе - это formatted string literal; см. f-струны. Строка 'f' может быть объединена с 'r', но не с 'b' или 'u', поэтому необработанные форматированные строки возможны, а форматированные байтовые литералы - нет.

В литералах, заключенных в тройные кавычки, допускаются (и сохраняются) неэкранированные новые строки и кавычки, за исключением того, что три неэкранированные кавычки подряд завершают литерал. (Кавычка - это символ, используемый для открытия литерала, то есть либо ', либо ").

2.4.1.1. Последовательности побега

Если нет префикса 'r' или 'R', управляющие последовательности в строковых и байтовых литералах интерпретируются по правилам, аналогичным тем, что используются в стандарте C. Распознаваемыми управляющими последовательностями являются:

Последовательность побега

Значение

Примечания

\<newline>

Обратный слеш и новая строка игнорируются

(1)

\\

Обратная косая черта (\)

\'

Одинарная кавычка (')

\"

Двойная кавычка (")

\a

ASCII Bell (BEL)

\b

ASCII Backspace (BS)

\f

ASCII Подача формы (FF)

\n

ASCII Linefeed (LF)

\r

Возврат каретки ASCII (CR)

\t

Горизонтальная табуляция ASCII (TAB)

\v

ASCII Вертикальная табуляция (VT)

\ooo

Символ с восьмеричным значением ooo

(2,4)

\xhh

Символ с шестнадцатеричным значением hh

(3,4)

В строковых литералах распознаются только экранирующие последовательности:

Последовательность побега

Значение

Примечания

\N{name}

Символ с именем name в базе данных Unicode

(5)

\uxxxx

Символ с 16-битным шестнадцатеричным значением xxxx

(6)

\Uxxxxxxxx

Символ с 32-битным шестнадцатеричным значением xxxxxxxx

(7)

Примечания:

  1. В конце строки можно добавить обратную косую черту, чтобы игнорировать новую строку:

    >>> 'This string will not include \
... backslashes or newline characters.'
'This string will not include backslashes or newline characters.'

    Того же результата можно добиться, используя triple-quoted strings или скобки и string literal concatenation.

  2. Как и в стандарте C, принимается до трех восьмеричных цифр.

    Изменено в версии 3.11: Октальные экраны со значением больше 0o377 выдают DeprecationWarning.

    Изменено в версии 3.12: Октальные эскейпы со значением больше 0o377 выдают SyntaxWarning. В будущих версиях Python они будут в конечном счете иметь значение SyntaxError.

  3. В отличие от стандарта C, здесь требуется ровно две шестнадцатеричные цифры.

  4. В байтовом литерале шестнадцатеричные и восьмеричные эскапады обозначают байт с заданным значением. В строковом литерале эти эскапады обозначают символ Юникода с заданным значением.

  5. Изменено в версии 3.3: Добавлена поддержка псевдонимов имен [1].

  6. Требуется ровно четыре шестнадцатеричных цифры.

  7. Любой символ Юникода может быть закодирован таким образом. Требуется ровно восемь шестнадцатеричных цифр.

В отличие от стандартного C, все нераспознанные управляющие последовательности оставляются в строке без изменений, т.е. обратный слеш остается в результате. (Такое поведение полезно при отладке: если ошибочно набрана управляющая последовательность, полученный результат легче распознать как нарушенный). Также важно отметить, что экранирующие последовательности, распознаваемые только в строковых литералах, попадают в категорию нераспознаваемых экранов для байтовых литералов.

Изменено в версии 3.6: Нераспознанные управляющие последовательности выдают DeprecationWarning.

Изменено в версии 3.12: Нераспознанные управляющие последовательности выдают SyntaxWarning. В будущих версиях Python они будут в конечном счёте выдавать SyntaxError.

Даже в необработанном литерале кавычки могут быть экранированы обратным слешем, но обратный слеш останется в результате; например, r"\"" - это правильный строковый литерал, состоящий из двух символов: обратного слеша и двойной кавычки; r"\" не является правильным строковым литералом (даже необработанная строка не может заканчиваться нечетным количеством обратных слешей). В частности, сырой литерал не может заканчиваться одной обратной косой чертой (поскольку обратная косая черта вытесняет следующий символ кавычек). Обратите внимание, что одиночная обратная косая черта, за которой следует новая строка, интерпретируется как эти два символа в составе литерала, не как продолжение строки.

2.4.2. Конкатенация строковых литералов

Допускается использование нескольких соседних строковых или байтовых литералов (разделенных пробелами), возможно, с использованием различных соглашений о кавычках, и их значение совпадает с их объединением. Таким образом, "hello" 'world' эквивалентен "helloworld". Эта возможность может быть использована для уменьшения количества обратных косых черточек, для удобного разбиения длинных строк на длинные строки или даже для добавления комментариев к частям строк, например:

re.compile("[A-Za-z_]"       # letter or underscore
           "[A-Za-z0-9_]*"   # letter, digit or underscore
          )

Обратите внимание, что эта возможность определена на синтаксическом уровне, но реализуется во время компиляции. Оператор „+“ должен использоваться для объединения строковых выражений во время выполнения. Также обратите внимание, что при конкатенации литералов могут использоваться различные стили кавычек для каждого компонента (даже смешивание необработанных строк и строк с тройными кавычками), а форматированные строковые литералы могут быть конкатенированы с обычными строковыми литералами.

2.4.3. f-струны

Added in version 3.6.

Строка formatted string literal или f-string - это строковый литерал, имеющий префикс 'f' или 'F'. Эти строки могут содержать поля замены, которые представляют собой выражения, разграниченные фигурными скобками {}. В то время как другие строковые литералы всегда имеют постоянное значение, форматированные строки на самом деле являются выражениями, оцениваемыми во время выполнения.

Escape-последовательности декодируются так же, как и обычные строковые литералы (за исключением случаев, когда литерал также помечен как необработанная строка). После декодирования грамматика для содержимого строки выглядит следующим образом:

f_string          ::=  (literal_char | "{{" | "}}" | replacement_field)*
replacement_field ::=  "{" f_expression ["="] ["!" conversion] [":" format_spec] "}"
f_expression      ::=  (conditional_expression | "*" or_expr)
                         ("," conditional_expression | "," "*" or_expr)* [","]
                       | yield_expression
conversion        ::=  "s" | "r" | "a"
format_spec       ::=  (literal_char | replacement_field)*
literal_char      ::=  <any code point except "{", "}" or NULL>

Части строки, находящиеся вне фигурных скобок, обрабатываются буквально, за исключением того, что любые удвоенные фигурные скобки '{{' или '}}' заменяются соответствующей одинарной фигурной скобкой. Одиночная открывающая фигурная скобка '{' обозначает поле замены, которое начинается с выражения Python. Чтобы отобразить как текст выражения, так и его значение после оценки (полезно при отладке), после выражения может быть добавлен знак равенства '='. За ним может следовать поле преобразования, представленное восклицательным знаком '!'. Также может быть добавлен спецификатор формата, представленный двоеточием ':'. Поле замены завершается закрывающей фигурной скобкой '}'.

Выражения в форматированных строковых литералах рассматриваются как обычные выражения Python, окруженные круглыми скобками, за некоторыми исключениями. Пустое выражение не допускается, а выражения lambda и присваивания := должны быть окружены явными круглыми скобками. Каждое выражение оценивается в том контексте, в котором появляется литерал форматированной строки, в порядке слева направо. Выражения-заменители могут содержать новые строки как в одинарных, так и в тройных кавычках в строках f, а также комментарии. Все, что идет после # внутри поля замены, является комментарием (даже закрывающие скобки и кавычки). В этом случае поля замены должны быть закрыты в другой строке.

>>> f"abc{a # This is a comment }"
... + 3}"
'abc5'

Изменено в версии 3.7: До Python 3.7 выражение await и выражения, содержащие клаузулу async for, были недопустимы в выражениях в форматированных строковых литералах из-за проблемы с реализацией.

Изменено в версии 3.12: До Python 3.12 комментарии не допускались внутри полей замены f-строк.

Если указан знак равенства '=', то на выходе будет текст выражения, скобка '=' и вычисленное значение. Пробелы после открывающей скобки '{', внутри выражения и после '=' сохраняются в выводе. По умолчанию '=' выводит repr() выражения, если не указан формат. Если формат указан, то по умолчанию используется str() выражения, если не объявлено преобразование '!r'.

Added in version 3.8: Знак равенства '='.

Если указано преобразование, результат вычисления выражения преобразуется перед форматированием. Преобразование '!s' вызывает str() для результата, '!r' вызывает repr(), а '!a' вызывает ascii().

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

Спецификаторы формата верхнего уровня могут включать вложенные поля замены. Эти вложенные поля могут включать собственные поля преобразования и format specifiers, но не могут включать более глубоко вложенные поля замены. Значение format specifier mini-language такое же, как и в методе str.format().

Форматированные строковые литералы могут быть объединены, но поля замены не могут быть разделены на литералы.

Некоторые примеры форматированных строковых литералов:

>>> name = "Fred"
>>> f"He said his name is {name!r}."
"He said his name is 'Fred'."
>>> f"He said his name is {repr(name)}."  # repr() is equivalent to !r
"He said his name is 'Fred'."
>>> width = 10
>>> precision = 4
>>> value = decimal.Decimal("12.34567")
>>> f"result: {value:{width}.{precision}}"  # nested fields
'result:      12.35'
>>> today = datetime(year=2017, month=1, day=27)
>>> f"{today:%B %d, %Y}"  # using date format specifier
'January 27, 2017'
>>> f"{today=:%B %d, %Y}" # using date format specifier and debugging
'today=January 27, 2017'
>>> number = 1024
>>> f"{number:#0x}"  # using integer format specifier
'0x400'
>>> foo = "bar"
>>> f"{ foo = }" # preserves whitespace
" foo = 'bar'"
>>> line = "The mill's closed"
>>> f"{line = }"
'line = "The mill\'s closed"'
>>> f"{line = :20}"
"line = The mill's closed   "
>>> f"{line = !r:20}"
'line = "The mill\'s closed" '

Повторное использование внешнего типа кавычек f-строки в поле замены разрешено:

>>> a = dict(x=2)
>>> f"abc {a["x"]} def"
'abc 2 def'

Изменено в версии 3.12: До Python 3.12 повторное использование одного и того же типа кавычек внешней f-строки внутри поля замены было невозможно.

Обратные косые черты также разрешены в полях замены и оцениваются так же, как и в любом другом контексте:

>>> a = ["a", "b", "c"]
>>> print(f"List a contains:\n{"\n".join(a)}")
List a contains:
a
b
c

Изменено в версии 3.12: До Python 3.12 обратные слеши не допускались внутри поля замены f-строки.

Форматированные строковые литералы не могут использоваться в качестве строк документов, даже если они не содержат выражений.

>>> def foo():
...     f"Not a docstring"
...
>>> foo.__doc__ is None
True

См. также PEP 498, в котором было предложено добавить литералы форматированных строк, и str.format(), в котором используется связанный механизм строк форматирования.

2.4.4. Числовые литералы

Существует три типа числовых литералов: целые числа, числа с плавающей запятой и мнимые числа. Комплексные литералы отсутствуют (комплексные числа образуются путем сложения действительного и мнимого чисел).

Обратите внимание, что числовые литералы не содержат знака; фраза типа -1 на самом деле является выражением, состоящим из унарного оператора „-“ и литерала 1.

2.4.5. Целочисленные литералы

Целочисленные литералы описываются следующими лексическими определениями:

integer      ::=  decinteger | bininteger | octinteger | hexinteger
decinteger   ::=  nonzerodigit (["_"] digit)* | "0"+ (["_"] "0")*
bininteger   ::=  "0" ("b" | "B") (["_"] bindigit)+
octinteger   ::=  "0" ("o" | "O") (["_"] octdigit)+
hexinteger   ::=  "0" ("x" | "X") (["_"] hexdigit)+
nonzerodigit ::=  "1"..."9"
digit        ::=  "0"..."9"
bindigit     ::=  "0" | "1"
octdigit     ::=  "0"..."7"
hexdigit     ::=  digit | "a"..."f" | "A"..."F"

Длина целочисленных литералов не ограничена, кроме той, что может быть сохранена в доступной памяти.

Подчеркивания игнорируются при определении числового значения литерала. Они могут использоваться для группировки цифр для повышения удобочитаемости. Одно подчеркивание может стоять между цифрами и после базовых спецификаторов, таких как 0x.

Обратите внимание, что ведущие нули в ненулевом десятичном числе не допускаются. Это сделано для разграничения с восьмеричными литералами в стиле C, которые Python использовал до версии 3.0.

Некоторые примеры целочисленных литералов:

7     2147483647                        0o177    0b100110111
3     79228162514264337593543950336     0o377    0xdeadbeef
      100_000_000_000                   0b_1110_0101

Изменено в версии 3.6: Подчеркивания теперь разрешены для группировки в литералах.

2.4.6. Литералы с плавающей запятой

Литералы с плавающей точкой описываются следующими лексическими определениями:

floatnumber   ::=  pointfloat | exponentfloat
pointfloat    ::=  [digitpart] fraction | digitpart "."
exponentfloat ::=  (digitpart | pointfloat) exponent
digitpart     ::=  digit (["_"] digit)*
fraction      ::=  "." digitpart
exponent      ::=  ("e" | "E") ["+" | "-"] digitpart

Обратите внимание, что целая и показательная части всегда интерпретируются с использованием радикала 10. Например, 077e010 является допустимым и обозначает то же число, что и 77e10. Допустимый диапазон литералов с плавающей запятой зависит от реализации. Как и в целочисленных литералах, для группировки цифр поддерживаются символы подчеркивания.

Некоторые примеры литералов с плавающей запятой:

3.14    10.    .001    1e100    3.14e-10    0e0    3.14_15_93

Изменено в версии 3.6: Подчеркивания теперь разрешены для группировки в литералах.

2.4.7. Воображаемые литералы

Воображаемые литералы описываются следующими лексическими определениями:

imagnumber ::=  (floatnumber | digitpart) ("j" | "J")

Мнимый литерал дает комплексное число с действительной частью 0,0. Комплексные числа представляются в виде пары чисел с плавающей точкой и имеют те же ограничения на диапазон. Чтобы создать комплексное число с ненулевой вещественной частью, добавьте к нему число с плавающей точкой, например, (3+4j). Некоторые примеры мнимых литералов:

3.14j   10.j    10j     .001j   1e100j   3.14e-10j   3.14_15_93j

2.5. Операторы

Следующие маркеры являются операторами:

+       -       *       **      /       //      %      @
<<      >>      &       |       ^       ~       :=
<       >       <=      >=      ==      !=

2.6. Разделители

Следующие лексемы служат разделителями в грамматике:

(       )       [       ]       {       }
,       :       .       ;       @       =       ->
+=      -=      *=      /=      //=     %=      @=
&=      |=      ^=      >>=     <<=     **=

Точка также может встречаться в литералах с плавающей запятой и мнимых литералах. Последовательность из трех точек имеет особое значение как литерал многоточия. Вторая половина списка - дополненные операторы присваивания - лексически служат разделителями, но также выполняют операции.

Следующие печатные ASCII-символы имеют особое значение как часть других лексем или имеют иное значение для лексического анализатора:

'       "       #       \

Следующие печатные ASCII-символы не используются в Python. Их появление вне строковых литералов и комментариев является безусловной ошибкой:

$       ?       `

Сноски