Разница между атрибутами экземпляра и атрибутами класса

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

• Атрибуты экземпляра создаются с использованием синтаксиса instance.attror self.attr( selfэто действительно соглашение, это просто идентификатор, который относится к самому экземпляру). Как уже было сказано, они локальны для этого экземпляра и поэтому доступны только из одного из них.

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

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

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

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

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

  Примечание. В Python 3 словарь класса имеет тип mappingproxy, не заходя слишком далеко, прямым следствием является сделать словарь доступным только для чтения, и в принципе вы __setattr__сможете изменить его только в своем случае. Это сделано для эффективности и стабильности, среди прочего гарантирует, что ключи могут быть только строками.

Важно знать порядок, в котором разрешается доступ к атрибуту, Python следует следующему порядку при поиске атрибута из объекта:

1. Специальные атрибуты ( __dict__, __slots__, __weakref__, и т.д.).
2. Дескрипторы данных (реализовать __set__) в словаре классов и возможных родительских классах.
3. Атрибуты экземпляра.
4. Дескрипторы, не относящиеся к данным (реализуются __get__, но не выполняются __set__) в словаре класса и родительских элементах.
5. Наконец, попробуйте делегировать __getattr__.

если мы игнорируем дескрипторы данных (и, следовательно, свойства с помощью setter ), Python сначала ищет атрибут в атрибутах экземпляра, а если не находит, ищет в атрибутах класса. Это означает, что если вы создаете атрибут экземпляра с тем же именем, что и у уже существующего атрибута класса, атрибут класса будет «скрытым», если к пути self.atributoили попытаются получить доступ instancia.atributo.

В случае уступки порядок следующий:

1. Дескрипторы данных в классе и родителях.
2. Метод__setattr__
3. Атрибуты экземпляра, если атрибут не существует и описанное выше не удается, новый атрибут автоматически добавляется как атрибут экземпляра .

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

Если кто-то не хочет читать дальше ツ, мораль такова:

Если новое значение будет присвоено атрибуту класса (который не является дескриптором данных), всегда делайте это со ссылкой на класс, а не на экземпляр. То есть через NombreClase.atributoили с помощью метода класса ( @classmethod), а не через self.atributoили nombre_instancia.atributo, поскольку это не изменяет атрибут класса, а создает новый атрибут экземпляра с тем же именем.

Как обсуждалось выше, мы можем получить доступ к атрибутам класса двумя способами:

>>> class Foo:
        n = 7

>>> inst = Foo()
>>> inst.n             # Acceso mediante nombre de una instancia
7
>>> Foo.n              # Acceso mediante nombre de la clase
7
>>> inst.__class__.n   # Acceso mediante el atributo __class__ de la instancia
7

Когда вместо простого доступа к значению мы хотим выполнить присваивание, все меняется:

• Если мы назначаем через класс поведение, как и ожидалось, значение изменяется для всех экземпляров класса:

  >>> class Foo:
          cls_n = 13
  
          @classmethod
          def set_cls_n(cls, v):
              cls.cls_n = v
  
  >>> inst1 = Foo()
  >>> inst2 = Foo()
  >>> inst1.cls_n
  13
  >>> inst2.cls_n
  13
  >>> Foo.cls_n = 7
  >>> inst1.cls_n
  7
  >>> inst2.cls_n
  7
  >>> inst1.set_cls_n(23)
  >>> inst1.cls_n
  23
  >>> inst2.cls_n
  23
  

  Вы можете видеть, как изменение значения с nпомощью Foo.nили через метод класса (где равенство clsотносится к ) изменение отражается во всех экземплярах класса.Foo__class__

• Если мы присвоим новое значение переменной класса, используя экземпляр для ссылки на нее, мы получим сюрприз:

  >>> class Foo:
          cls_n = 13
  
  >>> inst1 = Foo()
  >>> inst2 = Foo()
  >>> inst1.cls_n
  13
  >>> inst2.cls_n
  13
  >>> inst1.cls_n = 7
  >>> inst1.cls_n
  7
  >>> inst2.cls_n
  13               # ????????????????????
  

  Попытка присвоить новый объект атрибуту класса instancia.atributoс помощью метода экземпляра via или из него self.atributo(пока мы не имеем дело с дескриптором данных, который, как мы видели, имеет приоритет и будет вести себя так, как мы ожидаем) не изменяет атрибут класса, он создает атрибут экземпляра с тем же именем, и ему присваивается новое значение .

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

  >>> inst1 = Foo()
  >>> inst1.__dict__
  {}
  >>> inst1.__class__.__dict__
  mappingproxy({'__module__': '__main__',
               'cls_n': 13,
               '__dict__': <attribute '__dict__' of 'Foo' objects>,
               '__weakref__': <attribute '__weakref__' of 'Foo' objects>,
                '__doc__': None
              })
  
  
  >>> inst1.cls_n = 7
  >>> inst1.__dict__
  {'cls_n': 7}         # <<<< Nuestro nuevo atributo de instancia
  >>> inst1.__class__.__dict__
  mappingproxy({'__module__': '__main__',
               'cls_n': 13,
               '__dict__': <attribute '__dict__' of 'Foo' objects>,
               '__weakref__': <attribute
               '__weakref__' of 'Foo' objects>,
               '__doc__': None
              })
  

