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

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’s notepad).

Если объявлена кодировка, имя кодировки должно быть распознано Python (см. Стандартные кодировки). Кодировка используется для всего лексического анализа, включая строковые литералы, комментарии и идентификаторы.

2.1.5. Явное соединение линий¶

Две или более физических строк могут быть объединены в логические строки с помощью символов обратной косой черты (\) следующим образом: если физическая строка заканчивается обратной косой чертой, которая не является частью строкового литерала или комментария, она объединяется со следующей, образуя одну логическую строку, удаляя обратную косую черту и следующий символ конца строки. Например:

if 1900 < year < 2100 and 1 <= month <= 12 \
   and 1 <= day <= 31 and 0 <= hour < 24 \
   and 0 <= minute < 60 and 0 <= second < 60:   # Looks like a valid date
        return 1

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

2.1.6. Неявное соединение линий¶

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

month_names = ['Januari', 'Februari', 'Maart',      # These are the
               'April',   'Mei',      'Juni',       # Dutch names
               'Juli',    'Augustus', 'September',  # for the months
               'Oktober', 'November', 'December']   # of the year

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

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

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

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

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

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

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

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

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

Уровни отступов последовательных строк используются для генерации маркеров INDENT и DEDENT, используя стек, следующим образом.

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

Вот пример правильного (хотя и запутанного) отступа в коде Python:

def perm(l):
        # Compute the list of all permutations of l
    if len(l) <= 1:
                  return [l]
    r = []
    for i in range(len(l)):
             s = l[:i] + l[i+1:]
             p = perm(s)
             for x in p:
              r.append(l[i:i+1] + x)
    return r

В следующем примере показаны различные ошибки отступа:

 def perm(l):                       # error: first line indented
for i in range(len(l)):             # error: not indented
    s = l[:i] + l[i+1:]
        p = perm(l[:i] + l[i+1:])   # error: unexpected indent
        for x in p:
                r.append(l[i:i+1] + x)
            return r                # error: inconsistent dedent

(На самом деле, первые три ошибки обнаруживаются синтаксическим анализатором; только последняя ошибка обнаруживается лексическим анализатором — отступ return r не соответствует уровню, выведенному из стека).

2.1.9. Пробелы между лексемами¶

За исключением начала логической строки или строковых литералов, пробельные символы пробел, табуляция и форм-фид могут использоваться как взаимозаменяемые для разделения лексем. Пробел необходим между двумя лексемами только в том случае, если их объединение может быть интерпретировано как разные лексемы (например, ab - одна лексема, а a b - две лексемы).

2.3.1. Ключевые слова¶

Следующие идентификаторы используются как зарезервированные слова, или ключевые слова языка, и не могут быть использованы как обычные идентификаторы. Они должны быть написаны именно так, как написано здесь:

False      await      else       import     pass
None       break      except     in         raise
True       class      finally    is         return
and        continue   for        lambda     try
as         def        from       nonlocal   while
assert     del        global     not        with
async      elif       if         or         yield

2.3.2. Мягкие ключевые слова¶

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

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

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

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

_*

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

_

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

Отдельно интерактивный интерпретатор делает результат последней оценки доступным в переменной _. (Она хранится в модуле 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). Он также может использоваться для экранирования символов, имеющих специальное значение, таких как новая строка, обратная косая черта или символ кавычек. Примеры см. ниже в разделе escape sequences.

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

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

Строковый литерал с 'f' или 'F' в префиксе является formatted string literal; см. Форматированные строковые литералы. 'f' можно комбинировать с 'r', но не с 'b' или 'u', поэтому необработанные форматированные строки возможны, а форматированные байтовые литералы - нет.

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

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

Эскейп-последовательности распознаются только в строковых литералах:

Примечания:

1. Как и в стандарте С, принимается до трех восьмеричных цифр.

2. В отличие от Стандартного C, здесь требуется ровно две шестнадцатеричные цифры.

3. В литерале байта шестнадцатеричная и восьмеричная эскапады обозначают байт с заданным значением. В строковом литерале эти эскапады обозначают символ Юникода с заданным значением.

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

5. Требуется ровно четыре шестнадцатеричных цифры.

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

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

Изменено в версии 3.6: Нераспознанные управляющие последовательности выдают символ DeprecationWarning. В будущей версии Python они будут SyntaxWarning и, в конечном счете, SyntaxError.

Даже в необработанном литерале кавычки могут быть экранированы обратной косой чертой, но обратная косая черта остается в результате; например, 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. Форматированные строковые литералы¶

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