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

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

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

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

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

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

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

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

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

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

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

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

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

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

Нет

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

NotImplemented

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

Более подробную информацию см. в разделе Реализация арифметических операций.

Изменено в версии 3.9: Вычисление NotImplemented в булевом контексте устарело. Хотя в настоящее время она оценивается как true, она будет выдавать DeprecationWarning. В будущих версиях Python он будет вызывать TypeError.

Эллипсис

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

numbers.Number

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

Строковые представления числовых классов, вычисляемые по __repr__() и __str__(), обладают следующими свойствами:

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

• Представление ведется по основанию 10, когда это возможно.

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

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

• Знак указывается только в том случае, если число отрицательное.

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

numbers.Integral

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

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

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

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

Булевы (bool)

Они представляют истинностные значения False и True. Два объекта, представляющие значения False и True, являются единственными булевыми объектами. Тип Boolean является подтипом типа integer, и значения Boolean ведут себя как значения 0 и 1, соответственно, почти во всех контекстах, за исключением того, что при преобразовании в строку возвращаются строки "False" или "True", соответственно.

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

numbers.Real (float)

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

numbers.Complex (complex)

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

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

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

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

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

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

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

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

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

Струны

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

Кортежи

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

Байты

Объект bytes - это неизменяемый массив. Элементами являются 8-битные байты, представленные целыми числами в диапазоне 0 <= x < 256. Для создания байтовых объектов можно использовать литералы байтов (например, b'abc') и встроенный конструктор bytes(). Также объекты байтов могут быть декодированы в строки с помощью метода decode().

Мутируемые последовательности

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

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

Списки

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

Массивы байтов

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

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

Типы комплектов

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

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

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

Устанавливает

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

Замороженные декорации

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

Отображения

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

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

Словари

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

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

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

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

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

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

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

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

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

Специальные атрибуты:

Атрибут	Значение
__doc__	Строка документации функции, или None, если она недоступна; не наследуется подклассами.	Записываемый
__name__	Имя функции.	Записываемый
__qualname__	Функция qualified name. Добавлено в версии 3.3.	Записываемый
__module__	Имя модуля, в котором была определена функция, или None, если он недоступен.	Записываемый
__defaults__	Кортеж, содержащий значения аргументов по умолчанию для тех аргументов, которые имеют значения по умолчанию, или None, если ни один аргумент не имеет значения по умолчанию.	Записываемый
__code__	Объект кода, представляющий скомпилированное тело функции.	Записываемый
__globals__	Ссылка на словарь, хранящий глобальные переменные функции — глобальное пространство имен модуля, в котором была определена функция.	Только для чтения
__dict__	Пространство имен, поддерживающее произвольные атрибуты функций.	Записываемый
__closure__	None или кортеж ячеек, содержащих привязки для свободных переменных функции. Информацию об атрибуте cell_contents см. ниже.	Только для чтения
__annotations__	Диктант, содержащий аннотации параметров. Ключами dict являются имена параметров, а 'return' - аннотация return, если она предусмотрена. Для получения дополнительной информации о работе с этим атрибутом смотрите Лучшие методы работы с аннотациями.	Записываемый
__kwdefaults__	Диктант, содержащий значения по умолчанию для параметров только для ключевых слов.	Записываемый

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

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

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

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

Методы экземпляра

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

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

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

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

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

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

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

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

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

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

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

Корутинные функции

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

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

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

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

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

Объект встроенной функции - это обертка вокруг функции языка Си. Примерами встроенных функций являются len() и math.sin() (math является стандартным встроенным модулем). Количество и тип аргументов определяются функцией Си. Специальные атрибуты только для чтения: __doc__ - строка документации функции, или None, если она недоступна; __name__ - имя функции; __self__ устанавливается в None (но см. следующий пункт); __module__ - имя модуля, в котором была определена функция, или None, если она недоступна.

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

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

Занятия

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

Экземпляры классов

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

Модули

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

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

Предопределенные (записываемые) атрибуты:

__name__

Имя модуля.

__doc__

Строка документации модуля, или None, если она недоступна.

__file__

Путь к файлу, из которого был загружен модуль, если он был загружен из файла. Атрибут __file__ может отсутствовать для некоторых типов модулей, таких как модули C, статически подключаемые к интерпретатору. Для модулей расширения, загружаемых динамически из разделяемой библиотеки, это имя пути к файлу разделяемой библиотеки.

