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

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>

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

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

Если кодировка объявлена, имя кодировки должно быть распознано 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 не генерируется). Во время интерактивного ввода операторов обработка пустой строки может отличаться в зависимости от реализации цикла read-eval-print. В стандартном интерактивном интерпретаторе полностью пустая логическая строка (т. е. строка, не содержащая даже пробелов или комментария) завершает многострочное утверждение.

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. Зарезервированные классы идентификаторов

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

_*

Не импортируются from module import *. Специальный идентификатор _ используется в интерактивном интерпретаторе для хранения результата последнего вычисления; он хранится в builtins модуле. Когда интерактивный режим не используется, _ не имеет специального значения и не определён. См. раздел Оператор импорта.

Примечание

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

__*__

Определяемые системой имена, неофициально известные как имена «дундёр». Эти имена определяются интерпретатором и его реализацией (включая стандартную библиотеку). Текущие системные имена обсуждаются в разделе Специальные имена методов и в других местах. В будущих версиях 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' экранирования в сырых строках не обрабатываются специально. Учитывая, что сырые литералы Unicode в Python 2.x ведут себя по-другому, чем в Python 3.x, синтаксис 'ur' не поддерживается.

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

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

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

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

Примечания:

1. Как и в Стандартном C, принимается до трех восьмеричных цифр.
2. В отличие от Стандартного C, требуется ровно две шестнадцатеричные цифры.
3. В литерале байтов шестнадцатеричные и восьмеричные экранирования обозначают байт с заданным значением. В литерале строки эти экранирования обозначают символ Unicode с заданным значением.

4. Изменено в версии 3.3: Добавлена поддержка псевдонимов имен 1.

5. Требуется ровно четыре шестнадцатеричные цифры.
6. Любой символ Unicode может быть закодирован таким образом. Требуется ровно восемь шестнадцатеричных цифр.

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

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

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_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 | NULL | replacement_field)*
literal_char      ::=  <any code point except "{", "}" or NULL>

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

Выражения в форматируемых строковых литералах обрабатываются как обычные выражения Python, заключённые в круглые скобки, с несколькими исключениями. Не допускается пустое выражение, а выражения lambda 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

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

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

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