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

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 от Bram Moolenaar.

Если объявление кодировки не найдено, кодировка по умолчанию — 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 модуля для получения дополнительной информации об этой конвенции.

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

__*__

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