3. Модель данных

3.1. Объекты, значения и типы

Объекты являются Python абстракциями для данных. Все данные в Python программе представлены объектами или связями между объектами. (В некотором смысле, и в соответствии с моделью фон Неймана «Хранимого программного компьютера», код также представлен объектами.)

Каждый объект имеет идентификатор, тип и значение. Идентификатор объекта никогда не изменяется, как только он был создан; его можно рассматривать как адрес объекта в памяти. Оператор «is» сравнивает идентичность двух объектов; функция id() возвращает целое число, представляющее ее идентификатор.

Детали реализации CPython: Для CPython, id(x) - это адрес памяти, где хранится x.

Тип объекта определяет операции, которые поддерживает объект (например, «есть ли у него длина?»), и также определяет возможные значения для объектов этого типа. Функция type() возвращает тип объекта (который является самим объектом). Как его идентичность, type объекта также неизменно. [1]

Может измениться значение некоторых объектов. Объекты, значение которых может изменяться, называются изменчивыми; объекты, значение которых не изменяется после их создания, называются неизменный. (Значение неизменяемого объекта-контейнера, которое содержит ссылку на изменяемый объект, может изменяться при изменении значения последнего; однако контейнер по-прежнему считается незыблемым, так как набор содержащихся в нем объектов не может быть изменен. Таким образом, неизменяемость не является строго такой же, как наличие неизменяемого значения, она более тонкая.) Изменчивость объекта определяется его типом; например, числа, строки и кортежи являются неизменяемыми, а словари и списки могут изменяться.

Объекты никогда явно не уничтожаются; однако, когда они становятся недоступными, они могут быть собраны мусором. Внедрению позволяют отложить сборку мусора или опустить ее в целом —, это - вопрос качества внедрения, как сборка мусора осуществлена, пока никакие объекты не собраны, которые все еще достижимы.

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

Следует отметить, что использование средств трассировки или отладки реализации может поддерживать объекты, которые обычно являются доступными для сбора. Также обратите внимание что, ловя исключение с „try…:keyword:except“ оператор может поддержать объекты.

Некоторые объекты содержат ссылки на «внешние» ресурсы, такие как открытые файлы или окна. Понятно, что эти ресурсы освобождаются, когда объект собирается мусором, но так как сборка мусора не гарантирована, такие объекты также предоставляют явный способ освобождения внешнего ресурса, обычно close() метод. Программам настоятельно рекомендуется явно закрыть такие объекты. „try…:keyword:finally“ оператор и „with“ оператор обеспечивают удобные способы сделать это.

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

Типы затрагивают почти все аспекты поведения объекта. Даже важность идентичности объекта затронута в некотором смысле: для неизменных типов операции, которые вычисляют новые значения, могут на самом деле возвратить ссылку на любой существующий объект с тем же типом и стоимостью, в то время как для изменчивых объектов это не позволено. Например, после a = 1; b = 1 a и b могут или могут не относиться к тому же объекту со стоимостью один, в зависимости от внедрения, но после c = []; d = [], c и d, как гарантируют, будут относиться к двум различным, уникальным, недавно создал пустые списки. (Обратите внимание, что c = d = [] назначает тот же объект и на c и на d.)

3.2. Стандартная иерархия типов

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

Некоторые из приведенных ниже описаний типов содержат абзац с перечнем «специальных атрибутов». Эти атрибуты обеспечивают доступ к реализации и не предназначены для общего использования. Их определение может измениться в будущем.

None

У этого типа есть единственная стоимость. Есть единственный объект с этой стоимостью. К этому объекту получают доступ через встроенное имя None. Это - используемый, чтобы показать отсутствие стоимости во многих ситуациях, например, это возвращено из функций, которые ничего явно не возвращают. Его стоимость правды ложная.

NotImplemented

У этого типа есть единственная стоимость. Есть единственный объект с этой стоимостью. К этому объекту получают доступ через встроенное имя NotImplemented. Числовой методы и богатое сравнение, методы должен возвратить эту стоимость, если они не осуществляют операцию для обеспеченных операндов. (интерпретатор тогда попробует отраженную операцию или некоторое другое отступление, в зависимости от оператора.) его стоимость правды верна.

Дополнительные сведения см. в разделе Реализация арифметических операций.

Эллипсис

Этот тип имеет одно значение. Существует один объект с этим значением. Доступ к этому объекту осуществляется через литерал ... или встроенное имя Ellipsis. Его истинная ценность истинна.

numbers.Number

Они создаются числовыми литералами и возвращаются в виде результатов арифметическими операторами и арифметическими встроенными функциями. Числовые объекты являются неизменяемыми; после создания их ценность никогда не меняется. Python числа, конечно, сильно связаны с математическими числами, но с учетом ограничений числового представления в компьютерах.

Python различает целые числа, числа с плавающей запятой и комплексные числа:

numbers.Integral

Они представляют элементы из математического набора целых чисел (положительные и отрицательные).

Существует два типа целых чисел:

Целые числа (int)

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

Они представляют истинные значения Ложь и Истина. Два объекта, представляющие значения False и True, являются единственными логическими объектами. Логический тип является подтипом целочисленного типа, и логические значения ведут себя как значения 0 и 1 соответственно почти во всех контекстах, исключением является то, что при преобразовании в строку возвращаются соответственно строки "False" или "True".

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

numbers.Real (float)

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

numbers.Complex (complex)

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

Последовательности

Они представляют конечное упорядоченное множество, индексированное неотрицательными числами. Встроенная функция len() возвращает количество элементов последовательности. Когда длина последовательности равна n, набор индексов содержит числа 0, 1,…, n-1. Элемент i последовательности a выбирается a[i].

Последовательности также поддерживают разрезание: a[i:j] выбирает все предметы с индексом k, таким образом что i <= k < j. Когда используемый как выражение, часть - последовательность того же типа. Это означает, что набор индексов перенумерован так, что он начинается с 0.

Некоторые последовательности также поддерживают «расширенное нарезание» с третьим параметром «шаг»: a[i:j:k] выбирает все элементы a с индексом x где x = i + n*k, n >= 0 и i <= x < j.

Последовательности различают по их мутабельности:

Неизеняемые последовательности

Объект неизменяемого типа последовательности не может быть изменен после его создания. (Если объект содержит ссылки на другие объекты, эти другие объекты могут быть мутабельными и могут быть изменены; однако коллекция объектов, на которые непосредственно ссылается неизменяемый объект, не может быть изменена.)

Следующие типы являются неизменяемыми последовательностями:

Строки

Строка - последовательность ценностей, которые представляют точки Unicode код. Все точки код в диапазоне U+0000 - U+10FFFF могут быть представлены в строка. У Python нет a: тип c:type:char; вместо этого, каждая точка код в строка представлена, поскольку строка возражает с длиной 1. Встроенная функция ord() преобразовывает точку код от своей формы строка до целого числа в диапазоне 0 - 10FFFF; chr() преобразовывает целое число в диапазоне 0 - 10FFFF к соответствующему объекту 1 строка длины. str.encode() может быть используемый, чтобы преобразовать str в bytes, используя данное текстовое кодирование, и bytes.decode() может быть используемый, чтобы достигнуть противоположного.

Картежи

Элементы кортежа являются произвольными Python объектами. Кортежи из двух или более элементов формируются разделенными запятыми списками выражений. Кортеж из одного элемента («singleton») можно сформировать, прикрепив запятую к выражению (выражение само по себе не создает кортеж, так как скобки должны быть использованы для группировки выражений). Пустой кортеж может быть сформирован пустой парой скобок.

Байты

Объект байтов - неизменное множество. Предметы - 8-битные байты, представленные целыми числами в диапазоне 0 <= x <256. Опечатки байтов (как b'abc') и встроенный конструктор bytes() могут быть используемый, чтобы создать объекты байтов. Кроме того, объекты байтов могут быть расшифрованы к строки через decode() метод.

Изменяемые последовательности

Мутабельные последовательности могут быть изменены после их создания. Обозначения подписки и среза могут быть используемый в качестве цели назначения и del (удаления) операторы.

Есть в настоящее время две внутренних изменчивых последовательности types:

Списки

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

Байтовые массивы

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

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

Типы множеств

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

Для элементов набора применяются те же правила неизменяемости, что и для ключей словаря. Обратите внимание, что числовые типы подчиняются нормальным правилам для числового сравнения: если два числа сравниваются равными (например, 1 и 1.0), в наборе может содержаться только одно из них.

В настоящее время существует два внутренних типа наборов:

Множества

Они представляют собой мутабельный набор. Они создаются встроенным конструктором set() и могут быть изменены несколькими методами, такими как add().

Замороженные множества

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

Отображения

Они представляют конечные множества объектов, внесенных в указатель произвольными наборами индекса. Нижнее примечание a[k] выбирает предмет, внесенный в указатель k от отображения a; это может быть используемый в выражениях и как цель назначений или del операторы. Встроенная функция len() возвращает количество предметов в отображении.

В настоящее время существует один внутренний тип сопоставления:

Словари

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

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

Словари мутабельны; они могут быть созданы с помощью нотации {...} (см. раздел Отображение словаря).

Дополнительный dbm.ndbm модулей и dbm.gnu обеспечивают дополнительные примеры отображения типов, как делает модуль collections.

