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

2.1.1. Логические строки¶Logical lines

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

2.1.2. Физические строки¶Physical lines

Физическая строка – это последовательность символов, завершающаяся одной из следующих последовательностей конца строки:

• форма Unix, использующая ASCII LF (перевод строки),

• форма Windows, использующая последовательность ASCII CR LF (возврат каретки, затем перевод строки),

• форма ‘Classic Mac OS’, использующая символ ASCII CR (возврат каретки).

Независимо от платформы, каждая из этих последовательностей заменяется одним символом ASCII LF (перевод строки). (Это делается даже внутри строковых литералов.) В каждой строке может использоваться любая из этих последовательностей; они не обязаны быть согласованными в пределах одного файла.

Конец входных данных также служит неявным терминатором для последней физической строки.

Формально:

newline: <ASCII LF> | <ASCII CR> <ASCII LF> | <ASCII CR>

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

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

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

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

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

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

# vim:fileencoding=<encoding-name>

которая распознаётся VIM от Брама Муленаара.

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

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

Весь лексический анализ, включая строковые литералы, комментарии и идентификаторы, работает с текстом Unicode, декодированным с использованием исходной кодировки. Любая кодовая точка Unicode, кроме управляющего символа NUL, может встречаться в исходном коде Python.

source_character:  <any Unicode code point, except NUL>

2.1.5. Явное объединение строк¶Explicit line joining

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

if 1900 < year < 2100 and 1 <= month <= 12 \
   and 1 <= day <= 31 and 0 <= hour < 24 \
   and 0 <= minute < 60 and 0 <= second < 60:   # Похоже на корректную дату
        return 1

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

2.1.6. Неявное объединение строк¶Implicit line joining

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

month_names = ['Januari', 'Februari', 'Maart',      # Это
               'April',   'Mei',      'Juni',       # голландские названия
               'Juli',    'Augustus', 'September',  # для месяцев
               'Oktober', 'November', 'December']   # года

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

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

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

2.1.8. Отступы¶Indentation

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

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

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

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

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

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

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

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

def perm(l):
        # Вычислить список всех перестановок 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):                       # ошибка: первая строка с отступом
for i in range(len(l)):             # ошибка: нет отступа
    s = l[:i] + l[i+1:]
        p = perm(l[:i] + l[i+1:])   # ошибка: неожиданный отступ
        for x in p:
                r.append(l[i:i+1] + x)
            return r                # ошибка: несоответствие отступа

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

2.1.9. Пробельные символы между токенами¶Whitespace between tokens

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

whitespace:  ' ' | tab | formfeed

Пробельные символы нужны между двумя токенами только в том случае, если их слияние может быть интерпретировано как другой токен. Например, ab – один токен, но a b – два токена. Однако +a и + a оба дают два токена, + и a, поскольку +a не является допустимым токеном.

2.1.10. Конечный маркер¶End marker

В конце неинтерактивного ввода лексический анализатор генерирует токен ENDMARKER.

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

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

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. Мягкие ключевые слова¶Soft Keywords

Некоторые имена зарезервированы только в определённых контекстах. Они называются мягкими ключевыми словами:

• match, case и _ при использовании в инструкции match.

• type при использовании в инструкции type.

• lazy, если используется перед инструкцией import.

Синтаксически они ведут себя как ключевые слова в своих контекстах, но это различие проводится на уровне синтаксического анализатора, а не при токенизации.

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

2.3.3. Зарезервированные классы идентификаторов¶Reserved classes of identifiers

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

_*

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

_

В шаблоне case внутри инструкции match _ является мягким ключевым словом, которое обозначает шаблонный символ (wildcard).

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

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

Примечание

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

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

__*__

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

__*

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

2.3.4. Не-ASCII символы в именах¶Non-ASCII characters in names

Имена, содержащие не-ASCII символы, требуют дополнительной нормализации и проверки, помимо правил и грамматики, описанных выше. Например, ř_1, 蛇 или साँप являются допустимыми именами, а r〰2, € или 🐍 – нет.

