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

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

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

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

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

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

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

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

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

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

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

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

None

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

NotImplemented

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

Ellipsis

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

numbers.Number

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

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

numbers.Integral

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

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

Обычные целые числа

Эти числа представляют значения в диапазоне от -2147483648 до 2147483647. (Диапазон может быть больше на машинах с большим естественным размером слова, но не меньше.) Если результат операции выходит за этот диапазон, он обычно возвращается как длинное целое (в некоторых случаях вместо этого возбуждается исключение OverflowError). Для целей сдвиговых и битовых операций предполагается, что целые числа имеют двоичное представление в дополнительном коде с использованием 32 или более битов, при этом все биты доступны пользователю (то есть все 4294967296 различных комбинаций битов соответствуют разным значениям).

Длинные целые числа

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

Булевы значения

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

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

numbers.Real (float)

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

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

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

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

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

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

Строки

Элементами строки являются символы. Отдельного типа для символов нет; символ представляется строкой из одного элемента. Символы представляют (как минимум) 8-битные байты. Встроенные функции chr() и ord() преобразуют символы в неотрицательные целые числа, представляющие значения байтов, и обратно. Байты со значениями 0–127 обычно представляют соответствующие ASCII-значения, но интерпретация значений зависит от программы. Строковый тип данных также используется для представления массивов байтов, например для хранения данных, прочитанных из файла.

(В системах, где национальный набор символов не является ASCII, строки могут использовать EBCDIC для внутреннего представления, при условии что функции chr() и ord() реализуют отображение между ASCII и EBCDIC, а сравнение строк сохраняет порядок ASCII. Или, возможно, кто-то предложит лучшее правило?)

Unicode

Элементами объекта Unicode являются кодовые единицы Unicode. Кодовая единица Unicode представляется объектом Unicode из одного элемента и может содержать 16-битное или 32-битное значение, представляющее порядковый номер Unicode (максимальное значение порядкового номера задаётся в sys.maxunicode и зависит от того, как Python скомпилирован). В объекте Unicode могут присутствовать суррогатные пары, и они будут сообщаться как два отдельных элемента. Встроенные функции unichr() и ord() преобразуют кодовые единицы в неотрицательные целые числа, представляющие порядковые номера Unicode, определённые в стандарте Unicode 3.0, и обратно. Преобразование в другие кодировки и из них возможно через метод Unicode encode() и встроенную функцию unicode().

Кортежи

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

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

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

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

Списки

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

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

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

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

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

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

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

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

Множества

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

Неизменяемые множества

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

Отображения

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

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

Словари

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

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

Модули расширения dbm, gdbm и bsddb предоставляют дополнительные примеры типов отображений.

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

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

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

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

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

Атрибут	Значение
__doc__ func_doc	Строка документации функции или None, если она недоступна.	Доступно для записи
__name__ func_name	Имя функции	Доступно для записи
__module__	Имя модуля, в котором была определена функция, или None, если недоступно.	Доступно для записи
__defaults__ func_defaults	Кортеж, содержащий значения аргументов по умолчанию для тех аргументов, у которых есть значения по умолчанию, или None, если ни один аргумент не имеет значения по умолчанию.	Доступно для записи
__code__ func_code	Объект кода, представляющий скомпилированное тело функции.	Доступно для записи
__globals__ func_globals	Ссылка на словарь, содержащий глобальные переменные функции – глобальное пространство имён модуля, в котором функция была определена.	Только для чтения
__dict__ func_dict	Пространство имён, поддерживающее произвольные атрибуты функции.	Доступно для записи
__closure__ func_closure	None или кортеж ячеек, содержащих привязки для свободных переменных функции.	Только для чтения

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

Изменено в версии 2.4: func_name теперь доступен для записи.

Изменено в версии 2.6: Атрибуты с двойным подчёркиванием __closure__, __code__, __defaults__ и __globals__ были введены как псевдонимы для соответствующих атрибутов func_* для обеспечения прямой совместимости с Python 3.

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

Дополнительную информацию об определении функции можно получить из её объекта code; см. описание внутренних типов ниже.

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

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