Изменено в версии 3.7: Словари не сохранили порядок вставки в версиях Python до 3.6. В CPython 3.6 порядок вставки был сохранен, но в то время он считался детализацией реализации, а не языковой гарантией.

Вызываемые типы

Это типы, к которым можно применить операцию вызова функции (см. раздел Вызовы):

Определяемые пользователем функции

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

Специальный attributes:

Атрибут Значение  
__doc__ Строка документации функции или None, если она недоступна; не наследуется подклассами. Перезаписываемый
__name__ Название функции. Перезаписываемый
__qualname__

Квалифицированное имя функции.

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

Перезаписываемый
__module__ Имя модуля где функция была определено или None, если недоступно. Перезаписываемый
__defaults__ Кортеж, содержащий аргумент по умолчанию, значения тех же аргументов, у которые по умолчанию или None, если ни у каких аргументов нет значения по умолчанию. Перезаписываемый
__code__ Объект кода, представляющий тело скомпилированной функции. Перезаписываемый
__globals__ Ссылка на словарь, который содержит глобальные переменные функции — глобальное пространство имен модуля, в котором была определена функция. Только для чтения
__dict__ Пространство имен, поддерживающее произвольные атрибуты функции. Перезаписываемый
__closure__ None или кортеж ячеек, которые содержат биндинги для свободных переменных функции. См. ниже для получения информации о атрибуте cell_contents. Только для чтения
__annotations__ dict, содержащий аннотации параметров. Ключи dict - названия параметров и 'return' для возвращения аннотации, если передан. Перезаписываемый
__kwdefaults__ dict содержащий параметры по умолчанию только для ключевых параметров. Перезаписываемый

Большинство атрибутов, помеченных как «Записываемые», проверяют тип назначенного значения.

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

Объект ячейки имеет атрибут cell_contents. Это может быть используемый, чтобы получить ценность клетки, а также установить значение.

Дополнительная информация об определении функции может быть восстановлена от его объекта код; см. описание внутренних типов ниже. К типу cell можно получить доступ в модуле types.

Методы сущности

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

Специальные атрибуты только для чтения: __self__ - объект класс сущность, __func__ - объект функции; __doc__ является документацией метода (такой же, как __func__.__doc__); __name__ - имя метод (то же, что и __func__.__name__); __module__ - название модуля, метод был определен в, или None, если недоступный.

Методы также поддерживают доступ (но не установку) к атрибутам произвольной функции базового объекта функции.

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

Когда объект сущность метод создан, восстановив определенный пользователями объект функции от класс через один из его случаев, его признак __self__ - случай, и объект метод, как говорят, связан. Признак __func__ нового метода - оригинальный объект функции.

Когда объект сущность метод создается путем извлечения объекта класс метод из класс или экземпляра, его атрибутом __self__ является сам класс, а его атрибутом __func__ является объект функции, лежащий в основе класс метод.

При вызове объекта сущность метод вызывается базовая функция (__func__), вставляя класс сущность (__self__) перед списком аргументов. Например, когда C - класс, который содержит определение для функции f(), и x - сущность C, называние x.f(1) эквивалентно запросу C.f(x, 1).

Когда объект сущность метод является производным от объекта класс метод, «экземпляр <unk>», хранящийся в __self__, фактически будет самим класс, так что вызов x.f(1) или C.f(1) эквивалентен вызову f(C,1), где f является базовой функцией.

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

Функции генераторы

Функцию или метод, который использует yield оператор (см. раздел Инструкция yield) называют generator function. Такая функция, когда названо, всегда возвращает объект итератор, который может быть используемый, чтобы выполнить тело функции: запрос iterator.__next__() метод итератора заставит функцию выполнять, пока это не предоставит стоимость, используя yield оператор. Когда функция выполняет return оператор или падает с конца, исключение StopIteration поднято, и итератор достигнет конца набора ценностей, которые будут возвращены.

Функции корутины

Функция или метод, определяемая с помощью async def, называется coroutine function. Такая функция при вызове возвращает объект корутина. Он может содержать выражения await, а также async with и async for операторы. См. также раздел Объекты корутины.

Асихронные генератор функции

Функция или метод, определенная с помощью async def и использующая yield оператор, называется asynchronous generator function. Такая функция, когда она вызывается, возвращает асинхронный объект итератора, который может быть используемый в async for оператор для выполнения тела функции.

Вызов асинхронный итератора aiterator.__anext__() метод возвращает awaitable, который при ожидании будет выполняться до тех пор, пока не предоставит значение с помощью выражения yield. Когда функция выполняет пустой return оператор или падает с конца, возникает исключение StopAsyncIteration и асинхронный итератор достигает конца набора значений, которые должны быть выданы.

Встроенные функции

Встроенный объект функции - обертка вокруг функции C. Примеры встроенных функций - len(), и math.sin() (math - стандартный встроенный модуль). Число и тип аргументов определены функцией C. Специальные признаки только для чтения: __doc__ - последовательность документации функции или None если недоступный; __name__ - имя функции; __self__ установлен, to``None`` (but see the next item); __module __' является названием модуля, функция была определена в или ``None`, если недоступный.

Встроенные методы

Это действительно другая маскировка встроенной функции, на этот раз содержащая объект, переданный функции C, как неявный дополнительный аргумент. Примером встроенного метод является alist.append(), предполагая, что alist является объектом списка. В этом случае специальный атрибут __self__, доступный только для чтения, устанавливается на объект, обозначенный как alist.

Классы классы являются вызываемыми. Эти объекты обычно действуют как фабрики для нового сущности себя, но изменения возможны для типов класс, которые отвергают __new__(). Аргументы требования переданы к __new__() и, в типичном случае, к __init__(), чтобы инициализировать новый сущность.

Класс сущности сущности произвольного классы можно сделать вызываемым, определив __call__() метод в их класс.

Модули

Модули - основная организационная единица кодекса Python и созданы import system, столь же призванным или заявлением import, или вызвав функции, такие как importlib.import_module() и встроенный __import__(). Объект модуля имеет пространство имен, реализованное объектом словаря (это словарь, на который ссылается атрибут __globals__ функций, определенных в модуле). Ссылки на атрибуты переводятся на поиск в этом словаре, например, m.x эквивалентен m.__dict__["x"]. Объект модуля не содержит объекта код используемый для инициализации модуля (поскольку он не требуется после инициализации).

Назначение признака обновляет словарь пространства имен модуля, например, m.x = 1 эквивалентен m.__dict__["x"] = 1.

Предопределенные (доступные для записи) атрибуты: __name__ - имя модуля; __doc__ - строка документации модуля или None, если она недоступна; (Дополнительный) __annotations__ является словарем, содержащим аннотации переменных, собранный во время выполнения тела модуля; __file__ - путь к файлу, из которого был загружен модуль, если он был загружен из файла. Атрибут __file__ может отсутствовать для некоторых типов модулей, таких как C-модули, статически связанные с интерпретатором; для модулей расширений, динамически загружаемых из общей библиотеки, это путь к файлу общей библиотеки.

Специальный атрибут только для чтения: __dict__ - пространство имен модуля как объекта словаря.

Детали реализации CPython: Из-за того, как CPython очищает словари модулей, словарь модулей будет очищен, когда модуль выпадет из область видимости, даже если словарь все еще имеет живые ссылки. Чтобы избежать этого, скопируйте словарь или удерживайте модуль, используя его непосредственно.

Пользовательские классы

Пользовательские типы класс, как правило, создаются определениями класс (см. раздел Определения класса). класс осуществил пространство имен объект словаря. Ссылки признака класса переведены к поискам в этом словаре, например, C.x переведен к C.__dict__["x"] (хотя есть много крюков, которые допускают другие средства расположения признаков). Когда название атрибута не найдено там, поиск признака продолжается в основном классы. Этот поиск основного классы использует заказ резолюции C3 метод, который ведет себя правильно даже в присутствии „алмазных“ структур наследования, где есть несколько путей наследования, возвращающихся общему предку. Дополнительные детали о C3 MRO используемый Python могут быть найдены в документации, сопровождающей эти 2,3 выпуска в https://www.python.org/download/releases/2.3/mro/.

Когда ссылка атрибута класс (для класс C, скажем) дает объект класс метод, он преобразуется в объект сущность метод, атрибут __self__ которого является C. Когда он дает статический объект метод, он преобразуется в объект, обернутый статическим объектом метод. Посмотрите раздел Реализация дескрипторов для иначе, в котором признаки, восстановленные от класс, могут отличаться от на самом деле содержавшихся в его __dict__.

Назначения признака класса обновляют словарь класса, никогда словарь основного класс.

Объект класс можно назвать (см. выше) привести к класс сущность (см. ниже).

Специальные атрибуты: __name__ - имя класс; __module__ - имя модуля, на которое был определен класс; __dict__ - словарь, содержащий пространство имен класса; __bases__ - кортеж, содержащий базовые классы в заказе их возникновения в основном списке класс; __doc__ - строка документации класса или None, если она не определена; __annotations__ (необязательный) - словарь, содержащий аннотации переменных, собранные во время выполнения тела класс.

Сущности классов

