Как изменить переменную класса python

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

Переменные класса и экземпляра

Во-первых, быстрый обзор, если вы новичок в объектно-ориентированном программировании. Класс — это шаблон для создания объектов, а экземпляр — это сам объект. Классы часто представляют что-то в реальном мире, так что представьте, хотите ли вы создать класс, списка студентов. Вы можете создать класс с именем Student, который представляет собой шаблон, который определяет различные атрибуты студента. Таким образом, каждый студент является экземпляром класса Student.

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

Переменные класса

Переменные класса обычно являются переменными, которые являются общими для всех экземпляров. И они определены так:

class Student:
   teacher = 'Mrs. Jones'  # переменная класса

Каждый экземпляр класса будет иметь одинаковое значение для этих переменных:

tom = Student()
susan = Student()

print(tom.teacher)
>> "Mrs. Jones"

print(susan.teacher)
>> "Mrs. Jones"

Переменные экземпляра

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

class Student:
   teacher = 'Mrs. Jones'  # переменная класса   

   def __init__(self, name):
       self.name = name  # переменная экземпляра

Посмотрите, как каждый экземпляр теперь содержит уникальное значение name:

tom = Student('Tom')
susan = Student('Susan')

print(tom.name)
>> "Tom"

print(susan.name)
>> "Susan"

Резюме

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

Чего ожидать от переменных класса

Переменные класса являются общими для всех экземпляров класса. Напоминаем, что они определены так:

class Student:
   teacher = 'Mrs. Jones'

Иными словами, переменные класса ссылаются на одно и то же место в памяти. Смотрите следующее:

tom = Student()
susan = Student()

id(tom.teacher) == id(susan.teacher)
>> True

Функция id возвращает адрес объекта в памяти для реализации CPython.

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

Изменение переменной класса

Что произойдет, если мы изменим переменную класса даже после создания экземпляров?

tom = Student()

tom.teacher
>> Mrs. Jones

Student.teacher = 'Mr. Smith'

tom.teacher
>> Mr. Smith

Как и следовало ожидать, поскольку переменная teacher ссылается на общее местоположение в памяти, она также обновляется в экземпляре.

Изменение переменной экземпляра

Это, вероятно, наиболее очевидное и ожидаемое поведение, поэтому не стесняйтесь пропустить этот шаг. Но я все же покажу несколько примеров для полноты.

Рассмотрим наш класс Student с переменными класса и экземпляра:

class Student:
   teacher = 'Mrs. Jones'

   def __init__(self, name):
       self.name = name

Мы видим, что каждый экземпляр класса имеет уникальный адрес памяти для имени:

tom = Student('Tom')
susan = Student('Susan')

id(tom.name) == id(susan.name)
>> False

Как и следовало ожидать, обновление атрибута name в одном экземпляре не влияет на другой:

tom.name
>> Tom

susan.name
>> Susan

tom.name = 'Thomas'
tom.name
>> Thomas

susan.name
>> Susan

Переменные экземпляра переопределяют переменные класса (и методы)

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

Помните следующее?

tom = Student()
susan = Student()

id(tom.teacher) == id(susan.teacher)
>> True

Что произойдет, если мы изменим атрибут teacher прямо в одном из случаев:

tom.teacher = 'Mr. Clark'

Это важно отметить: переменные экземпляров не нужно объявлять, они создаются всякий раз, когда им присваиваются, а переменные экземпляра переопределяют переменные класса. Это означает, что в экземпляре Tom teacher больше не ссылается на переменную класса, а на вновь созданную переменную экземпляра.

И, естественно, экземпляр Сьюзен не затронут:

tom.teacher
>> Mr. Clark

susan.teacher
>> Mrs. Jones

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

Использование изменяемых объектов в качестве переменных класса

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

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

class Student:
   teacher = 'Mrs. Jones'
   test_scores = []

   def __init__(self, name):
       self.name = name

   def add_score(self, score):
       self.test_scores.append(score)

У нас есть переменная класса для хранения баллов, и у нас есть метод класса для добавления баллов. Теперь давайте добавим несколько баллов.

tom = Student('Tom')
susan = Student('Susan')

tom.add_score(90)
susan.add_score(100)

