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

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

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

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

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

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

Строковый литерал с 'f' или 'F' в префиксе — это *форматированный строковый литерал*; см. f-строки. 'f' может быть объединен с 'r', но не с 'b' или 'u', поэтому возможны сырые форматированные строки, но форматированные байтовые литералы — нет.

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

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

Последовательности экранирования, распознаваемые только в строковых литералах:

Примечания:

1. Обратный слэш может быть добавлен в конце строки, чтобы игнорировать символ новой строки:

   >>> 'This string will not include \
   ... backslashes or newline characters.'
   'This string will not include backslashes or newline characters.'
   

   Тот же результат можно получить, используя тройные строки или скобки и конкатенацию строковых литералов.

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

   Изменено в версии 3.11: Восьмеричные экранирования со значением больше, чем 0o377 вызывают предупреждение DeprecationWarning. В будущих версиях Python они будут предупреждением SyntaxWarning, а в конечном итоге — ошибкой SyntaxError.

3. В отличие от Стандартного C, требуется ровно две шестнадцатеричные цифры.
4. В байтовом литерале шестнадцатеричные и восьмеричные экранирования обозначают байт с указанным значением. В строковом литерале эти экранирования обозначают символ Unicode с данным значением.

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

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

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

Даже в сыром литерале кавычки можно экранировать обратным слэшем, но обратный слэш остается в результате; например, r"\"" — это допустимый строковый литерал, состоящий из двух символов: обратный слэш и двойная кавычка; r"\" — это недопустимый строковый литерал (даже сырая строка не может заканчиваться нечетным числом обратных слэшей). В частности, *сырой литерал не может заканчиваться одним обратным слэшем* (так как обратный слэш экранирует следующий символ кавычки). Также обратите внимание, что один обратный слэш, за которым следует символ новой строки, интерпретируется как эти два символа как часть литерала, *а не* как продолжение строки.

2.4.2. Конкатенация строковых литералов

Разрешается несколько смежных строковых или байтовых литералов (разделенных пробелами), возможно, использующих различные соглашения об использовании кавычек, и их значение такое же, как и их конкатенация. Таким образом, "hello" 'world' эквивалентно "helloworld". Это свойство можно использовать для сокращения количества необходимых обратных слэшей, удобного разбиения длинных строк на длинные строки или даже добавления комментариев к частям строк, например:

re.compile("[A-Za-z_]"       # letter or underscore
           "[A-Za-z0-9_]*"   # letter, digit or underscore
          )

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

2.4.3. f-строки

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

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

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__() выражения или результата преобразования. Если спецификатор формата опущен, передаётся пустая строка. Полученный результат форматирования включается в конечное значение всей строки.

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