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

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

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

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

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

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

_*

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

_

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

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

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

Примечание

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

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

__*__

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

__*

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

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

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

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; см. раздел Объявления кодировки.

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

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

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

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

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

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

Допускаются несколько расположенных рядом строковых литералов или литералов bytes (разделённых пробелами), возможно, с разными вариантами заключения в кавычки; они означают то же, что и их конкатенация. Таким образом, "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 и выражения присваивания := должны быть заключены в явные скобки. Выражения подстановки могут содержать переводы строк (например, в строках в тройных кавычках), но не могут содержать комментарии. Каждое выражение вычисляется в контексте, в котором находится форматированный строковый литерал, слева направо.

Если указан знак равенства '=', в выводе будут текст выражения, символ '=' и вычисленное значение. Пробелы после открывающей фигурной скобки '{', внутри выражения и после '=' сохраняются в выводе. По умолчанию '=' приводит к выводу результата 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"abc {a["x"]} def"    # error: outer string literal ended prematurely
f"abc {a['x']} def"    # workaround: use different quoting

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

f"newline: {ord('\n')}"  # raises SyntaxError

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

>>> 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. Числовые литералы

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

Обратите внимание, что числовые литералы не включают знак; запись вроде -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