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

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

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

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

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

• формат 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. Комментарии

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

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

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

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

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

# vim:fileencoding=<encoding-name>

распознаваемая Bram Moolenaar’s VIM.

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

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

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

source_character:  <any Unicode code point, except NUL>

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 не создаётся). При интерактивном вводе инструкций обработка пустой строки может различаться в зависимости от реализации цикла чтения, вычисления и вывода. В стандартном интерактивном интерпретаторе полностью пустая логическая строка (то есть строка, не содержащая даже пробельных символов или комментария) завершает многострочную инструкцию.

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. Пробельные символы между токенами

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

whitespace:  ' ' | tab | formfeed

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

2.1.10. Маркер конца

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

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

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

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

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

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

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

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

_*

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

_

В шаблоне case внутри инструкции match _ является мягким ключевым словом, обозначающим шаблон-заполнитель.

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

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

Примечание

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

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

__*__

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

__*

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

2.3.4. Символы не из ASCII в именах

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

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

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

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

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

Эти наборы основаны на наборах XID_Start и XID_Continue, определённых в приложении UAX-31 к стандарту Unicode. Набор Python 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. Строки в тройных кавычках

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

"""This is a triple-quoted string."""

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

"""This string has "quotes" inside."""

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

'''This triple-quoted string
continues on the next line.'''

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

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

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. Формальная грамматика

Строковые литералы, кроме «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-последовательности

Если не указан префикс «r» или «R», escape-последовательности в строковых и байтовых литералах интерпретируются по правилам, аналогичным правилам Standard 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. Байтовые литералы

Байтовые литералы всегда имеют префикс «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. Сырые строковые литералы

Строковые и байтовые литералы могут иметь необязательный префикс в виде буквы «r» или «R»; такие конструкции называются соответственно сырыми строковыми литералами и сырыми байтовыми литералами и рассматривают обратные косые черты как обычные символы. Поэтому в сырых строковых литералах escape-последовательности не обрабатываются особым образом:

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

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

2.5.7. f-строки

Форматированный строковый литерал, или 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-строках с одинарными кавычками, так и в 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-строка, — это строковый литерал с префиксом «t» или «T». Такие строки подчиняются тем же синтаксическим правилам, что и форматированные строковые литералы. Сведения об отличиях в правилах вычисления см. в разделе стандартной библиотеки о t-строках.

2.5.9. Формальная грамматика f-строк

Обработка 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-строк, за исключением того, что в начале правил и имён токенов, а также в префиксе вместо f используется t.

tstring:    TSTRING_START tstring_middle* TSTRING_END

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

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

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

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. Литералы чисел с плавающей точкой

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

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

2.71828
4.0

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

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

96_485.332_123
3.14_15_93

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

10.  # (equivalent to 10.0)
.001  # (equivalent to 0.001)

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

1.0e3  # (represents 1.0×10³, or 1000.0)
1.166e-5  # (represents 1.166×10⁻⁵, or 0.00001166)
6.02214076e+23  # (represents 6.02214076×10²³, or 602214076000000000000000.)

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

1e3  # (equivalent to 1.e3 and 1.0e3)
0e0  # (equivalent to 0.)

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

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

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

В 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   # equivalent to 1e+24j

В суффиксе j регистр не учитывается. Это значит, что вместо него можно использовать J:

3.14J   # equivalent to 3.14j

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

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