Класс сущность создается путем вызова объекта класс (см. выше). класс сущность имеет пространство имен, реализованное как словарь, который является первым местом, в котором ссылки на атрибуты являются найденный. Когда признак не найден там, и у класс случая есть признак тем именем, поиск продолжает признаки класс. Если обнаружен атрибут класс, являющийся объектом определяемой пользователем функции, он преобразуется в объект сущность метод, атрибутом __self__ которого является сущность. Статические метод и класс метод объекты также преобразуются; см. выше в разделе «Классы». Посмотрите раздел Реализация дескрипторов для иначе, в котором признаки класс, восстановленного через его сущности, могут отличаться от объектов, на самом деле хранивших в классе __dict__. Если признак № класс найден, и у класс объекта есть метод __getattr__(), который называют, чтобы удовлетворить поиск.

Назначения атрибутов и удаления обновляют словарь экземпляра, а не словарь класса. Если класс имеет метод __setattr__() или __delattr__(), это вызывается вместо прямого обновления словаря сущность.

Класс сущности может притворяться числами, последовательностями или сопоставлениями, если у них есть методы с определенными специальными именами. См. раздел Специальные имена метод.

Специальные атрибуты: __dict__ - словарь атрибутов; __class__ - класс экземпляра.

I/O объекты (также известные как файловые объекты)

Файловый объект представляет открытый файл. Для создания файловых объектов доступны различные ярлыки: встроенная функция open(), а также os.popen(), os.fdopen() и makefile() метод объектов сокет (а возможно, и другими функциями или методы, предоставляемыми модулями расширений).

Объекты sys.stdin, sys.stdout и sys.stderr инициализируются в файловые объекты, соответствующие стандартным входным, выходным и ошибочным потокам интерпретатора; они все открыты в текстовом режиме и поэтому следуют за интерфейсом, определенным абстрактным класс io.TextIOBase.

Внутренние типы

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

Объекты кода

Кодовые объекты представляют выполнимый кодекс Python byte-compiled или байт-код. Различие между объектом код и объектом функции - то, что объект функции содержит прямую ссылку на глобальные функции (модуль, в котором это было определено), в то время как объект код не содержит контекста; также значения аргументов по умолчанию хранятся в объекте функции, а не в объекте код (поскольку они представляют значения, рассчитанные во время выполнения). В отличие от функциональных объектов, код объекты являются неизменяемыми и не содержат ссылок (прямо или косвенно) на изменяемые объекты.

Специальные признаки только для чтения: co_name дает имя функции; co_argcount - общее количество позиционных аргументов (включая позиционно-единственные аргументы и споры со значениями по умолчанию); co_posonlyargcount - количество позиционно-единственных аргументов (включая споры со значениями по умолчанию); co_kwonlyargcount - количество аргументов только для ключевого слова (включая споры со значениями по умолчанию); co_nlocals - количество переменных локальная используемый функцией (включая аргументы); co_varnames - кортеж, содержащий названия переменных локальная (начинающийся с имен аргумента); co_cellvars - кортеж, содержащий названия переменных локальная, на которые ссылаются вложенные функции; co_freevars - кортеж, содержащий названия свободных переменных; co_code - строка, представляющий последовательность байт-код инструкций; co_consts - кортеж, содержащий опечатки используемый байт-кодом; co_names - кортеж, содержащий имена используемые байт-кодом; co_filename - имя файла, от которого был собран код; co_firstlineno - первый номер линии функции; co_lnotab - строка кодировка отображение от погашений байт-код до номеров линии (для получения дополнительной информации посмотрите источник код переводчика); co_stacksize - необходимый размер стека; co_flags - целое число кодировка много флагов для интерпретатор.

Для co_flags определены следующие биты флага: бит 0x04 устанавливается, если функция использует синтаксис *arguments для принятия произвольного количества позиционных аргументов; бит 0x08 устанавливается, если функция использует синтаксис **keywords для принятия произвольных аргументов ключевой; бит 0x20 устанавливается, если функция является генератор.

Будущие декларации особенности (from __future__ import division) также используют биты в co_flags, чтобы указать, был ли объект код собран с особой активированной опцией: разрядный 0x2000 установлен, если функция была собрана с будущим включенным подразделением; биты 0x10 и 0x1000 были используемый в более ранних версиях Python.

Другие биты в co_flags зарезервированы для внутреннего использования.

Если объект код представляет функцию, первый предмет в co_consts - документация строка функции или None, если неопределенный.

Объекты фрейма

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

Специальные атрибуты только для чтения: f_back - к предыдущему кадру стека (к вызывающему абоненту), или None, если это нижняя рамка стека; f_code - объект код, выполняемый в этом кадре; f_locals - словарь используемый, чтобы искать переменные локальная; f_globals является используемый для глобальных переменных; f_builtins является используемый для встроенных (внутренних) имен; f_lasti дает точную инструкцию (это индекс в байт-код строка объекта код).

Специальные записываемые атрибуты: f_trace, если не None, является функцией, вызываемой для различных событий во время выполнения код (это используемый отладчиком). Обычно событие инициируется для каждой новой исходной строки - это можно отключить, установив для параметра f_trace_lines значение False.

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

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

Объекты фрейма поддерживают один метод:

frame.clear()

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

RuntimeError возникает, если кадр выполняется в данный момент.

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

Объекты трейсбэка

Объекты Трэсебэка представляют трассировку стека исключения. Объект трейсбэк неявно создан, когда исключение происходит и может также быть явно создано, назвав types.TracebackType.

Для неявно созданного tracebacks, когда поиск укладчика исключения раскручивает стопку выполнения на каждом раскрученном уровне, объект трейсбэк вставлен перед текущим трейсбэк. При вводе обработчика исключений трассировка стека становится доступной для программы. (См. раздел Оператор try.) Он доступен как третий элемент кортежа, возвращенного sys.exc_info(), и как атрибут __traceback__ найденного исключения.

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

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

Специальные признаки только для чтения: tb_frame указывает на структуру выполнения текущего уровня; tb_lineno дает номер линии, где исключение произошло; tb_lasti указывает на точную инструкцию. Номер линии и последняя инструкция в трейсбэк могут отличаться от номера линии своего объекта структуры, если исключение произошло в try оператор без соответствия кроме пункта или с наконец пункт.

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

Изменено в версии 3.7: Объекты трэсебэка могут теперь явно иллюстрироваться примерами из кодекса Python, и признак tb_next существующего сущности может быть обновлен.

Слайс объекты

Объекты части - используемый, чтобы представлять части для __getitem__() методы. Они также создаются встроенной функцией slice().

Специальные атрибуты только для чтения: start - нижняя граница; stop - верхняя граница; step - значение шага; каждый из них None, если он опущен. Эти атрибуты могут иметь любой тип.

Объекты-фрагменты поддерживают один метод:

slice.indices(self, length)

Это метод принимает один целый аргумент length и вычисляет информацию о фрагменте, который объект среза будет описывать, если применить к последовательности элементов length. Возвращает кортеж из трёх целых чисел; соответственно это индексы start и stop и длина step или шага среза. Отсутствующие или вышедшие за границы индексы обрабатываются способом, согласующимся с обычными срезами.

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

Объект Class метод объект A класс метод, как статический объект метод, является оберткой вокруг другого объекта, которая изменяет способ извлечения этого объекта из классы и класс сущности. Поведение объектов класс метод при таком поиске описано выше в разделе «Определяемые пользователем методы». Объекты класса метод созданы встроенным конструктором classmethod().

3.3. Специальные имена метод

класс может реализовывать определенные операции, вызываемые специальным синтаксисом (например, арифметические операции или подстрочный индекс и нарезка), определяя методы со специальными именами. Это Python’s подход к operator overloading, позволяющий классы определять собственное поведение по отношению к языковым операторам. Например, если класс определяет метод с именем __getitem__(), а x является сущность этого класса, то x[i] примерно эквивалентен type(x).__getitem__(x, i). Кроме, где упомянуто, попытки выполнить операцию поднимают исключение, когда никакой соответствующий метод не определен (как правило, AttributeError или TypeError).

Настройка специального метод к None указывает, что соответствующая операция не доступна. Например, если класс устанавливает __iter__() в None, класс не является итерабельным, поэтому вызов iter() на его сущности поднимет TypeError (без возврата к __getitem__()). [2]

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

3.3.1. Основная настройка

object.__new__(cls[, ...])

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

Типичные реализации создают новый сущность класс, вызывая __new__() метод суперкласса, используя super().__new__(cls[, ...]) с соответствующими аргументами, а затем изменяя вновь созданный сущность по мере необходимости перед его возвратом.

Если __new__() будет призван во время строительства объекта, и это возвращает сущность или подкласс cls, то __init__() метод нового случая будет призван как __init__(self[, ...]), где self - новый сущность, и остающиеся аргументы совпадают с, были переданы конструктору объекта.

Если __new__() не возвращает сущность cls, то __init__() метод нового экземпляра не вызывается.

__new__() предназначен, главным образом, чтобы позволить подклассы неизменных типов (как интервал, str, или кортеж) настраивать создание сущность. Это также обычно отвергается в таможенных метаклассах, чтобы настроить создание класс.

object.__init__(self[, ...])

Вызывается после создания сущность (по __new__()), но до его возврата вызывающему абоненту. Аргументы передаются в выражение конструктора класс. Если базовый класс имеет метод __init__(), метод __init__() производного класса, если он имеется, должен явно вызвать его, чтобы обеспечить правильную инициализацию базовой класс части экземпляра; например: super().__init__([args...]).

Поскольку __new__() и __init__() работают вместе при построении объектов (__new__(), чтобы создать его, и __init__(), чтобы настроить его), значение non-None не может быть возвращено __init__(); это приведет к появлению TypeError во время выполнения.

