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

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

Некоторые идентификаторы зарезервированы только в определенных контекстах. Они известны как мягкие ключевые слова. Идентификаторы match, case, type и _ синтаксически могут действовать как ключевые слова в определенных контекстах, но это различие делается на уровне парсера, а не при разбиении на токены.

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

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

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

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

_*

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

_

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

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

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

Примечание

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

Строковый литерал с '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"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