datamodel.md

1> **Источник:** https://python-all.ru/3.15/reference/datamodel.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# 3. Модель данных89## 3.1. Объекты, значения и типы1011*Объекты* – это абстракция Python для данных. Все данные в программе Python представлены объектами или отношениями между объектами. Даже код представлен объектами.1213Каждый объект имеет идентификатор, тип и значение. *Идентификатор* объекта никогда не меняется после создания; его можно рассматривать как адрес объекта в памяти. Оператор [`is`](https://python-all.ru/3.15/reference/expressions.html#is) сравнивает идентификаторы двух объектов; функция [`id()`](https://python-all.ru/3.15/library/functions.html#id) возвращает целое число, представляющее его идентификатор.1415**Особенность реализации CPython:** Для CPython `id(x)` – это адрес памяти, где хранится `x`.1617Тип объекта определяет, какие операции он поддерживает (например, «есть ли у него длина?»), а также задаёт возможные значения для объектов этого типа. Функция [`type()`](https://python-all.ru/3.15/library/functions.html#type) возвращает тип объекта (который сам является объектом). Как и идентификатор, *тип* объекта также неизменен. [\[1\]](https://python-all.ru/3.15/reference/datamodel.html#id20)1819*Значение* некоторых объектов может изменяться. Объекты, значение которых может изменяться, называются *изменяемыми*; объекты, значение которых неизменно после создания, называются *неизменяемыми*. (Значение неизменяемого объекта-контейнера, содержащего ссылку на изменяемый объект, может измениться при изменении последнего; однако контейнер всё равно считается неизменяемым, потому что набор содержащихся в нём объектов изменить нельзя. Таким образом, неизменяемость не тождественна неизменности значения – это тоньше.) Изменяемость объекта определяется его типом; например, числа, строки и кортежи неизменяемы, а словари и списки изменяемы.2021Объекты никогда не уничтожаются явно; однако, когда они становятся недостижимыми, они могут быть собраны сборщиком мусора. Реализация может откладывать сборку мусора или вовсе её не выполнять – качество реализации определяет, как именно реализована сборка мусора, при условии, что не собираются объекты, которые всё ещё достижимы.2223**Особенность реализации CPython:** В CPython в настоящее время используется схема подсчёта ссылок с (опциональным) отложенным обнаружением циклически связанного мусора, которая собирает большинство объектов, как только они становятся недостижимыми, но не гарантирует сборку мусора, содержащего циклические ссылки. Обратитесь к документации модуля [`gc`](https://python-all.ru/3.15/library/gc.html#module-gc) для получения информации об управлении сборкой циклического мусора. Другие реализации работают иначе, и CPython может измениться. Не полагайтесь на немедленную финализацию объектов после их становления недостижимыми (поэтому файлы всегда следует явно закрывать).2425Обратите внимание, что использование средств трассировки или отладки реализации может поддерживать объекты живыми, которые в обычных условиях были бы собираемыми. Также обратите внимание, что перехват исключения с помощью оператора [`try`](https://python-all.ru/3.15/reference/compound_stmts.html#try)…[`except`](https://python-all.ru/3.15/reference/compound_stmts.html#except) может поддерживать объекты живыми.2627Некоторые объекты содержат ссылки на «внешние» ресурсы, такие как открытые файлы или окна. Подразумевается, что эти ресурсы освобождаются при сборке мусора объекта, но поскольку сборка мусора не гарантируется, такие объекты также предоставляют явный способ освобождения внешнего ресурса – обычно это метод `close()`. Настоятельно рекомендуется явно закрывать такие объекты. Оператор [`try`](https://python-all.ru/3.15/reference/compound_stmts.html#try)…[`finally`](https://python-all.ru/3.15/reference/compound_stmts.html#finally) и оператор [`with`](https://python-all.ru/3.15/reference/compound_stmts.html#with) предоставляют удобные способы сделать это.2829Некоторые объекты содержат ссылки на другие объекты; они называются *контейнерами*. Примерами контейнеров являются кортежи, списки и словари. Ссылки являются частью значения контейнера. В большинстве случаев, когда мы говорим о значении контейнера, мы подразумеваем значения, а не идентификаторы содержащихся объектов; однако, когда мы говорим об изменяемости контейнера, подразумеваются только идентификаторы непосредственно содержащихся объектов. Таким образом, если неизменяемый контейнер (например, кортеж) содержит ссылку на изменяемый объект, его значение изменяется при изменении этого изменяемого объекта.3031Типы влияют почти на все аспекты поведения объектов. Даже значение идентификатора объекта в некотором смысле зависит от типа: для неизменяемых типов операции, вычисляющие новые значения, могут фактически возвращать ссылку на любой существующий объект с тем же типом и значением, в то время как для изменяемых объектов это недопустимо. Например, после `a = 1; b = 1`, *a* и *b* могут ссылаться как на один и тот же объект со значением единицы, так и на разные – в зависимости от реализации. Это потому, что [`int`](https://python-all.ru/3.15/library/functions.html#int) является неизменяемым типом, поэтому ссылку на `1` можно использовать повторно. Такое поведение зависит от реализации, поэтому на него не стоит полагаться, но о нём следует знать при использовании проверок идентичности объектов. Однако после `c = []; d = []`, *c* и *d* гарантированно ссылаются на два разных, уникальных, только что созданных пустых списка. (Обратите внимание, что `e = f = []` присваивает *тот же* объект и *e*, и *f*.)3233## 3.2. Стандартная иерархия типов3435Ниже приведён список типов, встроенных в Python. Модули расширения (написанные на C, Java или других языках в зависимости от реализации) могут определять дополнительные типы. Будущие версии Python могут добавлять типы в иерархию (например, рациональные числа, эффективно хранимые массивы целых чисел и т.д.), хотя такие дополнения чаще будут предоставляться через стандартную библиотеку.3637Некоторые описания типов ниже содержат абзац, перечисляющий «специальные атрибуты». Это атрибуты, обеспечивающие доступ к реализации и не предназначенные для общего использования. Их определение может измениться в будущем.3839### 3.2.1. None4041Этот тип имеет единственное значение. Существует только один объект с этим значением. Доступ к этому объекту осуществляется через встроенное имя `None`. Он используется для обозначения отсутствия значения во многих ситуациях, например, возвращается из функций, которые явно ничего не возвращают. Его логическое значение – ложь.4243### 3.2.2. NotImplemented4445Этот тип имеет единственное значение. Существует только один объект с этим значением. Доступ к объекту осуществляется через встроенное имя [`NotImplemented`](https://python-all.ru/3.15/library/constants.html#NotImplemented). Числовые методы и методы расширенного сравнения должны возвращать это значение, если они не реализуют операцию для предоставленных операндов. (Интерпретатор затем попробует отражённую операцию или другой запасной вариант в зависимости от оператора.) Его не следует вычислять в логическом контексте.4647См. [Реализация арифметических операций](https://python-all.ru/3.15/library/numbers.html#implementing-the-arithmetic-operations) для получения дополнительных сведений.4849Изменено в версии 3.9: Вычисление [`NotImplemented`](https://python-all.ru/3.15/library/constants.html#NotImplemented) в логическом контексте было объявлено устаревшим.5051Изменено в версии 3.14: Вычисление [`NotImplemented`](https://python-all.ru/3.15/library/constants.html#NotImplemented) в логическом контексте теперь вызывает [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError). Ранее оно вычислялось в [`True`](https://python-all.ru/3.15/library/constants.html#True) и выдавало [`DeprecationWarning`](https://python-all.ru/3.15/library/exceptions.html#DeprecationWarning) начиная с Python 3.9.5253### 3.2.3. Ellipsis5455Этот тип имеет единственное значение. Существует только один объект с этим значением. Доступ к объекту осуществляется через литерал `...` или встроенное имя `Ellipsis`. Его логическое значение – истина.5657### 3.2.4. [`numbers.Number`](https://python-all.ru/3.15/library/numbers.html#numbers.Number)5859Они создаются числовыми литералами и возвращаются в результате работы арифметических операторов и встроенных арифметических функций. Числовые объекты неизменяемы; после создания их значение никогда не меняется. Числа в Python, конечно, тесно связаны с математическими числами, но подвержены ограничениям числового представления в компьютерах.6061Строковые представления числовых классов, вычисляемые [`__repr__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__repr__) и [`__str__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__str__), обладают следующими свойствами:6263- Они являются допустимыми числовыми литералами, которые при передаче в конструктор своего класса создают объект со значением исходного числа.64- Представление, когда возможно, даётся по основанию 10.65- Ведущие нули не отображаются, за возможным исключением одного нуля перед десятичной точкой.66- Замыкающие нули не отображаются, за возможным исключением одного нуля после десятичной точки.67- Знак отображается только для отрицательных чисел.6869Python различает целые числа, числа с плавающей точкой и комплексные числа:7071#### 3.2.4.1. [`numbers.Integral`](https://python-all.ru/3.15/library/numbers.html#numbers.Integral)7273Они представляют элементы из математического множества целых чисел (положительных и отрицательных).7475> **Примечание**76>77> Правила представления целых чисел призваны давать наиболее осмысленную интерпретацию операций сдвига и маскирования, в которых участвуют отрицательные целые числа.7879Существует два типа целых чисел:8081**Целые числа ([`int`](https://python-all.ru/3.15/library/functions.html#int))**8283Они представляют числа в неограниченном диапазоне, ограниченном лишь доступной (виртуальной) памятью. Для операций сдвига и маскирования используется двоичное представление, а отрицательные числа представляются в варианте дополнительного кода, который создаёт иллюзию бесконечной строки знаковых битов, уходящей влево.8485**Булевы значения ([`bool`](https://python-all.ru/3.15/library/functions.html#bool))**8687Они представляют истинностные значения False и True. Два объекта, представляющие значения `False` и `True`, являются единственными булевыми объектами. Булев тип является подтипом целочисленного типа, и булевы значения ведут себя как значения 0 и 1 соответственно почти во всех контекстах, за исключением того, что при преобразовании в строку возвращаются строки `"False"` или `"True"` соответственно.8889#### 3.2.4.2. [`numbers.Real`](https://python-all.ru/3.15/library/numbers.html#numbers.Real) ([`float`](https://python-all.ru/3.15/library/functions.html#float))9091Они представляют машинные числа с плавающей точкой двойной точности. По поводу принимаемого диапазона и обработки переполнения вы полностью зависите от архитектуры базовой машины (и реализации на C или Java). Python не поддерживает числа с плавающей точкой одинарной точности; экономия процессора и памяти, которая обычно является причиной их использования, ничтожна по сравнению с накладными расходами на использование объектов в Python, поэтому нет смысла усложнять язык двумя видами чисел с плавающей точкой.9293#### 3.2.4.3. [`numbers.Complex`](https://python-all.ru/3.15/library/numbers.html#numbers.Complex) ([`complex`](https://python-all.ru/3.15/library/functions.html#complex))9495Они представляют комплексные числа как пару машинных чисел с плавающей точкой двойной точности. Для них действуют те же оговорки, что и для чисел с плавающей точкой. Действительная и мнимая части комплексного числа `z` доступны через атрибуты только для чтения `z.real` и `z.imag`.9697### 3.2.5. Последовательности9899Они представляют конечные упорядоченные множества, индексируемые неотрицательными числами. Встроенная функция [`len()`](https://python-all.ru/3.15/library/functions.html#len) возвращает количество элементов последовательности. Если длина последовательности равна *n*, то множество индексов содержит числа 0, 1, …, *n*-1. Элемент *i* последовательности *a* выбирается с помощью `a[i]`. Некоторые последовательности, включая встроенные, интерпретируют отрицательные индексы, прибавляя длину последовательности. Например, `a[-2]` равно `a[n-2]` – предпоследнему элементу последовательности a длины `n`.100101Результирующее значение должно быть неотрицательным целым числом, меньшим количества элементов в последовательности. Если это не так, возбуждается [`IndexError`](https://python-all.ru/3.15/library/exceptions.html#IndexError).102103Последовательности также поддерживают срезы: `a[start:stop]` выбирает все элементы с индексом *k*, таким что *start* `<=` *k* `<` *stop*. При использовании в качестве выражения срез представляет собой последовательность того же типа. Сказанное выше об отрицательных индексах применимо и к отрицательным позициям в срезе. Обратите внимание, что ошибка не возникает, если позиция среза меньше нуля или больше длины последовательности.104105Если *start* опущен или равен [`None`](https://python-all.ru/3.15/library/constants.html#None), срез ведёт себя так, как если бы *start* был равен нулю. Если *stop* опущен или равен `None`, срез ведёт себя так, как если бы *stop* был равен длине последовательности.106107Некоторые последовательности также поддерживают «расширенную нарезку» с третьим параметром «шаг»: `a[i:j:k]` выбирает все элементы *a* с индексом *x*, где `x = i + n*k`, *n* `>=` `0` и *i* `<=` *x* `<` *j*.108109Последовательности различаются по изменяемости:110111#### 3.2.5.1. Неизменяемые последовательности112113Объект неизменяемого типа последовательности не может измениться после создания. (Если объект содержит ссылки на другие объекты, эти другие объекты могут быть изменяемыми и могут изменяться; однако совокупность объектов, на которые непосредственно ссылается неизменяемый объект, измениться не может.)114115Следующие типы являются неизменяемыми последовательностями:116117**Строки**118119Строка ([`str`](https://python-all.ru/3.15/library/stdtypes.html#str)) – это последовательность значений, представляющих *символы*, или, более формально, *кодовые точки Unicode*. Все кодовые точки в диапазоне от `0` до `0x10FFFF` могут быть представлены в строке.120121В Python нет отдельного типа *character*. Вместо этого каждая кодовая точка в строке представляется строковым объектом длины `1`.122123Встроенная функция [`ord()`](https://python-all.ru/3.15/library/functions.html#ord) преобразует кодовую точку из её строковой формы в целое число в диапазоне от `0` до `0x10FFFF`; [`chr()`](https://python-all.ru/3.15/library/functions.html#chr) преобразует целое число в диапазоне от `0` до `0x10FFFF` в строковый объект соответствующей длины `1`. [`str.encode()`](https://python-all.ru/3.15/library/stdtypes.html#str.encode) можно использовать для преобразования [`str`](https://python-all.ru/3.15/library/stdtypes.html#str) в [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) с помощью заданной текстовой кодировки, а [`bytes.decode()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.decode) – для обратного преобразования.124125**Кортежи**126127Элементами [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple) являются произвольные объекты Python. Кортежи из двух и более элементов создаются списками выражений, разделённых запятыми. Кортеж из одного элемента (синглтон) можно создать, добавив запятую к выражению (само по себе выражение не создаёт кортеж, так как круглые скобки должны быть доступны для группировки выражений). Пустой кортеж создаётся пустой парой круглых скобок.128129**Байты**130131Объект [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) – это неизменяемый массив. Его элементы – 8-битные байты, представленные целыми числами в диапазоне 0 \<= x \< 256. Байтовые литералы (например, `b'abc'`) и встроенный конструктор [`bytes()`](https://python-all.ru/3.15/library/stdtypes.html#bytes) используются для создания объектов bytes. Кроме того, объекты bytes можно декодировать в строки с помощью метода [`decode()`](https://python-all.ru/3.15/library/stdtypes.html#bytes.decode).132133#### 3.2.5.2. Изменяемые последовательности134135Изменяемые последовательности можно изменять после их создания. Обозначения подписки и срезов можно использовать как цель для присваивания и операторов [`del`](https://python-all.ru/3.15/reference/simple_stmts.html#del) (удаление).136137> **Примечание**138>139> Модули [`collections`](https://python-all.ru/3.15/library/collections.html#module-collections) и [`array`](https://python-all.ru/3.15/library/array.html#module-array) предоставляют дополнительные примеры изменяемых типов последовательностей.140141В настоящее время существует два встроенных изменяемых типа последовательностей:142143**Списки**144145Элементами списка являются произвольные объекты Python. Списки создаются путём помещения списка выражений, разделённых запятыми, в квадратные скобки. (Обратите внимание, что для создания списков длины 0 или 1 не требуется особых случаев.)146147**Байтовые массивы**148149Объект bytearray – это изменяемый массив. Они создаются встроенным конструктором [`bytearray()`](https://python-all.ru/3.15/library/stdtypes.html#bytearray). Помимо изменяемости (и, следовательно, невозможности хеширования), байтовые массивы в остальном предоставляют тот же интерфейс и функциональность, что и неизменяемые объекты [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes).150151### 3.2.6. Типы множеств152153Они представляют неупорядоченные, конечные множества уникальных, неизменяемых объектов. Поэтому к ним нельзя обратиться по индексу. Однако их можно перебирать, а встроенная функция [`len()`](https://python-all.ru/3.15/library/functions.html#len) возвращает количество элементов в множестве. Обычное применение множеств – быстрая проверка принадлежности, удаление дубликатов из последовательности и выполнение математических операций, таких как пересечение, объединение, разность и симметрическая разность.154155Для элементов множества действуют те же правила неизменяемости, что и для ключей словаря. Обратите внимание, что числовые типы следуют обычным правилам числового сравнения: если два числа считаются равными (например, `1` и `1.0`), только одно из них может содержаться в множестве.156157В настоящее время существует два встроенных типа множеств:158159**Множества**160161Они представляют изменяемое множество. Они создаются встроенным конструктором [`set()`](https://python-all.ru/3.15/library/stdtypes.html#set) и могут быть изменены впоследствии с помощью нескольких методов, таких как [`add()`](https://python-all.ru/3.15/library/stdtypes.html#set.add).162163**Неизменяемые множества**164165Они представляют неизменяемое множество. Они создаются встроенным конструктором [`frozenset()`](https://python-all.ru/3.15/library/stdtypes.html#frozenset). Поскольку frozenset неизменяем и [хешируем](https://python-all.ru/3.15/glossary.html#term-hashable), его можно снова использовать как элемент другого множества или как ключ словаря.166167### 3.2.7. Отображения168169Они представляют конечные наборы объектов, индексированных произвольными наборами индексов. Обозначение индекса `a[k]` выбирает элемент, индексированный `k`, из отображения `a`; это можно использовать в выражениях и как цель присваивания или операторов [`del`](https://python-all.ru/3.15/reference/simple_stmts.html#del). Встроенная функция [`len()`](https://python-all.ru/3.15/library/functions.html#len) возвращает количество элементов в отображении.170171Существует два встроенных типа отображений:172173#### 3.2.7.1. Словари174175Они представляют конечные наборы объектов, индексированных почти произвольными значениями. Единственные типы значений, неприемлемые в качестве ключей, – это значения, содержащие списки, словари или другие изменяемые типы, которые сравниваются по значению, а не по идентичности объекта. Причина в том, что эффективная реализация словарей требует, чтобы хеш-значение ключа оставалось постоянным. Числовые типы, используемые для ключей, подчиняются обычным правилам числового сравнения: если два числа считаются равными (например, `1` и `1.0`), то они могут использоваться взаимозаменяемо для индексации одной и той же записи словаря.176177Словари сохраняют порядок вставки, то есть ключи будут выдаваться в том же порядке, в котором они последовательно добавлялись в словарь. Замена существующего ключа не меняет порядок, однако удаление ключа и его повторная вставка добавит его в конец, а не сохранит на старом месте.178179Словари изменяемы; их можно создать с помощью обозначения `{}` (см. раздел [Отображения словарей](https://python-all.ru/3.15/reference/expressions.html#dict)).180181Модули расширения [`dbm.ndbm`](https://python-all.ru/3.15/library/dbm.html#module-dbm.ndbm) и [`dbm.gnu`](https://python-all.ru/3.15/library/dbm.html#module-dbm.gnu) предоставляют дополнительные примеры типов отображений, как и модуль [`collections`](https://python-all.ru/3.15/library/collections.html#module-collections).182183Изменено в версии 3.7: В версиях Python до 3.6 словари не сохраняли порядок вставки. В CPython 3.6 порядок вставки сохранялся, но в то время это считалось деталью реализации, а не гарантией языка.184185#### 3.2.7.2. Замороженные словари186187Они представляют неизменяемый словарь. Они создаются встроенным [`frozendict()`](https://python-all.ru/3.15/library/stdtypes.html#frozendict) конструктором. frozendict является [хешируемым](https://python-all.ru/3.15/glossary.html#term-hashable), если все его ключи и значения хешируемы, в этом случае его можно использовать как элемент множества или как ключ в другом отображении. `frozendict` не является подклассом [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict); он наследует напрямую от [`object`](https://python-all.ru/3.15/library/functions.html#object).188189Добавлено в версии 3.15.190191### 3.2.8. Вызываемые типы192193Это типы, к которым применима операция вызова функции (см. раздел [Вызовы](https://python-all.ru/3.15/reference/expressions.html#calls)):194195#### 3.2.8.1. Пользовательские функции196197Объект пользовательской функции создаётся определением функции (см. раздел [Определения функций](https://python-all.ru/3.15/reference/compound_stmts.html#function)). Она должна вызываться со списком аргументов, содержащим то же количество элементов, что и список формальных параметров функции.198199##### 3.2.8.1.1. Специальные атрибуты только для чтения200201| Атрибут | Значение |202| --- | --- |203| function.\_\_builtins\_\_ | Ссылка на [`dictionary`](https://python-all.ru/3.15/library/stdtypes.html#dict), которая содержит пространство имён builtins функции. Добавлено в версии 3.10. |204| function.\_\_globals\_\_ | Ссылка на [`dictionary`](https://python-all.ru/3.15/library/stdtypes.html#dict), содержащую [глобальные переменные](https://python-all.ru/3.15/reference/executionmodel.html#naming) функции – глобальное пространство имён модуля, в котором была определена функция. |205| function.\_\_closure\_\_ | `None` или [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple) ячеек, содержащих привязки для имён, указанных в атрибуте [`co_freevars`](https://python-all.ru/3.15/reference/datamodel.html#codeobject.co_freevars) [`code object`](https://python-all.ru/3.15/reference/datamodel.html#function.__code__) функции. Объект ячейки имеет атрибут `cell_contents`. Его можно использовать для получения значения ячейки, а также для его установки. |206207##### 3.2.8.1.2. Специальные атрибуты для записи208209Большинство этих атрибутов проверяют тип присваиваемого значения:210211| Атрибут | Значение |212| --- | --- |213| function.\_\_doc\_\_ | Строка документации функции или `None`, если она недоступна. |214| function.\_\_name\_\_ | Имя функции. См. также: [`__name__ attributes`](https://python-all.ru/3.15/library/stdtypes.html#definition.__name__). |215| function.\_\_qualname\_\_ | [Квалифицированное имя](https://python-all.ru/3.15/glossary.html#term-qualified-name) функции. См. также: [`__qualname__ attributes`](https://python-all.ru/3.15/library/stdtypes.html#definition.__qualname__). Добавлено в версии 3.3. |216| function.\_\_module\_\_ | Имя модуля, в котором была определена функция, или `None`, если оно недоступно. |217| function.\_\_defaults\_\_ | [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple), содержащий значения по умолчанию для [параметров](https://python-all.ru/3.15/glossary.html#term-parameter), имеющих значения по умолчанию, или `None`, если ни один параметр не имеет значения по умолчанию. |218| function.\_\_code\_\_ | [Объект кода](https://python-all.ru/3.15/reference/datamodel.html#code-objects), представляющий скомпилированное тело функции. |219| function.\_\_dict\_\_ | Пространство имён, поддерживающее произвольные атрибуты функции. См. также: [`__dict__ attributes`](https://python-all.ru/3.15/reference/datamodel.html#object.__dict__). |220| function.\_\_annotations\_\_ | [`dictionary`](https://python-all.ru/3.15/library/stdtypes.html#dict), содержащий аннотации [параметров](https://python-all.ru/3.15/glossary.html#term-parameter). Ключи словаря – имена параметров, а `'return'` – для аннотации возврата, если она указана. См. также: [`object.__annotations__`](https://python-all.ru/3.15/reference/datamodel.html#object.__annotations__). Изменено в версии 3.14: Аннотации теперь [вычисляются лениво](https://python-all.ru/3.15/reference/executionmodel.html#lazy-evaluation). См. [**PEP 649**](https://python-all.ru/3.15/reference/datamodel.html). |221| function.\_\_annotate\_\_ | [функция annotate](https://python-all.ru/3.15/glossary.html#term-annotate-function) для этой функции или `None`, если у функции нет аннотаций. См. [`object.__annotate__`](https://python-all.ru/3.15/reference/datamodel.html#object.__annotate__). Добавлено в версии 3.14. |222| function.\_\_kwdefaults\_\_ | [`dictionary`](https://python-all.ru/3.15/library/stdtypes.html#dict), содержащий значения по умолчанию для keyword-only [параметров](https://python-all.ru/3.15/glossary.html#term-parameter). |223| function.\_\_type\_params\_\_ | [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple), содержащий [параметры типа](https://python-all.ru/3.15/reference/compound_stmts.html#type-params) [обобщённой функции](https://python-all.ru/3.15/reference/compound_stmts.html#generic-functions). Добавлено в версии 3.12. |224225Объекты функций также поддерживают получение и установку произвольных атрибутов, которые можно использовать, например, для прикрепления метаданных к функциям. Для получения и установки таких атрибутов используется обычная tочечная нотация.226227**Деталь реализации CPython:** текущая реализация CPython поддерживает атрибуты функций только на пользовательских функциях. Атрибуты функций на [встроенных функциях](https://python-all.ru/3.15/reference/datamodel.html#builtin-functions) могут быть поддержаны в будущем.228229Дополнительная информация об определении функции может быть получена из её [объекта кода](https://python-all.ru/3.15/reference/datamodel.html#code-objects) (доступного через атрибут [`__code__`](https://python-all.ru/3.15/reference/datamodel.html#function.__code__)).230231#### 3.2.8.2. Методы экземпляра232233Объект метода экземпляра сочетает в себе класс, экземпляр класса и любой вызываемый объект (обычно функцию, определённую пользователем).234235Специальные атрибуты только для чтения:236237| method.\_\_self\_\_ | Ссылается на объект экземпляра класса, к которому метод [привязан](https://python-all.ru/3.15/reference/datamodel.html#method-binding) |238| --- | --- |239| method.\_\_func\_\_ | Ссылается на исходный [объект функции](https://python-all.ru/3.15/reference/datamodel.html#user-defined-funcs) |240| method.\_\_doc\_\_ | Документация метода (то же самое, что [`method.__func__.__doc__`](https://python-all.ru/3.15/reference/datamodel.html#function.__doc__)). [`string`](https://python-all.ru/3.15/library/stdtypes.html#str), если исходная функция имела docstring, иначе `None`. |241| method.\_\_name\_\_ | Имя метода (то же самое, что [`method.__func__.__name__`](https://python-all.ru/3.15/reference/datamodel.html#function.__name__)) |242| method.\_\_module\_\_ | Имя модуля, в котором был определён метод, или `None`, если недоступно. |243244Методы также поддерживают доступ (но не установку) к произвольным атрибутам функции на базовом [объекте функции](https://python-all.ru/3.15/reference/datamodel.html#user-defined-funcs).245246Объекты методов, определённых пользователем, могут создаваться при получении атрибута класса (возможно, через экземпляр этого класса), если этот атрибут является определённым пользователем [объектом функции](https://python-all.ru/3.15/reference/datamodel.html#user-defined-funcs) или объектом [`classmethod`](https://python-all.ru/3.15/library/functions.html#classmethod).247248Когда объект метода экземпляра создаётся путём получения определённого пользователем [объекта функции](https://python-all.ru/3.15/reference/datamodel.html#user-defined-funcs) из класса через один из его экземпляров, его атрибут [`__self__`](https://python-all.ru/3.15/reference/datamodel.html#method.__self__) является этим экземпляром, а объект метода называется *привязанным*. Атрибут [`__func__`](https://python-all.ru/3.15/reference/datamodel.html#method.__func__) нового метода – это исходный объект функции.249250Когда объект метода экземпляра создаётся путём получения объекта [`classmethod`](https://python-all.ru/3.15/library/functions.html#classmethod) из класса или экземпляра, его атрибут [`__self__`](https://python-all.ru/3.15/reference/datamodel.html#method.__self__) является самим классом, а его атрибут [`__func__`](https://python-all.ru/3.15/reference/datamodel.html#method.__func__) – объектом функции, лежащим в основе метода класса.251252При вызове объекта метода экземпляра вызывается базовая функция ([`__func__`](https://python-all.ru/3.15/reference/datamodel.html#method.__func__)), при этом экземпляр класса ([`__self__`](https://python-all.ru/3.15/reference/datamodel.html#method.__self__)) вставляется перед списком аргументов. Например, когда `C` – это класс, содержащий определение функции `f()`, а `x` – экземпляр `C`, вызов `x.f(1)` эквивалентен вызову `C.f(x, 1)`.253254Когда объект метода экземпляра получен из объекта [`classmethod`](https://python-all.ru/3.15/library/functions.html#classmethod), то «экземпляр класса», хранящийся в [`__self__`](https://python-all.ru/3.15/reference/datamodel.html#method.__self__), на самом деле будет самим классом, так что вызов `x.f(1)` или `C.f(1)` эквивалентен вызову `f(C,1)`, где `f` – это базовая функция.255256Важно отметить, что функции, определённые пользователем, которые являются атрибутами экземпляра класса, не преобразуются в привязанные методы; это происходит *только*, когда функция является атрибутом класса.257258#### 3.2.8.3. Функции-генераторы259260Функция или метод, использующие инструкцию [`yield`](https://python-all.ru/3.15/reference/simple_stmts.html#yield) (см. раздел [Инструкция yield](https://python-all.ru/3.15/reference/simple_stmts.html#yield)), называется *функцией-генератором*. Такая функция при вызове всегда возвращает объект [итератора](https://python-all.ru/3.15/glossary.html#term-iterator), который можно использовать для выполнения тела функции: вызов метода [`iterator.__next__()`](https://python-all.ru/3.15/library/stdtypes.html#iterator.__next__) итератора заставит функцию выполняться до тех пор, пока она не предоставит значение с помощью инструкции `yield`. Когда функция выполняет инструкцию [`return`](https://python-all.ru/3.15/reference/simple_stmts.html#return) или достигает конца, возбуждается исключение [`StopIteration`](https://python-all.ru/3.15/library/exceptions.html#StopIteration), и итератор достигает конца набора возвращаемых значений.261262#### 3.2.8.4. Корутинные функции263264Функция или метод, определённые с помощью [`async def`](https://python-all.ru/3.15/reference/compound_stmts.html#async-def), называются *корутинной функцией*. Такая функция при вызове возвращает объект [корутины](https://python-all.ru/3.15/glossary.html#term-coroutine). Она может содержать выражения [`await`](https://python-all.ru/3.15/reference/expressions.html#await), а также инструкции [`async with`](https://python-all.ru/3.15/reference/compound_stmts.html#async-with) и [`async for`](https://python-all.ru/3.15/reference/compound_stmts.html#async-for). См. также раздел [Объекты корутин](https://python-all.ru/3.15/reference/datamodel.html#coroutine-objects).265266#### 3.2.8.5. Асинхронные генераторные функции267268Функция или метод, определённые с помощью [`async def`](https://python-all.ru/3.15/reference/compound_stmts.html#async-def) и использующие инструкцию [`yield`](https://python-all.ru/3.15/reference/simple_stmts.html#yield), называются *асинхронной функцией-генератором*. Такая функция при вызове возвращает объект [асинхронного итератора](https://python-all.ru/3.15/glossary.html#term-asynchronous-iterator), который можно использовать в инструкции [`async for`](https://python-all.ru/3.15/reference/compound_stmts.html#async-for) для выполнения тела функции.269270Вызов метода [`aiterator.__anext__`](https://python-all.ru/3.15/reference/datamodel.html#object.__anext__) асинхронного итератора вернёт [ожидаемый объект](https://python-all.ru/3.15/glossary.html#term-awaitable), который при ожидании (await) будет выполняться до тех пор, пока не предоставит значение с помощью выражения [`yield`](https://python-all.ru/3.15/reference/simple_stmts.html#yield). Когда функция выполняет пустую инструкцию [`return`](https://python-all.ru/3.15/reference/simple_stmts.html#return) или достигает конца, возбуждается исключение [`StopAsyncIteration`](https://python-all.ru/3.15/library/exceptions.html#StopAsyncIteration), и асинхронный итератор достигает конца набора выдаваемых значений.271272#### 3.2.8.6. Встроенные функции273274Объект встроенной функции – это обёртка вокруг C-функции. Примерами встроенных функций являются [`len()`](https://python-all.ru/3.15/library/functions.html#len) и [`math.sin()`](https://python-all.ru/3.15/library/math.html#math.sin) ([`math`](https://python-all.ru/3.15/library/math.html#module-math) – это стандартный встроенный модуль). Количество и типы аргументов определяются C-функцией. Специальные атрибуты, доступные только для чтения:275276- `__doc__` – строка документации функции или `None`, если она недоступна. См. [`function.__doc__`](https://python-all.ru/3.15/reference/datamodel.html#function.__doc__).277- `__name__` – имя функции. См. [`function.__name__`](https://python-all.ru/3.15/reference/datamodel.html#function.__name__).278- `__self__` устанавливается в `None` (но см. следующий пункт).279- `__module__` – имя модуля, в котором определена функция, или `None`, если оно недоступно. См. [`function.__module__`](https://python-all.ru/3.15/reference/datamodel.html#function.__module__).280281#### 3.2.8.7. Встроенные методы282283Это, по сути, та же встроенная функция, но в другой «упаковке»: она содержит объект, передаваемый C-функции в качестве неявного дополнительного аргумента. Примером встроенного метода является `alist.append()`, если предположить, что *alist* – это объект списка. В этом случае специальный атрибут только для чтения `__self__` устанавливается в объект, обозначаемый *alist*. (Семантика этого атрибута такая же, как у [`other instance methods`](https://python-all.ru/3.15/reference/datamodel.html#method.__self__).)284285#### 3.2.8.8. Классы286287Классы являются вызываемыми. Обычно эти объекты выступают в роли фабрик для создания собственных экземпляров, но возможны варианты для типов классов, которые переопределяют [`__new__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__new__). Аргументы вызова передаются в `__new__()` и, в типичном случае, в [`__init__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__init__) для инициализации нового экземпляра.288289#### 3.2.8.9. Экземпляры классов290291Экземпляры произвольных классов можно сделать вызываемыми, определив в их классе метод [`__call__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__call__).292293### 3.2.9. Модули294295Модули – это основная организационная единица кода Python. Они создаются с помощью [системы импорта](https://python-all.ru/3.15/reference/import.html#importsystem), вызываемой либо оператором [`import`](https://python-all.ru/3.15/reference/simple_stmts.html#import), либо вызовом таких функций, как [`importlib.import_module()`](https://python-all.ru/3.15/library/importlib.html#importlib.import_module) и встроенной [`__import__()`](https://python-all.ru/3.15/library/functions.html#import__). У объекта модуля есть пространство имён, реализованное с помощью объекта [`dictionary`](https://python-all.ru/3.15/library/stdtypes.html#dict) (это словарь, на который ссылается атрибут [`__globals__`](https://python-all.ru/3.15/reference/datamodel.html#function.__globals__) функций, определённых в модуле). Обращение к атрибутам преобразуется в поиск по этому словарю; например, `m.x` эквивалентно `m.__dict__["x"]`. Объект модуля не содержит код, использовавшийся для его инициализации (он больше не нужен после завершения инициализации).296297Присваивание атрибуту обновляет словарь пространства имён модуля; например, `m.x = 1` эквивалентно `m.__dict__["x"] = 1`.298299#### 3.2.9.1. Атрибуты модуля, связанные с импортом300301У объектов модуля есть следующие атрибуты, относящиеся к [системе импорта](https://python-all.ru/3.15/reference/import.html#importsystem). Когда модуль создаётся с помощью механизмов системы импорта, эти атрибуты заполняются на основе [спецификации](https://python-all.ru/3.15/glossary.html#term-module-spec) модуля перед тем, как [загрузчик](https://python-all.ru/3.15/glossary.html#term-loader) выполнит и загрузит модуль.302303Для динамического создания модуля (вместо использования системы импорта) рекомендуется применять [`importlib.util.module_from_spec()`](https://python-all.ru/3.15/library/importlib.html#importlib.util.module_from_spec) – он установит соответствующие значения для различных атрибутов, управляемых импортом. Можно также использовать конструктор [`types.ModuleType`](https://python-all.ru/3.15/library/types.html#types.ModuleType) для прямого создания модулей, но этот подход более подвержен ошибкам, так как большинство атрибутов придётся вручную устанавливать у объекта модуля после его создания.304305> **Внимание**306>307> За исключением [`__name__`](https://python-all.ru/3.15/reference/datamodel.html#module.__name__), **настоятельно** рекомендуется полагаться на [`__spec__`](https://python-all.ru/3.15/reference/datamodel.html#module.__spec__) и его атрибуты, а не на любые другие отдельные атрибуты из этого подраздела. Обратите внимание, что обновление атрибута в `__spec__` не приводит к обновлению соответствующего атрибута самого модуля:308>309> ```pycon310> >>> import typing311> >>> typing.__name__, typing.__spec__.name312> ('typing', 'typing')313> >>> typing.__spec__.name = 'spelling'314> >>> typing.__name__, typing.__spec__.name315> ('typing', 'spelling')316> >>> typing.__name__ = 'keyboard_smashing'317> >>> typing.__name__, typing.__spec__.name318> ('keyboard_smashing', 'spelling')319> ```320321#### `module.__name__`322323Имя, используемое для уникальной идентификации модуля в системе импорта. Для модуля, запущенного напрямую, оно будет установлено в `"__main__"`.324325Этот атрибут должен быть установлен в полное квалифицированное имя модуля. Ожидается, что он будет совпадать со значением [`module.__spec__.name`](https://python-all.ru/3.15/library/importlib.html#importlib.machinery.ModuleSpec.name).326327#### `module.__spec__`328329Запись состояния модуля, связанного с системой импорта.330331Устанавливается в [`module spec`](https://python-all.ru/3.15/library/importlib.html#importlib.machinery.ModuleSpec), который использовался при импорте модуля. Подробнее см. в [Спецификации модулей](https://python-all.ru/3.15/reference/import.html#module-specs).332333Добавлено в версии 3.4.334335#### `module.__package__`336337[Пакет](https://python-all.ru/3.15/glossary.html#term-package), к которому принадлежит модуль.338339Если модуль является корневым (то есть не входит в какой-либо пакет), то атрибут должен быть установлен в `''` (пустая строка). В противном случае он должен быть установлен в имя пакета модуля (которое может быть равно [`module.__name__`](https://python-all.ru/3.15/reference/datamodel.html#module.__name__), если сам модуль является пакетом). Подробнее см. [**PEP 366**](https://python-all.ru/3.15/reference/datamodel.html).340341Этот атрибут используется вместо [`__name__`](https://python-all.ru/3.15/reference/datamodel.html#module.__name__) для вычисления явных относительных импортов в главных модулях. По умолчанию он равен `None` для модулей, создаваемых динамически с помощью конструктора [`types.ModuleType`](https://python-all.ru/3.15/library/types.html#types.ModuleType); используйте [`importlib.util.module_from_spec()`](https://python-all.ru/3.15/library/importlib.html#importlib.util.module_from_spec), чтобы атрибут был установлен в [`str`](https://python-all.ru/3.15/library/stdtypes.html#str).342343**Настоятельно** рекомендуется использовать [`module.__spec__.parent`](https://python-all.ru/3.15/library/importlib.html#importlib.machinery.ModuleSpec.parent) вместо `module.__package__`. [`__package__`](https://python-all.ru/3.15/reference/datamodel.html#module.__package__) теперь используется только как запасной вариант, если `__spec__.parent` не установлен; этот запасной путь объявлен устаревшим.344345Изменено в версии 3.4: Теперь для модулей, созданных динамически с помощью конструктора [`types.ModuleType`](https://python-all.ru/3.15/library/types.html#types.ModuleType), этот атрибут по умолчанию равен `None`. Ранее атрибут был необязательным.346347Изменено в версии 3.6: Значение `__package__` должно совпадать с [`__spec__.parent`](https://python-all.ru/3.15/library/importlib.html#importlib.machinery.ModuleSpec.parent). [`__package__`](https://python-all.ru/3.15/reference/datamodel.html#module.__package__) теперь используется только как запасной вариант при разрешении импорта, если `__spec__.parent` не определён.348349Изменено в версии 3.10: [`ImportWarning`](https://python-all.ru/3.15/library/exceptions.html#ImportWarning) возбуждается, если разрешение импорта возвращается к `__package__` вместо [`__spec__.parent`](https://python-all.ru/3.15/library/importlib.html#importlib.machinery.ModuleSpec.parent).350351Изменено в версии 3.12: При откате к `__package__` во время разрешения импорта теперь возбуждается исключение [`DeprecationWarning`](https://python-all.ru/3.15/library/exceptions.html#DeprecationWarning) вместо [`ImportWarning`](https://python-all.ru/3.15/library/exceptions.html#ImportWarning).352353Устарело с версии 3.13, удалено в версии 3.15: `__package__` перестанет устанавливаться или учитываться системой импорта или стандартной библиотекой.354355#### `module.__loader__`356357Объект [загрузчика](https://python-all.ru/3.15/glossary.html#term-loader), используемый механизмом импорта для загрузки модуля.358359Этот атрибут в основном полезен для интроспекции, но может использоваться для дополнительной функциональности, специфичной для загрузчика, например для получения данных, связанных с загрузчиком.360361`__loader__` по умолчанию равен `None` для модулей, созданных динамически с помощью конструктора [`types.ModuleType`](https://python-all.ru/3.15/library/types.html#types.ModuleType); используйте [`importlib.util.module_from_spec()`](https://python-all.ru/3.15/library/importlib.html#importlib.util.module_from_spec), чтобы гарантировать, что атрибут установлен в объект [загрузчика](https://python-all.ru/3.15/glossary.html#term-loader).362363**Настоятельно** рекомендуется использовать [`module.__spec__.loader`](https://python-all.ru/3.15/library/importlib.html#importlib.machinery.ModuleSpec.loader) вместо `module.__loader__`.364365Изменено в версии 3.4: Теперь для модулей, созданных динамически с помощью конструктора [`types.ModuleType`](https://python-all.ru/3.15/library/types.html#types.ModuleType), этот атрибут по умолчанию равен `None`. Ранее атрибут был необязательным.366367Устарело с версии 3.12, будет удалено в версии 3.16: Установка `__loader__` на модуле без установки `__spec__.loader` устарела. В Python 3.16 `__loader__` перестанет устанавливаться или учитываться системой импорта или стандартной библиотекой.368369#### `module.__path__`370371[Последовательность](https://python-all.ru/3.15/glossary.html#term-sequence) (возможно пустая) строк, перечисляющая местоположения, где будут найдены подмодули пакета. Непакетные модули не должны иметь атрибута `__path__`. Подробнее см. [атрибут \_\_path\_\_ у модулей](https://python-all.ru/3.15/reference/import.html#package-path-rules).372373**Настоятельно** рекомендуется использовать [`module.__spec__.submodule_search_locations`](https://python-all.ru/3.15/library/importlib.html#importlib.machinery.ModuleSpec.submodule_search_locations) вместо `module.__path__`.374375#### `module.__file__`376377`__file__` является необязательным атрибутом, который может быть установлен, а может и нет. Оба атрибута должны быть [`str`](https://python-all.ru/3.15/library/stdtypes.html#str), если они доступны.378379Необязательный атрибут, `__file__` указывает путь к файлу, из которого был загружен модуль (если загружен из файла), или путь к файлу общей библиотеки для модулей расширения, загружаемых динамически из общей библиотеки. Он может отсутствовать для некоторых типов модулей, таких как C модули, статически слинкованные с интерпретатором, и [система импорта](https://python-all.ru/3.15/reference/import.html#importsystem) может не устанавливать его, если он не имеет смыслового значения (например, модуль, загруженный из базы данных).380381Устарело с версии 3.13, удалено в версии 3.15: Установка `__cached__` в модуле без установки `__spec__.cached` устарела. В Python 3.15 `__cached__` перестанет устанавливаться или учитываться системой импорта или стандартной библиотекой.382383Изменено в версии 3.15: `__cached__` больше не устанавливается.384385#### 3.2.9.2. Другие перезаписываемые атрибуты объектов модуля386387Помимо перечисленных выше атрибутов, связанных с импортом, объекты модулей также имеют следующие перезаписываемые атрибуты:388389#### `module.__doc__`390391Документационная строка модуля или `None`, если недоступна. См. также: [`__doc__ attributes`](https://python-all.ru/3.15/library/stdtypes.html#definition.__doc__).392393#### `module.__annotations__`394395Словарь, содержащий [аннотации переменных](https://python-all.ru/3.15/glossary.html#term-variable-annotation), собранные во время выполнения тела модуля. Рекомендации по работе с `__annotations__` см. в [`annotationlib`](https://python-all.ru/3.15/library/annotationlib.html#module-annotationlib).396397Изменено в версии 3.14: Аннотации теперь [вычисляются лениво](https://python-all.ru/3.15/reference/executionmodel.html#lazy-evaluation). См. [**PEP 649**](https://python-all.ru/3.15/reference/datamodel.html).398399#### `module.__annotate__`400401[Функция аннотации](https://python-all.ru/3.15/glossary.html#term-annotate-function) для этого модуля или `None`, если у модуля нет аннотаций. См. также: атрибуты [`__annotate__`](https://python-all.ru/3.15/reference/datamodel.html#object.__annotate__).402403Добавлено в версии 3.14.404405#### `module.__lazy_modules__`406407Контейнер (объект, реализующий [`__contains__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__contains__)) строк с полными именами модулей. Если он определён на уровне модуля, любой обычный оператор [`import`](https://python-all.ru/3.15/reference/simple_stmts.html#import) в этом модуле, чьё целевое имя модуля присутствует в этом контейнере, рассматривается как [ленивый импорт](https://python-all.ru/3.15/reference/simple_stmts.html#lazy-imports), как если бы было использовано ключевое слово [`lazy`](https://python-all.ru/3.15/reference/simple_stmts.html#lazy). Импорты внутри функций, тел классов или блоков [`try`](https://python-all.ru/3.15/reference/compound_stmts.html#try)/[`except`](https://python-all.ru/3.15/reference/compound_stmts.html#except)/[`finally`](https://python-all.ru/3.15/reference/compound_stmts.html#finally) не затрагиваются.408409См. [Совместимость через \_\_lazy\_modules\_\_](https://python-all.ru/3.15/reference/simple_stmts.html#lazy-modules-compat) для подробностей и примеров.410411Добавлено в версии 3.15.412413#### 3.2.9.3. Словари модулей414415Объекты модулей также имеют следующий специальный атрибут, доступный только для чтения:416417#### `module.__dict__`418419Пространство имён модуля в виде словаря. В отличие от остальных перечисленных здесь атрибутов, `__dict__` нельзя получить как глобальную переменную внутри модуля; доступ к нему возможен только как к атрибуту объектов модуля.420421**Особенность реализации CPython:** Из-за того, как CPython очищает словари модулей, словарь модуля будет очищен, когда модуль выйдет из области видимости, даже если на словарь ещё есть активные ссылки. Чтобы этого избежать, скопируйте словарь или держите модуль в памяти, пока используете его словарь напрямую.422423### 3.2.10. Пользовательские классы424425Пользовательские классы обычно создаются с помощью определений классов (см. раздел [Определения классов](https://python-all.ru/3.15/reference/compound_stmts.html#class)). У класса есть пространство имён, реализованное в виде словаря. Обращения к атрибутам класса преобразуются в поиск по этому словарю, например `C.x` превращается в `C.__dict__["x"]` (хотя существуют хуки, позволяющие искать атрибуты другими способами). Если имя атрибута не найдено в словаре, поиск продолжается в базовых классах. Этот поиск по базовым классам использует порядок разрешения методов C3, который корректно работает даже при наличии ромбовидного наследования, когда существует несколько путей наследования, ведущих к общему предку. Дополнительные сведения о C3 MRO, используемом в Python, можно найти в [Порядок разрешения методов в Python 2.3](https://python-all.ru/3.15/howto/mro.html#python-2-3-mro).426427Если обращение к атрибуту класса (скажем, для класса `C`) возвращает объект метода класса, он преобразуется в объект метода экземпляра, у которого атрибут [`__self__`](https://python-all.ru/3.15/reference/datamodel.html#method.__self__) равен `C`. Если же оно возвращает объект [`staticmethod`](https://python-all.ru/3.15/library/functions.html#staticmethod), он преобразуется в объект, обёрнутый объектом статического метода. См. раздел [Реализация дескрипторов](https://python-all.ru/3.15/reference/datamodel.html#descriptors) о другом способе, которым атрибуты, полученные из класса, могут отличаться от тех, что на самом деле содержатся в его [`__dict__`](https://python-all.ru/3.15/reference/datamodel.html#object.__dict__).428429Присваивание атрибутов класса обновляет словарь самого класса, но никогда не словарь базового класса.430431Объект класса можно вызвать (см. выше), чтобы получить экземпляр класса (см. ниже).432433#### 3.2.10.1. Специальные атрибуты434435| Атрибут | Значение |436| --- | --- |437| type.\_\_name\_\_ | Имя класса. См. также: [`__name__ attributes`](https://python-all.ru/3.15/library/stdtypes.html#definition.__name__). |438| type.\_\_qualname\_\_ | [Квалифицированное имя](https://python-all.ru/3.15/glossary.html#term-qualified-name) класса. См. также: [`__qualname__ attributes`](https://python-all.ru/3.15/library/stdtypes.html#definition.__qualname__). |439| type.\_\_module\_\_ | Имя модуля, в котором был определён класс. |440| type.\_\_dict\_\_ | [`mapping proxy`](https://python-all.ru/3.15/library/types.html#types.MappingProxyType), предоставляющий доступ только для чтения к пространству имён класса. См. также: [`__dict__ attributes`](https://python-all.ru/3.15/reference/datamodel.html#object.__dict__). |441| type.\_\_bases\_\_ | [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple), содержащий базовые классы. В большинстве случаев для класса, определённого как `class X(A, B, C)`, `X.__bases__` будет в точности равен `(A, B, C)`. |442| type.\_\_base\_\_ | **Особенность реализации CPython:** Единственный базовый класс в цепочке наследования, отвечающий за расположение экземпляров в памяти. Этот атрибут соответствует [`tp_base`](https://python-all.ru/3.15/c-api/typeobj.html#c.PyTypeObject.tp_base) на уровне C. |443| type.\_\_doc\_\_ | Строка документации класса или `None`, если не определена. Не наследуется подклассами. |444| type.\_\_annotations\_\_ | Словарь, содержащий [аннотации переменных](https://python-all.ru/3.15/glossary.html#term-variable-annotation), собранные во время выполнения тела класса. См. также: [`__annotations__ attributes`](https://python-all.ru/3.15/reference/datamodel.html#object.__annotations__). Рекомендации по работе с [`__annotations__`](https://python-all.ru/3.15/reference/datamodel.html#object.__annotations__) см. в [`annotationlib`](https://python-all.ru/3.15/library/annotationlib.html#module-annotationlib). Используйте [`annotationlib.get_annotations()`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.get_annotations) вместо прямого обращения к этому атрибуту. Предупреждение Прямое обращение к атрибуту `__annotations__` у объекта класса может вернуть аннотации не того класса, особенно в случаях, когда класс, его базовый класс или метакласс определён с помощью `from __future__ import annotations`. Подробности см. в [**749**](https://python-all.ru/3.15/reference/datamodel.html). Этот атрибут отсутствует у некоторых встроенных классов. У пользовательских классов без `__annotations__` это пустой словарь. Изменено в версии 3.14: Аннотации теперь [вычисляются лениво](https://python-all.ru/3.15/reference/executionmodel.html#lazy-evaluation). См. [**PEP 649**](https://python-all.ru/3.15/reference/datamodel.html). |445| type.\_\_annotate\_\_() | [Функция annotate](https://python-all.ru/3.15/glossary.html#term-annotate-function) для этого класса или `None`, если у класса нет аннотаций. См. также: [`__annotate__ attributes`](https://python-all.ru/3.15/reference/datamodel.html#object.__annotate__). Добавлено в версии 3.14. |446| type.\_\_type\_params\_\_ | [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple), содержащий [параметры типа](https://python-all.ru/3.15/reference/compound_stmts.html#type-params) [обобщённого класса](https://python-all.ru/3.15/reference/compound_stmts.html#generic-classes). Добавлено в версии 3.12. |447| type.\_\_static\_attributes\_\_ | [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple), содержащий имена атрибутов этого класса, которые назначаются через `self.X` из любой функции его тела. Добавлено в версии 3.13. |448| type.\_\_firstlineno\_\_ | Номер строки первой строки определения класса, включая декораторы. Установка атрибута [`__module__`](https://python-all.ru/3.15/reference/datamodel.html#type.__module__) удаляет элемент `__firstlineno__` из словаря типа. Добавлено в версии 3.13. |449| type.\_\_mro\_\_ | [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple) классов, которые учитываются при поиске базовых классов во время разрешения методов. |450451#### 3.2.10.2. Специальные методы452453В дополнение к описанным выше специальным атрибутам все классы Python также имеют следующие два метода:454455#### `type.mro()`456457Этот метод может быть переопределён метаклассом для настройки порядка разрешения методов для своих экземпляров. Он вызывается при создании класса, и его результат сохраняется в [`__mro__`](https://python-all.ru/3.15/reference/datamodel.html#type.__mro__).458459#### `type.__subclasses__()`460461Каждый класс хранит список слабых ссылок на свои непосредственные подклассы. Этот метод возвращает список всех ещё живых ссылок. Список отсортирован в порядке определения. Пример:462463```pycon464>>> class A: pass465>>> class B(A): pass466>>> A.__subclasses__()467[<class 'B'>]468```469470### 3.2.11. Экземпляры классов471472Экземпляр класса создаётся вызовом объекта класса (см. выше). Экземпляр класса имеет пространство имён, реализованное как словарь, который является первым местом, где ищутся ссылки на атрибуты. Если атрибут не найден там, и класс экземпляра имеет атрибут с таким именем, поиск продолжается среди атрибутов класса. Если найден атрибут класса, являющийся объектом пользовательской функции, он преобразуется в объект метода экземпляра, чьим атрибутом [`__self__`](https://python-all.ru/3.15/reference/datamodel.html#method.__self__) является экземпляр. Объекты статического метода и метода класса также преобразуются; см. выше раздел «Классы». См. раздел [Реализация дескрипторов](https://python-all.ru/3.15/reference/datamodel.html#descriptors) для другого способа, которым атрибуты класса, полученные через его экземпляры, могут отличаться от объектов, фактически хранящихся в [`__dict__`](https://python-all.ru/3.15/reference/datamodel.html#object.__dict__) класса. Если атрибут класса не найден и у класса объекта есть метод [`__getattr__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getattr__), он вызывается для удовлетворения поиска.473474Присваивания и удаления атрибутов обновляют словарь экземпляра, но никогда не словарь класса. Если у класса есть метод [`__setattr__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__setattr__) или [`__delattr__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__delattr__), он вызывается вместо прямого обновления словаря экземпляра.475476Экземпляры классов могут вести себя как числа, последовательности или отображения, если у них есть методы с определёнными специальными именами. См. раздел [Имена специальных методов](https://python-all.ru/3.15/reference/datamodel.html#specialnames).477478#### 3.2.11.1. Специальные атрибуты479480#### `object.__class__`481482Класс, которому принадлежит экземпляр класса.483484#### `object.__dict__`485486Словарь или другой объект отображения, используемый для хранения (записываемых) атрибутов объекта. Не все экземпляры имеют атрибут `__dict__`; см. раздел [\_\_slots\_\_](https://python-all.ru/3.15/reference/datamodel.html#slots) для получения дополнительных сведений.487488### 3.2.12. Объекты ввода-вывода (также известные как файловые объекты)489490[Файловый объект](https://python-all.ru/3.15/glossary.html#term-file-object) представляет открытый файл. Существуют различные краткие способы создания файловых объектов: встроенная функция [`open()`](https://python-all.ru/3.15/library/functions.html#open), а также [`os.popen()`](https://python-all.ru/3.15/library/os.html#os.popen), [`os.fdopen()`](https://python-all.ru/3.15/library/os.html#os.fdopen) и метод [`makefile()`](https://python-all.ru/3.15/library/socket.html#socket.socket.makefile) объектов сокетов (и, возможно, другие функции или методы, предоставляемые модулями расширения).491492Файловые объекты реализуют общие методы, перечисленные ниже, чтобы упростить использование в общем коде. Ожидается, что они являются [контекстными менеджерами инструкции with](https://python-all.ru/3.15/reference/datamodel.html#context-managers).493494Объекты `sys.stdin`, `sys.stdout` и `sys.stderr` инициализируются как файловые объекты, соответствующие стандартным потокам ввода, вывода и ошибок интерпретатора; все они открыты в текстовом режиме и поэтому следуют интерфейсу, определённому абстрактным классом [`io.TextIOBase`](https://python-all.ru/3.15/library/io.html#io.TextIOBase).495496#### `file.read(size=-1, /)`497498Извлекает до *size* данных из файла. Для удобства, если *size* не указан или равен -1, извлекает все доступные данные.499500#### `file.write(data, /)`501502Сохраняет *data* в файл.503504#### `file.close()`505506Сбрасывает все буферы и закрывает нижележащий файл.507508### 3.2.13. Внутренние типы509510Некоторые типы, используемые внутри интерпретатора, доступны пользователю. Их определения могут измениться в будущих версиях интерпретатора, но здесь они упомянуты для полноты.511512#### 3.2.13.1. Объекты кода513514Объекты кода представляют собой *скомпилированный в байт-код* исполняемый код Python, или [байт-код](https://python-all.ru/3.15/glossary.html#term-bytecode). Разница между объектом кода и объектом функции в том, что объект функции содержит явную ссылку на глобальные переменные функции (модуль, в котором она определена), тогда как объект кода не содержит контекста; кроме того, значения аргументов по умолчанию хранятся в объекте функции, а не в объекте кода (поскольку они представляют значения, вычисляемые во время выполнения). В отличие от объектов функций, объекты кода неизменяемы и не содержат ссылок (прямых или косвенных) на изменяемые объекты.515516##### 3.2.13.1.1. Специальные атрибуты только для чтения517518| codeobject.co\_name | Имя функции |519| --- | --- |520| codeobject.co\_qualname | Полное квалифицированное имя функции Добавлено в версии 3.12. |521| codeobject.co\_argcount | Общее количество [параметров](https://python-all.ru/3.15/glossary.html#term-parameter) только по позиции (включая параметры только по позиции и параметры со значениями по умолчанию), которые есть у функции |522| codeobject.co\_posonlyargcount | Количество [параметров](https://python-all.ru/3.15/glossary.html#term-parameter) только по позиции (включая аргументы со значениями по умолчанию), которые есть у функции |523| codeobject.co\_kwonlyargcount | Количество [параметров](https://python-all.ru/3.15/glossary.html#term-parameter) только по ключевым словам (включая аргументы со значениями по умолчанию), которые есть у функции |524| codeobject.co\_nlocals | Количество [локальных переменных](https://python-all.ru/3.15/reference/executionmodel.html#naming), используемых функцией (включая параметры) |525| codeobject.co\_varnames | [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple), содержащий имена локальных переменных в функции (начиная с имён параметров) |526| codeobject.co\_cellvars | [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple), содержащий имена [локальных переменных](https://python-all.ru/3.15/reference/executionmodel.html#naming), на которые есть ссылки по крайней мере из одной [вложенной области видимости](https://python-all.ru/3.15/glossary.html#term-nested-scope) внутри функции |527| codeobject.co\_freevars | [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple), содержащий имена [свободных переменных (замыкания)](https://python-all.ru/3.15/glossary.html#term-closure-variable), на которые ссылается [вложенная область видимости](https://python-all.ru/3.15/glossary.html#term-nested-scope) во внешней области видимости. См. также [`function.__closure__`](https://python-all.ru/3.15/reference/datamodel.html#function.__closure__). Примечание: ссылки на глобальные и встроенные имена *не* включаются. |528| codeobject.co\_code | Строка, представляющая последовательность инструкций [байт-кода](https://python-all.ru/3.15/glossary.html#term-bytecode) в функции |529| codeobject.co\_consts | [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple), содержащий литералы, используемые [байт-кодом](https://python-all.ru/3.15/glossary.html#term-bytecode) в функции |530| codeobject.co\_names | [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple), содержащий имена, используемые [байт-кодом](https://python-all.ru/3.15/glossary.html#term-bytecode) в функции |531| codeobject.co\_filename | Имя файла, из которого был скомпилирован код |532| codeobject.co\_firstlineno | Номер строки первой строки функции. |533| codeobject.co\_stacksize | Требуемый размер стека объекта кода. |534| codeobject.co\_flags | [`integer`](https://python-all.ru/3.15/library/functions.html#int), кодирующий набор флагов для интерпретатора. |535536Для [`co_flags`](https://python-all.ru/3.15/reference/datamodel.html#codeobject.co_flags) определены следующие биты флагов: бит `0x04` установлен, если функция использует синтаксис `*arguments` для принятия произвольного числа позиционных аргументов; бит `0x08` установлен, если функция использует синтаксис `**keywords` для принятия произвольных именованных аргументов; бит `0x20` установлен, если функция является генератором. См. [Code Objects Bit Flags](https://python-all.ru/3.15/library/inspect.html#inspect-module-co-flags) для получения подробной информации о семантике каждого флага, который может присутствовать.537538Объявления будущих возможностей (например, `from __future__ import division`) также используют биты в [`co_flags`](https://python-all.ru/3.15/reference/datamodel.html#codeobject.co_flags), чтобы указать, был ли объект кода скомпилирован с включённой конкретной возможностью. См. [`compiler_flag`](https://python-all.ru/3.15/library/__future__.html#future__._Feature.compiler_flag).539540Остальные биты в [`co_flags`](https://python-all.ru/3.15/reference/datamodel.html#codeobject.co_flags) зарезервированы для внутреннего использования.541542Если объект кода представляет функцию и имеет строку документации, бит [`CO_HAS_DOCSTRING`](https://python-all.ru/3.15/library/inspect.html#inspect.CO_HAS_DOCSTRING) установлен в [`co_flags`](https://python-all.ru/3.15/reference/datamodel.html#codeobject.co_flags), а первый элемент в [`co_consts`](https://python-all.ru/3.15/reference/datamodel.html#codeobject.co_consts) является строкой документации функции.543544##### 3.2.13.1.2. Методы объектов кода545546#### `codeobject.co_positions()`547548Возвращает итератор по позициям в исходном коде для каждой инструкции [bytecode](https://python-all.ru/3.15/glossary.html#term-bytecode) в объекте кода.549550Итератор возвращает [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple), содержащие `(start_line, end_line, start_column, end_column)`. Кортеж *i-й* соответствует позиции исходного кода, который был скомпилирован в *i-й* код. Информация о столбцах представлена 0-индексированными смещениями в байтах UTF-8 на заданной строке исходного кода.551552Эта позиционная информация может отсутствовать. Неисчерпывающий список случаев, когда это может произойти:553554- Запуск интерпретатора с [`-X`](https://python-all.ru/3.15/using/cmdline.html#cmdoption-X) `no_debug_ranges`.555- Загрузка pyc-файла, скомпилированного при использовании [`-X`](https://python-all.ru/3.15/using/cmdline.html#cmdoption-X) `no_debug_ranges`.556- Кортежи позиций, соответствующие искусственным инструкциям.557- Номера строк и столбцов, которые не могут быть представлены из-за ограничений, специфичных для реализации.558559Когда это происходит, некоторые или все элементы кортежа могут быть [`None`](https://python-all.ru/3.15/library/constants.html#None).560561Добавлено в версии 3.12.562563> **Примечание**564>565> Эта возможность требует хранения позиций столбцов в объектах кода, что может привести к небольшому увеличению использования диска скомпилированными файлами Python или памяти интерпретатора. Чтобы избежать хранения лишней информации и/или отключить вывод дополнительной информации в трассировке, можно использовать флаг командной строки [`-X`](https://python-all.ru/3.15/using/cmdline.html#cmdoption-X) `no_debug_ranges` или переменную окружения [`PYTHONNODEBUGRANGES`](https://python-all.ru/3.15/using/cmdline.html#envvar-PYTHONNODEBUGRANGES).566567#### `codeobject.co_lines()`568569Возвращает итератор, который выдаёт информацию о последовательных диапазонах [bytecode](https://python-all.ru/3.15/glossary.html#term-bytecode). Каждый выдаваемый элемент – это `(start, end, lineno)` [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple):570571- `start` ([`int`](https://python-all.ru/3.15/library/functions.html#int)) представляет собой смещение (включительно) начала диапазона [bytecode](https://python-all.ru/3.15/glossary.html#term-bytecode)572- `end` ([`int`](https://python-all.ru/3.15/library/functions.html#int)) представляет собой смещение (исключительно) конца диапазона [bytecode](https://python-all.ru/3.15/glossary.html#term-bytecode)573- `lineno` – это [`int`](https://python-all.ru/3.15/library/functions.html#int), представляющий номер строки диапазона [bytecode](https://python-all.ru/3.15/glossary.html#term-bytecode), или `None`, если байт-коды в данном диапазоне не имеют номера строки.574575Выдаваемые элементы будут иметь следующие свойства:576577- Первый выданный диапазон будет иметь `start` равным 0.578- Диапазоны `(start, end)` будут неубывающими и последовательными. То есть для любой пары [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple) значение `start` второго будет равно значению `end` первого.579- Ни один диапазон не будет идти назад: `end >= start` для всех троек.580- Последнее выданное значение [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple) будет иметь `end`, равное размеру [байткода](https://python-all.ru/3.15/glossary.html#term-bytecode).581582Допускаются диапазоны нулевой ширины, где `start == end`. Диапазоны нулевой ширины используются для строк, присутствующих в исходном коде, но удалённых компилятором [байткода](https://python-all.ru/3.15/glossary.html#term-bytecode).583584Добавлено в версии 3.10.585586> **См. также**587>588> **[**PEP 626**](https://python-all.ru/3.15/reference/datamodel.html) – точные номера строк для отладки и других инструментов.**589>590> PEP, в котором был представлен метод `co_lines()`.591592#### `codeobject.replace(**kwargs)`593594Возвращает копию объекта кода с новыми значениями для указанных полей.595596Объекты кода также поддерживаются универсальной функцией [`copy.replace()`](https://python-all.ru/3.15/library/copy.html#copy.replace).597598Добавлено в версии 3.8.599600#### 3.2.13.2. Объекты фреймов601602Объекты фреймов представляют фреймы выполнения. Они могут встречаться в [объектах traceback](https://python-all.ru/3.15/reference/datamodel.html#traceback-objects), а также передаваться зарегистрированным функциям трассировки.603604##### 3.2.13.2.1. Специальные атрибуты только для чтения605606| frame.f\_back | Указывает на предыдущий фрейм стека (в сторону вызвавшего), или `None`, если это нижний фрейм стека |607| --- | --- |608| frame.f\_code | [Объект кода](https://python-all.ru/3.15/reference/datamodel.html#code-objects), выполняемый в этом фрейме. Обращение к этому атрибуту вызывает [событие аудита](https://python-all.ru/3.15/library/sys.html#auditing) `object.__getattr__` с аргументами `obj` и `"f_code"`. |609| frame.f\_locals | Отображение, используемое фреймом для поиска [локальных переменных](https://python-all.ru/3.15/reference/executionmodel.html#naming). Если фрейм ссылается на [оптимизированную область видимости](https://python-all.ru/3.15/glossary.html#term-optimized-scope), может быть возвращён прокси-объект со сквозной записью. Изменено в версии 3.13: Возвращает прокси для оптимизированных областей видимости. |610| frame.f\_globals | Словарь, используемый фреймом для поиска [глобальных переменных](https://python-all.ru/3.15/reference/executionmodel.html#naming) |611| frame.f\_builtins | Словарь, используемый фреймом для поиска [встроенных (intrinsic) имён](https://python-all.ru/3.15/reference/executionmodel.html#naming) |612| frame.f\_lasti | «Точная инструкция» объекта фрейма (это индекс в строке [байткода](https://python-all.ru/3.15/glossary.html#term-bytecode) объекта [кода](https://python-all.ru/3.15/reference/datamodel.html#code-objects)) |613| frame.f\_generator | [Генератор](https://python-all.ru/3.15/glossary.html#term-generator) или [корутина](https://python-all.ru/3.15/glossary.html#term-coroutine), владеющие этим фреймом, или `None`, если фрейм принадлежит обычной функции. Добавлено в версии 3.14. |614615##### 3.2.13.2.2. Специальные атрибуты для записи616617| frame.f\_trace | Если не `None`, то это функция, вызываемая для различных событий во время выполнения кода (используется отладчиками). Обычно событие возникает для каждой новой строки исходного кода (см. [`f_trace_lines`](https://python-all.ru/3.15/reference/datamodel.html#frame.f_trace_lines)). |618| --- | --- |619| frame.f\_trace\_lines | Установите этот атрибут в [`False`](https://python-all.ru/3.15/library/constants.html#False), чтобы отключить генерацию события трассировки для каждой строки исходного кода. |620| frame.f\_trace\_opcodes | Установите этот атрибут в [`True`](https://python-all.ru/3.15/library/constants.html#True), чтобы разрешить запрос событий на каждую опкоду. Учтите, что это может привести к неопределённому поведению интерпретатора, если исключения, вызванные функцией трассировки, выйдут за пределы трассируемой функции. |621| frame.f\_lineno | Текущий номер строки фрейма – запись в этот атрибут из функции трассировки переводит выполнение на указанную строку (только для самого нижнего фрейма). Отладчик может реализовать команду Jump (также известную как Set Next Statement), записывая значение в этот атрибут. |622623##### 3.2.13.2.3. Методы объекта Frame624625Объекты Frame поддерживают один метод:626627#### `frame.clear()`628629Этот метод удаляет все ссылки на [локальные переменные](https://python-all.ru/3.15/reference/executionmodel.html#naming), хранящиеся в фрейме. Кроме того, если фрейм принадлежал [генератору](https://python-all.ru/3.15/glossary.html#term-generator), генератор завершается. Это помогает разорвать циклические ссылки с участием объектов фреймов (например, при перехвате [исключения](https://python-all.ru/3.15/library/exceptions.html#bltin-exceptions) и сохранении его [трассировки](https://python-all.ru/3.15/reference/datamodel.html#traceback-objects) для последующего использования).630631[`RuntimeError`](https://python-all.ru/3.15/library/exceptions.html#RuntimeError) возбуждается, если фрейм в данный момент выполняется или приостановлен.632633Добавлено в версии 3.4.634635Изменено в версии 3.13: Попытка очистки приостановленного фрейма вызывает [`RuntimeError`](https://python-all.ru/3.15/library/exceptions.html#RuntimeError) (как и было для выполняющихся фреймов).636637#### 3.2.13.3. Объекты Traceback638639Объекты Traceback представляют стек вызовов [исключения](https://python-all.ru/3.15/tutorial/errors.html#tut-errors). Объект traceback неявно создается при возникновении исключения, а также может быть явно создан вызовом [`types.TracebackType`](https://python-all.ru/3.15/library/types.html#types.TracebackType).640641Изменено в версии 3.7: Теперь объекты Traceback можно явно создавать из кода Python.642643Для неявно созданных трассировок, когда поиск обработчика исключения разворачивает стек выполнения, на каждом развернутом уровне объект traceback вставляется перед текущей трассировкой. При входе в обработчик исключения трассировка стека становится доступной программе. (См. раздел [Инструкция try](https://python-all.ru/3.15/reference/compound_stmts.html#try).) Она доступна как третий элемент кортежа, возвращаемого [`sys.exc_info()`](https://python-all.ru/3.15/library/sys.html#sys.exc_info), и как атрибут [`__traceback__`](https://python-all.ru/3.15/library/exceptions.html#BaseException.__traceback__) перехваченного исключения.644645Если программа не содержит подходящего обработчика, трассировка стека выводится (в удобочитаемом формате) в стандартный поток ошибок; если интерпретатор работает в интерактивном режиме, она также становится доступной пользователю как [`sys.last_traceback`](https://python-all.ru/3.15/library/sys.html#sys.last_traceback).646647Для явно созданных трассировок создатель трассировки сам определяет, как атрибуты [`tb_next`](https://python-all.ru/3.15/reference/datamodel.html#traceback.tb_next) должны быть связаны для формирования полной трассировки стека.648649Специальные атрибуты только для чтения:650651| traceback.tb\_frame | Указывает на [фрейм](https://python-all.ru/3.15/reference/datamodel.html#frame-objects) выполнения текущего уровня. Доступ к этому атрибуту вызывает [событие аудита](https://python-all.ru/3.15/library/sys.html#auditing) `object.__getattr__` с аргументами `obj` и `"tb_frame"`. |652| --- | --- |653| traceback.tb\_lineno | Возвращает номер строки, в которой произошло исключение |654| traceback.tb\_lasti | Указывает на «точную инструкцию». |655656Номер строки и последняя инструкция в трассировке могут отличаться от номера строки [объекта фрейма](https://python-all.ru/3.15/reference/datamodel.html#frame-objects), если исключение произошло в [`try`](https://python-all.ru/3.15/reference/compound_stmts.html#try) операторе без соответствующего блока except или с [`finally`](https://python-all.ru/3.15/reference/compound_stmts.html#finally) блоком.657658#### `traceback.tb_next`659660Специальный атрибут для записи `tb_next` – это следующий уровень в трассировке стека (по направлению к фрейму, где произошло исключение), или `None`, если следующего уровня нет.661662Изменено в версии 3.7: Теперь этот атрибут доступен для записи663664#### 3.2.13.4. Объекты slice665666Объекты slice используются для представления срезов для [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__) методов. Они также создаются встроенной функцией [`slice()`](https://python-all.ru/3.15/library/functions.html#slice).667668Добавлено в версии 3.15: Тип [`slice()`](https://python-all.ru/3.15/library/functions.html#slice) теперь поддерживает [подписку](https://python-all.ru/3.15/reference/expressions.html#subscriptions). Например, `slice[float]` может использоваться в аннотациях типов для указания среза, содержащего объекты [`float`](https://python-all.ru/3.15/library/functions.html#float).669670Специальные атрибуты только для чтения: [`start`](https://python-all.ru/3.15/library/functions.html#slice.start) – нижняя граница; [`stop`](https://python-all.ru/3.15/library/functions.html#slice.stop) – верхняя граница; [`step`](https://python-all.ru/3.15/library/functions.html#slice.step) – шаг (значение); каждый равен `None`, если опущен. Эти атрибуты могут иметь любой тип.671672Объекты slice поддерживают один метод:673674#### `slice.indices(self, length)`675676Этот метод принимает единственный целочисленный аргумент *length* и вычисляет информацию о срезе, который объект среза описывал бы, если бы был применен к последовательности из *length* элементов. Он возвращает кортеж из трех целых чисел; соответственно это индексы *start* и *stop*, а также *step* или длина шага среза. Пропущенные или выходящие за границы индексы обрабатываются так же, как и для обычных срезов.677678#### 3.2.13.5. Объекты статических методов679680Объекты статических методов позволяют обойти преобразование объектов-функций в объекты-методы, описанное выше. Объект статического метода – это обёртка вокруг любого другого объекта, обычно пользовательского метода. При получении объекта статического метода из класса или экземпляра класса фактически возвращается обёрнутый объект, который не подвергается дальнейшим преобразованиям. Объекты статических методов также вызываемы. Они создаются встроенным конструктором [`staticmethod()`](https://python-all.ru/3.15/library/functions.html#staticmethod).681682#### 3.2.13.6. Объекты методов класса683684Объект метода класса, как и объект статического метода, является обёрткой вокруг другого объекта, которая изменяет способ получения этого объекта из классов и экземпляров классов. Поведение объектов методов класса при таком получении описано выше, в разделе [«методы экземпляра»](https://python-all.ru/3.15/reference/datamodel.html#instance-methods). Объекты методов класса создаются встроенным конструктором [`classmethod()`](https://python-all.ru/3.15/library/functions.html#classmethod).685686## 3.3. Специальные имена методов687688Класс может реализовать определённые операции, вызываемые специальным синтаксисом (например, арифметические операции или индексирование и срезы), определив методы со специальными именами. Это подход Python к *перегрузке операторов*, позволяющий классам определять собственное поведение для языковых операторов. Например, если класс определяет метод с именем [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__), а `x` – экземпляр этого класса, то `x[i]` примерно эквивалентно `type(x).__getitem__(x, i)`. За исключением оговоренных случаев, попытки выполнить операцию вызывают исключение, если не определён соответствующий метод (обычно [`AttributeError`](https://python-all.ru/3.15/library/exceptions.html#AttributeError) или [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError)).689690Установка специального метода в `None` означает, что соответствующая операция недоступна. Например, если класс устанавливает [`__iter__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__iter__) в `None`, класс не является итерируемым, поэтому вызов [`iter()`](https://python-all.ru/3.15/library/functions.html#iter) на его экземплярах вызовет исключение [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError) (без обращения к [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__)). [\[2\]](https://python-all.ru/3.15/reference/datamodel.html#id21)691692При реализации класса, эмулирующего какой-либо встроенный тип, важно, чтобы эмуляция выполнялась только в той степени, в которой это имеет смысл для моделируемого объекта. Например, некоторые последовательности могут хорошо работать с извлечением отдельных элементов, но извлечение среза может не иметь смысла. (Одним из примеров является интерфейс [NodeList](https://python-all.ru/3.15/library/xml.dom.html#dom-nodelist-objects) в объектной модели документа W3C.)693694### 3.3.1. Базовая настройка695696#### `object.__new__(cls[, ...])`697698Вызывается для создания нового экземпляра класса *cls*. `__new__()` – это статический метод (специальный случай, поэтому его не нужно объявлять таковым), который принимает в качестве первого аргумента класс, для которого запрашивается экземпляр. Остальные аргументы – это те, что были переданы в выражение конструктора объекта (вызов класса). Возвращаемое значение `__new__()` должно быть новым экземпляром объекта (обычно экземпляром *cls*).699700Типичные реализации создают новый экземпляр класса, вызывая метод `__new__()` суперкласса с помощью `super().__new__(cls[, ...])` с соответствующими аргументами, а затем при необходимости изменяют созданный экземпляр перед возвратом.701702Если `__new__()` вызывается во время создания объекта и возвращает экземпляр *cls*, то метод [`__init__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__init__) нового экземпляра будет вызван как `__init__(self[, ...])`, где *self* – это новый экземпляр, а остальные аргументы те же, что были переданы конструктору объекта.703704Если `__new__()` не возвращает экземпляр *cls*, то метод [`__init__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__init__) нового экземпляра вызываться не будет.705706`__new__()` в первую очередь предназначен для того, чтобы подклассы неизменяемых типов (таких как int, str или tuple) могли настраивать создание экземпляров. Он также часто переопределяется в пользовательских метаклассах для настройки создания классов.707708#### `object.__init__(self[, ...])`709710Вызывается после создания экземпляра (с помощью [`__new__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__new__)), но до его возврата вызывающему. Аргументы – это те, что были переданы в выражение конструктора класса. Если базовый класс имеет метод `__init__()`, то производный класс, если у него есть метод `__init__()`, должен явно вызвать его, чтобы гарантировать правильную инициализацию части экземпляра, относящейся к базовому классу; например: `super().__init__([args...])`.711712Поскольку [`__new__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__new__) и `__init__()` работают вместе при создании объектов (`__new__()` создаёт его, а `__init__()` настраивает), метод `__init__()` не должен возвращать никакого значения, кроме `None`; в противном случае во время выполнения будет возбуждено исключение [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError).713714#### `object.__del__(self)`715716Вызывается, когда экземпляр должен быть уничтожен. Это также называется финализатором или (некорректно) деструктором. Если базовый класс имеет метод `__del__()`, то производный класс, если у него есть метод `__del__()`, должен явно вызвать его, чтобы обеспечить корректное удаление части экземпляра, относящейся к базовому классу.717718Метод `__del__()` может (хотя это не рекомендуется!) отложить уничтожение экземпляра, создав на него новую ссылку. Это называется *воскрешением* объекта. Зависит от реализации, будет ли `__del__()` вызван второй раз, когда воскрешённый объект будет уничтожен; текущая реализация [CPython](https://python-all.ru/3.15/glossary.html#term-CPython) вызывает его только один раз.719720Не гарантируется, что методы `__del__()` будут вызваны для объектов, которые всё ещё существуют при завершении интерпретатора. [`weakref.finalize`](https://python-all.ru/3.15/library/weakref.html#weakref.finalize) предоставляет простой способ зарегистрировать функцию очистки, которая будет вызвана при сборке мусора объекта.721722> **Примечание**723>724> `del x` не вызывает напрямую `x.__del__()` – первая уменьшает счётчик ссылок на `x` на единицу, а вторая вызывается только тогда, когда счётчик ссылок `x` достигает нуля.725726**Особенность реализации CPython:** Циклическая ссылка может помешать счётчику ссылок объекта достичь нуля. В этом случае цикл будет позднее обнаружен и удалён [циклическим сборщиком мусора](https://python-all.ru/3.15/glossary.html#term-garbage-collection). Частая причина циклических ссылок – когда исключение было перехвачено в локальной переменной. Тогда локальные переменные фрейма ссылаются на исключение, которое ссылается на свою трассировку стека, а та, в свою очередь, ссылается на локальные переменные всех фреймов, захваченных в трассировку.727728> **См. также**729>730> Документация по модулю [`gc`](https://python-all.ru/3.15/library/gc.html#module-gc).731732> **Предупреждение**733>734> Из-за ненадёжных обстоятельств, при которых вызываются методы `__del__()`, исключения, возникающие во время их выполнения, игнорируются, а вместо этого предупреждение выводится в `sys.stderr`. В частности:735>736> - `__del__()` может быть вызван во время выполнения произвольного кода, в том числе из любого произвольного потока. Если `__del__()` требуется захватить блокировку или обратиться к другому блокирующему ресурсу, может возникнуть взаимоблокировка, поскольку ресурс может уже быть занят кодом, который прерывается для выполнения `__del__()`.737> - `__del__()` может выполняться во время завершения работы интерпретатора. В результате глобальные переменные, к которым ему нужно получить доступ (включая другие модули), могут уже быть удалены или установлены в `None`. Python гарантирует, что глобальные переменные, имена которых начинаются с одного символа подчёркивания, удаляются из своего модуля раньше, чем остальные; если других ссылок на такие глобальные переменные нет, это может помочь обеспечить доступность импортированных модулей на момент вызова метода `__del__()`.738739#### `object.__repr__(self)`740741Вызывается встроенной функцией [`repr()`](https://python-all.ru/3.15/library/functions.html#repr) для вычисления «официального» строкового представления объекта. Если возможно, это представление должно выглядеть как допустимое выражение Python, которое можно использовать для воссоздания объекта с тем же значением (в подходящем окружении). Если это невозможно, следует вернуть строку вида `<...some useful description...>`. Возвращаемое значение должно быть строковым объектом. Если класс определяет `__repr__()`, но не [`__str__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__str__), то `__repr__()` также используется, когда требуется «неформальное» строковое представление экземпляров этого класса.742743Обычно используется для отладки, поэтому важно, чтобы представление было информативным и недвусмысленным. Реализация по умолчанию предоставляется самим классом [`object`](https://python-all.ru/3.15/library/functions.html#object).744745#### `object.__str__(self)`746747Вызывается функцией [`str(object)`](https://python-all.ru/3.15/library/stdtypes.html#str), реализацией по умолчанию [`__format__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__format__) и встроенной функцией [`print()`](https://python-all.ru/3.15/library/functions.html#print) для вычисления «неформального» или красиво выводимого строкового представления объекта. Возвращаемое значение должно быть объектом [str](https://python-all.ru/3.15/library/stdtypes.html#textseq).748749Этот метод отличается от [`object.__repr__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__repr__) тем, что от `__str__()` не ожидается возврат корректного выражения Python: можно использовать более удобное или краткое представление.750751Реализация по умолчанию, определённая встроенным типом [`object`](https://python-all.ru/3.15/library/functions.html#object), вызывает [`object.__repr__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__repr__).752753#### `object.__bytes__(self)`754755Вызывается [bytes](https://python-all.ru/3.15/library/functions.html#func-bytes) для вычисления байтового строкового представления объекта. Должен возвращать объект [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes). Сам класс [`object`](https://python-all.ru/3.15/library/functions.html#object) не предоставляет этот метод.756757#### `object.__format__(self, format_spec)`758759Вызывается встроенной функцией [`format()`](https://python-all.ru/3.15/library/functions.html#format), а также, соответственно, при вычислении [форматированных строковых литералов](https://python-all.ru/3.15/reference/lexical_analysis.html#f-strings) и метода [`str.format()`](https://python-all.ru/3.15/library/stdtypes.html#str.format) для получения «форматированного» строкового представления объекта. Аргумент *format\_spec* – это строка с описанием желаемых параметров форматирования. Интерпретация аргумента *format\_spec* зависит от типа, реализующего `__format__()`, однако большинство классов либо делегируют форматирование одному из встроенных типов, либо используют похожий синтаксис параметров форматирования.760761Описание стандартного синтаксиса форматирования см. в [миниязыке спецификации формата](https://python-all.ru/3.15/library/string.html#formatspec).762763Возвращаемое значение должно быть строковым объектом.764765Реализации по умолчанию класса [`object`](https://python-all.ru/3.15/library/functions.html#object) следует передавать пустую строку *format\_spec*. Она делегирует вызов методу [`__str__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__str__).766767Изменено в версии 3.4: Метод \_\_format\_\_ самого `object` вызывает [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError), если ему передана непустая строка.768769Изменено в версии 3.7: `object.__format__(x, '')` теперь эквивалентен `str(x)` вместо `format(str(x), '')`.770771#### `object.__lt__(self, other)`772773#### `object.__le__(self, other)`774775#### `object.__eq__(self, other)`776777#### `object.__ne__(self, other)`778779#### `object.__gt__(self, other)`780781#### `object.__ge__(self, other)`782783Это так называемые методы «расширенного сравнения». Соответствие между символами операторов и именами методов следующее: `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)`.784785Метод расширенного сравнения может вернуть синглтон [`NotImplemented`](https://python-all.ru/3.15/library/constants.html#NotImplemented), если он не реализует операцию для данной пары аргументов. По соглашению, при успешном сравнении возвращаются `False` и `True`. Однако эти методы могут возвращать любое значение, поэтому если оператор сравнения используется в логическом контексте (например, в условии оператора `if`), Python вызовет [`bool()`](https://python-all.ru/3.15/library/functions.html#bool) для этого значения, чтобы определить, истинно оно или ложно.786787По умолчанию `object` реализует `__eq__()` с помощью `is`, возвращая [`NotImplemented`](https://python-all.ru/3.15/library/constants.html#NotImplemented) в случае ложного сравнения: `True if x is y else NotImplemented`. Для `__ne__()` по умолчанию он делегирует вызов `__eq__()` и инвертирует результат, если только он не равен `NotImplemented`. Других подразумеваемых связей между операторами сравнения или реализациями по умолчанию нет; например, истинность `(x<y or x==y)` не подразумевает `x<=y`. Чтобы автоматически генерировать операции упорядочивания из одной корневой операции, см. [`functools.total_ordering()`](https://python-all.ru/3.15/library/functools.html#functools.total_ordering).788789По умолчанию класс [`object`](https://python-all.ru/3.15/library/functions.html#object) предоставляет реализации, соответствующие [сравнению значений](https://python-all.ru/3.15/reference/expressions.html#expressions-value-comparisons): равенство сравнивается по идентичности объектов, а сравнения порядка вызывают [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError). Каждый метод по умолчанию может возвращать эти результаты напрямую, но также может вернуть [`NotImplemented`](https://python-all.ru/3.15/library/constants.html#NotImplemented).790791Важные замечания по созданию [хешируемых](https://python-all.ru/3.15/glossary.html#term-hashable) объектов, поддерживающих пользовательские операции сравнения и пригодных для использования в качестве ключей словаря, см. в параграфе [`__hash__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__hash__).792793Не существует версий этих методов с переставленными аргументами (для случаев, когда левый аргумент не поддерживает операцию, а правый – поддерживает); вместо этого `__lt__()` и `__gt__()` являются отражениями друг друга, `__le__()` и `__ge__()` – отражениями друг друга, а `__eq__()` и `__ne__()` являются собственными отражениями. Если операнды разных типов, и тип правого операнда является прямым или косвенным подклассом типа левого операнда, приоритет имеет отражённый метод правого операнда; в противном случае приоритет имеет метод левого операнда. Виртуальное наследование не учитывается.794795Если ни один подходящий метод не возвращает значение, отличное от [`NotImplemented`](https://python-all.ru/3.15/library/constants.html#NotImplemented), операторы `==` и `!=` будут использовать запасные варианты – `is` и `is not` соответственно.796797#### `object.__hash__(self)`798799Вызывается встроенной функцией [`hash()`](https://python-all.ru/3.15/library/functions.html#hash) и при операциях над элементами хешированных коллекций, включая [`set`](https://python-all.ru/3.15/library/stdtypes.html#set), [`frozenset`](https://python-all.ru/3.15/library/stdtypes.html#frozenset), [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict), и [`frozendict`](https://python-all.ru/3.15/library/stdtypes.html#frozendict). Метод `__hash__()` должен возвращать целое число. Единственное обязательное свойство: объекты, которые при сравнении равны, должны иметь одинаковое хеш-значение; рекомендуется объединить хеш-значения компонентов объекта, которые также участвуют в сравнении объектов, упаковав их в кортеж и вычислив хеш кортежа. Пример:800801```python802def __hash__(self):803    return hash((self.name, self.nick, self.color))804```805806> **Примечание**807>808> [`hash()`](https://python-all.ru/3.15/library/functions.html#hash) усекает значение, возвращаемое пользовательским методом `__hash__()` объекта, до размера [`Py_ssize_t`](https://python-all.ru/3.15/c-api/intro.html#c.Py_ssize_t). Обычно это 8 байт в 64-битных сборках и 4 байта в 32-битных. Если `__hash__()` объекта должна работать в сборках с разной разрядностью, обязательно проверьте ширину во всех поддерживаемых сборках. Простой способ сделать это – с помощью `python -c "import sys; print(sys.hash_info.width)"`.809810Если класс не определяет метод [`__eq__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__eq__), ему не следует определять и операцию `__hash__()`; если он определяет `__eq__()`, но не `__hash__()`, его экземпляры не смогут использоваться как элементы хешируемых коллекций. Если класс определяет изменяемые объекты и реализует метод `__eq__()`, ему не следует реализовывать `__hash__()`, поскольку реализация [хешируемых](https://python-all.ru/3.15/glossary.html#term-hashable) коллекций требует, чтобы хеш-значение ключа было неизменным (если хеш-значение объекта изменится, он окажется в неверной хеш-корзине).811812Пользовательские классы имеют методы [`__eq__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__eq__) и `__hash__()` по умолчанию (унаследованные от класса [`object`](https://python-all.ru/3.15/library/functions.html#object)); с ними все объекты сравниваются как неравные (кроме сравнения с самим собой), а `x.__hash__()` возвращает подходящее значение, так что `x == y` подразумевает как `x is y`, так и `hash(x) == hash(y)`.813814Класс, который переопределяет [`__eq__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__eq__) и не определяет `__hash__()`, будет иметь неявно установленный `__hash__()` в `None`. Когда метод `__hash__()` класса установлен в `None`, экземпляры класса будут вызывать соответствующее [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError) при попытке программы получить их хеш-значение, а также будут правильно идентифицироваться как нехешируемые при проверке `isinstance(obj, collections.abc.Hashable)`.815816Если класс, переопределяющий [`__eq__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__eq__), должен сохранить реализацию `__hash__()` от родительского класса, интерпретатору необходимо явно сообщить об этом, установив `__hash__ = <ParentClass>.__hash__`.817818Если класс, который не переопределяет [`__eq__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__eq__), хочет отключить поддержку хеширования, он должен включить `__hash__ = None` в определение класса. Класс, определяющий собственный `__hash__()`, который явно вызывает [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError), будет ошибочно идентифицирован как хешируемый при вызове `isinstance(obj, collections.abc.Hashable)`.819820> **Примечание**821>822> По умолчанию значения `__hash__()` объектов str и bytes «солятся» непредсказуемым случайным значением. Хотя они остаются постоянными в рамках одного процесса Python, между разными запусками Python они не предсказуемы.823>824> Это предназначено для защиты от отказа в обслуживании, вызванного специально подобранными входными данными, которые используют наихудшую производительность вставки в dict – сложность *O*(*n*2). Подробнее см. [https://ocert.org/advisories/ocert-2011-003.html](https://python-all.ru/3.15/reference/datamodel.html).825>826> Изменение хеш-значений влияет на порядок перебора множеств. Python никогда не давал гарантий относительно этого порядка (и он обычно различается между 32-битными и 64-битными сборками).827>828> См. также [`PYTHONHASHSEED`](https://python-all.ru/3.15/using/cmdline.html#envvar-PYTHONHASHSEED).829830Изменено в версии 3.3: Рандомизация хешей включена по умолчанию.831832#### `object.__bool__(self)`833834Вызывается для реализации проверки истинности и встроенной операции `bool()`; должна возвращать `False` или `True`. Если этот метод не определён, вызывается [`__len__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__len__), если он определён, и объект считается истинным, если его результат не равен нулю. Если класс не определяет ни `__len__()`, ни `__bool__()` (что верно для самого класса [`object`](https://python-all.ru/3.15/library/functions.html#object)), все его экземпляры считаются истинными.835836### 3.3.2. Настройка доступа к атрибутам837838Следующие методы могут быть определены для настройки смысла доступа к атрибутам (чтения, присваивания или удаления `x.name`) для экземпляров классов.839840#### `object.__getattr__(self, name)`841842Вызывается, когда обычный доступ к атрибуту завершается [`AttributeError`](https://python-all.ru/3.15/library/exceptions.html#AttributeError) (либо [`__getattribute__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getattribute__) вызывает `AttributeError`, потому что *name* не является атрибутом экземпляра или атрибутом в дереве классов для `self`; либо [`__get__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__get__) свойства *name* вызывает `AttributeError`). Этот метод должен либо вернуть (вычисленное) значение атрибута, либо вызвать исключение `AttributeError`. Сам класс [`object`](https://python-all.ru/3.15/library/functions.html#object) не предоставляет этот метод.843844Обратите внимание: если атрибут найден через обычный механизм, `__getattr__()` не вызывается. (Это намеренная асимметрия между `__getattr__()` и [`__setattr__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__setattr__).) Это сделано как по соображениям эффективности, так и потому что иначе `__getattr__()` не имел бы возможности получить доступ к другим атрибутам экземпляра. Заметьте, что по крайней мере для переменных экземпляра можно получить полный контроль, не вставляя никаких значений в словарь атрибутов экземпляра (а вставляя их в другой объект). См. метод [`__getattribute__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getattribute__) ниже для способа действительно получить полный контроль над доступом к атрибутам.845846#### `object.__getattribute__(self, name)`847848Вызывается безусловно для реализации доступа к атрибутам экземпляров класса. Если класс также определяет [`__getattr__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getattr__), последний не будет вызван, пока `__getattribute__()` либо не вызовет его явно, либо не вызовет [`AttributeError`](https://python-all.ru/3.15/library/exceptions.html#AttributeError). Этот метод должен возвращать (вычисленное) значение атрибута или вызывать исключение `AttributeError`. Чтобы избежать бесконечной рекурсии в этом методе, его реализация всегда должна вызывать метод базового класса с тем же именем для доступа к любым необходимым атрибутам, например, `object.__getattribute__(self, name)`.849850> **Примечание**851>852> Этот метод может быть обойдён при поиске специальных методов в результате неявного вызова через синтаксис языка или [встроенные функции](https://python-all.ru/3.15/reference/datamodel.html#builtin-functions). См. [Поиск специальных методов](https://python-all.ru/3.15/reference/datamodel.html#special-lookup).853854Для некоторых чувствительных операций доступа к атрибутам вызывает [событие аудита](https://python-all.ru/3.15/library/sys.html#auditing) `object.__getattr__` с аргументами `obj` и `name`.855856#### `object.__setattr__(self, name, value)`857858Вызывается при попытке присвоения атрибута. Этот метод вызывается вместо обычного механизма (т.е. сохранения значения в словаре экземпляра). *name* – имя атрибута, *value* – значение, которое ему присваивается.859860Если `__setattr__()` хочет присвоить значение атрибуту экземпляра, он должен вызвать метод базового класса с тем же именем, например, `object.__setattr__(self, name, value)`.861862Для некоторых чувствительных операций присвоения атрибутов вызывает [событие аудита](https://python-all.ru/3.15/library/sys.html#auditing) `object.__setattr__` с аргументами `obj`, `name`, `value`.863864#### `object.__delattr__(self, name)`865866Как [`__setattr__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__setattr__), но для удаления атрибутов вместо присваивания. Этот метод следует реализовывать, только если `del obj.name` имеет смысл для объекта.867868Для некоторых чувствительных операций удаления атрибутов вызывает [событие аудита](https://python-all.ru/3.15/library/sys.html#auditing) `object.__delattr__` с аргументами `obj` и `name`.869870#### `object.__dir__(self)`871872Вызывается, когда для объекта вызывается [`dir()`](https://python-all.ru/3.15/library/functions.html#dir). Должен возвращаться итерируемый объект. `dir()` преобразует возвращённый итерируемый объект в список и сортирует его.873874#### 3.3.2.1. Настройка доступа к атрибутам модуля875876#### `module.__getattr__()`877878#### `module.__dir__()`879880Специальные имена `__getattr__` и `__dir__` также могут использоваться для настройки доступа к атрибутам модуля. Функция `__getattr__` на уровне модуля должна принимать один аргумент – имя атрибута – и возвращать вычисленное значение или вызывать исключение [`AttributeError`](https://python-all.ru/3.15/library/exceptions.html#AttributeError). Если атрибут не найден на объекте модуля через обычный поиск, т.е. [`object.__getattribute__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getattribute__), то `__getattr__` ищется в модуле `__dict__` перед вызовом `AttributeError`. Если найдена, она вызывается с именем атрибута, и результат возвращается.881882Функция `__dir__` не должна принимать аргументов и должна возвращать итерируемый объект со строками, представляющими имена, доступные в модуле. Если эта функция присутствует, она переопределяет стандартный поиск [`dir()`](https://python-all.ru/3.15/library/functions.html#dir) в модуле.883884#### `module.__class__`885886Для более тонкой настройки поведения модуля (установка атрибутов, свойств и т.д.) можно установить атрибут `__class__` объекта модуля в подкласс [`types.ModuleType`](https://python-all.ru/3.15/library/types.html#types.ModuleType). Например:887888```python889import sys890from types import ModuleType891892class VerboseModule(ModuleType):893    def __repr__(self):894        return f'Verbose {self.__name__}'895896    def __setattr__(self, attr, value):897        print(f'Setting {attr}...')898        super().__setattr__(attr, value)899900sys.modules[__name__].__class__ = VerboseModule901```902903> **Примечание**904>905> Определение модуля `__getattr__` и установка модуля `__class__` влияют только на поиск через синтаксис доступа к атрибутам. Прямой доступ к глобальным переменным модуля (как из кода внутри модуля, так и через ссылку на словарь глобальных переменных модуля) не затрагивается.906907Изменено в версии 3.5: атрибут модуля `__class__` теперь доступен для записи.908909Добавлено в версии 3.7: атрибуты модуля `__getattr__` и `__dir__`.910911> **См. также**912>913> **[**PEP 562**](https://python-all.ru/3.15/reference/datamodel.html) – Модули \_\_getattr\_\_ и \_\_dir\_\_**914>915> Описывает функции `__getattr__` и `__dir__` для модулей.916917#### 3.3.2.2. Реализация дескрипторов918919Следующие методы применяются только тогда, когда экземпляр класса, содержащего метод (так называемый *класс дескриптора*), появляется в *классе-владельце* (дескриптор должен находиться либо в словаре класса-владельца, либо в словаре одного из его родительских классов). В примерах ниже «атрибут» относится к атрибуту, имя которого является ключом свойства в [`__dict__`](https://python-all.ru/3.15/reference/datamodel.html#object.__dict__) класса-владельца. Сам класс [`object`](https://python-all.ru/3.15/library/functions.html#object) не реализует ни один из этих протоколов.920921#### `object.__get__(self, instance, owner=None)`922923Вызывается для получения атрибута класса-владельца (доступ к атрибуту класса) или экземпляра этого класса (доступ к атрибуту экземпляра). Необязательный аргумент *owner* – это класс-владелец, а *instance* – экземпляр, через который был получен атрибут, или `None`, если атрибут получен через *owner*.924925Этот метод должен вернуть вычисленное значение атрибута или возбудить исключение [`AttributeError`](https://python-all.ru/3.15/library/exceptions.html#AttributeError).926927[**PEP 252**](https://python-all.ru/3.15/reference/datamodel.html) определяет, что `__get__()` можно вызывать с одним или двумя аргументами. Встроенные дескрипторы Python поддерживают эту спецификацию; однако некоторые сторонние инструменты могут иметь дескрипторы, которым требуются оба аргумента. Собственная реализация [`__getattribute__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getattribute__) в Python всегда передаёт оба аргумента, независимо от того, нужны ли они.928929#### `object.__set__(self, instance, value)`930931Вызывается для установки атрибута экземпляра *instance* класса-владельца в новое значение *value*.932933Обратите внимание: добавление `__set__()` или [`__delete__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__delete__) превращает дескриптор в «дескриптор данных». Подробнее см. [Вызов дескрипторов](https://python-all.ru/3.15/reference/datamodel.html#descriptor-invocation).934935#### `object.__delete__(self, instance)`936937Вызывается для удаления атрибута экземпляра *instance* класса-владельца.938939Экземпляры дескрипторов также могут иметь атрибут `__objclass__`:940941#### `object.__objclass__`942943Атрибут `__objclass__` интерпретируется модулем [`inspect`](https://python-all.ru/3.15/library/inspect.html#module-inspect) как указание класса, в котором был определён этот объект (правильная установка может помочь при интроспекции динамических атрибутов класса во время выполнения). Для вызываемых объектов он может указывать, что в качестве первого позиционного аргумента ожидается или требуется экземпляр указанного типа (или подкласса) (например, CPython устанавливает этот атрибут для несвязанных методов, реализованных на C).944945#### 3.3.2.3. Вызов дескрипторов946947В общем случае дескриптор – это атрибут объекта с «поведением привязки», доступ к которому переопределён методами протокола дескрипторов: [`__get__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__get__), [`__set__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__set__) и [`__delete__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__delete__). Если для объекта определён хотя бы один из этих методов, он считается дескриптором.948949Поведение по умолчанию при доступе к атрибуту – получение, установка или удаление атрибута из словаря объекта. Например, `a.x` имеет цепочку поиска, начинающуюся с `a.__dict__['x']`, затем `type(a).__dict__['x']`, и продолжающуюся по базовым классам `type(a)`, исключая метаклассы.950951Однако, если найденное значение является объектом, определяющим один из методов дескриптора, то Python может переопределить поведение по умолчанию и вместо этого вызвать метод дескриптора. Где именно это происходит в цепочке приоритетов, зависит от того, какие методы дескриптора определены и как они были вызваны.952953Отправная точка для вызова дескриптора – привязка, `a.x`. Способ сборки аргументов зависит от `a`:954955**Прямой вызов**956957Самый простой и наименее распространённый случай – когда пользовательский код напрямую вызывает метод дескриптора: `x.__get__(a)`.958959**Привязка к экземпляру**960961При привязке к экземпляру объекта `a.x` преобразуется в вызов: `type(a).__dict__['x'].__get__(a, type(a))`.962963**Привязка к классу**964965При привязке к классу `A.x` преобразуется в вызов: `A.__dict__['x'].__get__(None, A)`.966967**Привязка через super**968969Точечный поиск, например `super(A, a).x`, ищет в `a.__class__.__mro__` базовый класс `B`, следующий после `A`, а затем возвращает `B.__dict__['x'].__get__(a, A)`. Если это не дескриптор, `x` возвращается без изменений.970971Для привязок экземпляров приоритет вызова дескриптора зависит от того, какие методы дескриптора определены. Дескриптор может определять любую комбинацию [`__get__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__get__), [`__set__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__set__) и [`__delete__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__delete__). Если он не определяет `__get__()`, то при обращении к атрибуту будет возвращён сам объект дескриптора, если только в словаре экземпляра нет значения для этого атрибута. Если дескриптор определяет `__set__()` и/или `__delete__()`, то это дескриптор данных; если не определяет ни того, ни другого – это дескриптор не данных. Обычно дескрипторы данных определяют и `__get__()`, и `__set__()`, а дескрипторы не данных – только метод `__get__()`. Дескрипторы данных с определёнными `__get__()` и `__set__()` (и/или `__delete__()`) всегда переопределяют переопределение в словаре экземпляра. Напротив, дескрипторы не данных могут быть переопределены экземплярами.972973Методы Python (включая декорированные [`@staticmethod`](https://python-all.ru/3.15/library/functions.html#staticmethod) и [`@classmethod`](https://python-all.ru/3.15/library/functions.html#classmethod)) реализованы как дескрипторы не данных. Соответственно, экземпляры могут переопределять и замещать методы. Это позволяет отдельным экземплярам приобретать поведение, отличное от других экземпляров того же класса.974975Функция [`property()`](https://python-all.ru/3.15/library/functions.html#property) реализована как дескриптор данных. Соответственно, экземпляры не могут переопределить поведение свойства.976977#### 3.3.2.4. \_\_slots\_\_978979*\_\_slots\_\_* позволяет явно объявлять члены данных (например, свойства) и запрещает создание [`__dict__`](https://python-all.ru/3.15/reference/datamodel.html#object.__dict__) и *\_\_weakref\_\_* (если только они не объявлены явно в *\_\_slots\_\_* или не доступны в родительском классе).980981Экономия памяти по сравнению с использованием [`__dict__`](https://python-all.ru/3.15/reference/datamodel.html#object.__dict__) может быть значительной. Скорость поиска атрибутов также может заметно возрасти.982983#### `object.__slots__`984985Этой переменной класса можно присвоить строку, итерируемый объект или последовательность строк с именами переменных, используемых экземплярами. *\_\_slots\_\_* резервирует место для объявленных переменных и предотвращает автоматическое создание [`__dict__`](https://python-all.ru/3.15/reference/datamodel.html#object.__dict__) и *\_\_weakref\_\_* для каждого экземпляра.986987Примечания по использованию *\_\_slots\_\_*:988989- При наследовании от класса без *\_\_slots\_\_* атрибуты [`__dict__`](https://python-all.ru/3.15/reference/datamodel.html#object.__dict__) и *\_\_weakref\_\_* экземпляров всегда будут доступны.990- Без переменной [`__dict__`](https://python-all.ru/3.15/reference/datamodel.html#object.__dict__) экземплярам нельзя присвоить новые переменные, не перечисленные в определении *\_\_slots\_\_*. Попытка присвоить значение незарегистрированному имени переменной вызывает [`AttributeError`](https://python-all.ru/3.15/library/exceptions.html#AttributeError). Если требуется динамическое присвоение новых переменных, добавьте `'__dict__'` в последовательность строк в объявлении *\_\_slots\_\_*.991- Без переменной *\_\_weakref\_\_* для каждого экземпляра классы, определяющие *\_\_slots\_\_*, не поддерживают [`weak references`](https://python-all.ru/3.15/library/weakref.html#module-weakref) для своих экземпляров. Если нужна поддержка слабых ссылок, добавьте `'__weakref__'` в последовательность строк в объявлении *\_\_slots\_\_*.992- *\_\_slots\_\_* реализуются на уровне класса путём создания [дескрипторов](https://python-all.ru/3.15/reference/datamodel.html#descriptors) для каждого имени переменной. В результате атрибуты класса нельзя использовать для установки значений по умолчанию для переменных экземпляра, определённых через *\_\_slots\_\_*; иначе атрибут класса перезапишет присваивание дескриптора.993- Действие объявления *\_\_slots\_\_* не ограничивается классом, в котором оно определено. *\_\_slots\_\_*, объявленные в родительских классах, доступны в дочерних. Однако экземпляры дочернего подкласса получат [`__dict__`](https://python-all.ru/3.15/reference/datamodel.html#object.__dict__) и *\_\_weakref\_\_*, если только подкласс также не определяет *\_\_slots\_\_* (который должен содержать только имена любых *дополнительных* слотов).994- Если класс определяет слот, который также определён в базовом классе, переменная экземпляра, определённая слотом базового класса, становится недоступной (за исключением прямого получения её дескриптора из базового класса). Это делает поведение программы неопределённым. В будущем может быть добавлена проверка для предотвращения такой ситуации.995- [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError) будет вызвано, если *\_\_slots\_\_*, отличные от *\_\_dict\_\_* и *\_\_weakref\_\_*, определены для класса, производного от [`"variable-length" built-in type`](https://python-all.ru/3.15/c-api/typeobj.html#c.PyTypeObject.tp_itemsize), таких как [`int`](https://python-all.ru/3.15/library/functions.html#int), [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) и [`type`](https://python-all.ru/3.15/library/functions.html#type), за исключением [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple).996- Любой нестроковый [итерируемый объект](https://python-all.ru/3.15/glossary.html#term-iterable) может быть присвоен *\_\_slots\_\_*.997- Если для присваивания *\_\_slots\_\_* используется [`dictionary`](https://python-all.ru/3.15/library/stdtypes.html#dict), ключи словаря будут использоваться как имена слотов. Значения словаря можно использовать для указания строк документации для каждого атрибута, которые будут распознаны [`inspect.getdoc()`](https://python-all.ru/3.15/library/inspect.html#inspect.getdoc) и отображены в выводе [`help()`](https://python-all.ru/3.15/library/functions.html#help).998- Присваивание [`__class__`](https://python-all.ru/3.15/reference/datamodel.html#object.__class__) работает, только если оба класса имеют одинаковые *\_\_slots\_\_*.999- [Множественное наследование](https://python-all.ru/3.15/reference/compound_stmts.html#multiple-inheritance) с несколькими родительскими классами, имеющими слоты, возможно, но только один родитель может иметь атрибуты, созданные слотами (остальные базовые классы должны иметь пустые раскладки слотов) – нарушение вызывает [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError).1000- Если для *\_\_slots\_\_* используется [итератор](https://python-all.ru/3.15/glossary.html#term-iterator), то для каждого значения итератора создаётся [дескриптор](https://python-all.ru/3.15/glossary.html#term-descriptor). Однако атрибут *\_\_slots\_\_* будет пустым итератором.10011002Изменено в версии 3.15: Разрешено определять *\_\_dict\_\_* и *\_\_weakref\_\_* в качестве *\_\_slots\_\_* для любого класса. Разрешено определять любые *\_\_slots\_\_* для класса, производного от [`tuple`](https://python-all.ru/3.15/library/stdtypes.html#tuple).10031004### 3.3.3. Настройка создания классов10051006Всякий раз, когда класс наследуется от другого класса, у родительского класса вызывается [`__init_subclass__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__init_subclass__). Таким образом можно создавать классы, изменяющие поведение подклассов. Это тесно связано с декораторами классов, но в отличие от декораторов, которые влияют только на конкретный класс, к которому они применены, `__init_subclass__` применяется исключительно к будущим подклассам класса, определяющего этот метод.10071008#### `classmethod object.__init_subclass__(cls)`10091010Этот метод вызывается всякий раз, когда содержащий его класс наследуется. *cls* – это новый подкласс. Если метод определён как обычный метод экземпляра, он неявно преобразуется в метод класса.10111012Именованные аргументы, передаваемые новому классу, передаются в `__init_subclass__` родительского класса. Для совместимости с другими классами, использующими `__init_subclass__`, следует извлечь нужные именованные аргументы, а остальные передать базовому классу, как показано:10131014```python1015class Philosopher:1016    def __init_subclass__(cls, /, default_name, **kwargs):1017        super().__init_subclass__(**kwargs)1018        cls.default_name = default_name10191020class AustralianPhilosopher(Philosopher, default_name="Bruce"):1021    pass1022```10231024Реализация по умолчанию `object.__init_subclass__` ничего не делает, но возбуждает ошибку, если вызвана с какими-либо аргументами.10251026> **Примечание**1027>1028> Подсказка метакласса `metaclass` потребляется остальной частью механизма типов и никогда не передаётся в реализации `__init_subclass__`. Фактический метакласс (а не явная подсказка) доступен как `type(cls)`.10291030Добавлено в версии 3.6.10311032При создании класса `type.__new__()` сканирует переменные класса и вызывает колбэки для тех, у которых есть хук [`__set_name__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__set_name__).10331034#### `object.__set_name__(self, owner, name)`10351036Автоматически вызывается в момент создания владеющего класса *owner*. Объект был присвоен атрибуту *name* в этом классе:10371038```python1039class A:1040    x = C()  # Автоматически вызывает: x.__set_name__(A, 'x')1041```10421043Если переменная класса присваивается после создания класса, `__set_name__()` не будет вызван автоматически. При необходимости `__set_name__()` можно вызвать напрямую:10441045```python1046class A:1047   pass10481049c = C()1050A.x = c                  # Хук не вызывается1051c.__set_name__(A, 'x')   # Явный вызов хука1052```10531054Подробнее см. [Создание объекта класса](https://python-all.ru/3.15/reference/datamodel.html#class-object-creation).10551056Добавлено в версии 3.6.10571058#### 3.3.3.1. Метаклассы10591060По умолчанию классы создаются с помощью [`type()`](https://python-all.ru/3.15/library/functions.html#type). Тело класса выполняется в новом пространстве имён, а имя класса локально привязывается к результату `type(name, bases, namespace)`.10611062Процесс создания класса можно настроить, передав `metaclass` ключевой аргумент в строке определения класса или унаследовавшись от существующего класса, который содержит такой аргумент. В следующем примере как `MyClass`, так и `MySubclass` являются экземплярами `Meta`:10631064```python1065class Meta(type):1066    pass10671068class MyClass(metaclass=Meta):1069    pass10701071class MySubclass(MyClass):1072    pass1073```10741075Любые другие ключевые аргументы, указанные в определении класса, передаются всем операциям метакласса, описанным ниже.10761077При выполнении определения класса происходят следующие шаги:10781079- разрешаются записи MRO;1080- определяется подходящий метакласс;1081- подготавливается пространство имён класса;1082- выполняется тело класса;1083- создаётся объект класса.10841085#### 3.3.3.2. Разрешение записей MRO10861087#### `object.__mro_entries__(self, bases)`10881089Если базовый класс, указанный в определении класса, не является экземпляром [`type`](https://python-all.ru/3.15/library/functions.html#type), то в нём ищется метод `__mro_entries__()`. Если метод `__mro_entries__()` найден, то базовый класс заменяется результатом вызова `__mro_entries__()` при создании класса. Метод вызывается с исходным кортежем базовых классов, переданным в параметр *bases*, и должен вернуть кортеж классов, которые будут использоваться вместо базового. Возвращаемый кортеж может быть пустым: в этом случае исходный базовый класс игнорируется.10901091> **См. также**1092>1093> **[`types.resolve_bases()`](https://python-all.ru/3.15/library/types.html#types.resolve_bases)**1094>1095> Динамически разрешает базовые классы, не являющиеся экземплярами [`type`](https://python-all.ru/3.15/library/functions.html#type).1096>1097> **[`types.get_original_bases()`](https://python-all.ru/3.15/library/types.html#types.get_original_bases)**1098>1099> Получить «исходные базовые классы» класса до изменений, внесённых [`__mro_entries__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__mro_entries__).1100>1101> **[**PEP 560**](https://python-all.ru/3.15/reference/datamodel.html)**1102>1103> Базовая поддержка модуля typing и обобщённых типов.11041105#### 3.3.3.3. Определение подходящего метакласса11061107Подходящий метакласс для определения класса выбирается следующим образом:11081109- если не указаны ни базовые классы, ни явный метакласс, то используется [`type()`](https://python-all.ru/3.15/library/functions.html#type);1110- если указан явный метакласс и он *не* является экземпляром [`type()`](https://python-all.ru/3.15/library/functions.html#type), то он используется непосредственно как метакласс;1111- если в качестве явного метакласса указан экземпляр [`type()`](https://python-all.ru/3.15/library/functions.html#type), или определены базовые классы, то используется наиболее производный метакласс.11121113Наиболее производный метакласс выбирается из явно указанного метакласса (если есть) и метаклассов (т.е. `type(cls)`) всех указанных базовых классов. Наиболее производный метакласс – это такой метакласс, который является подтипом *всех* этих кандидатов. Если ни один из кандидатов не удовлетворяет этому критерию, то определение класса завершится ошибкой `TypeError`.11141115#### 3.3.3.4. Подготовка пространства имён класса11161117После того как подходящий метакласс определён, подготавливается пространство имён класса. Если у метакласса есть атрибут `__prepare__`, он вызывается как `namespace = metaclass.__prepare__(name, bases, **kwds)` (где дополнительные ключевые аргументы, если есть, берутся из определения класса). Метод `__prepare__` должен быть реализован как [`classmethod`](https://python-all.ru/3.15/library/functions.html#classmethod). Пространство имён, возвращённое `__prepare__`, передаётся в `__new__`, но при создании окончательного объекта класса пространство имён копируется в новый `dict`.11181119Если у метакласса нет атрибута `__prepare__`, то пространство имён класса инициализируется как пустое упорядоченное отображение.11201121> **См. также**1122>1123> **[**PEP 3115**](https://python-all.ru/3.15/reference/datamodel.html) – Метаклассы в Python 3000**1124>1125> Ввёл перехватчик пространства имён `__prepare__`11261127#### 3.3.3.5. Выполнение тела класса11281129Тело класса выполняется (приблизительно) как `exec(body, globals(), namespace)`. Ключевое отличие от обычного вызова [`exec()`](https://python-all.ru/3.15/library/functions.html#exec) заключается в том, что лексическая область видимости позволяет телу класса (включая любые методы) ссылаться на имена из текущей и внешних областей видимости, когда определение класса находится внутри функции.11301131Однако, даже если определение класса находится внутри функции, методы, определённые внутри класса, всё равно не видят имена, определённые на уровне класса. Доступ к переменным класса должен осуществляться через первый параметр методов экземпляра или класса, либо через неявную лексически ограниченную ссылку `__class__`, описанную в следующем разделе.11321133#### 3.3.3.6. Создание объекта класса11341135После заполнения пространства имён класса путём выполнения тела класса объект класса создаётся вызовом `metaclass(name, bases, namespace, **kwds)` (дополнительные ключевые аргументы, переданные здесь, те же, что и переданные в `__prepare__`).11361137Этот объект класса – тот самый, на который будет ссылаться форма без аргументов [`super()`](https://python-all.ru/3.15/library/functions.html#super). `__class__` – это неявная ссылка на замыкание, создаваемая компилятором, если какой-либо метод в теле класса обращается к `__class__` или `super`. Благодаря этому форма без аргументов `super()` может корректно определить определяемый класс, исходя из лексической области видимости, а класс или экземпляр, использованный для текущего вызова, определяется по первому аргументу, переданному методу.11381139**Особенность реализации CPython:** В CPython 3.6 и новее ячейка `__class__` передаётся метаклассу как запись `__classcell__` в пространстве имён класса. Если она присутствует, её необходимо передать дальше в вызов `type.__new__`, чтобы класс инициализировался корректно. В противном случае в Python 3.8 возникнет [`RuntimeError`](https://python-all.ru/3.15/library/exceptions.html#RuntimeError).11401141При использовании метакласса по умолчанию [`type`](https://python-all.ru/3.15/library/functions.html#type) или любого метакласса, который в конечном счёте вызывает `type.__new__`, после создания объекта класса выполняются следующие дополнительные шаги настройки:114211431. Метод `type.__new__` собирает все атрибуты в пространстве имён класса, которые определяют метод [`__set_name__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__set_name__);11442. Эти методы `__set_name__` вызываются с определяемым классом и присвоенным именем этого конкретного атрибута;11453. Хук [`__init_subclass__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__init_subclass__) вызывается на непосредственном родителе нового класса в порядке разрешения методов.11461147После создания объекта класса он передаётся декораторам класса,\\указанным в определении класса (если они есть), и полученный объект связывается в локальном пространстве имён как определённый класс.11481149Когда новый класс создаётся с помощью `type.__new__`, объект, переданный как параметр namespace, копируется в новое упорядоченное отображение, а исходный объект отбрасывается. Новая копия оборачивается в прокси только для чтения,\\который становится атрибутом [`__dict__`](https://python-all.ru/3.15/reference/datamodel.html#type.__dict__) объекта класса.11501151> **См. также**1152>1153> **[**PEP 3135**](https://python-all.ru/3.15/reference/datamodel.html) – Новый super**1154>1155> Описывает неявную ссылку на замыкание `__class__`11561157#### 3.3.3.7. Uses for metaclasses11581159Потенциальные применения метаклассов безграничны. Некоторые из изученных идей включают перечисления, логирование, проверку интерфейсов, автоматическое делегирование,\\навтоматическое создание свойств, прокси, фреймворки и автоматическую блокировку/синхронизацию ресурсов.11601161### 3.3.4. Customizing instance and subclass checks11621163Следующие методы используются для переопределения поведения по умолчанию встроенных функций [`isinstance()`](https://python-all.ru/3.15/library/functions.html#isinstance) и [`issubclass()`](https://python-all.ru/3.15/library/functions.html#issubclass).11641165В частности, метакласс [`abc.ABCMeta`](https://python-all.ru/3.15/library/abc.html#abc.ABCMeta) реализует эти методы,\\чтобы позволить добавлять абстрактные базовые классы (ABC) как «виртуальные базовые классы» к любому классу или типу (включая встроенные типы), в том числе к другим ABC.11661167#### `type.__instancecheck__(self, instance)`11681169Возвращает истину, если *instance* должен считаться (прямым или косвенным) экземпляром *class*. Если определён, вызывается для реализации `isinstance(instance, class)`.11701171#### `type.__subclasscheck__(self, subclass)`11721173Возвращает истину, если *subclass* должен считаться (прямым или косвенным) подклассом *class*. Если определён, вызывается для реализации `issubclass(subclass, class)`.11741175Обратите внимание, что эти методы ищутся на типе (метаклассе) класса. Их нельзя определить как методы класса в самом классе. Это согласуется с поиском специальных методов, которые вызываются на экземплярах, только в данном случае экземпляром является сам класс.11761177> **См. также**1178>1179> **[**PEP 3119**](https://python-all.ru/3.15/reference/datamodel.html) – Введение абстрактных базовых классов**1180>1181> Содержит спецификацию настройки поведения [`isinstance()`](https://python-all.ru/3.15/library/functions.html#isinstance) и [`issubclass()`](https://python-all.ru/3.15/library/functions.html#issubclass) через [`__instancecheck__()`](https://python-all.ru/3.15/reference/datamodel.html#type.__instancecheck__) и [`__subclasscheck__()`](https://python-all.ru/3.15/reference/datamodel.html#type.__subclasscheck__), с обоснованием этой функциональности в контексте добавления абстрактных базовых классов (см. модуль [`abc`](https://python-all.ru/3.15/library/abc.html#module-abc)) в язык.11821183### 3.3.5. Эмуляция обобщённых типов11841185При использовании [аннотаций типов](https://python-all.ru/3.15/glossary.html#term-annotation) часто бывает полезно *параметризовать* [обобщённый тип](https://python-all.ru/3.15/glossary.html#term-generic-type) с помощью квадратных скобок Python. Например, аннотация `list[int]` может означать [`list`](https://python-all.ru/3.15/library/stdtypes.html#list), в котором все элементы имеют тип [`int`](https://python-all.ru/3.15/library/functions.html#int).11861187> **См. также**1188>1189> **[**PEP 484**](https://python-all.ru/3.15/reference/datamodel.html) – Аннотации типов**1190>1191> Введение в инфраструктуру Python для аннотаций типов1192>1193> **[Типы обобщённых псевдонимов](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias)**1194>1195> Документация по объектам, представляющим параметризованные обобщённые классы1196>1197> **[Дженерики](https://python-all.ru/3.15/library/typing.html#generics), [пользовательские дженерики](https://python-all.ru/3.15/library/typing.html#user-defined-generics) и [`typing.Generic`](https://python-all.ru/3.15/library/typing.html#typing.Generic)**1198>1199> Документация по реализации обобщённых классов, которые можно параметризовать во время выполнения и которые понятны статическим анализаторам типов.12001201A class can *generally* only be parameterized if it defines the special class method `__class_getitem__()`.12021203#### `classmethod object.__class_getitem__(cls, key)`12041205Возвращает объект, представляющий специализацию обобщённого класса по аргументам типа, переданным в *key*.12061207При определении на классе `__class_getitem__()` автоматически является методом класса. Поэтому его не нужно декорировать [`@classmethod`](https://python-all.ru/3.15/library/functions.html#classmethod) при определении.12081209#### 3.3.5.1. Назначение *\_\_class\_getitem\_\_*12101211Назначение [`__class_getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__class_getitem__) – обеспечить возможность параметризации стандартных библиотечных обобщённых классов во время выполнения,\\чтобы было удобнее применять [подсказки типов](https://python-all.ru/3.15/glossary.html#term-type-hint) к этим классам.12121213Чтобы реализовать пользовательские обобщённые классы, которые можно параметризовать во время выполнения и которые распознаются статическими проверками типов, следует либо унаследовать от класса из стандартной библиотеки, который уже реализует [`__class_getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__class_getitem__), либо унаследовать от [`typing.Generic`](https://python-all.ru/3.15/library/typing.html#typing.Generic), у которого есть собственная реализация `__class_getitem__()`.12141215Пользовательские реализации [`__class_getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__class_getitem__) в классах, определённых вне стандартной библиотеки, могут не распознаваться сторонними проверками типов, такими как mypy. Использование `__class_getitem__()` для любого класса в целях, отличных от аннотации типов, не рекомендуется.12161217#### 3.3.5.2. *\_\_class\_getitem\_\_* и *\_\_getitem\_\_*12181219Обычно [подписка](https://python-all.ru/3.15/reference/expressions.html#subscriptions) объекта с использованием квадратных скобок вызывает метод экземпляра [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__), определённый в классе объекта. Однако если подписываемый объект сам является классом, вместо него может быть вызван метод класса [`__class_getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__class_getitem__). `__class_getitem__()` должен возвращать объект [GenericAlias](https://python-all.ru/3.15/library/stdtypes.html#types-genericalias), если он правильно определён.12201221При встрече с [выражением](https://python-all.ru/3.15/glossary.html#term-expression) `obj[x]` интерпретатор Python следует примерно следующему процессу, чтобы решить, следует ли вызывать [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__) или [`__class_getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__class_getitem__):12221223```python1224from inspect import isclass12251226def subscribe(obj, x):1227    """Возвращает результат выражения 'obj[x]'"""12281229    class_of_obj = type(obj)12301231    # Если класс obj определяет __getitem__,1232    # вызывается class_of_obj.__getitem__(obj, x)1233    if hasattr(class_of_obj, '__getitem__'):1234        return class_of_obj.__getitem__(obj, x)12351236    # Иначе, если obj является классом и определяет __class_getitem__,1237    # вызывается obj.__class_getitem__(x)1238    elif isclass(obj) and hasattr(obj, '__class_getitem__'):1239        return obj.__class_getitem__(x)12401241    # Иначе, возбуждается исключение1242    else:1243        raise TypeError(1244            f"'{class_of_obj.__name__}' object is not subscriptable"1245        )1246```12471248В Python все классы сами являются экземплярами других классов. Класс класса называется его [метаклассом](https://python-all.ru/3.15/glossary.html#term-metaclass), и большинство классов имеют в качестве метакласса класс [`type`](https://python-all.ru/3.15/library/functions.html#type). `type` не определяет [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__), поэтому выражения вроде `list[int]`, `dict[str, float]` и `tuple[str, bytes]` приводят к вызову [`__class_getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__class_getitem__):12491250```python1251>>> # list имеет класс "type" в качестве метакласса, как и большинство классов:1252>>> type(list)1253<class 'type'>1254>>> type(dict) == type(list) == type(tuple) == type(str) == type(bytes)1255True1256>>> # "list[int]" вызывает "list.__class_getitem__(int)"1257>>> list[int]1258list[int]1259>>> # list.__class_getitem__ возвращает объект GenericAlias:1260>>> type(list[int])1261<class 'types.GenericAlias'>1262```12631264Однако если у класса есть пользовательский метакласс, определяющий [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__), то подписка класса может привести к другому поведению. Пример этого можно найти в модуле [`enum`](https://python-all.ru/3.15/library/enum.html#module-enum):12651266```python1267>>> from enum import Enum1268>>> class Menu(Enum):1269...     """Меню завтрака"""1270...     SPAM = 'spam'1271...     BACON = 'bacon'1272...1273>>> # Классы Enum имеют собственный метакласс:1274>>> type(Menu)1275<class 'enum.EnumMeta'>1276>>> # EnumMeta определяет __getitem__,1277>>> # поэтому __class_getitem__ не вызывается,1278>>> # и результат не является объектом GenericAlias:1279>>> Menu['SPAM']1280<Menu.SPAM: 'spam'>1281>>> type(Menu['SPAM'])1282<enum 'Menu'>1283```12841285> **См. также**1286>1287> **[**PEP 560**](https://python-all.ru/3.15/reference/datamodel.html) – основная поддержка модуля typing и обобщённых типов**1288>1289> Вводится [`__class_getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__class_getitem__) и описывается, когда [подписка](https://python-all.ru/3.15/reference/expressions.html#subscriptions) приводит к вызову `__class_getitem__()` вместо [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__)12901291### 3.3.6. Эмуляция вызываемых объектов12921293#### `object.__call__(self[, args...])`12941295Вызывается, когда экземпляр «вызывается» как функция; если этот метод определён, `x(arg1, arg2, ...)` примерно преобразуется в `type(x).__call__(x, arg1, ...)`. Сам класс [`object`](https://python-all.ru/3.15/library/functions.html#object) не предоставляет этот метод.12961297### 3.3.7. Эмуляция контейнерных типов12981299Следующие методы могут быть определены для реализации контейнерных объектов. Ни один из них не предоставляется самим классом [`object`](https://python-all.ru/3.15/library/functions.html#object). Контейнеры обычно являются [последовательностями](https://python-all.ru/3.15/glossary.html#term-sequence) (такими как [`lists`](https://python-all.ru/3.15/library/stdtypes.html#list) или [`tuples`](https://python-all.ru/3.15/library/stdtypes.html#tuple)) или [отображениями](https://python-all.ru/3.15/glossary.html#term-mapping) (например, [словарями](https://python-all.ru/3.15/glossary.html#term-dictionary)), но могут представлять и другие контейнеры. Первый набор методов используется для эмуляции последовательности или для эмуляции отображения; разница в том, что для последовательности допустимыми ключами должны быть целые числа *k*, для которых `0 <= k < N`, где *N* – длина последовательности, или объекты [`slice`](https://python-all.ru/3.15/library/functions.html#slice), которые определяют диапазон элементов. Также рекомендуется, чтобы отображения предоставляли методы `keys()`, `values()`, `items()`, `get()`, `clear()`, `setdefault()`, `pop()`, `popitem()`, `copy()` и `update()`, ведущие себя аналогично соответствующим методам стандартных объектов Python [`dictionary`](https://python-all.ru/3.15/library/stdtypes.html#dict). Модуль [`collections.abc`](https://python-all.ru/3.15/library/collections.abc.html#module-collections.abc) предоставляет [`MutableMapping`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.MutableMapping) [абстрактный базовый класс](https://python-all.ru/3.15/glossary.html#term-abstract-base-class), чтобы помочь создать эти методы на основе базового набора [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__), [`__setitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__setitem__), [`__delitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__delitem__) и `keys()`.13001301Изменяемые последовательности должны предоставлять методы [`append()`](https://python-all.ru/3.15/library/stdtypes.html#sequence.append), [`clear()`](https://python-all.ru/3.15/library/stdtypes.html#sequence.clear), [`count()`](https://python-all.ru/3.15/library/stdtypes.html#sequence.count), [`extend()`](https://python-all.ru/3.15/library/stdtypes.html#sequence.extend), [`index()`](https://python-all.ru/3.15/library/stdtypes.html#sequence.index), [`insert()`](https://python-all.ru/3.15/library/stdtypes.html#sequence.insert), [`pop()`](https://python-all.ru/3.15/library/stdtypes.html#sequence.pop), [`remove()`](https://python-all.ru/3.15/library/stdtypes.html#sequence.remove) и [`reverse()`](https://python-all.ru/3.15/library/stdtypes.html#sequence.reverse), как стандартные объекты Python [`list`](https://python-all.ru/3.15/library/stdtypes.html#list). Наконец, типы последовательностей должны реализовывать сложение (т.е. конкатенацию) и умножение (т.е. повторение), определяя методы [`__add__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__add__), [`__radd__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__radd__), [`__iadd__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__iadd__), [`__mul__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__mul__), [`__rmul__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__rmul__) и [`__imul__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__imul__), описанные ниже; они не должны определять другие числовые операторы.13021303Рекомендуется, чтобы и отображения, и последовательности реализовывали метод [`__contains__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__contains__) для эффективного использования оператора `in`; для отображений `in` должен искать по ключам отображения; для последовательностей – по значениям. Также рекомендуется, чтобы и отображения, и последовательности реализовывали метод [`__iter__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__iter__) для эффективного итерирования по контейнеру; для отображений `__iter__()` должен итерироваться по ключам объекта; для последовательностей – по значениям.13041305#### `object.__len__(self)`13061307Вызывается для реализации встроенной функции [`len()`](https://python-all.ru/3.15/library/functions.html#len). Должен возвращать длину объекта – целое число `>=` 0. Кроме того, объект, не определяющий метод [`__bool__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__bool__) и чей метод `__len__()` возвращает ноль, считается ложным в булевом контексте.13081309**Особенность реализации CPython:** В CPython длина должна быть не более [`sys.maxsize`](https://python-all.ru/3.15/library/sys.html#sys.maxsize). Если длина больше `sys.maxsize`, некоторые возможности (например, [`len()`](https://python-all.ru/3.15/library/functions.html#len)) могут вызывать [`OverflowError`](https://python-all.ru/3.15/library/exceptions.html#OverflowError). Чтобы предотвратить вызов `OverflowError` при проверке истинности, объект должен определять метод [`__bool__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__bool__).13101311#### `object.__length_hint__(self)`13121313Вызывается для реализации [`operator.length_hint()`](https://python-all.ru/3.15/library/operator.html#operator.length_hint). Должен возвращать предполагаемую длину объекта (которая может быть больше или меньше фактической длины). Длина должна быть целым числом `>=` 0. Возвращаемое значение также может быть [`NotImplemented`](https://python-all.ru/3.15/library/constants.html#NotImplemented), которое обрабатывается так же, как если бы метод `__length_hint__` вообще не существовал. Этот метод является исключительно оптимизацией и никогда не требуется для корректности.13141315Добавлено в версии 3.4.13161317#### `object.__getitem__(self, subscript)`13181319Вызывается для реализации *подписки*, то есть `self[subscript]`. См. [Подписки и срезы](https://python-all.ru/3.15/reference/expressions.html#subscriptions) для подробностей о синтаксисе.13201321Существует два типа встроенных объектов, поддерживающих подписку через `__getitem__()`:13221323- **Последовательности**, где *подписка* (также называется [индексом](https://python-all.ru/3.15/glossary.html#term-index)) должна быть целым числом или объектом [`slice`](https://python-all.ru/3.15/library/functions.html#slice). См. [документацию по последовательностям](https://python-all.ru/3.15/reference/datamodel.html#datamodel-sequences) для ожидаемого поведения, включая обработку объектов `slice` и отрицательных индексов.1324- **Отображения**, где *подписка* также называется [ключом](https://python-all.ru/3.15/glossary.html#term-key). См. [документацию по отображениям](https://python-all.ru/3.15/reference/datamodel.html#datamodel-mappings) для ожидаемого поведения.13251326Если *подписка* имеет неподходящий тип, `__getitem__()` должен вызывать [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError). Если *подписка* имеет неподходящее значение, `__getitem__()` должен вызывать [`LookupError`](https://python-all.ru/3.15/library/exceptions.html#LookupError) или одно из его подклассов ([`IndexError`](https://python-all.ru/3.15/library/exceptions.html#IndexError) для последовательностей; [`KeyError`](https://python-all.ru/3.15/library/exceptions.html#KeyError) для отображений).13271328> **Примечание**1329>1330> Срезы обрабатываются с помощью `__getitem__()`, [`__setitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__setitem__) и [`__delitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__delitem__). Вызов вида1331>1332> ```python1333> a[1:2] = b1334> ```1335>1336> преобразуется в1337>1338> ```python1339> a[slice(1, 2, None)] = b1340> ```1341>1342> и так далее. Отсутствующие элементы среза всегда заполняются `None`.13431344> **Примечание**1345>1346> Протокол итерации последовательностей (используемый, например, в циклах [`for`](https://python-all.ru/3.15/reference/compound_stmts.html#for)) ожидает, что для недопустимых индексов будет вызываться [`IndexError`](https://python-all.ru/3.15/library/exceptions.html#IndexError), чтобы обеспечить правильное обнаружение конца последовательности.13471348> **Примечание**1349>1350> При [подписке](https://python-all.ru/3.15/reference/expressions.html#subscriptions) *класса* вместо `__getitem__()` может вызываться специальный метод класса [`__class_getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__class_getitem__). См. [\_\_class\_getitem\_\_ и \_\_getitem\_\_](https://python-all.ru/3.15/reference/datamodel.html#classgetitem-versus-getitem) для подробностей.13511352#### `object.__setitem__(self, key, value)`13531354Вызывается для реализации присваивания `self[key]`. То же примечание, что и для [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__). Этот метод следует реализовывать только для отображений, если объекты поддерживают изменение значений по ключам или добавление новых ключей, или для последовательностей, если элементы можно заменять. Те же исключения должны возбуждаться для неправильных значений *ключа*, что и для метода `__getitem__()`.13551356#### `object.__delitem__(self, key)`13571358Вызывается для реализации удаления `self[key]`. То же примечание, что и для [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__). Этот метод следует реализовывать только для отображений, если объекты поддерживают удаление ключей, или для последовательностей, если элементы можно удалять из последовательности. Те же исключения должны возбуждаться для неправильных *ключа* значений, что и для метода `__getitem__()`.13591360#### `object.__missing__(self, key)`13611362Вызывается методом [`dict`](https://python-all.ru/3.15/library/stdtypes.html#dict).[`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__) для реализации `self[key]` в подклассах dict, когда ключ отсутствует в словаре.13631364#### `object.__iter__(self)`13651366Этот метод вызывается, когда для контейнера требуется [итератор](https://python-all.ru/3.15/glossary.html#term-iterator). Метод должен возвращать новый объект-итератор, который может перебирать все объекты в контейнере. Для отображений он должен перебирать ключи контейнера.13671368#### `object.__reversed__(self)`13691370Вызывается (если определён) встроенной функцией [`reversed()`](https://python-all.ru/3.15/library/functions.html#reversed) для реализации обратной итерации. Должен возвращать новый объект-итератор, который перебирает все объекты в контейнере в обратном порядке.13711372Если метод `__reversed__()` не определён, встроенная функция [`reversed()`](https://python-all.ru/3.15/library/functions.html#reversed) будет использовать протокол последовательности ([`__len__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__len__) и [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__)). Объекты, поддерживающие протокол последовательности, должны определять `__reversed__()` только в том случае, если могут предоставить реализацию, которая эффективнее, чем предоставленная `reversed()`.13731374Операторы проверки вхождения ([`in`](https://python-all.ru/3.15/reference/expressions.html#in) и [`not in`](https://python-all.ru/3.15/reference/expressions.html#not-in)) обычно реализуются как перебор контейнера. Однако объекты-контейнеры могут предоставить следующий специальный метод с более эффективной реализацией, которая также не требует, чтобы объект был итерируемым.13751376#### `object.__contains__(self, item)`13771378Вызывается для реализации операторов проверки вхождения. Должен возвращать true, если *элемент* находится в *self*, и false в противном случае. Для объектов-отображений следует учитывать ключи отображения, а не значения или пары ключ-значение.13791380Для объектов, которые не определяют `__contains__()`, проверка вхождения сначала пытается выполнить итерацию через [`__iter__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__iter__), затем старый протокол итерации последовательностей через [`__getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getitem__); см. [этот раздел в справочнике по языку](https://python-all.ru/3.15/reference/expressions.html#membership-test-details).13811382### 3.3.8. Эмуляция числовых типов13831384Следующие методы можно определить для эмуляции числовых объектов. Методы, соответствующие операциям, которые не поддерживаются конкретным типом реализуемого числа (например, побитовые операции для нецелых чисел), следует оставить неопределёнными.13851386#### `object.__add__(self, other)`13871388#### `object.__sub__(self, other)`13891390#### `object.__mul__(self, other)`13911392#### `object.__matmul__(self, other)`13931394#### `object.__truediv__(self, other)`13951396#### `object.__floordiv__(self, other)`13971398#### `object.__mod__(self, other)`13991400#### `object.__divmod__(self, other)`14011402#### `object.__pow__(self, other[, modulo])`14031404#### `object.__lshift__(self, other)`14051406#### `object.__rshift__(self, other)`14071408#### `object.__and__(self, other)`14091410#### `object.__xor__(self, other)`14111412#### `object.__or__(self, other)`14131414Эти методы вызываются для реализации бинарных арифметических операций (`+`, `-`, `*`, `@`, `/`, `//`, `%`, [`divmod()`](https://python-all.ru/3.15/library/functions.html#divmod), [`pow()`](https://python-all.ru/3.15/library/functions.html#pow), `**`, `<<`, `>>`, `&`, `^`, `|`). Например, для вычисления выражения `x + y`, где *x* является экземпляром класса, у которого есть метод `__add__()`, вызывается `type(x).__add__(x, y)`. Метод `__divmod__()` должен быть эквивалентен использованию `__floordiv__()` и `__mod__()`; он не должен быть связан с `__truediv__()`. Обратите внимание, что `__pow__()` следует определять с возможностью принимать необязательный третий аргумент, если должна поддерживаться трёхаргументная версия встроенной функции `pow()`.14151416Если один из этих методов не поддерживает операцию с переданными аргументами, он должен вернуть [`NotImplemented`](https://python-all.ru/3.15/library/constants.html#NotImplemented).14171418#### `object.__radd__(self, other)`14191420#### `object.__rsub__(self, other)`14211422#### `object.__rmul__(self, other)`14231424#### `object.__rmatmul__(self, other)`14251426#### `object.__rtruediv__(self, other)`14271428#### `object.__rfloordiv__(self, other)`14291430#### `object.__rmod__(self, other)`14311432#### `object.__rdivmod__(self, other)`14331434#### `object.__rpow__(self, other[, modulo])`14351436#### `object.__rlshift__(self, other)`14371438#### `object.__rrshift__(self, other)`14391440#### `object.__rand__(self, other)`14411442#### `object.__rxor__(self, other)`14431444#### `object.__ror__(self, other)`14451446Эти методы вызываются для реализации бинарных арифметических операций (`+`, `-`, `*`, `@`, `/`, `//`, `%`, [`divmod()`](https://python-all.ru/3.15/library/functions.html#divmod), [`pow()`](https://python-all.ru/3.15/library/functions.html#pow), `**`, `<<`, `>>`, `&`, `^`, `|`) с отражёнными (переставленными) операндами. Эти функции вызываются только в том случае, когда операнды имеют разные типы, левый операнд не поддерживает соответствующую операцию [\[3\]](https://python-all.ru/3.15/reference/datamodel.html#id22) или класс правого операнда является подклассом класса левого операнда. [\[4\]](https://python-all.ru/3.15/reference/datamodel.html#id23) Например, для вычисления выражения `x - y`, где *y* – экземпляр класса, у которого есть метод `__rsub__()`, вызывается `type(y).__rsub__(y, x)`, если `type(x).__sub__(x, y)` возвращает [`NotImplemented`](https://python-all.ru/3.15/library/constants.html#NotImplemented) или `type(y)` является подклассом `type(x)`. [\[5\]](https://python-all.ru/3.15/reference/datamodel.html#id24)14471448Обратите внимание, что `__rpow__()` должен быть определён с возможностью принимать необязательный третий аргумент, если требуется поддержка трёхаргументной версии встроенной функции [`pow()`](https://python-all.ru/3.15/library/functions.html#pow).14491450Изменено в версии 3.14: Трёхаргументная [`pow()`](https://python-all.ru/3.15/library/functions.html#pow) теперь при необходимости вызывает `__rpow__()`. Ранее она вызывалась только в двухаргументной `pow()` и бинарном операторе возведения в степень.14511452> **Примечание**1453>1454> Если тип правого операнда является подклассом типа левого операнда и этот подкласс предоставляет другую реализацию отражённого метода для данной операции, этот метод будет вызван до неотражённого метода левого операнда. Такое поведение позволяет подклассам переопределять операции своих предков.14551456#### `object.__iadd__(self, other)`14571458#### `object.__isub__(self, other)`14591460#### `object.__imul__(self, other)`14611462#### `object.__imatmul__(self, other)`14631464#### `object.__itruediv__(self, other)`14651466#### `object.__ifloordiv__(self, other)`14671468#### `object.__imod__(self, other)`14691470#### `object.__ipow__(self, other[, modulo])`14711472#### `object.__ilshift__(self, other)`14731474#### `object.__irshift__(self, other)`14751476#### `object.__iand__(self, other)`14771478#### `object.__ixor__(self, other)`14791480#### `object.__ior__(self, other)`14811482Эти методы вызываются для реализации расширенных арифметических присваиваний (`+=`, `-=`, `*=`, `@=`, `/=`, `//=`, `%=`, `**=`, `<<=`, `>>=`, `&=`, `^=`, `|=`). Эти методы должны пытаться выполнить операцию на месте (изменяя *self*) и вернуть результат (который может быть, но не обязан быть *self*). Если конкретный метод не определён или если этот метод возвращает [`NotImplemented`](https://python-all.ru/3.15/library/constants.html#NotImplemented), расширенное присваивание переходит к обычным методам. Например, если *x* является экземпляром класса с методом `__iadd__()`, `x += y` эквивалентно `x = x.__iadd__(y)` . Если `__iadd__()` не существует или если `x.__iadd__(y)` возвращает `NotImplemented`, рассматриваются `x.__add__(y)` и `y.__radd__(x)`, как при вычислении `x + y`. В определённых ситуациях расширенное присваивание может приводить к неожиданным ошибкам (см. [Почему a\_tuple\[i\] += \['item'\] вызывает исключение, хотя сложение работает?](https://python-all.ru/3.15/faq/programming.html#faq-augmented-assignment-tuple-error)), но это поведение на самом деле является частью модели данных.14831484#### `object.__neg__(self)`14851486#### `object.__pos__(self)`14871488#### `object.__abs__(self)`14891490#### `object.__invert__(self)`14911492Вызывается для реализации унарных арифметических операций (`-`, `+`, [`abs()`](https://python-all.ru/3.15/library/functions.html#abs) и `~`).14931494#### `object.__complex__(self)`14951496#### `object.__int__(self)`14971498#### `object.__float__(self)`14991500Вызывается для реализации встроенных функций [`complex()`](https://python-all.ru/3.15/library/functions.html#complex), [`int()`](https://python-all.ru/3.15/library/functions.html#int) и [`float()`](https://python-all.ru/3.15/library/functions.html#float). Должен возвращать значение соответствующего типа.15011502#### `object.__index__(self)`15031504Вызывается для реализации [`operator.index()`](https://python-all.ru/3.15/library/operator.html#operator.index), а также всякий раз, когда Python необходимо без потерь преобразовать числовой объект в целое число (например, при срезе или во встроенных функциях [`bin()`](https://python-all.ru/3.15/library/functions.html#bin), [`hex()`](https://python-all.ru/3.15/library/functions.html#hex) и [`oct()`](https://python-all.ru/3.15/library/functions.html#oct)). Наличие этого метода указывает, что числовой объект является целочисленным типом. Должен возвращать целое число.15051506Если [`__int__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__int__), [`__float__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__float__) и [`__complex__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__complex__) не определены, то соответствующие встроенные функции [`int()`](https://python-all.ru/3.15/library/functions.html#int), [`float()`](https://python-all.ru/3.15/library/functions.html#float) и [`complex()`](https://python-all.ru/3.15/library/functions.html#complex) используют `__index__()`.15071508#### `object.__round__(self[, ndigits])`15091510#### `object.__trunc__(self)`15111512#### `object.__floor__(self)`15131514#### `object.__ceil__(self)`15151516Вызывается для реализации встроенной функции [`round()`](https://python-all.ru/3.15/library/functions.html#round) и функций [`math`](https://python-all.ru/3.15/library/math.html#module-math): [`trunc()`](https://python-all.ru/3.15/library/math.html#math.trunc), [`floor()`](https://python-all.ru/3.15/library/math.html#math.floor) и [`ceil()`](https://python-all.ru/3.15/library/math.html#math.ceil). Если *ndigits* не передан в `__round__()`, все эти методы должны возвращать значение объекта, усечённое до [`Integral`](https://python-all.ru/3.15/library/numbers.html#numbers.Integral) (обычно [`int`](https://python-all.ru/3.15/library/functions.html#int)).15171518Изменено в версии 3.14: [`int()`](https://python-all.ru/3.15/library/functions.html#int) больше не делегирует полномочия методу `__trunc__()`.15191520### 3.3.9. Контекстные менеджеры оператора with15211522*Контекстный менеджер* – это объект, который определяет контекст выполнения, устанавливаемый при выполнении оператора [`with`](https://python-all.ru/3.15/reference/compound_stmts.html#with). Контекстный менеджер обрабатывает вход в требуемый контекст выполнения и выход из него для выполнения блока кода. Контекстные менеджеры обычно вызываются с помощью оператора `with` (описанного в разделе [Оператор with](https://python-all.ru/3.15/reference/compound_stmts.html#with)), но также могут использоваться прямым вызовом их методов.15231524Типичные случаи использования контекстных менеджеров включают сохранение и восстановление различных видов глобального состояния, блокировку и разблокировку ресурсов, закрытие открытых файлов и т.д.15251526Дополнительную информацию о контекстных менеджерах см. в [Типы контекстных менеджеров](https://python-all.ru/3.15/library/stdtypes.html#typecontextmanager). Сам класс [`object`](https://python-all.ru/3.15/library/functions.html#object) не предоставляет методы контекстного менеджера.15271528#### `object.__enter__(self)`15291530Входит в контекст выполнения, связанный с этим объектом. Оператор [`with`](https://python-all.ru/3.15/reference/compound_stmts.html#with) привязывает возвращаемое значение этого метода к цели(ям), указанным в предложении `as` этого оператора, если таковые имеются.15311532#### `object.__exit__(self, exc_type, exc_value, traceback)`15331534Выходит из контекста выполнения, связанного с этим объектом. Параметры описывают исключение, которое привело к выходу из контекста. Если контекст был завершён без исключения, все три аргумента будут [`None`](https://python-all.ru/3.15/library/constants.html#None).15351536Если передано исключение и метод хочет подавить его (т.е. предотвратить его распространение), он должен вернуть истинное значение. В противном случае исключение будет обработано обычным образом при выходе из этого метода.15371538Обратите внимание, что методы `__exit__()` не должны повторно возбуждать переданное исключение; это ответственность вызывающего кода.15391540> **См. также**1541>1542> **[**PEP 343**](https://python-all.ru/3.15/reference/datamodel.html) – Оператор «with»**1543>1544> Спецификация, предыстория и примеры для инструкции [`with`](https://python-all.ru/3.15/reference/compound_stmts.html#with) в Python.15451546### 3.3.10. Настройка позиционных аргументов в сопоставлении с образцом класса15471548При использовании имени класса в образце позиционные аргументы в образце по умолчанию не допускаются, т.е. `case MyClass(x, y)` обычно недействительно без специальной поддержки в `MyClass`. Чтобы можно было использовать такой образец, класс должен определить атрибут *\_\_match\_args\_\_*.15491550#### `object.__match_args__`15511552Эта переменная класса может быть присвоена кортежу строк. Когда этот класс используется в образце класса с позиционными аргументами, каждый позиционный аргумент будет преобразован в именованный аргумент, используя соответствующее значение из *\_\_match\_args\_\_* в качестве ключа. Отсутствие этого атрибута эквивалентно установке его в `()`.15531554Например, если `MyClass.__match_args__` равно `("left", "center", "right")`, это означает, что `case MyClass(x, y)` эквивалентно `case MyClass(left=x, center=y)`. Обратите внимание, что количество аргументов в шаблоне должно быть меньше или равно количеству элементов в *\_\_match\_args\_\_*; если оно больше, попытка сопоставления с шаблоном вызовет [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError).15551556Добавлено в версии 3.10.15571558> **См. также**1559>1560> **[**PEP 634**](https://python-all.ru/3.15/reference/datamodel.html) – Структурное сопоставление с образцом**1561>1562> Спецификация оператора Python `match`.15631564### 3.3.11. Эмуляция типов буфера15651566[Протокол буфера](https://python-all.ru/3.15/c-api/buffer.html#bufferobjects) предоставляет способ для объектов Python обеспечить эффективный доступ к низкоуровневому массиву памяти. Этот протокол реализован встроенными типами, такими как [`bytes`](https://python-all.ru/3.15/library/stdtypes.html#bytes) и [`memoryview`](https://python-all.ru/3.15/library/stdtypes.html#memoryview), а сторонние библиотеки могут определять дополнительные типы буфера.15671568Хотя типы буфера обычно реализуются на C, также возможно реализовать протокол на Python.15691570#### `object.__buffer__(self, flags)`15711572Вызывается, когда запрашивается буфер у *self* (например, конструктором [`memoryview`](https://python-all.ru/3.15/library/stdtypes.html#memoryview)). Аргумент *flags* представляет собой целое число, указывающее тип запрашиваемого буфера, влияющий, например, на то, будет ли возвращаемый буфер доступен только для чтения или для записи. [`inspect.BufferFlags`](https://python-all.ru/3.15/library/inspect.html#inspect.BufferFlags) предоставляет удобный способ интерпретации флагов. Метод должен возвращать объект `memoryview`.15731574**Безопасность потоков:** В [свободно-поточном](https://python-all.ru/3.15/glossary.html#term-free-threading) Python реализации должны управлять любым внутренним счётчиком экспорта с помощью атомарных операций. Метод должен быть безопасен для параллельного вызова из нескольких потоков, а базовые данные возвращаемого буфера должны оставаться корректными до завершения соответствующего вызова [`__release_buffer__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__release_buffer__). Подробнее см. [Безопасность потоков для объектов memoryview](https://python-all.ru/3.15/library/threadsafety.html#thread-safety-memoryview).15751576#### `object.__release_buffer__(self, buffer)`15771578Вызывается, когда буфер больше не нужен. Аргумент *buffer* является объектом [`memoryview`](https://python-all.ru/3.15/library/stdtypes.html#memoryview), который был ранее возвращён [`__buffer__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__buffer__). Метод должен освободить все ресурсы, связанные с буфером. Этот метод должен возвращать `None`.15791580**Безопасность потоков:** В [свободно-поточном](https://python-all.ru/3.15/glossary.html#term-free-threading) Python любое уменьшение счётчика экспорта должно использовать атомарные операции. Очистка ресурсов должна быть потокобезопасной, так как финальное освобождение может конкурировать с параллельными освобождениями из других потоков.15811582Буферные объекты, которым не требуется выполнять какую-либо очистку, не обязаны реализовывать этот метод.15831584Добавлено в версии 3.12.15851586> **См. также**1587>1588> **[**PEP 688**](https://python-all.ru/3.15/reference/datamodel.html) – Делаем протокол буфера доступным в Python**1589>1590> Вводит методы Python `__buffer__` и `__release_buffer__`.1591>1592> **[`collections.abc.Buffer`](https://python-all.ru/3.15/library/collections.abc.html#collections.abc.Buffer)**1593>1594> ABC для типов буфера.15951596### 3.3.12. Аннотации15971598Функции, классы и модули могут содержать [аннотации](https://python-all.ru/3.15/glossary.html#term-annotation), которые являются способом связать информацию (обычно [подсказки типов](https://python-all.ru/3.15/glossary.html#term-type-hint)) с символом.15991600#### `object.__annotations__`16011602Этот атрибут содержит аннотации для объекта. Он [вычисляется лениво](https://python-all.ru/3.15/reference/executionmodel.html#lazy-evaluation), поэтому обращение к атрибуту может выполнять произвольный код и вызывать исключения. Если вычисление успешно, атрибут устанавливается в словарь, отображающий имена переменных на аннотации.16031604Изменено в версии 3.14: Аннотации теперь вычисляются лениво.16051606#### `object.__annotate__(format)`16071608[Функция аннотации](https://python-all.ru/3.15/glossary.html#term-annotate-function). Возвращает новый объект словаря, отображающий имена атрибутов/параметров в их значения аннотаций.16091610Принимает параметр format, указывающий формат, в котором должны предоставляться значения аннотаций. Он должен быть элементом перечисления [`annotationlib.Format`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.Format) или целым числом, значение которого соответствует элементу перечисления.16111612Если функция аннотации не поддерживает запрошенный формат, она должна вызвать [`NotImplementedError`](https://python-all.ru/3.15/library/exceptions.html#NotImplementedError). Функции аннотации всегда должны поддерживать формат [`VALUE`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.Format.VALUE); они не должны вызывать [`NotImplementedError()`](https://python-all.ru/3.15/library/exceptions.html#NotImplementedError) при вызове с этим форматом.16131614При вызове с форматом [`VALUE`](https://python-all.ru/3.15/library/annotationlib.html#annotationlib.Format.VALUE) функция аннотации может вызвать [`NameError`](https://python-all.ru/3.15/library/exceptions.html#NameError); она не должна вызывать `NameError` при вызове с запросом любого другого формата.16151616Если объект не имеет аннотаций, [`__annotate__`](https://python-all.ru/3.15/reference/datamodel.html#object.__annotate__) следует предпочтительно установить в `None` (его нельзя удалить), а не устанавливать в функцию, возвращающую пустой dict.16171618Добавлено в версии 3.14.16191620> **См. также**1621>1622> **[**PEP 649**](https://python-all.ru/3.15/reference/datamodel.html) – Отложенное вычисление аннотаций с помощью дескрипторов**1623>1624> Вводит ленивое вычисление аннотаций и функцию `__annotate__`.16251626### 3.3.13. Поиск специальных методов16271628Для пользовательских классов неявные вызовы специальных методов гарантированно работают корректно только в том случае, если они определены в типе объекта, а не в словаре экземпляра объекта. Это поведение является причиной того, что следующий код вызывает исключение:16291630```python1631>>> class C:1632...     pass1633...1634>>> c = C()1635>>> c.__len__ = lambda: 51636>>> len(c)1637Traceback (most recent call last):1638  File "<stdin>", line 1, in <module>1639TypeError: object of type 'C' has no len()1640```16411642Обоснование этого поведения связано с рядом специальных методов, таких как [`__hash__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__hash__) и [`__repr__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__repr__), которые реализованы всеми объектами, включая объекты типов. Если бы неявный поиск этих методов использовал обычный процесс поиска, они бы не сработали при вызове на самом объекте типа:16431644```python1645>>> 1 .__hash__() == hash(1)1646True1647>>> int.__hash__() == hash(int)1648Traceback (most recent call last):1649  File "<stdin>", line 1, in <module>1650TypeError: descriptor '__hash__' of 'int' object needs an argument1651```16521653Попытка некорректного вызова несвязанного метода класса таким образом иногда называется «путаницей метаклассов»; её можно избежать, обходя экземпляр при поиске специальных методов:16541655```python1656>>> type(1).__hash__(1) == hash(1)1657True1658>>> type(int).__hash__(int) == hash(int)1659True1660```16611662В дополнение к обходу атрибутов экземпляра для обеспечения корректности, неявный поиск специальных методов обычно также обходит метод [`__getattribute__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getattribute__) даже метакласса объекта:16631664```python1665>>> class Meta(type):1666...     def __getattribute__(*args):1667...         print("Metaclass getattribute invoked")1668...         return type.__getattribute__(*args)1669...1670>>> class C(object, metaclass=Meta):1671...     def __len__(self):1672...         return 101673...     def __getattribute__(*args):1674...         print("Class getattribute invoked")1675...         return object.__getattribute__(*args)1676...1677>>> c = C()1678>>> c.__len__()                 # Явный поиск через экземпляр1679Class getattribute invoked1680101681>>> type(c).__len__(c)          # Явный поиск через тип1682Metaclass getattribute invoked1683101684>>> len(c)                      # Неявный поиск1685101686```16871688Обход механизма [`__getattribute__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__getattribute__) таким образом даёт значительную возможность для оптимизации скорости в интерпретаторе, ценой некоторой гибкости в обработке специальных методов (специальный метод *должен* быть установлен на самом объекте класса, чтобы интерпретатор мог его последовательно вызывать).16891690## 3.4. Корутины16911692### 3.4.1. Ожидаемые объекты16931694Объект [ожидаемый](https://python-all.ru/3.15/glossary.html#term-awaitable) обычно реализует метод [`__await__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__await__). Объекты [корутины](https://python-all.ru/3.15/glossary.html#term-coroutine), возвращаемые из функций [`async def`](https://python-all.ru/3.15/reference/compound_stmts.html#async-def), являются ожидаемыми.16951696> **Примечание**1697>1698> Объекты [итератор генератора](https://python-all.ru/3.15/glossary.html#term-generator-iterator), возвращаемые из генераторов, декорированных [`types.coroutine()`](https://python-all.ru/3.15/library/types.html#types.coroutine), также являются ожидаемыми, но они не реализуют [`__await__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__await__).16991700#### `object.__await__(self)`17011702Должен возвращать [итератор](https://python-all.ru/3.15/glossary.html#term-iterator). Следует использовать для реализации объектов [ожидаемый](https://python-all.ru/3.15/glossary.html#term-awaitable). Например, [`asyncio.Future`](https://python-all.ru/3.15/library/asyncio-future.html#asyncio.Future) реализует этот метод для совместимости с выражением [`await`](https://python-all.ru/3.15/reference/expressions.html#await). Сам класс [`object`](https://python-all.ru/3.15/library/functions.html#object) не является ожидаемым и не предоставляет этого метода.17031704> **Примечание**1705>1706> Язык не накладывает никаких ограничений на тип или значение объектов, возвращаемых итератором, полученным от `__await__`, поскольку это зависит от реализации асинхронной среды выполнения (например, [`asyncio`](https://python-all.ru/3.15/library/asyncio.html#module-asyncio)), которая будет управлять объектом [ожидаемый](https://python-all.ru/3.15/glossary.html#term-awaitable).17071708Добавлено в версии 3.5.17091710> **См. также**1711>1712> [**PEP 492**](https://python-all.ru/3.15/reference/datamodel.html) для получения дополнительной информации об ожидаемых объектах.17131714### 3.4.2. Объекты корутин17151716Объекты [корутины](https://python-all.ru/3.15/glossary.html#term-coroutine) являются объектами [ожидаемыми](https://python-all.ru/3.15/glossary.html#term-awaitable). Выполнение корутины можно контролировать с помощью вызова [`__await__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__await__) и итерации по результату. Когда корутина завершает выполнение и возвращает значение, итератор возбуждает [`StopIteration`](https://python-all.ru/3.15/library/exceptions.html#StopIteration), и атрибут [`value`](https://python-all.ru/3.15/library/exceptions.html#StopIteration.value) исключения содержит возвращаемое значение. Если корутина возбуждает исключение, оно распространяется через итератор. Корутины не должны непосредственно возбуждать необработанные исключения `StopIteration`.17171718Корутины также имеют методы, перечисленные ниже, которые аналогичны методам генераторов (см. [Методы итератора генератора](https://python-all.ru/3.15/reference/expressions.html#generator-methods)). Однако, в отличие от генераторов, корутины напрямую не поддерживают итерацию.17191720Корутины являются [обобщёнными](https://python-all.ru/3.15/library/typing.html#generics) по типам значений yield, send и return соответственно.17211722Изменено в версии 3.5.2: Ожидание корутины более одного раза является [`RuntimeError`](https://python-all.ru/3.15/library/exceptions.html#RuntimeError).17231724#### `coroutine.send(value)`17251726Запускает или возобновляет выполнение корутины. Если *value* равно `None`, это эквивалентно продвижению итератора, возвращаемого [`__await__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__await__). Если *value* не равно `None`, этот метод делегирует методу [`send()`](https://python-all.ru/3.15/reference/expressions.html#generator.send) итератора, который вызвал приостановку корутины. Результат (возвращаемое значение, [`StopIteration`](https://python-all.ru/3.15/library/exceptions.html#StopIteration) или другое исключение) такой же, как при итерации по возвращаемому значению `__await__()`, описанной выше.17271728#### `coroutine.throw(value)`17291730#### `coroutine.throw(type[, value[, traceback]])`17311732Возбуждает указанное исключение в корутине. Этот метод делегирует методу [`throw()`](https://python-all.ru/3.15/reference/expressions.html#generator.throw) итератора, который вызвал приостановку корутины, если у него есть такой метод. В противном случае исключение возбуждается в точке приостановки. Результат (возвращаемое значение, [`StopIteration`](https://python-all.ru/3.15/library/exceptions.html#StopIteration) или другое исключение) такой же, как при итерации по возвращаемому значению [`__await__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__await__), описанной выше. Если исключение не перехвачено в корутине, оно распространяется обратно к вызывающему.17331734Изменено в версии 3.12: Вторая сигнатура (type\[, value\[, traceback\]\]) является устаревшей и может быть удалена в будущей версии Python.17351736#### `coroutine.close()`17371738Заставляет корутину выполнить очистку и завершиться. Если корутина приостановлена, этот метод сначала делегирует методу [`close()`](https://python-all.ru/3.15/reference/expressions.html#generator.close) итератора, который вызвал приостановку корутины, если у него есть такой метод. Затем он возбуждает [`GeneratorExit`](https://python-all.ru/3.15/library/exceptions.html#GeneratorExit) в точке приостановки, заставляя корутину немедленно выполнить очистку. Наконец, корутина помечается как завершившая выполнение, даже если она никогда не была запущена.17391740Объекты корутин автоматически закрываются с помощью описанного выше процесса, когда они собираются быть уничтоженными.17411742### 3.4.3. Асинхронные итераторы17431744Объект *асинхронный итератор* может вызывать асинхронный код в своем методе `__anext__`.17451746Асинхронные итераторы можно использовать в операторе [`async for`](https://python-all.ru/3.15/reference/compound_stmts.html#async-for).17471748Сам класс [`object`](https://python-all.ru/3.15/library/functions.html#object) не предоставляет этих методов.17491750#### `object.__aiter__(self)`17511752Должен возвращать объект *асинхронный итератор*.17531754#### `object.__anext__(self)`17551756Должен возвращать *ожидаемый объект*, который даёт следующее значение итератора. Должен возбуждать ошибку [`StopAsyncIteration`](https://python-all.ru/3.15/library/exceptions.html#StopAsyncIteration), когда итерация завершена.17571758Пример асинхронного итерируемого объекта:17591760```python1761class Reader:1762    async def readline(self):1763        ...17641765    def __aiter__(self):1766        return self17671768    async def __anext__(self):1769        val = await self.readline()1770        if val == b'':1771            raise StopAsyncIteration1772        return val1773```17741775Добавлено в версии 3.5.17761777Изменено в версии 3.7: До Python 3.7 [`__aiter__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__aiter__) мог возвращать *ожидаемый объект*, который разрешался в [асинхронный итератор](https://python-all.ru/3.15/glossary.html#term-asynchronous-iterator).17781779Начиная с Python 3.7, [`__aiter__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__aiter__) должен возвращать объект асинхронного итератора. Возврат чего-либо ещё приводит к ошибке [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError).17801781### 3.4.4. Асинхронные менеджеры контекста17821783*Асинхронный менеджер контекста* – это *менеджер контекста*, способный приостанавливать выполнение в своих методах `__aenter__` и `__aexit__`.17841785Асинхронные менеджеры контекста можно использовать в инструкции [`async with`](https://python-all.ru/3.15/reference/compound_stmts.html#async-with).17861787Сам класс [`object`](https://python-all.ru/3.15/library/functions.html#object) не предоставляет этих методов.17881789#### `object.__aenter__(self)`17901791Семантически аналогичен [`__enter__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__enter__), с той лишь разницей, что должен возвращать *ожидаемый объект*.17921793#### `object.__aexit__(self, exc_type, exc_value, traceback)`17941795Семантически аналогичен [`__exit__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__exit__), с той лишь разницей, что должен возвращать *ожидаемый объект*.17961797Пример класса асинхронного менеджера контекста:17981799```python1800class AsyncContextManager:1801    async def __aenter__(self):1802        await log('entering context')18031804    async def __aexit__(self, exc_type, exc, tb):1805        await log('exiting context')1806```18071808Добавлено в версии 3.5.18091810Сноски18111812\[[1](https://python-all.ru/3.15/reference/datamodel.html#id1)\]18131814It *is* possible in some cases to change an object’s type, under certain controlled conditions. It generally isn’t a good idea though, since it can lead to some very strange behaviour if it is handled incorrectly.18151816\[[2](https://python-all.ru/3.15/reference/datamodel.html#id12)\]18171818Методы [`__hash__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__hash__), [`__iter__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__iter__), [`__reversed__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__reversed__), [`__contains__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__contains__), [`__class_getitem__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__class_getitem__) и [`__fspath__()`](https://python-all.ru/3.15/library/os.html#os.PathLike.__fspath__) имеют для этого особую обработку. Остальные по-прежнему будут возбуждать [`TypeError`](https://python-all.ru/3.15/library/exceptions.html#TypeError), но могут делать это, полагаясь на поведение, при котором `None` не является вызываемым.18191820\[[3](https://python-all.ru/3.15/reference/datamodel.html#id16)\]18211822«Не поддерживает» здесь означает, что у класса нет такого метода или метод возвращает [`NotImplemented`](https://python-all.ru/3.15/library/constants.html#NotImplemented). Не устанавливайте метод в `None`, если хотите принудительно вернуться к отражённому методу правого операнда – это даст противоположный эффект, явно *блокируя* такой возврат.18231824\[[4](https://python-all.ru/3.15/reference/datamodel.html#id17)\]18251826Для операндов одного типа считается, что если неотражённый метод (например, [`__add__()`](https://python-all.ru/3.15/reference/datamodel.html#object.__add__)) завершается ошибкой, то операция не поддерживается, поэтому отражённый метод не вызывается.18271828\[[5](https://python-all.ru/3.15/reference/datamodel.html#id18)\]18291830Если тип правого операнда является подклассом типа левого операнда, приоритет отражённого метода позволяет подклассам переопределять операции своих предков.1831