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

Программа Python читается парсером. Вход в парсер - это поток токенов, генерируемый лексическим анализатором. В этой главе описывается, как лексический анализатор разбивает файл на маркеры.

Python читает текст программы как Unicode кодовые точки; кодировка исходного файла может быть дан декларацией кодировка и дефолтами к UTF-8, видеть PEP 3120 для деталей. Если исходный файл не может быть расшифрован, поднимается SyntaxError.

2.1. Строковая структура

Программа Python разделена на ряд логические строки.

2.1.1. Логические строки

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

2.1.2. Физические строки

Физическая строка представляет собой последовательность символов, завершенную последовательностью конца строки. В исходных файлах и строках может быть используемый любая из стандартных последовательностей окончания линии платформы - Unix-форма с использованием ASCII LF (linefeed), Windows-форма с использованием ASCII-последовательности CR LF (возврат с последующим переводом строки) или старая Macintosh-форма с использованием символа ASCII CR (возврат). Все эти формы могут быть используемый одинаково, независимо от платформы. Конец ввода также служит неявным терминатором для конечной физической линии.

Включая питон, исходный код строки должен быть передан к API Python, используя стандарт C конвенции для newline знаков (характер \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 (это поддержано, среди других, notepad Microsoft).

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

2.1.5. Явное соединение строк

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

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

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

2.1.6. Неявное соединение строк

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

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

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

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

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

2.1.8. Вложенность

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

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

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

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

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

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

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

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

def perm(l):
        # Вычислить список всех перестановок 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):                       # ошибка: первая строка с отступом
for i in range(len(l)):             # ошибка: без отступа
    s = l[:i] + l[i+1:]
        p = perm(l[:i] + l[i+1:])   # ошибка: неожиданный отступ
        for x in p:
                r.append(l[i:i+1] + x)
            return r                # ошибка: противоречивый отступ

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

2.1.9. Пробел между токенами

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

2.2. Другие токены

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

2.3. Идентификаторы и ключевые слова

Идентификаторы (также называемые names) описываются следующими лексическими определениями.

синтаксис идентификаторов в Python основан на стандартном приложении UAX-31 к юникоду с уточнением и изменениями, определенными ниже; для получения дополнительной информации см. также PEP 3131.

В диапазоне ASCII (U 0001..U 007F) допустимые символы для идентификаторов такие же, как в Python 2.x: прописные и строчные буквы A - Z, подчеркивание _ и, кроме первого символа, цифры 0 - 9.

Python 3.0 содержит дополнительные символы вне диапазона ASCII (см. PEP 3131). Для этих символов в классификации используется версия базы данных символов юникода, включенная в модуль unicodedata.

Идентификаторы имеют неограниченную длину. Дело значимое.

identifier   ::=  xid_start xid_continue*
id_start     ::=  <all characters in general categories Lu, Ll, Lt, Lm, Lo, Nl, the underscore, and characters with the Other_ID_Start property>
id_continue  ::=  <all characters in id_start, plus characters in the categories Mn, Mc, Nd, Pc and others with the Other_ID_Continue property>
xid_start    ::=  <all characters in id_start whose NFKC normalization is in "id_start xid_continue*">
xid_continue ::=  <all characters in id_continue whose NFKC normalization is in "id_continue*">

Категория Unicode упомянутый выше коды стоит for:

  • Lu - прописные буквы
  • Ll - строчные буквы
  • Lt - titlecase письма
  • Lm - письма о модификаторе
  • Lo - другие письма
  • Nl - письмо номера
  • Mn - неделающие интервалы отметки
  • Mc - делающий интервалы между объединяющимися отметками
  • Nd - десятичные числа
  • Pc - пунктуация соединителя
  • Other_ID_Start - явный список знаков in`PropList.txt <http://www.unicode.org/Public/12.1.0/ucd/PropList.txt>`_to поддерживают назад совместимость
  • Other_ID_Continue - также

Все идентификаторы преобразуются в нормальную форму NFKC при анализе; сравнение идентификаторов основано на NFKC.

Нестандартный HTML-файл, содержащий все допустимые символы идентификатора для юникода 4.1, можно найти по адресу https://www.dcl.hpi.uni-potsdam.de/home/loewis/table-3131.html.

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

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

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. Зарезервированное классы идентификаторов

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

_*

Не импортировано from module import *. Специальный идентификатор _ является используемый в интерактивном интерпретатор, чтобы сохранить результат последней оценки; он хранится в модуле builtins. Если не находится в интерактивном режиме, _ не имеет особого значения и не определяется. См. раздел Инструкция import.

Примечание

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

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

2.4. Литералы

Литералы являются нотациями для постоянных значений некоторых встроенных типов.

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

В английском языке оба типа литералов могут быть заключены в соответствующие одинарные кавычки (') или двойные кавычки ("). Они также могут быть заключены в совпадающие группы из трех одинарных или двойных кавычек (их обычно называют triple-quoted strings). Обратная косая черта (\), характер - используемый, чтобы избежать знаков, у которых иначе есть специальное значение, такое как новая строка, сама обратная косая черта или символ цитаты.

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

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

Добавлено в версии 3.3: Префикс 'rb' сырых опечаток байтов был добавлен как синоним 'br'.

Добавлено в версии 3.3: Была вновь введена поддержка устаревшего литерала юникода (u'value') для упрощения обслуживания двойных баз кодов Python 2 .x и 3 .x. Дополнительные сведения см. в разделе PEP 414.

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

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

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

Экранирующая последовательность Значение Прим.
\newline Обратный слэш и новая строка игнорируются  
\\ Бэкслэш (\)  
\' Одиночная кавычка (')  
\" Двойная кавычка (")  
\a ASCII звонок (BEL)  
\b ASCII бекспейс (BS)  
\f ASCII подача бумаги (FF)  
\n ASCII перевод строки (LF)  
\r ASCII возврат каретки (CR)  
\t ASCII горизонтальная табуляция (TAB)  
\v ASCII вертикальная табуляция (VT)  
\ooo Символ с восьмеричным значением ooo (1,3)
\xhh Символ с шестнадцатеричным значением hh (2,3)

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