object.__del__(self)

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

Это возможно (хотя не рекомендуемый!), чтобы __del__() метод отложил разрушение сущность, создав новую ссылку на него. Это называется воскрешение объекта. Это зависит от реализации, называется ли __del__() второй раз, когда восстанавливаемый объект собирается быть уничтоженным; текущая реализация CPython вызывает его только один раз.

Не гарантируется, что __del__() методы вызываются для объектов, которые все еще существуют при выходе интерпретатор.

Примечание

del x не вызывает x.__del__() — первый уменьшает счетчик опорного сигнала для x на единицу, а второй вызывается только тогда, когда счетчик опорного сигнала x достигает нуля.

Детали реализации CPython: Ссылочный цикл позволяет предотвратить переход к нулю количества привязок объекта. В этом случае цикл будет позже обнаружен и удален циклическим сборщиком мусора. Общей причиной ссылочных циклов является захват исключения в переменной локальная. Затем местные жители кадра ссылаются на исключение, которое ссылается на собственный трассировку, которая ссылается на местных жителей всех кадров, захваченных в трейсбэк.

См. также::
Документация для модуля gc.

Предупреждение

Из-за сомнительных обстоятельств, при котором __del__() методы призваны, исключения, которые происходят во время их выполнения, проигнорированы, и предупреждение напечатано к sys.stderr вместо этого. В частности:

  • __del__() может вызываться при выполнении произвольного код, в том числе из любого произвольного потока. Если __del__() необходимо взять блокировку или вызвать любой другой блокирующий ресурс, это может привести к взаимоблокировке, так как ресурс уже может быть взят код, который прерывается для выполнения __del__().
  • __del__() может быть выполнен во время закрытия интерпретатор. Как следствие, глобальные переменные, к которым он должен получить доступ (включая другие модули), могут быть уже удалены или установлены в значение None. Python гарантирует, что глобалы, имя которых начинается с одного подчеркивания, будут удалены из их модуля до удаления других глобалов; если других ссылок на такие глобалы не существует, это может помочь в обеспечении доступности импортированных модулей во время вызова __del__() метод.
object.__repr__(self)

Названный встроенной функцией repr(), чтобы вычислить «официальное» представление строка объекта. Если это вообще возможно, это должно выглядеть как допустимое выражение Python, которое может быть используемый для воссоздания объекта с тем же значением (с соответствующей средой). Если это невозможно, необходимо вернуть строка формы <...some useful description...>. Возвращаемое значение должно быть объектом строка. Если класс определяет __repr__(), но не __str__(), то __repr__() - также используемый, когда «неофициальное» представление строка сущности того класс требуется.

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

object.__str__(self)

Названный str(object) и встроенными функциями format() и print(), чтобы вычислить «неофициальное» или приятно пригодное для печатания представление строка объекта. Возвращаемое значение должно быть объектом string.

Этот метод отличается от object.__repr__(), в котором нет никакого ожидания, что __str__() возвращают действительное выражение Python: более удобное или краткое представление может быть используемый.

Внедрение по умолчанию, определенное встроенным типом object, называет object.__repr__().

object.__bytes__(self)

Вызывается bytes для вычисления представления объекта byte-строка. При этом должен быть возвращен объект bytes.

object.__format__(self, format_spec)

Названный встроенной функцией format(), и следовательно, оценка formatted string literals и метода str.format(), чтобы произвести «отформатированное» представление строка объекта. Аргумент format_spec - это строка, содержащий описание требуемых параметров форматирования. Интерпретация аргумента format_spec до типа, осуществляющего __format__(), однако большая часть классы будет или делегировать форматирование к одному из встроенных типов или использовать подобный синтаксис параметра форматирования.

См. Мини-язык спецификации формата для описания стандартного синтаксиса форматирования.

Возвращаемое значение должно быть объектом строка.

Изменено в версии 3.4: Само __format__ метод object поднимает TypeError, если пройден какой-либо непустой строка.

Изменено в версии 3.7: object.__format__(x, '') теперь эквивалентен str(x), а не format(str(self), '').

object.__lt__(self, other)
object.__le__(self, other)
object.__eq__(self, other)
object.__ne__(self, other)
object.__gt__(self, other)
object.__ge__(self, other)

Это так называемое «богатое сравнение» методы. Корреспонденция между символами оператора и именами метод следующие: x<y называет x.__lt__(y), x<=y называет x.__le__(y), x==y называет x.__eq__(y), x!=y называет x.__ne__(y), x>y называет x.__gt__(y), и x>=y называет x.__ge__(y).

Богатый метод сравнения может возвратить единичный предмет NotImplemented, если это не осуществляет операцию для данной пары аргументов. В соответствии с соглашением, False и True возвращены для успешного сравнения. Однако эти методы могут возвратить любую стоимость, поэтому если оператор сравнения будет используемый в булевом контекст (например, в условии заявления if), Python назовет bool() на стоимости, чтобы определить, верный ли результат или ложный.

По умолчанию __ne__() делегирует __eq__() и инвертирует результат, если он не является NotImplemented. Других подразумеваемых отношений между операторами сравнения не существует, например, истинность (x<y or x==y) не подразумевает x<=y. Сведения об автоматической генерации операций упорядочивания из одной корневой операции см. в разделе functools.total_ordering().

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

Нет версий swapped-argument этих методы (быть используемый, если левый аргумент не поддерживает операцию, а правый аргумент); скорее, __lt__() и __gt__() являются отражением друг друга, __le__() и __ge__() - отражением друг друга, а __eq__() и __ne__() - собственным отражением. Если операнды имеют разные типы, а тип правого операнда является прямым или косвенным подкласс типа левого операнда, то отраженный метод правого операнда имеет приоритет, в противном случае метод левого операнда имеет приоритет. Виртуальная подкласса не рассматривается.

object.__hash__(self)

Вызывается встроенной функцией hash() и для операций с членами хэшированных коллекций, включая set, frozenset и dict. __hash__() должен возвращать целое число. Единственное необходимое свойство состоит в том, что сравниваемые объекты имеют одинаковое хэш-значение; рекомендуется смешивать хэш- значения компонентов объекта, которые также играют роль в сравнении объектов, путем их упаковки в кортеж и хеширования кортежа. Пример:

def __hash__(self):
    return hash((self.name, self.nick, self.color))

Примечание

hash() усекает стоимость, возвращенную от таможенного __hash__() метод объекта до размера a: c:type:Py_ssize_t. Это, как правило - 8 байтов на 64 битах, строит, и 4 байта на 32 битах строит. Если __hash__() объекта должен взаимодействовать на, строит из различных диаметров долота, несомненно, проверят, что ширина на всех поддержанных строит. Легкий способ сделать это с python -c "import sys; print(sys.hash_info.width)".

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

Определяемые пользователем классы имеют __eq__() и __hash__() методы по умолчанию; с ними все объекты сравнивают неравноценно (кроме самих себя) и x.__hash__() возвращает соответствующее значение, такое, что x == y подразумевает как то x is y, так и hash(x) == hash(y).

класс, который отвергает __eq__() и не определяет __hash__(), установят его __hash__() неявно в None. Когда __hash__() метод класс будет None, сущности класс поднимет соответствующий TypeError, когда программа пытается восстановить их стоимость мешанины и будет также правильно идентифицирована как нехэшируемый, проверяя isinstance(obj, collections.abc.Hashable).

Если класс, который отвергает __eq__(), должен сохранить внедрение __hash__() от родительского класса, интерпретатор нужно сказать это явно, установив __hash__ = <ParentClass>.__hash__.

Если класс, который не переопределяет __eq__(), хочет подавить поддержку хэша, он должен включить __hash__ = None в определение класс. класс, определяющий свой собственный __hash__(), который явно вызывает TypeError, будет неправильно идентифицирован как хэшируемый вызовом isinstance(obj, collections.abc.Hashable).

Примечание

По умолчанию значения __hash__() объектов str и bytes «засолены» с непредсказуемым случайным значением. Хотя они остаются постоянными в рамках отдельного процесса Python, они не предсказуемы между повторными вызовами Python.

Это предназначено, чтобы обеспечить защиту против отказа в обслуживании, вызванного внимательно выбранными исходными данными, которые эксплуатируют худшее исполнение случая dict вставки, O (n^2) сложность. Посмотрите http://www.ocert.org/advisories/ocert-2011-003.html для деталей.

Изменение хэш-значений влияет на порядок итераций наборов. Python никогда не давал гарантий относительно этого заказа (и обычно он варьируется между 32-разрядными и 64-разрядными сборками).

См. также PYTHONHASHSEED.

Изменено в версии 3.3: Рандомизация хеша включена по умолчанию.

object.__bool__(self)

Призван реализовать проверку истинной значения и встроенную операцию bool(); должен возвращать False или True. Когда этот метод не определен, __len__() называют, если он определен, и объект считают верным, если его результат отличный от нуля. Если класс не определяет ни __len__(), ни __bool__(), все его сущности считаются верными.

3.3.2. Настройка доступа признака

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

object.__getattr__(self, name)

Названный, когда доступ признака по умолчанию терпит неудачу с AttributeError (или __getattribute__() поднимает AttributeError, потому что name не признак сущность или признак в дереве класс для self; или __get__() собственности name поднимает AttributeError). Этот метод должен или возвратить (вычисленное) значение атрибута или поднять исключение AttributeError.

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

