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

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

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

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

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

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

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

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

Типы влияют практически на все аспекты поведения объектов. Даже значимость идентичности объекта в некотором смысле меняется: для неизменяемых типов операции, вычисляющие новые значения, могут фактически возвращать ссылку на любой существующий объект с тем же типом и значением, в то время как для изменяемых объектов это не допускается. Например, после a = 1; b = 1, a и b могут ссылаться или не ссылаться на один и тот же объект со значением 1 в зависимости от реализации, но после 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

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

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

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

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

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

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

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

numbers.Real (float)

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

numbers.Complex (complex)

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

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

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

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

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

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

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

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

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

Строки

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

Кортежи

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

Байты

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

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

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

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

Списки

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

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

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

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

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

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

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

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

Множества

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

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

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

Отображения

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

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

Словари

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Когда объект определённого пользователем метода создаётся путём получения другого объекта метода из класса или экземпляра, поведение такое же, как для объекта функции, за исключением того, что атрибут __func__ нового экземпляра – это не исходный объект метода, а его атрибут __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), называется функцией-генератором. При вызове такая функция всегда возвращает итератор, который можно использовать для выполнения тела функции: вызов метода __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__() для инициализации нового экземпляра

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

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

Модули

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Объекты кода

Объекты кода представляют собой скомпилированный в байт-код исполняемый код 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_lasti – точная инструкция (индекс в строке байткода объекта кода).

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

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

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

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

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

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

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

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

slice.indices(self, length)¶

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

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

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

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

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

3.3. Имена специальных методов¶Special method names

Класс может реализовать определённые операции, вызываемые специальным синтаксисом (например, арифметические операции или индексация и срезы), определяя методы со специальными именами. Это подход Python к перегрузке операторов, позволяющий классам определять собственное поведение в отношении операторов языка. Например, если класс определяет метод с именем __getitem__(), и x – экземпляр этого класса, то x[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 OrderedClass(type):

     @classmethod
     def __prepare__(metacls, name, bases, **kwds):
        return collections.OrderedDict()

     def __new__(cls, name, bases, classdict):
        result = type.__new__(cls, name, bases, dict(classdict))
        result.members = tuple(classdict)
        return result

class A(metaclass=OrderedClass):
    def one(self): pass
    def two(self): pass
    def three(self): pass
    def four(self): pass

>>> A.members
('__module__', 'one', 'two', 'three', 'four')

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