Специальные атрибуты только для чтения: im_self – объект-экземпляр класса, im_func – объект-функция; im_class – класс объекта im_self для связанных методов или класс, запросивший метод, для несвязанных методов; __doc__ – документация метода (то же, что im_func.__doc__); __name__ – имя метода (то же, что im_func.__name__); __module__ – имя модуля, в котором определён метод, или None, если недоступно.

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

Изменено в версии 2.6: Для совместимости с Python 3 вперёд, im_func также доступен как __func__, а im_self как __self__.

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

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

Когда объект пользовательского метода создаётся путём извлечения объекта пользовательской функции из класса, его атрибут im_self равен None, и такой метод называется несвязанным. Когда он создаётся путём извлечения объекта пользовательской функции из класса через один из его экземпляров, его атрибут im_self равен этому экземпляру, и метод называется связанным. В обоих случаях атрибут im_class нового метода – это класс, из которого производится извлечение, а его атрибут im_func – исходный объект функции.

Когда объект пользовательского метода создаётся путём извлечения другого объекта метода из класса или экземпляра, поведение такое же, как для объекта функции, за исключением того, что атрибут im_func нового экземпляра – это не исходный объект метода, а его атрибут im_func.

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

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

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

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

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

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

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

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

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

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

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

Типы классов

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

Классические классы

Объекты классов описаны ниже. Когда вызывается объект класса, создаётся и возвращается новый экземпляр класса (также описанный ниже). Это подразумевает вызов метода __init__() класса, если он есть. Любые аргументы передаются методу __init__(). Если метод __init__() отсутствует, класс должен вызываться без аргументов.

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

Экземпляры классов описаны ниже. Экземпляры классов вызываемы только в том случае, если класс имеет метод __call__(); x(arguments) – это сокращение для x.__call__(arguments).

Модули

Модули импортируются оператором import (см. раздел Оператор import). Объект модуля имеет пространство имён, реализованное в виде словаря (это словарь, на который ссылается атрибут func_globals функций, определённых в модуле). Обращения к атрибутам преобразуются в поиск по этому словарю, например, m.x эквивалентно m.__dict__["x"]. Объект модуля не содержит объект кода, использованный для инициализации модуля (поскольку он не нужен после завершения инициализации).

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

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

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

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

Классы

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

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

Присваивание атрибутов класса обновляет словарь самого класса, но никогда не словарь базового класса.

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

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

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

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

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

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

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

Файлы

Объект файла представляет открытый файл. Объекты файлов создаются встроенной функцией open(), а также функциями os.popen(), os.fdopen() и методом makefile() объектов сокетов (и, возможно, другими функциями или методами, предоставляемыми модулями расширения). Объекты sys.stdin, sys.stdout и sys.stderr инициализируются как объекты файлов, соответствующие стандартным потокам ввода, вывода и ошибок интерпретатора. См. Объекты файлов для полной документации по объектам файлов.

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

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

Объекты кода

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

Специальные атрибуты только для чтения: co_name – имя функции; co_argcount – количество позиционных аргументов (включая аргументы со значениями по умолчанию); 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 установлен, если функция была скомпилирована с включённым future division; биты 0x10 и 0x1000 использовались в более ранних версиях Python.

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

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

Объекты фреймов

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

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

Специальные атрибуты, доступные для записи: f_trace, если не None, – функция, вызываемая в начале каждой строки исходного кода (используется отладчиком); f_exc_type, f_exc_value, f_exc_traceback представляют последнее исключение, возникшее в родительском кадре, если в текущем кадре когда-либо возникало другое исключение (во всех остальных случаях они равны None); f_lineno – текущий номер строки кадра – запись в этот атрибут из трассировочной функции переходит на заданную строку (только для самого нижнего кадра). Отладчик может реализовать команду Jump (также Set Next Statement), записывая в f_lineno.

Объекты трассировки стека