object.__getattribute__(self, name)

Вызывается безоговорочно для реализации доступа к атрибутам для сущности класс. Если класс также определит __getattr__(), то последнего не позвонят, если __getattribute__() или не назовет его явно или поднимает AttributeError. Это метод должно возвращать (вычисляемое) значение атрибута или вызывать исключение AttributeError. Чтобы избежать бесконечной рекурсии в этом методе, его реализация должна всегда вызывать базовый класс метод с тем же именем для доступа к любым необходимым атрибутам, например, object.__getattribute__(self, name).

Примечание

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

object.__setattr__(self, name, value)

Названный, когда назначение признака предпринято. Это называют вместо нормального механизма (т.е. сохраните стоимость в словаре сущность). name - название атрибута, value - стоимость, которая будет назначена на него.

Если __setattr__() хочет назначить на признак сущность, он должен назвать основной класс метод с тем же именем, например, object.__setattr__(self, name, value).

object.__delattr__(self, name)

Как __setattr__(), но для удаления атрибута вместо назначения. Это должно быть реализовано только в том случае, если del obj.name имеет значение для объекта.

object.__dir__(self)

Вызывается при вызове метода dir() для объекта. Необходимо вернуть последовательность. dir() преобразует возвращенную последовательность в список и сортирует ее.

3.3.2.1. Настройка атрибутов доступа модуля

Специальными именами __getattr__ и __dir__ может быть также используемый, чтобы настроить доступ к признакам модуля. The``__getattr__`` функция на уровне модуля должна принять один аргумент, который является именем атрибута, и вернуть вычисленное значение или поднять AttributeError. Если атрибут не найден в объекте модуля при обычном поиске, т. е. object.__getattribute__(), тогда __getattr__ является найденный в модуле __dict__ прежде, чем поднять AttributeError. Если найдено, это называют с названием атрибута, и результат возвращен.

Функция __dir__ не должна принимать аргументов и возвращать последовательность строки, которая представляет имена, доступные для модуля. Если существующий, эта функция отвергает стандартный поиск dir() на модуле.

Для более мелкой настройки поведения модуля (устанавливающий признаки, свойства, и т.д.), можно установить признак __class__ объекта модуля к подкласс types.ModuleType. Например:

import sys
from types import ModuleType

class VerboseModule(ModuleType):
    def __repr__(self):
        return f'Verbose {self.__name__}'

    def __setattr__(self, attr, value):
        print(f'Setting {attr}...')
        super().__setattr__(attr, value)

sys.modules[__name__].__class__ = VerboseModule

Примечание

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

Изменено в версии 3.5: Атрибут __class__ модуля теперь доступен для записи.

Добавлено в версии 3.7: атрибуты модуля __getattr__ и __dir__.

См.также

PEP 562 - модуль __getattr__ и __dir__ описание функций __getattr__ и __dir__ на модулях.

3.3.2.2. Реализация дескрипторов

Следующие методы только применяются, когда сущность класс, содержащего метод (так называемый класс descriptor), появляется в owner класс (описатель должен быть или в словаре владельца класс или в словаре класс для одного из его родителей). В приведенных ниже примерах «атрибут» относится к атрибуту, имя которого является ключом свойства в классе владельца „<unk>.

object.__get__(self, instance, owner=None)

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

Это метод должно вернуть вычисленное значение атрибута или вызвать исключение AttributeError.

PEP 252 указывает, что __get__() может вызываться с одним или двумя аргументами. Python’s собственные встроенные дескрипторы поддерживают данную спецификацию; однако, вероятно, некоторые сторонние инструменты имеют дескрипторы, которые требуют обоих аргументов. Python’s владеют внедрением __getattribute__(), всегда проходит в обоих аргументах, требуются ли они или нет.

object.__set__(self, instance, value)

Вызывается, чтобы задать для атрибута сущность instance владельца класс новое значение value.

Отметьте, добавив __set__(), или __delete__() изменяет вид описателя к «описателю данных». Дополнительную информацию см. в Вызов дескрипторов.

object.__delete__(self, instance)

Вызывается для удаления атрибута на сущность instance владельца класс.

object.__set_name__(self, owner, name)

Вызывается во время создания владельца класс owner. Дескриптор назначен name.

Примечание

__set_name__() вызывается только неявно как часть конструктора type, поэтому его необходимо будет вызвать явно с соответствующими параметрами, когда дескриптор добавляется в класс после первоначального создания:

class A:
   pass
descr = custom_descriptor()
A.attr = descr
descr.__set_name__(A, 'attr')

Дополнительные сведения см. в разделе Создание объекта класс.

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

Атрибут __objclass__ интерпретируется модулем inspect как указывающий класс, где был определен этот объект (установка этого соответствующего параметра может помочь во время выполнения интроспекции динамических атрибутов класс). Для вызываемых объектов он может указывать, что ожидается или требуется сущность данного типа (или подкласса) в качестве первого позиционного аргумента (например, CPython задает этот атрибут для несвязанных методы, которые реализованы в C).

3.3.2.3. Вызов дескрипторов

В целом описатель - признак объекта с «поведением биндинг», то, доступ признака которого был отвергнут методы в дескрипторном протоколе: __get__(), __set__() и __delete__(). Если какой-либо из тех методы определен для объекта, он, как говорят, описатель.

Поведение по умолчанию для доступа к атрибуту заключается в получении, установке или удалении атрибута из словаря объекта. Например, у a.x есть цепь поиска, начинающаяся с a.__dict__['x'], тогда type(a).__dict__['x'], и продолжающаяся через основной классы type(a), исключая метаклассы.

Однако если проверяемое значение является объектом, определяющим один из методов дескриптора, то Python может переопределить поведение по умолчанию и вместо этого вызвать дескриптор метод. Где это происходит в цепочке приоритетов, зависит от того, какой дескриптор методы был определен и как они были вызваны.

Отправной точкой для вызова дескриптора является привязка, a.x. То, как собираются аргументы, зависит от a:

Прямой вызов самый простой и наименее распространенный вызов - это если пользователь код напрямую вызывает дескрипторный метод: x.__get__(a).

Привязка экземпляра если биндинг с экземпляром объекта, a.x преобразуется в вызов: type(a).__dict__['x'].__get__(a, type(a)).

Привязка класса если биндинг с классом, A.x преобразуется в вызов: A.__dict__['x'].__get__(None, A).

Super Binding If a является сущность super, тогда биндинг super(B, obj).m() ищет obj.__class__.__mro__ класс A непосредственно перед B, а затем вызывает дескриптор с вызовом: A.__dict__['m'].__get__(obj, obj.__class__).

Для привязок сущность приоритет вызова дескриптора зависит от того, какой дескриптор методы определен. Дескриптор может определять любую комбинацию __get__(), __set__() и __delete__(). Если он не определяет __get__(), то доступ к атрибуту вернет сам объект дескриптора, если в словаре сущность объекта нет значения. Если дескриптор определяет __set__() и/или __delete__(), он является дескриптором данных; если он не определяет ни то, ни другое, он не является дескриптором данных. Обычно дескрипторы данных определяют как __get__(), так и __set__(), в то время как дескрипторы, не относящиеся к данным, имеют только __get__() метод. Дескрипторы данных с заданными __set__() и __get__() всегда переопределяют переопределение в словаре сущность. В отличие от этого дескрипторы, не связанные с данными, могут быть переопределены функцией сущности.

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

Функция property() осуществлена как описатель данных. Соответственно, сущности не может отвергнуть поведение собственности.

3.3.2.4. __slots__

__slots__ позволяют нам явно объявлять членов данных (например, свойства) и отказывать в создании __dict__ и __weakref__ (если явно не указано в __slots__ или доступно в родительском.)

Пространство, сэкономленное при использовании __dict__, может быть значительным. Скорость поиска атрибутов также может быть значительно улучшена.

object.__slots__

Этой переменной класс можно назначить строку, итерабль или последовательность строки с именами переменных используемый по сущности. __slots__ резервирует пространство для объявленных переменных и предотвращает автоматическое создание __dict__ и __weakref__ для каждого сущность.

3.3.2.4.1. Примечания по использованию __slots__
  • При наследовании от класс без __slots__ атрибут __dict__ и __weakref__ сущности всегда будет доступен.
  • Без переменной __dict__ сущности нельзя назначить новые переменные, не перечисленные в определении __slots__. Попытки назначить на не включенное в список имя переменной поднимают AttributeError. Если динамическое назначение новых переменных желаемо, то добавьте '__dict__' к последовательности строки в декларации __slots__.
  • Без переменной __weakref__ для каждого случая классы, определяющие __slots__, не поддерживают слабые ссылки на его сущности. Если требуется слабая опорная поддержка, добавьте '__weakref__' в последовательность строки в объявлении __slots__.
  • __slots__ реализуются на уровне класс путем создания дескрипторов (Реализация дескрипторов) для каждого имени переменной. В результате атрибуты класс не могут быть используемый для установки значений по умолчанию для переменных сущность, определенных __slots__; в противном случае атрибут класс перезаписывает назначение дескриптора.
  • Действие объявления __slots__ не ограничивается класс, где оно определено. __slots__, объявленные у родителей, доступны в детских классы. Однако дочерние подклассы получат __dict__ и __weakref__, если они также не определят __slots__ (которые должны содержать только имена любых additional слотов).
  • Если класс определяет место, также определенное в базовом классе, переменная сущность, определенная основным слотом класс, недоступна (кроме, восстанавливая его описатель непосредственно от базового класса). Это отдает значение неопределенной программы. В будущем проверка может быть добавлена, чтобы предотвратить это.
  • Непустые __slots__ не работают для классы, полученных из встроенных типов переменной длины, таких как int, bytes и tuple.
  • Любой non-строка повторяемый может быть назначен на __slots__. Могут также использоваться сопоставления; однако в будущем особое значение может быть присвоено значениям, соответствующим каждому ключу.
  • Назначение __class__ работает только в том случае, если оба классы имеют одинаковый __slots__.
  • Можно использовать множественное наследование с несколькими слотированными родительскими классы, но только один родитель может иметь атрибуты, созданные слотами (другие базы должны иметь пустые макеты слотов) - нарушения поднимают TypeError.
  • Если итератор - используемый для __slots__ тогда, описатель создан для каждого из значения итератора. Однако атрибут __slots__ будет пустым итератором.

