Заметки об объектной системе языка Python ч.1

Несколько заметок об объектной системе python'a. Рассчитаны на тех, кто уже умеет программировать на python. Речь идет только о новых классах (new-style classes) в python 2.3 и выше. В этой статье рассказывается, что такое объекты и как происходит поиск атрибутов.

Объекты

Все данные в питоне — это объекты. Каждый объект имеет 2 специальных атрибута __class__ и __dict__.

  • __class__ — определяет класс или тип, экзмепляром которого является объект. Тип (или класс объекта) определяет его поведение; он есть у всех объектов, в том числе и встроенных. Тип и класс — это разные названия одного и того же. x.__class__ <==> type(x).
  • __dict__ словарь, дающий доступ к внутреннему пространству имен, он есть почти у всех объектов, у многих встроенных типов его нет.

Примеры.

  1. >>> def foo(): pass
  2. ...
  3. >>> foo.__class__
  4. <type 'function'>
  5. >>> foo.__dict__
  6. {}
  7. >>> (42).__dict__
  8. Traceback (most recent call last):
  9. File "<stdin>", line 1, in <module>
  10. AttributeError: 'int' object has no attribute '__dict__'
  11. >>> (42).__class__
  12. <type 'int'>
  13. >>> class A(object):
  14. ... qux = 'A'
  15. ... def __init__(self, name):
  16. ... self.name=name
  17. ... def foo(self):
  18. ... print 'foo'
  19. ...
  20. >>> a = A('a')

У a тоже есть __dict__ и __class__:

  1. >>> a.__dict__ {'name': 'a'}
  2. >>> a.__class__
  3. <class '__main__.A'>
  4. >>> type(a)
  5. <class '__main__.A'>
  6. >>> a.__class__ is type(a)
  7. True

Класс и тип — это одно и то же.

  1. >>> a.__class__ is type(a) is A
  2. True

a.__dict__ — это словарь, в котором находятся внутренние (или специфичные для объекта) атрибуты, в данном случае 'name'. А в a.__class__ класс (тип). И, например, в методах класса присваивание self.foo = bar практически идентично self.__dict__['foo'] = bar или сводится к аналогичному вызову.

В __dict__ объекта нет методов класса, дескрипторов, классовых переменных, свойств, статических методов класса, все они определяются динамически с помощью класса из __class__ атрибута, и являются специфичными именно для класса (типа) объекта, а не для самого объекта. Пример. Переопределим класс объекта a:

  1. >>> class B(object):
  2. ... qux = 'B'
  3. ... def __init__(self):
  4. ... self.name = 'B object'
  5. ... def bar(self):
  6. ... print 'bar'
  7. ...
  8. >>> a.__dict__
  9. {'name': 'a'}
  10. >>> a.foo()
  11. foo
  12. >>> a.__class__
  13. <class '__main__.A'>
  14. >>> a.__class__ = B
  15. >>> a.__class__
  16. <class '__main__.B'>

Смотрим, что поменялось. Значение a.name осталось прежним, т.е. __init__ не вызывался при смене класса.

  1. >>> a.__dict__
  2. {'name': 'a'}

Доступ к классовым переменным и методам «прошлого» класса A пропал:

  1. >>> a.foo()
  2. Traceback (most recent call last):
  3. File "<stdin>", line 1, in <module>
  4. AttributeError: 'B' object has no attribute 'foo'

А вот классовые переменные и методы класса B доступы:

  1. >>> a.bar()
  2. bar
  3. >>> a.qux
  4. 'B'

Работа с атрибутам объекта: установка, удаление и поиск, равносильна вызову встроенных функций settattr, delattr, getattr:

  1. a.x = 1 <==> setattr(a, 'x', 1)
  2. del a.x <==> delattr(a, 'x')
  3. a.x <==> getattr(a, 'x')

При этом стоит стоит понимать, что setattr и delattr влияют и изменяют только сам объект (точнее a.__dict__), и не изменяют класс объекта.

qux — является классовой переменной, т.е. она «принадлежит» классу B, а не объекту a:

  1. >>> a.qux
  2. 'B'
  3. >>> a.__dict__
  4. {'name': 'a'}

Если мы попытаемся удалить этот атрибут, то получим ошибку, т.к. delattr будет пытаться удалить атрибут из a.__dict__

  1. >>> delattr(a, 'qux')
  2. Traceback (most recent call last):
  3. File "<stdin>", line 1, in <module>
  4. AttributeError: qux
  5. >>> del a.qux
  6. Traceback (most recent call last):
  7. File "<stdin>", line 1, in <module>
  8. AttributeError: qux
  9. >>> a.qux
  10. 'B'
  11. >>>

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

  1. >>> b = B()
  2. >>> b.qux
  3. 'B'
  4. >>> a.qux = 'myB'
  5. >>> a.qux
  6. 'myB'
  7. >>> a.__dict__
  8. {'qux': 'myB', 'name': 'a'}
  9. >>> b.qux
  10. 'B'
  11. >>>

Ну и раз есть 'qux' в __dict__ объекта, его можно удалить с помощью delattr:

  1. >>> del a.qux

После удаления, a.qux будет возвращать значение классовой переменной:

  1. >>> a.qux
  2. 'B'
  3. >>> a.__dict__
  4. {'name': 'a'}

Итак:

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

Объекты и классы