Объекты трассировки представляют стек вызовов исключения. Объект трассировки создаётся при возникновении исключения. Когда поиск обработчика исключения разворачивает стек выполнения, на каждом разворачиваемом уровне перед текущей трассировкой вставляется объект трассировки. Когда обработчик исключения входит, стек вызовов становится доступен программе. (См. раздел Оператор try.) Он доступен как sys.exc_traceback, а также как третий элемент кортежа, возвращаемого функцией sys.exc_info(). Последний является предпочтительным интерфейсом, поскольку он корректно работает, когда программа использует несколько потоков. Если в программе нет подходящего обработчика, трассировка стека выводится (в красивом формате) в стандартный поток ошибок; если интерпретатор работает в интерактивном режиме, она также становится доступна пользователю как sys.last_traceback.

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

Объекты срезов

Объекты срезов используются для представления срезов при использовании расширенного синтаксиса срезов. Это срез с двумя двоеточиями, или несколько срезов или многоточий, разделённых запятыми, например, a[i:j:step], a[i:j, k:l] или a[..., i:j]. Они также создаются встроенной функцией slice().

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

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

slice.indices(self, length)¶

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

Новое в версии 2.3.

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

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

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

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

3.3. Классы нового стиля и классические классы¶New-style and classic classes

Классы и экземпляры бывают двух видов: старого стиля (или классические) и нового стиля.

До Python 2.1 концепция class не была связана с концепцией type, и единственным доступным видом были классы старого стиля. Для класса старого стиля оператор x.__class__ возвращает класс объекта x, но type(x) всегда равно <type 'instance'>. Это отражает тот факт, что все экземпляры старого стиля, независимо от их класса, реализованы с помощью одного встроенного типа, называемого instance.

Классы нового стиля были введены в Python 2.2, чтобы объединить понятия class и type. Класс нового стиля – это просто определяемый пользователем тип, не более и не менее. Если x – экземпляр класса нового стиля, то type(x) обычно совпадает с x.__class__ (хотя это не гарантируется – экземпляр класса нового стиля может переопределять значение, возвращаемое для x.__class__).

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

По причинам обратной совместимости классы по умолчанию остаются старого стиля. Классы нового стиля создаются указанием другого класса нового стиля (т.е. типа) в качестве родительского или «верхнего типа» object, если другой родитель не нужен. Поведение классов нового стиля отличается от поведения классов старого стиля по ряду важных деталей помимо того, что возвращает type(). Некоторые из этих изменений являются фундаментальными для новой объектной модели, например, способ вызова специальных методов. Другие – это «исправления», которые раньше нельзя было реализовать из соображений совместимости, например, порядок разрешения методов при множественном наследовании.

Хотя данное руководство стремится дать всестороннее описание механики классов Python, в некоторых областях, касающихся классов нового стиля, оно может быть неполным. Дополнительные сведения см. на странице https://www.python.org/doc/newstyle/.

Классы старого стиля удалены в Python 3, остались только классы нового стиля.

3.4. Специальные имена методов¶Special method names

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

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

class metacls(type):
    def __new__(mcs, name, bases, dict):
        dict['foo'] = 'metacls was here'
        return type.__new__(mcs, name, bases, dict)

class MyClass:
    ...
    def __getitem__(self, index):
        ...
    def __setitem__(self, index, value):
        ...
    def __delitem__(self, index):
        ...

    if sys.version_info < (2, 0):
        # Они не будут определены, если версия не ниже 2.0 final

        def __getslice__(self, i, j):
            return self[max(0, i):max(0, j):]
        def __setslice__(self, i, j, seq):
            self[max(0, i):max(0, j):] = seq
        def __delslice__(self, i, j):
            del self[max(0, i):max(0, j):]
    ...

>>> class C:
...     pass
...
>>> c1 = C()
>>> c2 = C()
>>> c1.__len__ = lambda: 5
>>> c2.__len__ = lambda: 9
>>> len(c1)
5
>>> len(c2)
9

>>> class C(object):
...     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__()                 # Явный поиск через экземпляр
Class getattribute invoked
10
>>> type(c).__len__(c)          # Явный поиск через тип
Metaclass getattribute invoked
10
>>> len(c)                      # Неявный поиск
10