Экранирующая последовательность Значение Прим.
\N{name} Именнованный символ name в базе данных Юникод (4)
\uxxxx Символ с 16-битным hex значением xxxx (5)
\Uxxxxxxxx Символ с 32-битным hex значением xxxxxxxx (6)

Примечания:

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

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

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

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

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

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

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

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

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

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

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

re.compile("[A-Za-z_]"       # буква или подчеркивание
           "[A-Za-z0-9_]*"   # буква, цифра или подчеркивание
          )

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

2.4.3. Форматированные строковые литералы

Добавлено в версии 3.6.

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

Изменено в версии 3.7: До Python 3.7 выражение await и понимания, содержащие пункт async for, были незаконны в выражениях в отформатированных опечатках строка из-за проблемы с внедрением.

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

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

Спецификаторы формата верхнего уровня могут включать вложенные поля замены. Эти вложенные поля могут включать свои собственные конверсионные поля и описатель формата, но могут не включать более глубоко вложенные поля замены. мини-язык спецификатора формата совпадает с используемый строка .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'
>>> number = 1024
>>> f"{number:#0x}"  # using integer format specifier
'0x400'

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

f"abc {a["x"]} def"    # ошибка: внешний строковый литерал закончился преждевременно
f"abc {a['x']} def"    # обходной путь: используйте различные кавычки

Обратная косая черта не разрешена в выражениях формата и вызовет ошибку:

>>> newline = ord('\n')
>>> f"newline: {newline}"
'newline: 10'

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

>>> newline = ord('\n')
>>> f"newline: {newline}"
'newline: 10'

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

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

Изменено в версии 3.6: Подчеркивания теперь разрешены для группировки в литералах.

2.4.6. Литералы плавающей точки

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

floatnumber   ::=  pointfloat | exponentfloat
pointfloat    ::=  [digitpart] fraction | digitpart "."
exponentfloat ::=  (digitpart | pointfloat) exponent
digitpart     ::=  digit (["_"] digit)*
fraction      ::=  "." digitpart
exponent      ::=  ("e" | "E") ["+" | "-"] digitpart

Обратите внимание, что целочисленные и экспонентные части всегда интерпретируются с помощью radix 10. Например, 077e010 является легальным и обозначает то же число, что и 77e10. Допустимый диапазон литералов с плавающей запятой зависит от реализации. Как и в целочисленных литералах, для группировки цифр поддерживаются подчеркивания.

Некоторые примеры литералов с плавающей запятой:

3.14    10.    .001    1e100    3.14e-10    0e0    3.14_15_93

Изменено в версии 3.6: Подчеркивания теперь разрешены для группировки в литералах.

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

2.5. Операторы

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

+       -       *       **      /       //      %      @
<<      >>      &       |       ^       ~       :=
<       >       <=      >=      ==      !=

2.6. Разделители

Следующие маркеры служат разделителями в грамматике:

(       )       [       ]       {       }
,       :       .       ;       @       =       ->
+=      -=      *=      /=      //=     %=      @=
&=      |=      ^=      >>=     <<=     **=

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

Следующие печатные символы ASCII имеют особое значение как часть других маркеров или иным образом значимы для лексического анализатора:

'       "       #       \

Следующие символы ASCII не используемый в Python. Их возникновение вне опечаток строка и комментариев - безоговорочный error:

$       ?       `

Сноски

[1]http://www.unicode.org/Public/11.0.0/ucd/NameAliases.txt