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

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

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

Как строковые, так и байтовые литералы могут иметь необязательный префикс в виде буквы 'r' или 'R'; такие конструкции называются соответственно сырыми строковыми литералами и сырыми байтовыми литералами, в них обратные косые черты рассматриваются как обычные символы. Поэтому в сырых строковых литералах последовательности экранирования '\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'. Такие строки могут содержать поля подстановки — выражения, заключённые в фигурные скобки {}. Если значение других строковых литералов всегда постоянно, то форматированные строки фактически являются выражениями, которые вычисляются во время выполнения.

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

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

Обратите внимание, что целая и экспоненциальная части всегда интерпретируются в системе счисления с основанием 10. Например, 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