Original Address 68957848
Original Address 78165645
Original Address https://www.cnblogs.com/1204guo/p/7832167.html
In Python, the methods defined in class can be broadly divided into three categories: instance methods, class methods, and static methods.
Use a table to summarize the following:
Method Type |
Retouching |
called by |
Default first parameter |
Instance method |
No |
Instance |
Self |
Class method |
@classmethod |
CLS, instance |
Cls |
Static methods |
@staticmethod |
CLS, instance |
No |
Example:
classFoo ():#No modification defInstance_method (self):#The first parameter passed in is self, which is the instance itself Print('The first argument of Instance_method:', self) @classmethoddefClass_method (CLS):#The first parameter passed in is class Print('The first argument of Class_method:', CLS) @staticmethoddefStatic_method ():#There is no default first parameter, only custom parameters Print('The first argument of Static_method:') Foo=Foo () Foo.instance_method () Foo.class_method () Foo.class_method () Foo.static_method () Foo.static_method () Try: Foo.instance_method ()except: Print('instance method can not be accessed through class.')
Output:
The first argument of Instance_method: <__main__. Foo object at 0x7fd135ec3b38><class'__main__. Foo'><class'__main__. Foo'>notclass
Need to note:
1. @classmethod
with the @staticmethod
built-in methods that is Python.
2. The special method __new__
, although not @classmethod
decorated, is also a class method.
--------------------------------------------------------------------------------------------------------------- -------------------------------------------------------
--------------------------------------------------------------------------------------------------------------- -------------------------------------------------------
--------------------------------------------------------------------------------------------------------------- -------------------------------------------------------
Classmethod: Class method
Staticmethod: Static method
In Python, both static and class methods can be accessed through class objects and class object instances. But the difference is:
@classmethod is a function modifier, which means that next is a class method, which is called an instance method for what we usually see. The first parameter of the class method is CLS, and the first argument of the instance method is self, which represents an instance of the class.
A normal object method requires at least one self parameter, which represents the Class object instance
Class methods have the class variable CLS incoming, so that some related processing can be done with the CLS. and with subclass inheritance, when the class method is called, the passed-in class variable CLS is a subclass, not a parent class.
For a class method, it can be called through a class, like C.F (), a bit like a static method in C + +, or it can be called through an instance of the class, like C (). f (), here C (), written so that it is an instance of the class.
Static method is not, it is basically the same as a global function, generally used very little
Classmethod must use a class object as the first argument, and Staticmethod can pass no arguments.
classDate:def __init__(Self,day=0, Month=0, year=0): Self.day=Day Self.month=month Self.year=Year @classmethoddeffrom_string (CLS, date_as_string): Day, month, year= Map (Int,date_as_string.split ('-')) My_date=CLS (Day, month, year)returnmy_date @staticmethoddefIs_date_valid (date_as_string): Day, month, year= Map (int, date_as_string.split ('-')) returnDay <= 31 andMonth <= 12 andYear <= 3999if __name__=='__main__': My_date= Date.from_string ('11-09-2012') Print(My_date.day, my_date.month,my_date.year) is_date= Date.is_date_valid ('13-13-2012') Print(is_date) outputs:11 9 2012False
Looking at another example, in order to verify that a subclass inherits, when a subclass calls that class method, the passed-in class variable CLS is a subclass, not a parent class
classA: @classmethoddefcm (CLS):Print('class method cm (CLS) Caller:'Cls.__name__) @staticmethoddefSM ():Print('static method SM () is called')classB (A):Passa.cm ()#class method cm (CLS) Caller: AB.CM ()#class method cm (CLS) Caller: BA.sm ()#static method SM () is calledB.sm ()#static method SM () is called
Let's see why we need to use Staticmethod and Classmethod.
class Kls: def __init__ (self,data): = Data def printd (self): print(self.data) ik1=kls ( ' Arun ' ) ik2=kls ('Seema') ik1.printd () Ik2.printd ()
#What if we wanted to write a few ways to just interact with the class instead of interacting with the instance? We can write an easy way out of the class to do this,#but doing so spreads out the class code's relationship to the outside of the class definition. If you write like this, it can cause difficulties in future code maintenance:defget_no_of_instances (cls_obj):returnCls_obj.no_instclassKls:no_inst=0def __init__(self): Kls.no_inst= Kls.no_inst + 1Ik1=Kls () ik2=Kls ()Print(Get_no_of_instances (Kls))#2
Application Classmethod
classKls (object): No_inst=0def __init__(self): Kls.no_inst= Kls.no_inst + 1@classmethoddefget_no_of_instance (cls_obj):returnCls_obj.no_instik1=Kls () ik2=Kls ()Print(Ik1.get_no_of_instance ())Print(Kls.get_no_of_instance ())#2#2
@staticmethod
There are often functions that are related to the class, but static methods are required when the runtime does not require instances and classes to participate.
--------------------------------------------------------------------------------------------------------------- -------------------------------------------------------
--------------------------------------------------------------------------------------------------------------- -------------------------------------------------------
--------------------------------------------------------------------------------------------------------------- -------------------------------------------------------
There are 3 main methods of Python, namely static methods (Staticmethod), class methods (Classmethod), and instance methods, as follows:
12345678910111213141516 |
def
foo(x):
print "executing foo(%s)"
%
(x)
class
A(
object
):
def
foo(
self
,x):
print "executing foo(%s,%s)"
%
(
self
,x)
@classmethod
def
class_foo(
cls
,x):
print "executing class_foo(%s,%s)"
%
(
cls
,x)
@staticmethod
def
static_foo(x):
print
"executing static_foo(%s)"
%
x
a
=
A()
|
The self and the CLS are bindings to classes or instances, which we can call for general functions, which are foo(x)
most commonly used, and whose work has nothing to do with anything (classes, instances). For instance methods, we know that we need to bind this instance every time we define a method in a class, that is foo(self, x)
, why do you do this? Because the invocation of the instance method is inseparable from the instance, we need to pass the instance to the function, which is a.foo(x)
called when (In fact foo(a, x)
). class method, except that it passes a class instead of an instance A.class_foo(x)
. Note that the self and the CLS here can replace the other parameters, but the Python convention is these two, or do not change the good.
For static methods, like normal methods, there is no need to bind to who, the only difference is that the call needs to be used a.static_foo(x)
or A.static_foo(x)
called.
Staticmethod and Classmethod in Python