3.3.3. Настройка создания класс

Каждый раз, когда класс наследует другому классу, к __init_subclass__ обращаются это класс. Таким образом, возможно написать классы, которые изменяют поведение подклассы. Это тесно связано с декораторами класс, но где декораторы класс только затрагивают определенный класс, к ним относятся, __init_subclass__ только относится к будущему подклассы класс, определяющего метод.

объект. __ init_subclass __ (cls)

Это метод вызывается всякий раз, когда содержащий класс является подклассом. cls - это новый подкласс. Если определено как нормальный метод сущность, этот метод неявно преобразован в класс метод.

Аргументы ключевых слов, заданные новому класс, передаются родительскому класс __init_subclass__. Для совместимости с другими классы, использующими __init_subclass__, необходимо извлечь необходимые аргументы ключевой и передать остальные в базовый класс, как в:

class Philosopher:
    def __init_subclass__(cls, /, default_name, **kwargs):
        super().__init_subclass__(**kwargs)
        cls.default_name = default_name

class AustralianPhilosopher(Philosopher, default_name="Bruce"):
    pass

Внедрение по умолчанию object.__init_subclass__ ничего не делает, но поднимает ошибку, если это называют с какими-либо аргументами.

Примечание

Метакласс намекают, что metaclass потребляется остальной частью оборудования типа и никогда не передается к внедрениям __init_subclass__. К фактическому метакласс (а не явный намек) можно получить доступ как type(cls).

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

3.3.3.1. Метаклассы

По умолчанию классы создаются с помощью type(). Тело класс выполняется в новом пространстве имен, а имя класс привязывается локально к результату type(name, bases, namespace).

Процесс создания класс можно настроить путем передачи аргумента metaclass ключевой в строку определения класс или путем наследования от существующего класс, включавшего такой аргумент. В следующем примере и MyClass и MySubclass - сущности Meta:

class Meta(type):
    pass

class MyClass(metaclass=Meta):
    pass

class MySubclass(MyClass):
    pass

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

При выполнении определения класс выполняются следующие шаги:

  • Записи MRO решены;
  • соответствующий метакласс определен;
  • пространство имен класс подготовлено;
  • тело класс выполнено;
  • объект класс создан.

3.3.3.2. Разрешение MRO записей

Если основой, которая появляется в определении класс, не является сущность type, то __mro_entries__ метод - найденный на нем. Если он найден, он вызывается с исходным кортежем баз. Эта метод должна возвращать кортеж классы, который будет используемый вместо этой базы. Кортеж может быть пустым, в таком случае исходная база игнорируется.

См.также

PEP 560 - основная поддержка типизации модулей и универсальных типов

3.3.3.3. Определение соответствующего метакласса

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

  • если оснований и явных метакласс не дано, то используется type();
  • если явный метакласс дан, и это - не сущность type(), то это - используемый непосредственно как метакласс;
  • если сущность type() дан как явный метакласс, или основания определены, то наиболее полученный метакласс - используемый.

Наиболее полученный метакласс отобран из явно указанного метакласс (если таковые имеются) и метаклассы (т.е. type(cls)) всего указанного основного классы. Наиболее полученный метакласс - тот, который является подтипом all этих метаклассов кандидата. Если ни один из метаклассов кандидата не будет соответствовать тому критерию, то определение класс потерпит неудачу с TypeError.

3.3.3.4. Подготовка пространства имен класса

После идентификации соответствующего метакласс подготавливается пространство имен класс. Если метакласс имеет атрибут __prepare__, он вызывается как namespace = metaclass.__prepare__(name, bases, **kwds) (где дополнительные аргументы ключевой, если таковые имеются, берутся из определения класс). Метод __prepare__ должен быть реализован как a classmethod(). Пространство имён, возвращаемое __prepare __ `` передается в ``__new__, но когда создается последний объект класса, пространство имен копируется в новый dict.

Если метакласс не имеет атрибута __prepare__, то пространство имен класс инициализируется как пустое упорядоченное отображение.

См.также

PEP 3115 - метаклассы в Python 3000 представлен hook пространства имен __prepare__

3.3.3.5. Выполнение тела класса

Тело класс выполняется (приблизительно) как exec(body, globals(), namespace). Основное отличие от нормального требования до exec() - то, что лексический обзор позволяет тело класс (включая любые методы) к справочным названиям от текущего и внешнего области видимости, когда определение класс происходит в функции.

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

3.3.3.6. Создание объекта класс

Как только пространство имен класс заполнено выполнением тела класс, объект класс создается вызовом metaclass(name, bases, namespace, **kwds) (переданные здесь дополнительные ключевые слова совпадают с переданными в __prepare__).

Этот объект класс является объектом, на который будет ссылаться форма нулевого аргумента super(). __class__ является неявной ссылкой на замыкание, созданной компилятором, если какая-либо методы в теле класс ссылается либо на __class__, либо на super. Это позволяет нулевой форме аргумента super() правильно определять класс, определяемый на основе лексического обзора, в то время как класс или сущность, который был используемый, чтобы сделать текущий вызов, определены на основе первого аргумента, переданного к метод.

Детали реализации CPython: В CPython 3.6 и более поздних версиях ячейка __class__ передается метакласс в качестве записи __classcell__ в пространстве имен класс. Если он присутствует, он должен распространяться до type.__new__ вызова, чтобы инициализировать класс правильно. Если этого не сделать, это приведет к RuntimeError в Python 3.8.

При использовании метакласс type по умолчанию или любого метакласс, который в конечном итоге вызывает type.__new__, после создания объекта класс инициируются следующие дополнительные шаги настройки:

  • сначала type.__new__ собирает все дескрипторы в пространстве имен класс, которые определяют метод __set_name__(); во-вторых, все эти __set_name__ методы вызываются с определяемым класс и присвоенным именем этого конкретного дескриптора; наконец, крюк __init_subclass__() называют на непосредственном родителе нового класс в его заказе резолюции метод.

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

Когда новый класс создан type.__new__, объект, обеспеченный, поскольку параметр пространства имен скопирован к новому заказанному отображению, и от оригинального объекта отказываются. Новая копия помещается в прокси, доступный только для чтения, который становится атрибутом __dict__ объекта класс.

См.также

PEP 3135 - новый super описывает неявную ссылку закрытия __class__

3.3.3.7. Использование для метаклассов

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

3.3.4. Настройка сущности и проверок подкласса

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

В частности, метакласс abc.ABCMeta осуществляет эти методы, чтобы позволить добавление абстрактных базовых классов (ABC) как «виртуальные базовые классы» к любому класс или типу (включая встроенные типы), включая другой ABCs.

class.__instancecheck__(self, instance)

Возвратитесь верный, если instance нужно считать (прямым или косвенным) сущность class. Если определено, вызывается для реализации isinstance(instance, class).

class.__subclasscheck__(self, subclass)

Возвратитесь верный, если subclass нужно считать (прямым или косвенным) подкласс class. Если определено, вызывается для реализации issubclass(subclass, class).

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

См.также

PEP 3119 - представление абстрактных базовых классов включает спецификацию для настройки isinstance() и поведения issubclass() через __instancecheck__() и __subclasscheck__() с мотивацией для этой функциональности в контекст добавления абстрактных базовых классов (см. модуль abc) на язык.

3.3.5. Эмуляция универсальных типов

Можно осуществить универсальный синтаксис класс, как определено PEP 484 (например, List[int]), определив специальный метод:

classmethod object.__class_getitem__(cls, key)

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

Эта метод просматривается на самом объекте класс, и при определении в теле класс эта метод неявно является класс метод. Обратите внимание, что этот механизм в основном зарезервирован для использования со статическими подсказками типа, другое использование не рекомендуется.

См.также

PEP 560 - основная поддержка типизации модулей и универсальных типов

3.3.6. Эмуляция вызываемых объектов

object.__call__(self[, args...])

Вызывается, когда сущность называется как функция; если этот метод определен, x(arg1, arg2, ...) является кратким для x.__call__(arg1, arg2, ...).

3.3.7. Эмуляция контейнерным типами

