The mutual invocation of Python class methods and the meaning of self

each time the internal method is called, the method is preceded by self. 

Class MyClass:
def __init__ (self):
Pass
def func1 (self):
# do something
Print (' a ') #for example
Self.common_func ()
def func2 (self):
# do something
Self.common_func ()

def common_func (self):
Pass

 
 The meaning of self in Python

when I first started to learn Python's class writing, I found it very troublesome, why we need to call when the definition is not needed, why not internal simplification to reduce the number of keystrokes we hit?

You will understand all the questions after reading this article.

Self represents an instance of a class, not a class.

Example to illustrate

class Test: def prt (self): Print (self) Print (self.) __class__  = Test () t.prt ()

Execution results are as follows

<__main__. Test object at 0x000000000284e080> <class'__main__. Test'>

As can be seen from the above example, self represents an instance of a class. The self.__class__, however, points to the class.

Self does not have to be written self

There are many children's shoes to learn other languages and then learn python, so always feel self strange, want to write this, can you?
Sure, or rewrite the code above.

class Test:     def PRT (This):         Print (this)         Print (this.) __class__  = Test () t.prt ()

After you change this, the result is exactly the same.
Of course, it is better to respect the customary custom and use self.

Can self not write?

Inside the Python interpreter, when we call T.prt (), Python is actually interpreted as test.prt (t), which means to replace self with an instance of the class.
Interested children's shoes can rewrite the above t.prt () line, the actual results after the run is exactly the same.
In fact, it has been partly explained that self cannot be omitted when defined, so if you want to try it, see below:

class Test:     def prt ():         Print  = Test () t.prt ()

The runtime reminder error is as follows: PRT does not have parameters when it is defined, but we are forced to pass a parameter when we run it.
Since the above explained that T.prt () is equivalent to TEST.PRT (t), the program reminds us to pass a parameter T more.

" h.py "  in <module>1 was given

Of course, this is the class method if neither of our definitions nor the invocation is capable of passing class instances.

class Test:     def prt ():         Print (__class__) test.prt ()

The operation results are as follows

<class'__main__. Test'

In inheritance, which instance is passed in, which is the incoming instance, not the instance of the class that defines self.

Look at the code first

class Parent:     def pprt (self):         Print  class  child (Parent):    def  cprt (self):        Print  == Parent () p.pprt ()

The operation results are as follows

<__main__. The child object is at 0x0000000002a47080><__main__. The child object is at 0x0000000002a47080><__main__. Parent Object at 0x0000000002a47240>

Explain:
The problem should not be understood when running c.cprt (), referring to an instance of the child class.
However, when running C.pprt (), it is equivalent to CHILD.PPRT (c), so self refers to an instance of the child class, and because the Pprt () method is not defined in self, the Pprt () method is defined in the parent class, as it is found on the inheritance tree. So it will be successfully called.

In a descriptor class, self refers to an instance of a descriptor class

Not very easy to understand, first look at the example:

classDesc:def __get__(self, INS, CLS):Print('Self in Desc:%s'%Self )Print(self, INS, CLS)classtest:x=Desc ()defprt (self):Print('Self in Test:%s'%Self ) T=Test () t.prt () T.x

The results of the operation are as follows:

inch Test: <__main__. Test object at 0x0000000002a570b8> in Desc: <__main__. Desc object at 0x000000000283e208> <__main__. Desc object at 0x000000000283e208> <__main__. Test object at 0x0000000002a570b8> <class'__main__. Test'>

Most children's shoes are starting to have doubts, why is self defined in the Desc class not supposed to be the instance t that calls it? How does it become an instance of the Desc class?
Note: It's important to keep your eyes open, The call here is T.x, which is the property x of the instance T of the test class, because the attribute x is not defined in the instance T, so the class attribute x is found, and the property is a descriptor property, an instance of the Desc class, so there is no method for test.
Then we can get the same result if we call property X directly through the class.
Here is the result of changing the t.x to Test.x run.

inch Test: <__main__. Test object at 0x00000000022570b8> in Desc: <__main__. Desc object at 0x000000000223e208><__main__. Desc object at 0x000000000223e208> None <class'__main__. Test'>

Digression: Because in many cases the descriptor class still needs to know who the instance that called the descriptor is, so there is a second argument in the Descriptor class, INS, which is used to represent the class instance that called it, so t.x can see the second item in the run result in the third row as <main. Test object at 0x0000000002a570b8>. When called with Test.x, none is returned because there are no instances.

Summarize

• Self is defined when it is defined, but is automatically passed in when it is called.
• Self's name is not a rule of death, but it is best to use self as agreed.
• Self always refers to an instance of the class at the time of invocation.

All of the above code is tested in Python3.4.

Source: 78171655

Source: 80626035
 From for notes (Wiz)

The mutual invocation of Python class methods and the meaning of self