В этом разделе объясняются точные правила.

Все имена при синтаксическом анализе преобразуются в форму нормализации NFKC. Это означает, что, например, некоторые типографские варианты символов преобразуются в свою «базовую» форму. Например, fiⁿₐˡᵢᶻₐᵗᵢᵒₙ нормализуется в finalization, поэтому Python считает их одним и тем же именем:

>>> fiⁿₐˡᵢᶻₐᵗᵢᵒₙ = 3
>>> finalization
3

Аналогично тому, как имена, состоящие только из ASCII, должны содержать только буквы, цифры и символ подчёркивания и не могут начинаться с цифры, допустимое имя должно начинаться с символа из «буквоподобного» набора xid_start, а остальные символы должны быть из «букво- и цифроподобного» набора xid_continue.

Эти наборы основаны на множествах XID_Start и XID_Continue, определённых в приложении к стандарту Unicode UAX-31. Python’s xid_start дополнительно включает символ подчёркивания (_). Обратите внимание, что Python не обязательно соответствует UAX-31.

Неформальный перечень символов из множеств XID_Start и XID_Continue, определённых в стандарте Unicode, доступен в файле DerivedCoreProperties.txt в базе данных символов Unicode. Для справки, правила построения наборов xid_* приведены ниже.

Множество id_start определяется как объединение:

• Категория Unicode <Lu> – прописные буквы (включает A – Z)

• Категория Unicode <Ll> – строчные буквы (включает a – z)

• Категория Unicode <Lt> – буквы заглавного регистра

• Категория Unicode <Lm> – модифицирующие буквы

• Категория Unicode <Lo> – прочие буквы

• Категория Unicode <Nl> – буквенные числа

• {"_"} – символ подчёркивания

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

Множество xid_start затем замыкает это множество относительно нормализации NFKC, удаляя все символы, чья нормализация не имеет вида id_start id_continue*.

Множество id_continue определяется как объединение:

• id_start (см. выше)

• Категория Unicode <Nd> – десятичные числа (включает 0 – 9)

• Категория Unicode <Pc> – соединительные знаки пунктуации

• Категория Unicode <Mn> – некомбинируемые знаки

• Категория Unicode <Mc> – комбинируемые знаки с увеличением ширины

• <Other_ID_Continue> – ещё один явный набор символов из PropList.txt для поддержки обратной совместимости

Снова xid_continue замыкает это множество относительно нормализации NFKC.

Категории Unicode используют версию базы данных символов Unicode, включённую в модуль unicodedata.

2.5.1. Строки в тройных кавычках¶Triple-quoted strings

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

"""Это строка в тройных кавычках."""

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

"""В этой строке есть "кавычки" внутри."""

Неэкранированные символы новой строки также допускаются и сохраняются:

'''Эта строка в тройных кавычках
продолжается на следующей строке.'''

2.5.2. Префиксы строк¶String prefixes

Строковые литералы могут иметь необязательный префикс, который влияет на то, как разбирается содержимое литерала, например:

b"data"
f'{result=}'

Допустимые префиксы:

• b: Литерал байтов

• r: Сырая строка

• f: Форматированный строковый литерал («f-строка»)

• t: Шаблонный строковый литерал («t-строка»)

• u: Нет эффекта (допускается для обратной совместимости)

Подробнее о каждом типе см. в соответствующих разделах по ссылкам.

Префиксы нечувствительны к регистру (например, «B» работает так же, как «b»). Префикс «r» можно комбинировать с «f», «t» или «b», так что «fr», «rf», «tr», «rt», «br» и «rb» также являются допустимыми префиксами.

2.5.3. Формальная грамматика¶Formal grammar

Строковые литералы, за исключением «f-строк» и «t-строк», описываются следующими лексическими определениями.

В этих определениях используются отрицательные опережающие проверки (!), чтобы указать, что конечная кавычка завершает литерал.