Следующий методы может быть определен, чтобы осуществить контейнерные объекты. Контейнеры обычно представляют собой последовательности (например, списки или кортежи) или сопоставления (например, словари), но могут также представлять другие контейнеры. Первый набор методы - используемый или чтобы подражать последовательности или подражать отображению; различие - то, что для последовательности, допустимые ключи должны быть целыми числами k, для которого, 0 <= k < N где N - длина последовательности или объекты части, которые определяют ряд предметов. Также рекомендуется, чтобы сопоставления обеспечивали поведение методы keys(), values(), items(), get(), clear(), setdefault(), pop(), popitem(), copy(), update() и Python’s, аналогичное поведению для стандартных объектов словаря. Модуль collections.abc обеспечивает абстрактный основной класс MutableMapping, чтобы помочь создать те методы из основного набора __getitem__(), __setitem__(), __delitem__() и keys(). Изменчивые последовательности должны обеспечить методы append(), count(), index(), extend(), insert(), pop(), remove(), reverse() и sort(), как стандартные объекты списка Python. Наконец, типы последовательности должны осуществить дополнение (значение связи) и умножение (значение повторения), определив методы __add__(), __radd__(), __iadd__(), __mul__(), __rmul__() и __imul__(), описанный ниже; они не должны определять другие числовые операторы. Рекомендуется, чтобы как отображения, так и последовательности реализовывали __contains__() метод для обеспечения эффективного использования оператора in; для отображений in должен искать ключи отображения; для последовательностей следует выполнять поиск по значениям. Рекомендуется также, чтобы как отображения, так и последовательности реализовывали __iter__() метод для обеспечения эффективной итерации через контейнер; для сопоставлений, __iter__() должен повторяться через ключи объекта; для последовательностей следует выполнять итерацию по значениям.

object.__len__(self)

Вызывается для реализации встроенной функции len(). Возвращает длину объекта, целое число >= 0. Кроме того, объект, который не определяет __bool__() метод и чей __len__() метод возвращает ноль, считается ложным в булевом контекст.

Детали реализации CPython: В CPython длина должна быть не более sys.maxsize. Если длина превышает sys.maxsize, некоторые элементы (например, len()) могут поднять OverflowError. Чтобы предотвратить подъем OverflowError тестированием стоимости правды, объект должен определить __bool__() метод.

object.__length_hint__(self)

Вызывается для реализации operator.length_hint(). Возвращает расчетную длину объекта (которая может быть больше или меньше фактической длины). Длина должна быть целым числом >= 0. Возвращаемое значение также может быть равно NotImplemented, которое обрабатывается так же, как если бы __length_hint__ метод не существовало вообще. Это метод является чисто оптимизацией и никогда не требуется для корректности.

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

Примечание

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

a[1:2] = b

переведен к:

a[slice(1, 2, None)] = b

и так далее. Отсутствующие элементы фрагмента всегда заполняются None.

object.__getitem__(self, key)

Призван проводить оценку self[key]. Для типов последовательностей принятыми ключами должны быть целые числа и секущие объекты. Обратите внимание, что специальная интерпретация отрицательных индексов (если класс хочет эмулировать тип последовательности) до __getitem__() метод. Если key имеет несоответствующий тип, TypeError может быть поднят; если из стоимости вне набора индексов для последовательности (после какой-либо специальной интерпретации отрицательных величин), IndexError должен быть поднят. Для типов сопоставления, если key отсутствует (не в контейнере), следует поднять KeyError.

Примечание

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

object.__setitem__(self, key, value)

Вызывается для реализации назначения self[key]. Та же заметка, что и для __getitem__(). Это должно быть реализовано только для сопоставлений, если объекты поддерживают изменения значений ключей или если можно добавить новые ключи, или для последовательностей, если элементы могут быть заменены. Для неправильных значений key следует создать те же исключения, что и для __getitem__() метод.

object.__delitem__(self, key)

Вызывается для выполнения удаления self[key]. Та же заметка, что и для __getitem__(). Это должно быть реализовано только для сопоставлений, если объекты поддерживают удаление ключей, или для последовательностей, если элементы могут быть удалены из последовательности. Для неправильных значений key следует создать те же исключения, что и для __getitem__() метод.

object.__missing__(self, key)

Вызывается dict.__getitem__() для реализации функции self[key] for dict подклассы, если ключ отсутствует в словаре.

object.__iter__(self)

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

Объекты итератора также должны реализовать этот метод; они обязаны вернуться сами. Дополнительные сведения об объектах итератора см. в разделе Типы итератора.

object.__reversed__(self)

Вызывается (если присутствует) встроенной функцией reversed() для реализации обратной итерации. Он должен вернуть новый объект итератора, который итерируется по всем объектам в контейнере в обратном порядке.

Если __reversed__() метод не будет обеспечен, то встроенное reversed() отступит к использованию протокола последовательности (__len__() и __getitem__()). Объекты, поддерживающие протокол последовательности, должны предоставлять __reversed__() только в том случае, если они могут обеспечить реализацию, более эффективную, чем та, которая предоставляется reversed().

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

object.__contains__(self, item)

Названный, чтобы осуществить членство проверяют операторов. Должен возвратиться верный, если item находится в self, ложном иначе. Для отображения объектов это должно рассмотреть ключи отображения, а не ценностей или пар ключевого предмета.

Для объектов, которые не определяют __contains__(), тест членства сначала пытается итерацию через __iter__(), затем старый протокол итерации последовательности через __getitem__(), см. раздел этот раздел в языкового справочника.

3.3.8. Эмуляция числовым типам

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

object.__add__(self, other)
object.__sub__(self, other)
object.__mul__(self, other)
object.__matmul__(self, other)
object.__truediv__(self, other)
object.__floordiv__(self, other)
object.__mod__(self, other)
object.__divmod__(self, other)
object.__pow__(self, other[, modulo])
object.__lshift__(self, other)
object.__rshift__(self, other)
object.__and__(self, other)
object.__xor__(self, other)
object.__or__(self, other)