Наконец, помните, что в Python есть изменяемые объекты, такие как ( list, dict, set) и неизменяемые ( int, float, bool, tuple, frozenset, str). Неизменяемые объекты не могут быть изменены после создания, когда мы объединяем строку, создается новый объект, чего не происходит со списком:

    >>> a = "Hola"
    >>> b = "StackOverflow"
    >>> id(a)
    2105306070744
    >>> id(b)
    2105306118320
    >>> a += b
    >>> a
    'HolaStackOverflow'
    >>> id(a)       
    2105306110544    # a ahora hace referencia a otro objeto

    >>> a = ["Hola"]
    >>> b = ["StackOverflow"]
    >>> id(a)
    2105306091848
    >>> id(b)
    2105305993800
    >>> a += b
    >>> a 
    ['Hola', 'StackOverflow']
    >>> id(a)
    2105306091848    # a sigue haciendo referencia al mismo objeto

Python обрабатывает назначение по ссылке, переменная или атрибут — это не что иное, как идентификатор, имя, которое ссылается на объект в памяти. Атрибуты класса являются общими для всех экземпляров, потому что они ссылаются на один и тот же объект в памяти, поэтому, когда мы изменяем изменяемые атрибуты класса с помощью instancia.atributoили self.atributoизменение, если это отражается во всех экземплярах:

class Foo:
    a = [100]                # Atributo de clase

    def __init__(self, n):
        self.b = [n]         # Atributo de instancia


>>> inst1 = Foo(1)
>>> inst2 = Foo(2)

>>> inst1.a
[100]
>>> inst2.a
[100]
>>> inst1.a += [5]
>>> inst1.a
[100, 5]
>>> inst2.a
[100, 5]

Этого не происходит с атрибутом экземпляра, поскольку он специфичен для каждого объекта:

>>> inst1.b
[1]    
>>> inst2.b
[2] 
>>> inst1.b += [5]
>>> inst1.b
[1, 5]
>>> inst2.b
[2]

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

>>> class Foo:
        s = "Hola"

>>> a = Foo()
>>> b = Foo()
>>> a.s += " StackOverflow"
>>> a.s
'Hola StackOverflow'
>>> b.s
'Hola'

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

Хотя дескрипторы тесно связаны со всем этим и неоднократно упоминаются, они не вводятся, потому что объяснение протокола дескриптора означало бы слишком большое расширение ответа, когда он уже, возможно, слишком длинный, мы можем увидеть в самой документации общее руководство по этому поводу. : Дескриптор HowTo Guide

Переменная класса наследуется всеми производными от нее экземплярами. Если вы посмотрите на этот пример:

pi@rp1:~ $ python3
Python 3.4.2 (default, Oct 19 2014, 13:31:11)
[GCC 4.9.1] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> class Perro:
...     numero_patas = 4
...
>>> pancho = Perro()
>>> fido = Perro()
>>> pancho.numero_patas
4
>>> fido.numero_patas
4
>>> Perro.numero_patas
4

panchoи fidoдва экземпляра Perro, которые унаследовали значение переменной numero_patas. Теперь меняем значение переменной в экземпляреfido

>>> fido.numero_patas = 3
>>> fido.numero_patas
3
>>>

Теперь мы добавляем новую переменную экземпляра в фидо:

>>> fido.cola = 'cortada'
>>> fido.cola
'cortada'

В Python переменные класса и экземпляра хранятся в разных словарях. Если мы посмотрим в словарь каждого созданного экземпляра:

>>> pancho.__dict__
{}
>>> fido.__dict__
{'cola': 'cortada', 'numero_patas': 3}
>>>

Мы видим, что panchoу него нет переменных экземпляра. Однако, когда мы попросили его , он numero_patasвернулся к нам 4. Это связано с тем, что существует второй словарь, словарь класса, к которому обращаются, когда переменная экземпляра не найдена в его словаре. Если мы получим к нему доступ:

>>> pancho.__class__.__dict__
mappingproxy({'__weakref__': <attribute '__weakref__' of 'Perro' objects>, '__dict__': <attribute '__dict__' of 'Perro' objects>, 'numero_patas': 4, '__module__': '__main__', '__doc__': None})
>>> fido.__class__.__dict__
mappingproxy({'__weakref__': <attribute '__weakref__' of 'Perro' objects>, '__dict__': <attribute '__dict__' of 'Perro' objects>, 'numero_patas': 4, '__module__': '__main__', '__doc__': None})
>>>

Вы увидите, что они идентичны. Если вы создаете один экземпляр класса, вы должны использовать переменные экземпляра, так как сначала доступ к словарю переменных экземпляра будет немного быстрее.

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