STRING:          [stringprefix] (stringcontent)
stringprefix:    <("r" | "u" | "b" | "br" | "rb"), case-insensitive>
stringcontent:
   | "'''" ( !"'''" longstringitem)* "'''"
   | '"""' ( !'"""' longstringitem)* '"""'
   | "'" ( !"'" stringitem)* "'"
   | '"' ( !'"' stringitem)* '"'
stringitem:      stringchar | stringescapeseq
stringchar:      <any source_character, except backslash and newline>
longstringitem:  stringitem | newline
stringescapeseq: "\" <any source_character>

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

2.5.4. Escape-последовательности¶Escape sequences

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

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

>>> print('C:\\Program Files')
C:\Program Files

>>> print('\' and \"')
' and "

>>> '\120'
'P'

>>> '\x50'
'P'

>>> '\N{LATIN CAPITAL LETTER P}'
'P'
>>> '\N{SNAKE}'
'🐍'

>>> '\u1234'
'ሴ'
>>> '\U0001f40d'
'🐍'

>>> print('\q')
\q
>>> list('\q')
['\\', 'q']

2.5.5. Байтовые литералы¶Bytes literals

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

>>> b'\x89PNG\r\n\x1a\n'
b'\x89PNG\r\n\x1a\n'
>>> list(b'\x89PNG\r\n\x1a\n')
[137, 80, 78, 71, 13, 10, 26, 10]

Аналогично, нулевой байт должен быть выражен с помощью escape-последовательности (обычно \0 или \x00).

2.5.6. Сырые строковые литералы¶Raw string literals

Как строковые, так и байтовые литералы могут по желанию иметь префикс 'r' или 'R'; такие конструкции называются сырыми строковыми литералами и сырыми байтовыми литералами соответственно и обрабатывают обратную косую черту как буквенный символ. В результате в сырых строковых литералах escape-последовательности не обрабатываются особым образом:

>>> r'\d{4}-\d{2}-\d{2}'
'\\d{4}-\\d{2}-\\d{2}'

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

2.5.7. f-строки¶f-strings

Форматированный строковый литерал или f-строка – это строковый литерал с префиксом 'f' или 'F'. В отличие от других строковых литералов, f-строки не имеют постоянного значения. Они могут содержать поля подстановки, ограниченные фигурными скобками {}. Поля подстановки содержат выражения, которые вычисляются во время выполнения. Например:

>>> who = 'nobody'
>>> nationality = 'Spanish'
>>> f'{who.title()} expects the {nationality} Inquisition!'
'Nobody expects the Spanish Inquisition!'

Любые удвоенные фигурные скобки ({{ или }}) вне полей подстановки заменяются соответствующей одинарной фигурной скобкой:

>>> print(f'{{...}}')
{...}

Другие символы вне полей подстановки обрабатываются как в обычных строковых литералах. Это означает, что escape-последовательности декодируются (за исключением случаев, когда литерал также помечен как сырая строка), и в f-строках с тройными кавычками возможны новые строки:

>>> name = 'Galahad'
>>> favorite_color = 'blue'
>>> print(f'{name}:\t{favorite_color}')
Galahad:       blue
>>> print(rf"C:\Users\{name}")
C:\Users\Galahad
>>> print(f'''Three shall be the number of the counting
... and the number of the counting shall be three.''')
Three shall be the number of the counting
and the number of the counting shall be three.

Выражения в форматированных строковых литералах обрабатываются как обычные выражения Python. Каждое выражение вычисляется в контексте, где появляется форматированный строковый литерал, слева направо. Пустое выражение не допускается, и как lambda, так и выражения присваивания := должны быть окружены явными круглыми скобками:

>>> f'{(half := 1/2)}, {half * 42}'
'0.5, 21.0'

Повторное использование типа кавычек внешней f-строки внутри поля подстановки разрешено:

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

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

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

Возможно вложение f-строк:

>>> name = 'world'
>>> f'Repeated:{f' hello {name}' * 3}'
'Repeated: hello world hello world hello world'

Переносимые программы на Python не должны использовать более 5 уровней вложенности.

