Почему разрешено добавление атрибутов к уже созданному объекту?

Главный принцип заключается в том, что декларации не существует. То есть вы никогда не объявляете «этот класс имеет метод foo» или «экземпляры этого класса имеют панель атрибутов», не говоря уже о том, чтобы делать заявления о типах объектов, которые должны там храниться. Вы просто определяете метод, атрибут, класс и т. д., и они добавляются. Как указывает Дж. Бернардо, любой метод __init__ делает то же самое. Было бы бессмысленно произвольно ограничивать создание новых атрибутов методами с именем __init__. И иногда полезно хранить функцию как __init__, которая на самом деле не имеет этого имени (например, декораторы), и такое ограничение нарушит это.

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

Если вы хотите подстраховку, что ж, очень жаль. Python не предлагает его, и вы не можете разумно добавить его, и, что наиболее важно, его будут избегать программисты Python, которые используют этот язык (читай: почти все те, с которыми вы хотите работать). Тестирование и дисциплина по-прежнему имеют большое значение для обеспечения правильности. Не позволяйте создавать атрибуты за пределами __init__, если этого можно избежать, и проводите автоматизированное тестирование. У меня очень редко возникает AttributeError или логическая ошибка из-за подобных ухищрений, а из тех, что случаются, почти все отлавливаются тестами.

Просто чтобы прояснить некоторые недоразумения в обсуждениях здесь. Этот код:

class Foo(object):
    def __init__(self, bar):
        self.bar = bar

foo = Foo(5)

И этот код:

class Foo(object):
    pass

foo = Foo()
foo.bar = 5

полностью эквивалентен. На самом деле нет никакой разницы. Он делает то же самое. Это отличие состоит в том, что в первом случае он инкапсулирован и понятно, что атрибут bar является нормальной частью объектов типа Foo. Во втором случае не понятно, что это так.

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

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

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

Причина, по которой это работает, заключается в том, что большинство экземпляров хранят свои атрибуты в словаре. Да, обычный словарь Python, который вы бы определили с помощью {}. Словарь хранится в атрибуте экземпляра с именем __dict__. На самом деле, некоторые люди говорят, что «классы — это просто синтаксический сахар для словарей». То есть вы можете делать все, что вы можете делать с классом со словарем; классы только облегчают.

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

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

Однако есть хитрость: использование атрибута __slots__ в определении класса не позволит вам от создания дополнительных атрибутов, не определенных в последовательности __slots__:

>>> class Foo(object):
...     __slots__ = ()
... 
>>> f = Foo()
>>> f.bar = 'spam'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'Foo' object has no attribute 'bar'
>>> class Foo(object):
...     __slots__ = ('bar',)
... 
>>> f = Foo()
>>> f.bar
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: bar
>>> f.bar = 'spam'

Он создает элемент данных radius из my_circle.

Если бы вы запросили my_circle.radius, он бы выдал исключение:

>>> print my_circle.radius # AttributeError

Интересно, что это не меняет класс; только тот экземпляр. Так:

>>> my_circle = Circle()
>>> my_circle.radius = 5
>>> my_other_circle = Circle()
>>> print my_other_circle.radius # AttributeError

В Python есть два типа атрибутов — Class Data Attributes и Instance Data Attributes.

Python дает вам возможность создавать Data Attributes на лету.

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

class Demo(object):
    classAttr = 30
    def __init__(self):
         self.inInit = 10

demo = Demo()
demo.outInit = 20
Demo.new_class_attr = 45; # You can also create class attribute here.

print demo.classAttr  # Can access it 

del demo.classAttr         # Cannot do this.. Should delete only through class

demo.classAttr = 67  # creates an instance attribute for this instance.
del demo.classAttr   # Now OK.
print Demo.classAttr  

Итак, вы видите, что мы создали два атрибута экземпляра, один внутри __init__ и один снаружи, после создания экземпляра.

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

Это отличается от Java, где каждый экземпляр класса имеет одинаковый набор переменных экземпляра.

• ПРИМЕЧАНИЕ. - Хотя вы можете получить доступ к атрибуту класса через экземпляр, вы не можете его удалить. Кроме того, если вы попытаетесь изменить атрибут класса через экземпляр, вы фактически создадите атрибут экземпляра, который затеняет атрибут класса.

Как сказал Делнан, вы можете получить такое поведение с помощью атрибута __slots__. Но тот факт, что это способ сэкономить место в памяти и тип доступа, не отменяет того факта, что это (также) средство для отключения динамических атрибутов.

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

Кроме того, поскольку библиотека attrs достигла версии 16 в 2016 году (очевидно, намного позже исходного вопроса и ответов), создание закрытого класса со слотами никогда не было проще.

>>> import attr
...
... @attr.s(slots=True)
... class Circle:
...   radius = attr.ib()
...
... f = Circle(radius=2)
... f.color = 'red'
AttributeError: 'Circle' object has no attribute 'color'

Чтобы управлять созданием новых атрибутов, вы можете перезаписать метод __setattr__. Он будет вызываться каждый раз, когда вызывается my_obj.x = 123.

См. документацию:

class A():
  def __init__(self):
    # Call object.__setattr__ to bypass the attribute checking
    super().__setattr__('x', 123)

  def __setattr__(self, name, value):
    # Cannot create new attributes
    if not hasattr(self, name):
      raise AttributeError('Cannot set new attributes')
    # Can update existing attributes
    super().__setattr__(name, value)

a = A()
a.x = 123  # Allowed
a.y = 456  # raise AttributeError

Обратите внимание, что пользователи по-прежнему могут обойти проверку, если они вызывают напрямую object.__setattr__(a, 'attr_name', attr_value).