Эти методы вызваны для реализации бинарных арифметических операций (+,``-, ``*, @, /, //, %, divmod(), pow(), **, <<, >>, &, ^, |). Например, чтобы вычислить выражение x + y, где x сущность класса у которого есть метод __add__(), вызывается x.__add__(y). Метод __divmod__() должен быть эквивалентен использованию __floordiv__' и :meth:`__mod__(); он не должен быть связан с __truediv__(). Обратите внимание, что __pow__() должен быть определен, чтобы принять дополнительный третий аргумент, если тернарная версия встроенной функции pow() должна быть поддержана.

Если один из этих методы не поддерживает операцию с предоставленными аргументами, он должен возвращать NotImplemented.

object.__radd__(self, other)
object.__rsub__(self, other)
object.__rmul__(self, other)
object.__rmatmul__(self, other)
object.__rtruediv__(self, other)
object.__rfloordiv__(self, other)
object.__rmod__(self, other)
object.__rdivmod__(self, other)
object.__rpow__(self, other[, modulo])
object.__rlshift__(self, other)
object.__rrshift__(self, other)
object.__rand__(self, other)
object.__rxor__(self, other)
object.__ror__(self, other)

Эти методы называют, чтобы осуществить операции по двоичной арифметике (+, -, *, @, /, //, %, divmod(), pow(), **, <<, >>, &, ^, |) с отраженными (обменянными) операндами. Эти функции вызываются только в том случае, если левый операнд не поддерживает соответствующую операцию [3] и операнды имеют различные типы. [4], например, чтобы оценить выражение x - y, где y - сущность класс, у которого есть метод __rsub__(), y.__rsub__(x), называют, если x.__sub__(y) возвращает NotImplemented.

Обратите внимание, что ternary pow() не будет пытаться вызвать __rpow__() (правила принуждения стали бы слишком сложными).

Примечание

Если тип правильного операнда будет подкласс типа левого операнда и что подкласс обеспечивает отраженный метод для операции, этот метод назовут, прежде чем левый операнд не отразил метод. Это поведение позволяет подклассы отвергать действия их предков.

object.__iadd__(self, other)
object.__isub__(self, other)
object.__imul__(self, other)
object.__imatmul__(self, other)
object.__itruediv__(self, other)
object.__ifloordiv__(self, other)
object.__imod__(self, other)
object.__ipow__(self, other[, modulo])
object.__ilshift__(self, other)
object.__irshift__(self, other)
object.__iand__(self, other)
object.__ixor__(self, other)
object.__ior__(self, other)

Эти методы называют, чтобы осуществить увеличенные арифметические назначения (+=, -=, *=, @=, /=, //=, %=, **=, <<=, >>=, &=, ^=, |=). Эти методы должны попытаться сделать оперативную операцию (изменяющий self) и возвратить результат (который мог быть, но не должен быть, self). Если определенный метод не определен, увеличенное назначение отступает к нормальному методы. Например, если x - сущность класс с методом __iadd__(), x += y эквивалентен x = x.__iadd__(y). Иначе x.__add__(y) и y.__radd__(x) рассматривают, как с оценкой x + y. В определенных ситуациях увеличенное назначение может привести к неожиданным ошибкам (см. Почему a_tuple[i] += [„item“] создает исключение при работе сложения?), но это поведение - на самом деле часть модели данных.

object.__neg__(self)
object.__pos__(self)
object.__abs__(self)
object.__invert__(self)

Вызывается для реализации унарных арифметических операций (-, +, abs() и ~).

object.__complex__(self)
object.__int__(self)
object.__float__(self)

Вызывается для реализации встроенных функций complex(), int() и float(). Возвращает значение соответствующего типа.

object.__index__(self)

Вызывается для реализации operator.index() и всякий раз, когда Python должен без потерь преобразовать числовой объект в целочисленный объект (например, в секционировании или в встроенных функциях bin(), hex() и oct()). Присутствие этого метод указывает, что числовой объект - целочисленный тип. Должен возвращать целое число.

Если __int__(), __float__() и __complex__() не определены, то соответствующие встроенные функции int(), float() и complex() возвращаются к __index__().

object.__round__(self[, ndigits])
object.__trunc__(self)
object.__floor__(self)
object.__ceil__(self)

Названный, чтобы осуществить встроенную функцию round() и math функционируют trunc(), floor() и ceil(). Если ndigits не передан к __round__(), все эти методы должны возвратить ценность объекта, усеченного к Integral (как правило, int).

Если __int__() не определен, то встроенная функция int() возвращается к __trunc__().

3.3.9. Оператор with контекстных менеджеров

context manager - это объект, определяющий время выполнения контекст, которое должно быть установлено при выполнении with оператор. Менеджер контекст обращается с входом в, и выход из, желаемый контекст во время выполнения для выполнения блока код. Менеджеры контекста обычно вызываются с использованием with оператор (описано в разделе Оператор with), но также могут быть используемый путем прямого вызова их методы.

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

Дополнительные сведения о менеджерах контекст см. в разделе Типы менеджера контекста.

object.__enter__(self)

Войдите в контекст во время выполнения, связанный с этим объектом. Функция with оператор свяжет возвращаемое значение этого метода с целевыми объектами, указанными в предложении as инструкции, если таковое имеется.

object.__exit__(self, exc_type, exc_value, traceback)

Выйдите из контекст во время выполнения, связанного с этим объектом. Параметры описывают исключение, вызвавшее выход контекст. Если контекст был завершен без исключения, все три аргумента будут None.

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

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

См.также

PEP 343 - «с» оператор спецификация, фон и примеры для Python with оператор.

3.3.10. Специальный поиск метод

Для таможенных классов неявные просьбы специального методы, как только гарантируют, будут работать правильно, если определено над типом объекта, не в словаре объекта сущность. То поведение - причина, почему следующий код поднимает исключение:

>>> class C:
...     pass
...
>>> c = C()
>>> c.__len__ = lambda: 5
>>> len(c)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: object of type 'C' has no len()

В основе такого поведения лежит ряд специальных методы, таких как __hash__() и __repr__(), которые реализуются всеми объектами, включая объекты типа. Если бы неявный поиск их методы используемый обычный процесс поиска, они потерпели бы неудачу, когда они призваны на сам объект типа:

>>> 1 .__hash__() == hash(1)
True
>>> int.__hash__() == hash(int)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: descriptor '__hash__' of 'int' object needs an argument

Неправильная попытка вызвать таким образом несвязанную метод класс иногда упоминается как «метакласс путаница» и избегается путем обхода сущность при поиске специальных методов:

>>> type(1).__hash__(1) == hash(1)
True
>>> type(int).__hash__(int) == hash(int)
True

В дополнение к обходу любых признаков сущность в интересах правильности неявный специальный поиск метод обычно также обходит __getattribute__() метод даже метакласса объекта:

>>> class Meta(type):
...     def __getattribute__(*args):
...         print("Metaclass getattribute invoked")
...         return type.__getattribute__(*args)
...
>>> class C(object, metaclass=Meta):
...     def __len__(self):
...         return 10
...     def __getattribute__(*args):
...         print("Class getattribute invoked")
...         return object.__getattribute__(*args)
...
>>> c = C()
>>> c.__len__()                 # Явный поиск через сущность
Class getattribute invoked
10
>>> type(c).__len__(c)          # Явный поиск через тип
Metaclass getattribute invoked
10
>>> len(c)                      # Неявный поиск
10

Обход оборудования __getattribute__() этим способом обеспечивает значительный область видимости для оптимизаций скорости в переводчике, за счет некоторой гибкости в обработке специального методы (специальный метод must быть установленным на самом объекте класс, чтобы последовательно призываться переводчиком).

3.4. Корутины

3.4.1. Await объекты

Объект awaitable обычно осуществляет __await__() метод. Объекты корутины, возвращенные из функций async def, awaitable.

Примечание

Объекты генератор итератор возвратились из генераторов, украшенных types.coroutine(), или asyncio.coroutine() также awaitable, но они не осуществляют __await__().

object.__await__(self)

Должен вернуть итератор. Должен быть используемый, чтобы осуществить объекты awaitable. Например, asyncio.Future осуществляет этот метод, чтобы быть совместимым с выражением await.

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

См.также

PEP 492 for additional information about awaitable objects.

3.4.2. Объекты корутины

Корутины объекты являются awaitable объектами. Выполнение корутины может управляться вызовом __await__() и итерацией по результату. Когда сопрограмма закончила выполнять и прибыль, итератор поднимает StopIteration, и признак value исключения держит возвращаемое значение. Если корутина вызывает исключение, оно распространяется итератором. Корутины не должны прямо выдвигать необработанные StopIteration исключения.

Корутины также имеют перечисленные ниже методы, которые аналогичны таковым генераторов (см. Методы генератора-итератора). Однако, в отличие от генераторов, корутины не поддерживают непосредственно итерацию.

Изменено в версии 3.5.2: Это RuntimeError, чтобы await на корутине не один раз.

coroutine.send(value)

Запуски или выполнение возобновляет сопрограммы. Если value - None, это эквивалентно продвижению итератора, возвращенного __await__(). Если value не None, этот метод делегаты в send() метод итератора, который заставил сопрограмму приостанавливать. Результат (возвращаемое значение, StopIteration или другое исключение) совпадает с, повторяя по возвращаемому значению __await__(), описанному выше.

coroutine.throw(type[, value[, traceback]])

Поднимает указанное исключение в сопрограмме. Этот метод делегирует к throw() метод итератора, который заставил сопрограмму приостанавливать, если у этого есть такой метод. Иначе исключение поднято в точке приостановки. Результат (возвращаемое значение, StopIteration или другое исключение) совпадает с, повторяя по возвращаемому значению __await__(), описанному выше. Если исключение не поймано в сопрограмме, оно размножается назад посетителю.

coroutine.close()

Заставляет корутину очистить себя и выйти. Если сопрограмма приостановлена, этот метод сначала делегирует к close() метод итератора, который заставил сопрограмму приостанавливать, если у этого есть такой метод. Затем он поднимает GeneratorExit в точке подвески, заставляя корутину немедленно очиститься. Наконец, корутину помечается как завершивший выполнение, даже если он никогда не был запущен.

Объекты корутины автоматически закрываются с помощью вышеописанного процесса, когда они собираются быть уничтоженными.

3.4.3. Асинхронные итераторы

Асинхронный итератор может вызывать асинхронные код в своих __anext__ метод.

Асинхронные итераторы можно использовать в async for оператор.

object.__aiter__(self)

Должен возвратить объект асинхронный итератор.

object.__anext__(self)

Должен возвратить awaitable, приводящий к следующей значения итератора. Должно вызвать ошибку StopAsyncIteration, когда итерация закончена.

Пример асинхронного итерабельного объекта:

class Reader:
    async def readline(self):
        ...

    def __aiter__(self):
        return self

    async def __anext__(self):
        val = await self.readline()
        if val == b'':
            raise StopAsyncIteration
        return val

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

Изменено в версии 3.7: До Python 3.7 __aiter__ может вернуть awaitable, который решит асинхронный итератор.

Начиная с Python 3.7, __aiter__ должен возвращать асинхронный объект итератора. Возврат чего-либо другого приведет к ошибке TypeError.

3.4.4. Асинхронные контекстные менеджеры

Асинхронный менеджер контекста - это контекстный менеджер, который может приостановить выполнение в своих __aenter__ и __aexit__ методы.

Асинхронные менеджеры контекст могут быть используемый в async with оператор.

object.__aenter__(self)

Семантически подобный __enter__(), единственная разница, являющаяся этим, это должно возвратить awaitable.

object.__aexit__(self, exc_type, exc_value, traceback)

Семантически похожа на __exit__(), единственное отличие состоит в том, что она должна возвращать awaitable.

Пример асинхронного класса менеджера контекст:

class AsyncContextManager:
    async def __aenter__(self):
        await log('entering context')

    async def __aexit__(self, exc_type, exc, tb):
        await log('exiting context')

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

Сниоски

[1]Это is возможный в некоторых случаях, чтобы изменить тип объекта, под определенным условия, которыми управляют. Это, как правило, нехорошая идея, так как она может привести к какому-то очень странному поведению, если с ней обращаться неправильно.
[2]__hash__(), __iter__(), __reversed__(), и __contains__() методы иметь для этого специальное обращение; другие все еще поднимут TypeError, но могут сделать так, полагаясь на поведение, что None не подлежащий выкупу.
[3]«Не поддерживает» здесь означает, что класс не имеет такого метода, или метод возвращает NotImplemented. Не устанавливайте метод в None, если вы хотите вызвать отступление к отраженному методу правильного операнда - который будет вместо этого иметь противоположный эффект явно blocking такое отступление.
[4]Для операндов того же типа предполагается, что если не отражённый метод (например, __add__()) не удается выполнить операцию, поэтому отраженный метод не вызывается.