Выражения подстановки могут содержать новые строки как в f-строках с одинарными кавычками, так и с тройными, и они могут содержать комментарии. Всё, что следует после # внутри поля подстановки, является комментарием (даже закрывающие скобки и кавычки). Это означает, что поля подстановки с комментариями должны быть закрыты на другой строке:

>>> a = 2
>>> f"abc{a  # This comment  }"  continues until the end of the line
...       + 3}"
'abc5'

После выражения поля подстановки могут по желанию содержать:

• спецификатор отладки – знак равенства (=), по желанию окружённый пробелами с одной или обеих сторон;

• спецификатор преобразования – !s, !r или !a; и/или

• спецификатор формата с префиксом в виде двоеточия (:).

См. раздел «f-строки» в стандартной библиотеке для подробностей о том, как вычисляются эти поля.

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

>>> number = 14.3
>>> f'{number:20.7f}'
'          14.3000000'

Спецификаторы формата верхнего уровня могут включать вложенные поля подстановки:

>>> field_size = 20
>>> precision = 7
>>> f'{number:{field_size}.{precision}f}'
'          14.3000000'

Эти вложенные поля могут включать собственные поля преобразования и спецификаторы формата:

>>> number = 3
>>> f'{number:{field_size}}'
'                   3'
>>> f'{number:{field_size:05}}'
'00000000000000000003'

Однако эти вложенные поля не могут включать более глубоко вложенные поля подстановки.

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

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

2.5.8. t-строки¶t-strings

Шаблонный строковый литерал или t-строка – это строковый литерал с префиксом ‘t’ или ‘T’. Такие строки подчиняются тем же правилам синтаксиса, что и f-строки (форматированные строковые литералы). Об отличиях в правилах вычисления см. раздел о t-строках в стандартной библиотеке

2.5.9. Формальная грамматика f-строк¶Formal grammar for f-strings

F-строки обрабатываются частично лексическим анализатором, который генерирует токены FSTRING_START, FSTRING_MIDDLE и FSTRING_END, а частично – парсером, который обрабатывает выражения в поле подстановки. Точное распределение работы зависит от реализации CPython.

Соответственно, грамматика f-строк представляет собой смесь лексических и синтаксических определений.

Пробельные символы значимы в следующих ситуациях:

• В FSTRING_START не должно быть пробелов (между префиксом и кавычкой).

• Пробелы в FSTRING_MIDDLE являются частью содержимого строкового литерала.

