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

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 — один токен, а 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, если в исходном файле не указано другое объявление кодировки; см. раздел Объявления кодировок.

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

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

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

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

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

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