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

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

Лексический анализатор определяет кодировку текста программы (по умолчанию UTF-8) и декодирует текст в исходные символы. Если текст не может быть декодирован, возбуждается исключение `SyntaxError`.

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

Символ | Следующий токен (или другая соответствующая документация)
--- | ---
пробел табуляция перевод страницы | Пробельный символ
CR, LF | Новая строка Отступ
обратный слэш (`\`) | Явное объединение строк (Также имеет значение в строковых экранированных последовательностях)
решётка (`#`) | Комментарий
кавычка (`'`, `"`) | Строковый литерал
ASCII-буква (`a`–`z`, `A`–`Z`) не-ASCII символ | Имя Префиксный строковый или байтовый литерал
подчёркивание (`_`) | Имя (Также может быть частью числовых литералов)
цифра (`0`–`9`) | Числовой литерал
точка (`.`) | Числовой литерал Оператор
вопросительный знак (`?`) доллар (`$`) обратная кавычка (`​`​`) управляющий символ | Ошибка (за пределами строковых литералов и комментариев)
прочий отображаемый символ | Оператор или разделитель
конец файла | Конечный маркер

## 2.1. Структура строк

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

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

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

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

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

- форма Unix с использованием ASCII LF (перевод строки),

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

- форма «Классической 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>

которые распознаются редактором VIM Брэма Муленаара.

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

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

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

    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:   # Похоже на корректную дату
            return 1

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

### 2.1.6. Неявное объединение строк

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

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

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

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

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

### 2.1.8. Отступы

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

Табуляции заменяются (слева направо) на несколько пробелов — от одного до восьми — так, чтобы общее количество символов от начала строки до конца замены включительно было кратно восьми (это соответствует правилу, используемому в 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:  ' ' | tab | formfeed

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

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

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

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

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

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

Токены `NAME` представляют собой идентификаторы, ключевые слова и мягкие ключевые слова.

Имена состоят из следующих символ:

- прописных и строчных букв (`A-Z` и `a-z`),

- символа подчеркивания (`_`),

- цифр (`0` – `9`), которые не могут быть первым символом, и

- не-ASCII-символов. Допустимые имена могут содержать только символы, «похожие» на буквы и цифры; подробности см. в разделе Не-ASCII символы в именах.

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

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

    NAME:          name_start name_continue*
    name_start:    "a"..."z" | "A"..."Z" | "_" | <non-ASCII character>
    name_continue: name_start | "0"..."9"
    identifier:    <NAME, except keywords>

Обратите внимание, что не все имена, соответствующие этой грамматике, являются допустимыми; подробности см. в разделе Не-ASCII символы в именах.

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

Добавлено в версии 3.10.

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

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

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

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

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

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

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

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

`_*`

  Не импортируются при использовании `from module import *`.

`_`

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

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

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

  Примечание

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

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

`__*__`

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

`__*`

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

### 2.3.4. Не-ASCII символы в именах

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

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

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

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

Примечание

Нормализация выполняется только на лексическом уровне. Функции времени выполнения, которые принимают имена как строки, обычно не нормализуют свои аргументы. Например, переменная, определённая выше, доступна во время выполнения через словарь `globals()` как `globals()["finalization"]`, но не как `globals()["ﬁⁿₐˡᵢᶻₐᵗᵢᵒₙ"]`.

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

These sets are based on the XID_Start and XID_Continue sets as defined by the Unicode standard annex UAX-31. Python’s `xid_start` additionally includes the underscore (`_`). Note that Python does not necessarily conform to 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`.

См. также

- PEP 3131 — Поддержка идентификаторов с не-ASCII символами

- PEP 672 — Соображения безопасности Python, связанные с Unicode

## 2.4. Литералы

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

С точки зрения лексического анализа в Python существуют строковые, байтовые и числовые литералы.

Другие «литералы» лексически обозначаются с помощью ключевых слов (`None`, `True`, `False`) и специального токена многоточия (`...`).

## 2.5. Строковые и байтовые литералы

Строковые литералы — это текст, заключённый в одиночные (`'`) или двойные кавычки (`"`). Например:

    "spam"
    'eggs'

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

    'Скажи "Привет", пожалуйста.'
    "Не делайте 'это' здесь!"

За исключением этого ограничения выбор символа кавычек (`'` или `"`) не влияет на то, как литерал разбирается.

Внутри строкового литерала символ обратного слэша (`\`) вводит экранированную последовательность, значение которой зависит от символа, следующего за обратным слэшем. Например, `\"` обозначает символ двойной кавычки и не завершает строку:

    >>> print("Скажи \"Привет\" всем!")
    Скажи "Привет" всем!

Полный список таких последовательностей и дополнительные сведения см. ниже в разделе экранированные последовательности.

### 2.5.1. Строки в тройных кавычках

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

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

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

    """Эта строка содержит "кавычки" внутри."""

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

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

### 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`“ также являются допустимыми префиксами.

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

Поддержка устаревшего литерала Unicode (`u'value'`) была вновь введена для упрощения сопровождения кодовых баз, совместимых с Python 2.x и 3.x. Дополнительные сведения см. в PEP 414.

### 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. Экранированные последовательности

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

Экранированная последовательность | Значение
--- | ---
`\`<newline> | Игнорирование конца строки
`\\` | Обратный слэш
`\'` | Одинарная кавычка
`\"` | Двойная кавычка
`\a` | Сигнал «звонка» ASCII (BEL)
`\b` | Возврат каретки назад ASCII (BS)
`\f` | Перевод страницы ASCII (FF)
`\n` | Перевод строки ASCII (LF)
`\r` | Возврат каретки ASCII (CR)
`\t` | Горизонтальная табуляция ASCII (TAB)
`\v` | Вертикальная табуляция ASCII (VT)
`\ooo` | Символы в восьмеричной записе
`\xhh` | Символы в шестнадцатеричной записе
`\N{name}` | Именованные символы Unicode
`\uxxxx` | Шестнадцатеричный символ Unicode
`\Uxxxxxxxx` | Шестнадцатеричный символ Unicode

#### 2.5.4.1. Игнорирование конца строки

В конце строки можно добавить обратный слэш, чтобы игнорировать перевод строки:

    >>> 'Эта строка не будет включать \
    ... обратные слэши или символы перевода строки.'
    'Эта строка не будет включать обратные слэши или символы перевода строки.'

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

#### 2.5.4.2. Экранированные символы

Чтобы включить обратный слэш в не сырой строковый литерал Python, его нужно удвоить. Экранированная последовательность `\\` обозначает один символ обратного слэша:

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

Аналогично, последовательности `\'` и `\"` обозначают соответственно одинарную и двойную кавычку:

    >>> print('\' и \"')
    ' и "

#### 2.5.4.3. Символы в восьмеричной записе

Последовательность `\ooo` обозначает символ с восьмеричным (по основанию 8) значением ooo:

    >>> '\120'
    'P'

Допускается до трёх восьмеричных цифр (от 0 до 7).

В байтовом литерале символ означает байт с указанным значением. В строковом литерале — символ Unicode с указанным значением.

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

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

#### 2.5.4.4. Символы в шестнадцатеричной записе

Последовательность `\xhh` обозначает символ с шестнадцатеричным (по основанию 16) значением hh:

    >>> '\x50'
    'P'

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

В байтовом литерале символ означает байт с указанным значением. В строковом литерале — символ Unicode с указанным значением.

#### 2.5.4.5. Именованные символы Unicode

Последовательность `\N{name}` обозначает символ Unicode с указанным именем:

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

Эта последовательность не должна встречаться в байтовых литералах.

Изменено в версии 3.3: Support for name aliases has been added.

#### 2.5.4.6. Символы Unicode в шестнадцатеричной записе

Последовательности `\uxxxx` и `\Uxxxxxxxx` обозначают символ Unicode с указанным шестнадцатеричным (по основанию 16) значением. Для `\u` требуется ровно четыре цифры; для `\U` — ровно восемь. Последняя форма может кодировать любой символ Unicode.

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

Эти последовательности не могут появляться в байтовых литералах.

#### 2.5.4.7. Нераспознанные экранированные последовательности

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

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

Обратите внимание, что для байтовых литералов экранированные последовательности, распознаваемые только в строковых литералах (`\N...`, `\u...`, `\U...`), относятся к категории нераспознанных.

Изменено в версии 3.6: Нераспознанные экранированные последовательности вызывают `DeprecationWarning`.

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

### 2.5.5. Байтовые литералы

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

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

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

### 2.5.6. Сырые строковые литералы

Строковые и байтовые литералы могут иметь необязательный префикс „`r`“ или „`R`“; такие конструкции называются соответственно сырыми строковыми литералами и сырыми байтовыми литералами и рассматривают обратные слэши как обычные символы. В результате, в сырых строковых литералах экранированные последовательности не обрабатываются специальным образом:

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

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

### 2.5.7. f-строки

Добавлено в версии 3.6.

Изменено в версии 3.7: Ключевые слова `await` и `async for` могут использоваться в выражениях внутри f-строк.

Изменено в версии 3.8: Добавлен отладочный спецификатор (`=`).

Изменено в версии 3.12: Сняты многие ограничения на выражения внутри f-строк. В частности, теперь допускаются вложенные строки, комментарии и обратные слэши.

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

    >>> who = 'никто'
    >>> nationality = 'испанскую'
    >>> f'Кто ожидает {nationality} инквизицию? — {who.title()}!'
    'Кто ожидает испанскую инквизицию? — Никто!'

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

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

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

    >>> name = 'Галахад'
    >>> favorite_color = 'синий'
    >>> print(f'{name}:\t{favorite_color}')
    Галахад: синий
    >>> print(rf"C:\Users\{name}")
    C:\Users\Галахад
    >>> print(f'''Три шага к цели,
    ... и цель — три шага.''')
    Три шага к цели,
    и цель — три шага.

Выражения в форматированных строковых литералах обрабатываются как обычные выражения 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"Список a содержит:\n{"\n".join(a)}")
    Список a содержит:
    a
    b
    c

Допускается вложенность f-строк:

    >>> name = 'мир'
    >>> f'Повтор:{f' привет {мир}' * 3}'
    'f'Повтор: привет мир привет мир привет мир'

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

CPython не ограничивает глубину вложенности f-строк.

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

    >>> a = 2
    >>> f"abc{a  # Этот комментарий }" продолжается до конца строки
    ...       + 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"Это не строка документации"
    ...
    >>> print(foo.__doc__)
    None

См. также

- PEP 498 — Интерполяция строковых литералов

- PEP 701 — Синтаксическая формализация f-строк

- `str.format()`, использующий связанный механизм форматных строк

### 2.5.8. t-строки

Добавлено в версии 3.14.

Шаблонный строковый литерал или 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`, сохраняются как часть выражения.

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

Определение `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

Примечание

В приведённом выше фрагменте грамматики правила `f_quote` и `FSTRING_MIDDLE` являются контекстно-зависимыми — они зависят от содержимого токена `FSTRING_START` ближайшей окружающей `fstring`.

Построение более традиционной формальной грамматики на основе этого шаблона оставлено как упражнение для читателя.

Грамматика для t-строк идентична грамматике f-строк, за исключением того, что вместо f используется t в начале правил, токенов и префикса.

    tstring:    TSTRING_START tstring_middle* TSTRING_END

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

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

Токены `NUMBER` представляют числовые литералы, которые делятся на три типа: целые числа, числа с плавающей точкой и мнимые числа.

    NUMBER: integer | floatnumber | imagnumber

Числовое значение числового литерала соответствует значению, которое получилось бы, если бы оно было передано в виде строки в конструктор класса `int`, `float` или `complex` соответственно. Обратите внимание, что не все допустимые входные значения для этих конструкторов также являются допустимыми литералами.

Числовые литералы не включают знак. Запись вроде `-1` на самом деле является выражением, состоящим из унарного оператора `-` и литерала `1`.

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

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

### 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.  # (эквивалентно 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

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

### 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
    10000000000000000000000000000j # эквивалентно 1e+24j

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

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

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

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

## 2.7. Операторы и разделители

Следующая грамматика определяет токены оператор и разделитель, то есть общий тип токена `OP`. Список этих токенов и их имён также доступен в документации модуля `token`.

    OP:
       | assignment_operator
       | bitwise_operator
       | comparison_operator
       | enclosing_delimiter
       | other_delimiter
       | arithmetic_operator
       | "..."
       | other_op

    assignment_operator:   "+=" | "-=" | "*=" | "**=" | "/="  | "//=" | "%=" |
                           "&=" | "|=" | "^=" | "<<=" | ">>=" | "@="  | ":="
    bitwise_operator:      "&"  | "|"  | "^"  | "~"   | "<<"  | ">>"
    comparison_operator:   "<=" | ">=" | "<"  | ">"   | "=="  | "!="
    enclosing_delimiter:   "("  | ")"  | "["  | "]"   | "{"   | "}"
    other_delimiter:       ","  | ":"  | "!"  | ";"   | "="   | "->"
    arithmetic_operator:   "+"  | "-"  | "**" | "*"   | "//"  | "/"   | "%"
    other_op:              "."  | "@"

Примечание

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

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

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

Некоторые операторы Python, такие как `and`, `or` и `not in`, используют токены ключевых слов, а не «символы» (токены-операторы).

Последовательность из трёх точек подряд (`...`) имеет специальное значение как литерал `Ellipsis`.