• В fstring_replacement_field, если присутствует f_debug_specifier, все пробелы после открывающей фигурной скобки до f_debug_specifier, а также пробелы, следующие непосредственно за f_debug_specifier, сохраняются как часть выражения.

  Деталь реализации CPython: Выражение не обрабатывается на этапе токенизации; оно извлекается из исходного кода с использованием позиций токена { и токена после =.

Определение FSTRING_MIDDLE использует отрицательные опережающие проверки (!) для обозначения специальных символов (обратная косая черта, новая строка, {, }) и последовательностей (f_quote).

fstring:    FSTRING_START fstring_middle* FSTRING_END

FSTRING_START:      fstringprefix ("'" | '"' | "'''" | '"""')
FSTRING_END:        f_quote
fstringprefix:      <("f" | "fr" | "rf"), case-insensitive>
f_debug_specifier:  '='
f_quote:            <the quote character(s) used in FSTRING_START>

fstring_middle:
   | fstring_replacement_field
   | FSTRING_MIDDLE
FSTRING_MIDDLE:
   | (!"\" !newline !'{' !'}' !f_quote) source_character
   | stringescapeseq
   | "{{"
   | "}}"
   | <newline, in triple-quoted f-strings only>
fstring_replacement_field:
   | '{' f_expression [f_debug_specifier] [fstring_conversion]
         [fstring_full_format_spec] '}'
fstring_conversion:
   | "!" ("s" | "r" | "a")
fstring_full_format_spec:
   | ':' fstring_format_spec*
fstring_format_spec:
   | FSTRING_MIDDLE
   | fstring_replacement_field
f_expression:
   | ','.(conditional_expression | "*" or_expr)+ [","]
   | yield_expression

Грамматика t-строк идентична грамматике f-строк, с заменой t на f в начале имён правил и токенов, а также в префиксе.

tstring:    TSTRING_START tstring_middle* TSTRING_END

<rest of the t-string grammar is omitted; see above>

2.6.1. Целочисленные литералы¶Integer literals

Целочисленные литералы обозначают целые числа. Например:

7
3
2147483647

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

7922816251426433759354395033679228162514264337593543950336

Символы подчёркивания можно использовать для группировки цифр для улучшения читаемости; они игнорируются при определении числового значения литерала. Например, следующие литералы эквивалентны:

100_000_000_000
100000000000
1_00_00_00_00_000

Символы подчёркивания могут находиться только между цифрами. Например, _123, 321_ и 123__321 не являются допустимыми литералами.

Целые числа могут быть заданы в двоичной (основание 2), восьмеричной (основание 8) или шестнадцатеричной (основание 16) системе с помощью префиксов 0b, 0o и 0x соответственно. Шестнадцатеричные цифры от 10 до 15 обозначаются буквами от A до F без учёта регистра. Например:

0b100110111
0b_1110_0101
0o177
0o377
0xdeadbeef
0xDead_Beef

Символ подчёркивания может следовать за указателем основания. Например, 0x_1f – допустимый литерал, а 0_x1f и 0x__1f – нет.

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

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

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

2.6.2. Литералы с плавающей точкой¶Floating-point literals

Литералы с плавающей точкой (float), такие как 3.14 или 1.5, обозначают приближения вещественных чисел.

Они состоят из целой и дробной частей, каждая из которых состоит из десятичных цифр. Части разделяются десятичной точкой .:

2.71828
4.0

В отличие от целочисленных литералов, ведущие нули допускаются. Например, 077.010 допустимо и обозначает то же число, что и 77.01.

Как и в целочисленных литералах, одиночные символы подчёркивания могут встречаться между цифрами для улучшения читаемости:

96_485.332_123
3.14_15_93

Любая из этих частей, но не обе, может быть пустой. Например:

10.  # (эквивалентно 10.0)
.001  # (эквивалентно 0.001)

Целая и дробная части могут дополнительно сопровождаться экспонентой: буква e или E, после которой может идти знак (+ или -), а затем число, записанное в том же формате, что и целая с дробной частями. e или E означает «умножить на десять в степени»:

1.0e3  # (представляет 1.0×10³, или 1000.0)
1.166e-5  # (представляет 1.166×10⁻⁵, или 0.00001166)
6.02214076e+23  # (представляет 6.02214076×10²³, или 602214076000000000000000.)

В числах с плавающей точкой, содержащих только целую часть и экспоненту, десятичную точку можно опускать:

1e3  # (эквивалентно 1.e3 и 1.0e3)
0e0  # (эквивалентно 0.)

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

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

2.6.3. Мнимые литералы¶Imaginary literals

В Python есть объекты комплексных чисел, но нет комплексных литералов. Вместо этого мнимые литералы обозначают комплексные числа с нулевой действительной частью.

Например, в математике комплексное число 3+4.2i записывается как действительное число 3, сложенное с мнимым числом 4.2i. Python использует похожий синтаксис, только мнимая единица записывается как j а не как i:

3+4.2j

Это выражение состоит из целочисленного литерала 3, оператора ‘+’ и мнимого литерала 4.2j. Поскольку это три отдельных токена, между ними допускаются пробелы:

3 + 4.2j

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

Число перед j имеет тот же синтаксис, что и литерал с плавающей точкой. Таким образом, следующие мнимые литералы допустимы:

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

В отличие от литерала с плавающей точкой, десятичную точку можно опустить, если мнимое число имеет только целую часть. Число по-прежнему вычисляется как число с плавающей точкой, а не как целое:

10j
0j
1000000000000000000000000j   # эквивалентно 1e+24j

Суффикс j не чувствителен к регистру. То есть вместо него можно использовать J:

3.14J   # эквивалентно 3.14j

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

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