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

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

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

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

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

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

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

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

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

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

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

Эта форма также распознаётся GNU Emacs, а следующая

# vim:fileencoding=<encoding-name>

распознаётся Bram Moolenaar’s VIM.

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

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

2.1.5. Явное объединение строк

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

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

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

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

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

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

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

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

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

2.1.8. Отступы

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

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

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

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

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

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

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

Ниже приведён пример фрагмента кода Python с корректными (хотя и запутанными) отступами:

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

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

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

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

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

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

2.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, type и _ в определённых контекстах могут синтаксически выступать в роли ключевых слов, но это различие определяется на уровне синтаксического анализатора, а не при токенизации.

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

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

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

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

_*

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

_

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

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

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

Примечание

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

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

__*__

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

__*

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2.4.3. f-строки

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

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

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

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

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

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

Если указан знак равенства '=', в результате будут выведены текст выражения, '=' и вычисленное значение. Пробелы после открывающей скобки '{', внутри выражения и после '=' сохраняются в результате. По умолчанию '=' приводит к выводу 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() is equivalent to !r
"He said his name is 'Fred'."
>>> width = 10
>>> precision = 4
>>> value = decimal.Decimal("12.34567")
>>> f"result: {value:{width}.{precision}}"  # nested fields
'result:      12.35'
>>> today = datetime(year=2017, month=1, day=27)
>>> f"{today:%B %d, %Y}"  # using date format specifier
'January 27, 2017'
>>> f"{today=:%B %d, %Y}" # using date format specifier and debugging
'today=January 27, 2017'
>>> number = 1024
>>> f"{number:#0x}"  # using integer format specifier
'0x400'
>>> foo = "bar"
>>> f"{ foo = }" # preserves whitespace
" foo = 'bar'"
>>> line = "The mill's closed"
>>> f"{line = }"
'line = "The mill\'s closed"'
>>> f"{line = :20}"
"line = The mill's closed   "
>>> f"{line = !r:20}"
'line = "The mill\'s closed" '

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примеры литералов с плавающей точкой:

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

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

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

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

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

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