__annotations__

Словарь, содержащий variable annotations, собранный во время выполнения тела модуля. О лучших практиках работы с __annotations__ смотрите Лучшие методы работы с аннотациями.

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

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

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

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

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

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

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

Специальные атрибуты:

__name__

Имя класса.

__module__

Имя модуля, в котором был определен класс.

__dict__

Словарь, содержащий пространство имен класса.

__bases__

Кортеж, содержащий базовые классы в порядке их появления в списке базовых классов.

__doc__

Строка документации класса, или None, если она не определена.

__annotations__

Словарь, содержащий variable annotations, собранный во время выполнения тела класса. О лучших практиках работы с __annotations__ см. в разделе Лучшие методы работы с аннотациями.

Экземпляры классов

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

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

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

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

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

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

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

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

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

Кодовые объекты

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

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

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

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

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

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

Рамочные объекты

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

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

Доступ к f_code вызывает auditing event object.__getattr__ с аргументами obj и "f_code".

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

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

f_lineno - это номер текущей строки кадра — запись в него из функции трассировки переходит на заданную строку (только для самого нижнего кадра). Отладчик может реализовать команду Jump (она же Set Next Statement) путем записи в f_lineno.

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

frame.clear()¶

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

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

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

Отслеживание объектов

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

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

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

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

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

Доступ к tb_frame вызывает auditing event object.__getattr__ с аргументами obj и "tb_frame".

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

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

Нарезка объектов

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

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

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

slice.indices(self, length)¶

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

Объекты статических методов

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

Объекты методов класса

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

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

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

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

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

import sys
from types import ModuleType

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

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

sys.modules[__name__].__class__ = VerboseModule

class Meta(type):
    pass

class MyClass(metaclass=Meta):
    pass

class MySubclass(MyClass):
    pass

from inspect import isclass

def subscribe(obj, x):
    """Return the result of the expression `obj[x]`"""

    class_of_obj = type(obj)

    # If the class of obj defines __getitem__,
    # call class_of_obj.__getitem__(obj, x)
    if hasattr(class_of_obj, '__getitem__'):
        return class_of_obj.__getitem__(obj, x)

    # Else, if obj is a class and defines __class_getitem__,
    # call obj.__class_getitem__(x)
    elif isclass(obj) and hasattr(obj, '__class_getitem__'):
        return obj.__class_getitem__(x)

    # Else, raise an exception
    else:
        raise TypeError(
            f"'{class_of_obj.__name__}' object is not subscriptable"
        )

>>> # list has class "type" as its metaclass, like most classes:
>>> type(list)
<class 'type'>
>>> type(dict) == type(list) == type(tuple) == type(str) == type(bytes)
True
>>> # "list[int]" calls "list.__class_getitem__(int)"
>>> list[int]
list[int]
>>> # list.__class_getitem__ returns a GenericAlias object:
>>> type(list[int])
<class 'types.GenericAlias'>

>>> from enum import Enum
>>> class Menu(Enum):
...     """A breakfast menu"""
...     SPAM = 'spam'
...     BACON = 'bacon'
...
>>> # Enum classes have a custom metaclass:
>>> type(Menu)
<class 'enum.EnumMeta'>
>>> # EnumMeta defines __getitem__,
>>> # so __class_getitem__ is not called,
>>> # and the result is not a GenericAlias object:
>>> Menu['SPAM']
<Menu.SPAM: 'spam'>
>>> type(Menu['SPAM'])
<enum 'Menu'>

a[1:2] = b

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

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

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

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

>>> class Meta(type):
...     def __getattribute__(*args):
...         print("Metaclass getattribute invoked")
...         return type.__getattribute__(*args)
...
>>> class C(object, metaclass=Meta):
...     def __len__(self):
...         return 10
...     def __getattribute__(*args):
...         print("Class getattribute invoked")
...         return object.__getattribute__(*args)
...
>>> c = C()
>>> c.__len__()                 # Explicit lookup via instance
Class getattribute invoked
10
>>> type(c).__len__(c)          # Explicit lookup via type
Metaclass getattribute invoked
10
>>> len(c)                      # Implicit lookup
10

3.4. Корутины¶

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

    def __aiter__(self):
        return self

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

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

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