2. Лексический анализ¶

2.1.1. Логические линии¶

Конец логической строки обозначается символом НОВОЙ строки. Операторы не могут пересекать границы логической строки, за исключением случаев, когда синтаксис разрешает перевод строки (например, между операторами в составных операторах). Логическая линия строится из одной или нескольких физических линий в соответствии с явными или неявными правилами соединения линий.

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>

который признан Брэмом Муленаром ВИМОМ.

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

Строки с неявным продолжением могут содержать комментарии. Отступы в строках с продолжением не важны. Допускаются пустые строки с продолжением. Между строками с неявным продолжением нет символа новой строки. Неявно продолженные строки также могут содержаться в строках, заключенных в тройные кавычки (см. ниже); в этом случае они не могут содержать комментариев.

2.1.7. Пустые строки¶

Логическая строка, содержащая только пробелы, табуляцию, ввод форм и, возможно, комментарий, игнорируется (т.е. не генерируется символ новой строки). Во время интерактивного ввода инструкций обработка пустой строки может отличаться в зависимости от реализации цикла чтения-оценки-печати. В стандартном интерактивном интерпретаторе полностью пустая логическая строка (т.е. строка, не содержащая даже пробелов или комментариев) завершает многострочный оператор.

2.1.8. Вдавливание¶

Начальные пробелы (пробелы и знаки табуляции) в начале логической строки используются для вычисления уровня отступа в строке, который, в свою очередь, используется для определения группировки утверждений.

Символы табуляции заменяются (слева направо) от одного до восьми пробелов таким образом, чтобы общее количество символов до замены, включая их, было кратно восьми (предполагается, что это будет то же правило, которое используется в Unix). Общее количество пробелов, предшествующих первому непустому символу, определяет отступ строки. Отступ не может быть разделен на несколько физических строк с помощью обратной косой черты; отступ определяется пробелом до первой обратной косой черты.

Отступы отклоняются как несогласованные, если в исходном файле табуляция и пробелы смешаны таким образом, что значение зависит от значения табуляции в пробелах; в этом случае указывается TabError.

** Примечание по кросс-платформенной совместимости:** из-за особенностей текстовых редакторов, работающих на платформах, отличных от UNIX, неразумно использовать сочетание пробелов и символов табуляции для оформления отступов в одном исходном файле. Следует также отметить, что различные платформы могут явно ограничивать максимальный уровень отступа.

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

Уровни отступов в последовательных строках используются для генерации токенов ОТСТУПА и дедентирования с использованием стека следующим образом.

Перед считыванием первой строки файла в стек помещается один ноль, который больше никогда не будет удален. Числа, помещаемые в стек, всегда будут строго увеличиваться снизу вверх. В начале каждой логической строки уровень отступа сравнивается с вершиной стека. Если он равен, ничего не происходит. Если он больше, он помещается в стек и генерируется один маркер отступа. Если оно меньше, то это должно быть одно из чисел, встречающихся в стеке; все числа в стеке, которые больше, удаляются, и для каждого удаленного числа генерируется токен удержания. В конце файла генерируется токен удержания для каждого числа, оставшегося в стеке, которое больше нуля.

Вот пример корректного (хотя и сбивающего с толку) фрагмента кода на 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. Пробелы между токенами¶

За исключением начала логической строки или строковых литералов, пробельные символы space, tab и formfeed могут взаимозаменяемо использоваться для разделения токенов. Пробел необходим между двумя токенами только в том случае, если их объединение в противном случае может быть интерпретировано как другой токен (например, 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. Мягкие ключевые слова¶

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

Поскольку это неявные ключевые слова, их использование с сопоставлением с шаблоном возможно при сохранении совместимости с существующим кодом, который использует match, case и _ в качестве имен идентификаторов.

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

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

_*

Не импортирован с помощью from module import *.

_

В шаблоне case внутри оператора match _ - это soft keyword, который обозначает wildcard.

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

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

Примечание

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

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

__*__

Системные имена, неофициально известные как имена «dunder». Эти имена определяются интерпретатором и его реализацией (включая стандартную библиотеку). Текущие системные имена обсуждаются в разделе Названия специальных методов и в других местах. Скорее всего, в будущих версиях Python будет определено больше. Любое использование имен __*__ в любом контексте, которое не соответствует явно задокументированному использованию, может быть прекращено без предупреждения.

__*

Частные имена классов. Имена в этой категории, используемые в контексте определения класса, переписываются в искаженном виде, чтобы избежать конфликтов имен между «частными» атрибутами базового и производного классов. Смотрите раздел Идентификаторы (Имена).

2.4.1. Строковые и байтовые литералы¶

Строковые литералы описываются следующими лексическими определениями:

stringliteral   ::=  [stringprefix](shortstring | longstring)
stringprefix    ::=  "r" | "u" | "R" | "U" | "f" | "F"
                     | "fr" | "Fr" | "fR" | "FR" | "rf" | "rF" | "Rf" | "RF"
shortstring     ::=  "'" shortstringitem* "'" | '"' shortstringitem* '"'
longstring      ::=  "'''" longstringitem* "'''" | '"""' longstringitem* '"""'
shortstringitem ::=  shortstringchar | stringescapeseq
longstringitem  ::=  longstringchar | stringescapeseq
shortstringchar ::=  <any source character except "\" or newline or the quote>
longstringchar  ::=  <any source character except "\">
stringescapeseq ::=  "\" <any source character>

bytesliteral   ::=  bytesprefix(shortbytes | longbytes)
bytesprefix    ::=  "b" | "B" | "br" | "Br" | "bR" | "BR" | "rb" | "rB" | "Rb" | "RB"
shortbytes     ::=  "'" shortbytesitem* "'" | '"' shortbytesitem* '"'
longbytes      ::=  "'''" longbytesitem* "'''" | '"""' longbytesitem* '"""'
shortbytesitem ::=  shortbyteschar | bytesescapeseq
longbytesitem  ::=  longbyteschar | bytesescapeseq
shortbyteschar ::=  <any ASCII character except "\" or newline or the quote>
longbyteschar  ::=  <any ASCII character except "\">
bytesescapeseq ::=  "\" <any ASCII character>

Одно синтаксическое ограничение, не указанное в этих произведениях, заключается в том, что пробелы недопустимы между stringprefix или bytesprefix и остальной частью литерала. Исходный набор символов определяется описанием кодировки; это UTF-8, если в исходном файле не указано описание кодировки; смотрите раздел Объявления о кодировании.

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

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

Как строковые, так и байтовые литералы могут необязательно иметь префикс в виде буквы 'r' или 'R'; такие строки называются raw strings и обрабатывают обратную косую черту как буквальные символы. В результате в строковых литералах экранирующие значения '\U' и '\u' в необработанных строках не обрабатываются специальным образом. Учитывая, что необработанные литералы unicode в Python 2.x ведут себя иначе, чем в Python 3.x, синтаксис 'ur' не поддерживается.

Строковый литерал с префиксом 'f' или 'F' равен formatted string literal; смотрите 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-струны¶

formatted string literal или f-string - это строковый литерал с префиксом 'f' или 'F'. Эти строки могут содержать заменяющие поля, которые представляют собой выражения, разделенные фигурными скобками {}. В то время как другие строковые литералы всегда имеют постоянное значение, форматированные строки на самом деле являются выражениями, вычисляемыми во время выполнения.

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

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

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

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

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

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