Study on access rules for class instance attributes in Python-Python tutorial

This article mainly introduces Python class instance attribute access rules. This article summarizes some aspects that are not intuitive to C ++ and Java programmers to illustrate class instance attribute access in Python, for more information, see. in Python, access rules for class instance attributes are intuitive.

However, there are still some inintuitive points, especially for C ++ and Java programmers.

Here, we need to understand the following:

1. Python is a dynamic language. any entity can dynamically add or delete attributes.
2. a class defines a scope.
3. the class instance also introduces a scope, which is different from the scope defined by the corresponding class.
4. when you search for attributes in a class instance, you first search for attributes in the instance's own scope. if the attributes are not found, you can search for attributes in the scope defined by the class.
5. when assigning values to class instance attributes, an attribute is actually added to the scope defined by the class instance (if it does not exist), and the attributes with the same name defined in the corresponding class are not affected.

Let's take an example to better understand the above:

The code is as follows:

Class:
Cls_ I = 0
Cls_j = {}
Def _ init _ (self ):
Self. instance_ I = 0
Self. instance_j = {}

Here, we first define an instance A of Class a, and then look at the scope of Class A and the scope of instance a in what are different:

The code is as follows:

>>> A = ()
>>> A. _ dict __
{'Instance _ j': {}, 'instance _ I ': 0}
>>> A. _ dict __
{'_ Init _':, '_ module _': '_ main _', 'cls _ I ': 0, 'cls _ j ': {}, '_ doc _': None}

We can see that instance_ I and instance_j are in the scope of a, and cls_ I and cls_j are in the scope of.

Let's take a look at how the name search happens:

The code is as follows:

>>> A. cls_ I
0
>>> A. instance_ I
0

When searching for cls_ I, instance a does not have its scope, but it is found in the scope of instance A. When searching for instance_ I, you can find it directly in the scope of.

What if we try to modify the cls_ I value through instance:

The code is as follows:

>>> A. cls_ I = 1
>>> A. _ dict __
{'Instance _ j': {}, 'cls _ I ': 1, 'instance _ I': 0}
>>> A. _ dict __
{'_ Init _':, '_ module _': '_ main _', 'cls _ I ': 0, 'cls _ j ': {}, '_ doc _': None}

We can see that there is a cls_ I attribute in the scope of A, and its value is 1. at the same time, we also note that the value of the cls_ I attribute in the scope of a is still 0. here, we actually added an instance attribute and did not modify it to the class attribute.

What if we use instance a to manipulate the data in cls_j (note that it is not cls_j itself:

The code is as follows:

>>> A. cls_j ['A'] = 'A'
>>> A. _ dict __
{'Instance _ j': {}, 'cls _ I ': 1, 'instance _ I': 0}
>>> A. _ dict __
{'_ Init _':, '_ module _': '_ main _', 'cls _ I ': 0, 'cls _ j ': {'a': 'A'}, '_ doc _': None}

We can see that the scope of a has not changed, but the scope of A has changed, and the data in cls_j has changed.

The instance scope changes and does not affect other instances of the class. However, changes in the scope of the class affect all instances of the class, including the instances created before this:

The code is as follows:

>>> A. cls_k = 0
>>> I. cls_k
0