Классы — это объекты, и у них тоже есть специальные атрибуты __class__ и __dict__.

  1. >>> class A(object):
  2. ... pass
  3. ...

У класса тип type.

  1. >>> A.__class__
  2. <type 'type'>

Правда __dict__ у классов не совсем словарь

  1. >>> A.__dict__
  2. <dictproxy object at 0x1111e88>

Но __dict__ ответственен за доступ к внутреннему пространству имен, в котором хранятся методы, дескрипторы, переменные, свойства и прочее:

  1. >>> dict(A.__dict__)
  2. {'__module__': '__main__', 'qux': 'A', '__dict__': <attribute '__dict__' of 'A' objects>, 'foo': <function foo at 0x7f7797a25c08>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
  3. >>> A.__dict__.keys()
  4. ['__module__', 'qux', '__dict__', 'foo', '__weakref__', '__doc__']<

В классах помимо __class__ и __dict__, имеется еще несколько специальных атрибутов: __bases__ — список прямых родителей, __name__ — имя класса. [1]

Классы можно считать эдакими расширениями обычных объектов, которые реализуют интерфейс типа. Множество всех классов (или типов) принадлежат множеству всех объектов, а точнее является его подмножеством. Иначе говоря, любой класс является объектом, но не всякий объект является классом. Договоримся называть обычными объектами(regular objects) те объекты, которые классами не являются.

Небольшая демонстрация, которая станет лучше понятна чуть позже.

Класс является объектом.

  1. >>> class A(object):
  2. ... pass
  3. ...
  4. >>> isinstance(A, object)
  5. True

Число — это тоже объект.

  1. >>> isinstance(42, object)
  2. True

Класс — это класс (т.е. тип).

  1. >>> isinstance(A, type)
  2. True

А вот число классом (типом) не является. (Что такое type будет пояснено позже)

  1. >>> isinstance(42, type)
  2. False
  3. >>>

Ну и a — тоже обычный объект.

  1. >>> a = A()
  2. >>> isinstance(a, A)
  3. True
  4. >>> isinstance(a, object)
  5. True
  6. >>> isinstance(a, type)
  7. False

И у A всего один прямой родительский класс — object.

  1. >>> A.__bases__
  2. (<type 'object'>,)

Часть специальных параметров можно даже менять:

  1. >>> A.__name__
  2. 'A'
  3. >>> A.__name__ = 'B'
  4. >>> A
  5. <class '__main__.B'>

С помощью getattr получаем доступ к атрибутам класса:

  1. >>> A.qux
  2. 'A'
  3. >>> A.foo
  4. <unbound method A.foo>
  5. >>>

Поиск атрибутов в обычном объекте

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

  1. >>> class A(object):
  2. ... qux = 'A'
  3. ... def __init__(self, name):
  4. ... self.name=name
  5. ... def foo(self):
  6. ... print 'foo'
  7. ...
  8. >>> a = A()
  9. >>> b = A()

Т.к. в обычных объектах a и b нет в __dict__ атрибута 'qux', то поиск продолжается во внутреннем словаре __dict__ их типа (класса), а потом по __dict__ словарям родителей в определенном порядке:

  1. >>> b.qux
  2. 'A'
  3. >>> A.qux
  4. 'A'

Меняем атрибут qux у класса A. И соответственно должны поменяться значения, которые возвращают экземпляры класса A — a и b:

  1. >>> A.qux='B'
  2. >>> a.qux
  3. 'B'
  4. >>> b.qux
  5. 'B'
  6. >>>

Точно так же в рантайме к классу можно добавить метод:

  1. >>> A.quux = lambda self: 'i have quux method'
  2. >>> A.__dict__['quux']
  3. <function <lambda> at 0x7f7797a25b90>
  4. >>> A.quux
  5. <unbound method A.<lambda>>

И доступ к нему появится у экземпляров:

  1. >>> a.quux()
  2. 'i have quux method'

Точно так же как и с любыми другими объектами, можно удалить атрибут класса, например, классовую переменную qux:

>>> del A.qux

Она удалиться из __dict__

  1. >>> A.__dict__['qux']
  2. Traceback (most recent call last):
  3. File "<stdin>", line 1, in <module>
  4. KeyError: 'qux'

И доступ у экземляров пропадет.

  1. >>> a.qux
  2. Traceback (most recent call last):
  3. File "<stdin>", line 1, in <module>
  4. AttributeError: 'A' object has no attribute 'qux'
  5. >>>

У классов почти такой же поиск атрибутов, как и у обычных объектов, но есть отличия: поиск начинается с собственного __dict__ словаря, а потом идет поиск по __dict__ словарям суперклассов (которые хранятся в __bases__) по опредленному алгоритму, а затем по классу в __class__ и его суперклассах. (Подробнее об этом позже).

Cсылки

Unifying types and classes in Python — главный документ, объясняющий что, как и зачем в новых классах.

Making Types Look More Like Classes — PEP 252, описывающий отличие старых классов от новых.

Built-in functions — детальное описание работы всех встроенных функций.

Data model — детальное описание модели данных python'а.

Python types and objects — объяснение объектной модели python на простых примерах с картинками.

Примечания

[1] О __module__ и __doc__ для простоты изложения пока забудем. Полный список атрибутов класса можно посмотреть в документации

Взято с портала ХабраХабр http://habrahabr.ru/blogs/python/114576/

Баннер SGU.RU