Assignment of non-existing class variable is accepted - Why?

[DrZ]

Hi, I am a newbie. My understanding is that I cannot assign to a non-existing class variable, but the python interpreter (3.8.3) allows this to occur. Why does the following code work without complaint? See the comment for the statement I would think should cause an error. TIA.

class My_object:
    class_var1 = 123

def main():
    my_obj = My_object()
    print(my_obj.class_var1)
    my_obj.foobar = 101   #foobar is not a My_object variable
    print(my_obj.foobar)

main()

[Yoriz]

The line

my_obj.foobar = 101

has created a new instance attribute foobar and assigned it the value of 101

[DrZ]

The line

my_obj.foobar = 101

has created a new instance attribute foobar and assigned it the value of 101

My question should have been expanded a little more...Why is this allowed? Is it a commonly used feature in python programming? I am starting to get a grasp on the subject of object data encapsulation and as I understand it for python this is self-imposed via leading underscores in variable names and using data access methods. As a newbie, it seems to me that allowing "on-the-fly" creation of class variables is an encapsulation violation - no? Why would I ever want to do this? Any and all answers appreciated.

[bowlofred]

You're correct. In python it is generally expected that you can create attributes of classes and instances after instantiation.

There are some ways to prevent that for in individual class (like overriding __setattr__ or __slots__), but using them in that way is not simple. Using them improperly can break other bits in subtle ways. Python isn't Java or C++, and attribute creation outside of __init__ is considered normal. Yes, this can cause some problems, but it also gives benefits allowing users the flexibility to do things the author had not anticipated.

[DrZ]

Ok, thanks for that explanation.

"You're correct. In python it is generally expected that you can create attributes of classes and instances after instantiation."
FWIW, I noticed that one can create attributes of the class before any instantiation has occurred and all instances will inherit the newly added attribute.

This all started when I made a bogus assignment to a class instance with a spelling error. The assignment was quietly taken in - no complaints - and I spent a lot of time finding the error. So, I gather that on-the-fly object variables are inherited, but if applied to an instance only remain with that instance.

I will try to understand how to use this "feature".

Thanks again.

[bowlofred]

Yup, and typos/spelling/author confusion is the biggest drawback to this flexibility. But linters can help find problems like this early.

[deanhystad]

Only class variables and methods are inherited. The only relationship between instance variables and the class is that something executed code that created an instance variable.

class Things:

    favorite_things = ['Raindrops on roses'] # Class variable

    def do_something(self):
        self.favorite_things = ['Bright copper kettles'] # instance variable

a = Things()
b = Things()
b.do_something()
c = Things()
c.favorite_things = ['Warm wollen mittens']

print('Things', Things.favorite_things)
print('a', a.favorite_things)
print('b', b.favorite_things)
print('c', c.favorite_things)

Output:
Things ['Raindrops on roses']
a ['Raindrops on roses']
b ['Bright copper kettles']
c ['Warm wollen mittens']

In this example, "a" has a class variable and no instance variables. "b" and "c" have a class variable and an instance variable. For "b" the instance variable is defined in a method of Things, but the instance variable for "c" is defined outside the scope of the class. The instance variable "favorite_things" is obviously not inherited, and relies on code that is executed after the instance is created.

When I first started writing classes with inheritance I ran into the "X is not defined" errors all the time. I would look at the code and see the instance variable created in the __init__, but setting a breakpoint before the error I would inspect the instance and there was no instance variable! My problem was that the instance variable was not defined yet. Even though it was defined inside __init__ of the base class, it was used before the base class __init__ was called, or before the base class __init__ had completed.

A linter will complain about instance variables defined outside the __init__ method. Listen to the linter and make you code complient. It is also a good idea to call __init__ for all superclass(es) at the top of the __init__ method.

As for typos, learn how to write unit tests and test everything. The compiler safety net is gone