Можете ли вы угадать, какую ошибку мы только что сделали?

tom.test_scores
>> [90, 100]

Да, test_scores — это переменная класса, а не переменная экземпляра. Каждый экземпляр просто добавляет значения в переменную класса. Мы действительно хотим, чтобы каждый экземпляр содержал свой собственный список test_scores.

Так что лучший класс может выглядеть так:

class Student:
   teacher = 'Mrs. Jones'

   def __init__(self, name):
       self.name = name
       self.test_scores = []

   def add_score(self, score):
       self.test_scores.append(score)

И теперь наша проблема решена!

Заключение

Надеюсь, вы узнали разницу между переменными класса и экземпляра и что ожидать от каждой из них. Если я что-то упустил в этом руководстве или у вас есть отличные примеры путаницы переменных класса и экземпляра, пожалуйста, прокомментируйте ниже. Я был бы рад добавить их в это руководство!

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

class Dog:

    # атрибут данных (переменная класса), 
    # общая для всех экземпляров класса
    kind = 'canine'

    def __init__(self, name):
        # переменная экземпляра класса
        # уникальна для каждого экземпляра
        self.name = name

>>> d = Dog('Fido')
>>> e = Dog('Buddy')

# переменная `kind` будет общая для 
# всех экземпляров объекта `Dog`
>>> d.kind
# 'canine'
>>> e.kind    
# 'canine'

# переменная `name` будет уникальна 
# для каждого из экземпляров
>>> d.name
# 'Fido'
>>> e.name    
# 'Buddy'

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

class Dog:

    # ошибочное использование атрибута tricks -
    #  переменной класса
    tricks = []

    def __init__(self, name):
        self.name = name

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')

# неожиданно разделяется всеми собаками
>>> d.tricks
# ['roll over', 'play dead']

Правильный дизайн класса должен использовать tricks не как атрибут данных класса, а как переменную экземпляра класса:

class Dog:
    def __init__(self, name):
        self.name = name
        # создает новый пустой список 
        # трюков для каждой собаки
        self.tricks = []

    def add_trick(self, trick):
        self.tricks.append(trick)

>>> d = Dog('Fido')
>>> e = Dog('Buddy')
>>> d.add_trick('roll over')
>>> e.add_trick('play dead')
>>> d.tricks
# ['roll over']
>>> e.tricks
# ['play dead']

Если одно и то же имя атрибута встречается как в экземпляре класса, так и в самом классе, то поиск атрибута определяет приоритет экземпляра класса:

>>> class Warehouse:
        purpose = 'storage'
        region = 'west'

>>> w1 = Warehouse()
>>> print(w1.purpose, w1.region)
# storage west
>>> w2 = Warehouse()
>>> w2.region = 'east'
>>> print(w2.purpose, w2.region)
# storage east

На атрибуты данных класса могут ссылаться как методы, так и обычные пользователи — «клиенты» объекта. Другими словами, классы не могут использоваться для реализации чисто абстрактных типов данных. Фактически, ничто в Python не позволяет принудительно скрывать данные — все основано на соглашении.

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

В Python нет сокращений для ссылки на атрибуты данных или другие методы изнутри методов. Это повышает удобочитаемость методов: нет возможности путать локальные переменные и переменные экземпляра при просмотре метода.

Вместо использования привычной точечной нотации для доступа к атрибутам можно использовать встроенные функции:

• getattr(obj, name [, default]) — для доступа к атрибуту name объекта класса obj.
• hasattr(obj, name) — проверить, есть ли в классе obj атрибут name.
• setattr(obj, name, value) — задать атрибут name со значением value. Если атрибут не существует, он будет создан.
• delattr(obj, name) — удалить атрибут name из объекта класса obj.

Встроенные атрибуты класса.

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

• __dict__ — словарь, содержащий пространство имен класса.
• __doc__ — строка документации класса. None если, документация отсутствует.
• __name__ — имя класса.
• __module__ — имя модуля, в котором определяется класс.
• __bases__ — кортеж, содержащий базовые классы, в порядке их появления. Кортеж будет пустым, если наследование не было.
• __mro__ — Порядок разрешения методов в множественном наследовании.

