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

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

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

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

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

Строковый литерал с '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. В отличие от Стандартного 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. Форматируемые строковые литералы

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

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

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

Для включения значения, в котором требуется escape-последовательность обратного слэша, создайте временную переменную.

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