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

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

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

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

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

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

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’xefxbbxbf’) игнорируется, а не вызывает синтаксическую ошибку.

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

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, применяя стек, следующим образом.

Before the first line of the file is read, a single zero is pushed on the stack; this will never be popped off again. The numbers pushed on the stack will always be strictly increasing from bottom to top. At the beginning of each logical line, the line’s indentation level is compared to the top of the stack. If it is equal, nothing happens. If it is larger, it is pushed on the stack, and one INDENT token is generated. If it is smaller, it must be one of the numbers occurring on the stack; all numbers on the stack that are larger are popped off, and for each number popped off a DEDENT token is generated. At the end of the file, a DEDENT token is generated for each number remaining on the stack that is larger than zero.

Вот пример корректно (хотя и запутанно) оформленного отступами фрагмента кода 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

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

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

The following identifiers are used as reserved words, or keywords of the language, and cannot be used as ordinary identifiers. They must be spelled exactly as written here:

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, case и _ в качестве имён идентификаторов.

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

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

_*

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

_

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

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

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

Примечание

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

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

__*__

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

__*

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

2.4.1. Строковые литералы и литералы байтов¶String and Bytes literals

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

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

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

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

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

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

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

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

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

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

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

re.compile("[A-Za-z_]"       # буква или подчёркивание
           "[A-Za-z0-9_]*"   # буква, цифра или подчёркивание
          )

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

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

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

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

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

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

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

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

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

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

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

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

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

>>> name = "Fred"
>>> f"He said his name is {name!r}."
"He said his name is 'Fred'."
>>> f"He said his name is {repr(name)}."  # repr() эквивалентно !r
"He said his name is 'Fred'."
>>> width = 10
>>> precision = 4
>>> value = decimal.Decimal("12.34567")
>>> f"result: {value:{width}.{precision}}"  # вложенные поля
'result:      12.35'
>>> today = datetime(year=2017, month=1, day=27)
>>> f"{today:%B %d, %Y}"  # использование спецификатора формата даты
'January 27, 2017'
>>> f"{today=:%B %d, %Y}" # использование спецификатора формата даты и отладка
'today=January 27, 2017'
>>> number = 1024
>>> f"{number:#0x}"  # использование спецификатора формата целого числа
'0x400'
>>> foo = "bar"
>>> f"{ foo = }" # сохраняет пробельные символы
" foo = 'bar'"
>>> line = "The mill's closed"
>>> f"{line = }"
'line = "The mill\'s closed"'
>>> f"{line = :20}"
"line = The mill's closed   "
>>> f"{line = !r:20}"
'line = "The mill\'s closed" '

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

f"abc {a["x"]} def"    # ошибка: внешний строковый литерал закончился преждевременно
f"abc {a['x']} def"    # обходной путь: используйте другие кавычки

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

f"newline: {ord('\n')}"  # возбуждает SyntaxError

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

>>> newline = ord('\n')
>>> f"newline: {newline}"
'newline: 10'

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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