Где хранятся атрибуты класса и экземпляра класса?

Python не был бы Python без четко определенного и настраиваемого поведения атрибутов. Атрибуты в Python хранятся в магическом методе с именем __dict__. Получить доступ к нему можно следующим образом:

class MyClass:
    class_attr = "Class"

    def __init__(self):
        self.instance_attr = "Instance"

>>> my_object = MyClass()
# атрибут экземпляра класса
>>> my_object.__dict__
# {'instance_attribute': 'Instance'}

# атрибут экземпляра класса
>>> MyClass.__dict__['class_attr']
# 'Class'

>>> my_object.class_attr
'Class'
>>> my_object.instance_attr
'Instance'

>>> class A():
...     i = 0
...     def add_i(self):
...             self.i = self.i + 1
...
>>> A.i
0
>>> a = A()
>>> a.add_i()
>>> A.i
0
>>> a.i
1

6 ответов

Лучший ответ

>>> print id(A.i), id(a.i)
9437588 9437576

A.i = A.i + 1

A.i += 1

#a.i = 1, A.i = 1
a.add_i()
#a.i = 2, A.i = 2

a = A()
b = A()
a.add_i()

print A.i()

In [15]: class A():
   ....:    i = 0
   ....:    @classmethod
   ....:    def incr(cls):
   ....:         cls.i += 1
   ....:         

In [16]: 

In [16]: A.incr()

In [17]: A.i
Out[17]: 1

In [18]: A().incr()

In [19]: A.i
Out[19]: 2

def incr(self):
    A.i += 1

In [29]: class Class4Test(object):
    mylist = []
    @classmethod
    def add2list_class(cls, val):
        cls.mylist.append(val)
    def add2list_by_class(self, val):
        Class4Test.mylist.append(val)
    def add2list_by_inst(self,val):
        self.mylist.append(val)
   ....:         

In [30]: obj = Class4Test()

In [31]: obj.add2list_by_inst('val1')

In [32]: obj.add2list_by_class('val2')

In [33]: Class4Test.add2list_class('val3')

In [34]: obj.add2list_class('val4')

In [35]: Class4Test.mylist
Out[35]: ['val1', 'val2', 'val3', 'val4']

class A():
    i = 0
    def add_i(self):
        print 'n-----In add_i function-----'
        print 'BEFORE: a.__dict__ :',a.__dict__
        print 'BEFORE: id(self)   : %dn' % id(self.i)
        self.i = self.i + 1
        print 'self.i = self.i + 1  donen'
        print 'AFTER: a.__dict__ :',a.__dict__
        print 'AFTER: id(self)   : %d' % id(self.i)
        print '-----end of add_i function-----n'

a = A()

print 'nA.i     ==',A.i
print 'id(A.i) ==',id(A.i)
print 'A.__dict__.keys() :',A.__dict__.keys()

print 'na.i     ==',a.i
print 'id(a.i) ==',id(a.i)
print 'a.__dict__.keys() :',a.__dict__.keys()

a.add_i()

print 'nA.i     ==',A.i
print 'id(A.i) ==',id(A.i)
print 'A.__dict__.keys() :',A.__dict__.keys()

print 'na.i     ==',a.i
print 'id(a.i) ==',id(a.i)
print 'a.__dict__.keys() :',a.__dict__.keys()

A.i     == 0
id(A.i) == 10021948
A.__dict__.keys() : ['i', 'add_i', '__module__', '__doc__']

a.i     == 0
id(a.i) == 10021948
a.__dict__.keys() : []

-----In add_i function-----
BEFORE: a.__dict__ : {}
BEFORE: id(self)   : 10021948

self.i = self.i + 1  done

AFTER: a.__dict__ : {'i': 1}
AFTER: id(self)   : 10021936
-----end of add_i function-----


A.i     == 0
id(A.i) == 10021948
A.__dict__.keys() : ['i', 'add_i', '__module__', '__doc__']

a.i     == 1
id(a.i) == 10021936
a.__dict__.keys() : ['i']

class A(object):
    i = 0
    def add_i(self):
        self.__class__.i += 1      

>> a = A()
>> a.add_i()
>> A.i
1