Difference between staticmethod and classmethod

Question

What is the difference between a function decorated with  staticmethod and one decorated with  classmethod

User · Answer

Analyze  staticmethod literally providing different insights   A normal method of a class is an implicit dynamic method which takes the instance as first argument  In contrast  a staticmethod does not take the instance as first argument  so is called  static    A staticmethod is indeed such a normal function the same as those outside a class definition  It is luckily grouped into the class just in order to stand closer where it is applied  or you might scroll around to find it

User · Answer

To decide whether to use  staticmethod or  classmethod you have to look inside your method  If your method accesses other variables methods in your class then use  classmethod  On the other hand  if your method does not touches any other parts of the class then use  staticmethod   class Apple        counter   0       staticmethod     def about apple            print  Apple is good for you               note you can still access other member of the class           but you have to use the class instance            which is not very nice  because you have repeat yourself                      For example             staticmethod              print  Number of apples have been juiced   s    Apple  counter                       classmethod              print  Number of apples have been juiced   s    cls  counter                          classmethod is especially useful when you move your function to other class                  you don t have to rename the class reference        classmethod     def make apple juice cls  number of apples           print  Make juice            for i in range number of apples               cls  juice this i        classmethod     def  juice this cls  apple           print  Juicing  d       apple          cls  counter    1

User · Answer

tldr  A staticmethod is essentially a function bound to a class  and consequently its instances  A classmethod is essentially an inheritable staticmethod  For details  see the excellent answers by others

User · Answer

Basically  classmethod makes a method whose first argument is the class it s called from  rather than the class instance    staticmethod does not have any implicit arguments

User · Answer

I started learning programming language with C   and then Java and then Python and so this question bothered me a lot as well  until I understood the simple usage of each    Class Method  Python unlike Java and C   doesn t have constructor overloading   And so to achieve this you could use classmethod  Following example will explain this   Let s consider we have a Person class which takes two arguments first name and last name and creates the instance of Person    class Person object        def   init   self  first name  last name           self first name   first name         self last name   last name   Now  if the requirement comes where you need to create a class using a single name only  just a first name  you can t do something like this in Python    This will give you an error when you will try to create an object  instance    class Person object        def   init   self  first name  last name           self first name   first name         self last name   last name      def   init   self  first name           self first name   first name   However  you could achieve the same thing using  classmethod as mentioned below   class Person object        def   init   self  first name  last name           self first name   first name         self last name   last name       classmethod     def get person cls  first name           return cls first name        Static Method  This is rather simple  it s not bound to instance or class and you can simply call that using class name    So let s say in above example you need a validation that first name should not exceed 20 characters  you can simply do this     staticmethod   def validate name name       return len name   lt   20   and you could simply call using class name  Person validate name  Gaurang Shah

User · Answer

What is the difference between  staticmethod and  classmethod in Python   You may have seen Python code like this pseudocode  which demonstrates the signatures of the various method types and provides a docstring to explain each  class Foo object        def a normal instance method self  arg 1  kwarg 2 None                       Return a value that is a function of the instance with its         attributes  and other arguments such as arg 1 and kwarg2                   staticmethod     def a static method arg 0                       Return a value that is a function of arg 0  It does not know the          instance or class it is called from                    classmethod     def a class method cls  arg1                       Return a value that is a function of the class and other arguments          respects subclassing  it is called with the class it is called from               The Normal Instance Method First I ll explain a normal instance method  This is precisely called an  quot instance method quot   When an instance method is used  it is used as a partial function  as opposed to a total function  defined for all values when viewed in source code  that is  when used  the first of the arguments is predefined as the instance of the object  with all of its given attributes  It has the instance of the object bound to it  and it must be called from an instance of the object  Typically  it will access various attributes of the instance  For example  this is an instance of a string        if we use the instance method  join on this string  to join another iterable  it quite obviously is a function of the instance  in addition to being a function of the iterable list    a    b    c     gt  gt  gt       join   a    b    c     a  b  c   Bound methods Instance methods can be bound via a dotted lookup for use later  For example  this binds the str join method to the     instance   gt  gt  gt  join with colons       join   And later we can use this as a function that already has the first argument bound to it  In this way  it works like a partial function on the instance   gt  gt  gt  join with colons  abcde    a b c d e   gt  gt  gt  join with colons   FF    FF    FF    FF    FF    FF     FF FF FF FF FF FF   Static Method The static method does not take the instance as an argument  It is very similar to a module level function  However  a module level function must live in the module and be specially imported to other places where it is used  If it is attached to the object  however  it will follow the object conveniently through importing and inheritance as well  An example of a static method is str maketrans  moved from the string module in Python 3   It makes a translation table suitable for consumption by str translate  It does seem rather silly when used from an instance of a string  as demonstrated below  but importing the function from the string module is rather clumsy  and it s nice to be able to call it from the class  as in str maketrans   demonstrate same function whether called from instance or not   gt  gt  gt       maketrans  ABC    abc    65  97  66  98  67  99   gt  gt  gt  str maketrans  ABC    abc    65  97  66  98  67  99   In python 2  you have to import this function from the increasingly less useful string module   gt  gt  gt  import string  gt  gt  gt   ABCDEFG  translate string maketrans  ABC    abc     abcDEFG   Class Method A class method is a similar to an instance method in that it takes an implicit first argument  but instead of taking the instance  it takes the class  Frequently these are used as alternative constructors for better semantic usage and it will support inheritance  The most canonical example of a builtin classmethod is dict fromkeys  It is used as an alternative constructor of dict   well suited for when you know what your keys are and want a default value for them    gt  gt  gt  dict fromkeys   a    b    c      c   None   b   None   a   None   When we subclass dict  we can use the same constructor  which creates an instance of the subclass   gt  gt  gt  class MyDict dict    A dict subclass  use to demo classmethods   gt  gt  gt  md   MyDict fromkeys   a    b    c     gt  gt  gt  md   a   None   c   None   b   None   gt  gt  gt  type md   lt class    main   MyDict  gt   See the pandas source code for other similar examples of alternative constructors  and see also the official Python documentation on classmethod and staticmethod

User · Answer

I think a better question is  quot When would you use  classmethod vs  staticmethod  quot   classmethod allows you easy access to private members that are associated to the class definition  this is a great way to do singletons  or factory classes that control the number of instances of the created objects exist   staticmethod provides marginal performance gains  but I have yet to see a productive use of a static method within a class that couldn t be achieved as a standalone function outside the class

User · Answer

Here is a short article on this question   staticmethod function is nothing more than a function defined inside a class  It is callable without instantiating the class first  It   s definition is immutable via inheritance   classmethod function also callable without instantiating the class  but its definition follows Sub class  not Parent class  via inheritance  That   s because the first argument for  classmethod function must always be cls  class

User · Answer

The definitive guide on how to use static  class or abstract methods in Python is one good link for this topic  and summary it as following    staticmethod function is nothing more than a function defined inside a class  It is callable without instantiating the class first  It   s definition is immutable via inheritance    Python does not have to instantiate a bound-method for object  It eases the readability of the code  and it does not depend on the state of object itself     classmethod function also callable without instantiating the class  but its definition follows Sub class  not Parent class  via inheritance  can be overridden by subclass  That   s because the first argument for  classmethod function must always be cls  class     Factory methods  that are used to create an instance for a class using for example some sort of pre-processing  Static methods calling static methods  if you split a static methods in several static methods  you shouldn t hard-code the class name but use class methods

User · Answer

A class method receives the class as implicit first argument  just like an instance method receives the instance  It is a method which is bound to the class and not the object of the class It has access to the state of the class as it takes a class parameter that points to the class and not the object instance  It can modify a class state that would apply across all the instances of the class  For example it can modify a class variable that will be applicable to all the instances    On the other hand  a static method does not receive an implicit first argument  compared to class methods or instance methods  And can   t access or modify class state  It only belongs to the class because from design point of view that is the correct way  But in terms of functionality is not bound  at runtime  to the class   as a guideline  use static methods as utilities  use class methods for example as factory   Or maybe to define a singleton  And use instance methods to model the state and behavior of instances   Hope I was clear

User · Answer

Let me tell the similarity between a method decorated with  classmethod vs  staticmethod first   Similarity  Both of them can be called on the Class itself  rather than just the instance of the class  So  both of them in a sense are Class s methods    Difference  A classmethod will receive the class itself as the first argument  while a staticmethod does not   So a static method is  in a sense  not bound to the Class itself and is just hanging in there just because it may have a related functionality     gt  gt  gt  class Klaus           classmethod         def classmthd  args               return args           staticmethod         def staticmthd  args               return args    1  Call classmethod without any arg  gt  gt  gt  Klaus classmthd        main   Klaus      the class gets passed as the first argument    2  Call classmethod with 1 arg  gt  gt  gt  Klaus classmthd  chumma      main   Klaus   chumma      3  Call staticmethod without any arg  gt  gt  gt  Klaus staticmthd           4  Call staticmethod with 1 arg  gt  gt  gt  Klaus staticmthd  chumma     chumma

User · Answer

First let s start with an example code that we ll use to understand both concepts  class Employee       NO OF EMPLOYEES   0        def   init   self  first name  last name  salary           self first name   first name         self last name   last name         self salary   salary         self increment employees        def give raise self  amount           self salary    amount       classmethod     def employee from full name cls  full name  salary           split name   full name split              first name   split name 0          last name   split name 1          return cls first name  last name  salary        classmethod     def increment employees cls           cls NO OF EMPLOYEES    1       staticmethod     def get employee legal obligations txt            legal obligations    quot  quot  quot          1  An employee must complete 8 hours per working day         2               quot  quot  quot          return legal obligations   Class method A class method accepts the class itself as an implicit argument and -optionally- any other arguments specified in the definition  It   s important to understand that a class method  does not have access to object instances  like instance methods do   Therefore  class methods cannot be used to alter the state of an instantiated object but instead  they are capable of changing the class state which is shared amongst all the instances of that class  Class methods are typically useful when we need to access the class itself     for example  when we want to create a factory method  that is a method that creates instances of the class  In other words  class methods can serve as alternative constructors  In our example code  an instance of Employee can be constructed by providing three arguments  first name   last name and salary  employee 1   Employee  Andrew    Brown   85000  print employee 1 first name  print employee 1 salary    Andrew  85000  Now let   s assume that there   s a chance that the name of an Employee can be provided in a single field in which the first and last names are separated by a whitespace  In this case  we could possibly use our class method called employee from full name that accepts three arguments in total  The first one  is the class itself  which is an implicit argument which means that it won   t be provided when calling the method     Python will automatically do this for us  employee 2   Employee employee from full name  John Black   95000  print employee 2 first name  print employee 2 salary    John  95000  Note that it is also possible to call employee from full name from object instances although in this context it doesn   t make a lot of sense  employee 1   Employee  Andrew    Brown   85000  employee 2   employee 1 employee from full name  John Black   95000   Another reason why we might want to create a class method  is when we need to change the state of the class  In our example  the class variable NO OF EMPLOYEES keeps track of the number of employees currently working for the company  This method is called every time a new instance of Employee is created and it updates the count accordingly  employee 1   Employee  Andrew    Brown   85000  print f Number of employees   Employee NO OF EMPLOYEES    employee 2   Employee employee from full name  John Black   95000  print f Number of employees   Employee NO OF EMPLOYEES     Number of employees  1 Number of employees  2   Static methods On the other hand  in static methods neither the instance  i e  self  nor the class itself  i e  cls  is passed as an implicit argument  This means that such methods  are not capable of accessing the class itself or its instances  Now one could argue that static methods are not useful in the context of classes as they can also be placed in helper modules instead of adding them as members of the class  In object oriented programming  it is important to structure your classes into logical chunks and thus  static methods are quite useful when we need to add a method under a class simply because it logically belongs to the class  In our example  the static method named get employee legal obligations txt simply returns a string that contains the legal obligations of every single employee of a company  This function  does not interact with the class itself nor with any instance  It could have been placed into a different helper module however  it is only relevant to this class and therefore we have to place it under the Employee class  A static method can be access directly from the class itself print Employee get employee legal obligations txt          1  An employee must complete 8 hours per working day     2       or from an instance of the class  employee 1   Employee  Andrew    Brown   85000  print employee 1 get employee legal obligations txt          1  An employee must complete 8 hours per working day     2        References  What s the difference between static and class methods in Python

User · Answer

decorators were added in python 2 4 If you re using python  lt  2 4 you can use the classmethod   and staticmethod   function   For example  if you want to create a factory method  A function returning an instance of a different implementation of a class depending on what argument it gets  you can do something like   class Cluster object        def  is cluster for cls  name                       see if this class is the cluster with this name         this is a classmethod                      return cls   name      name      is cluster for   classmethod  is cluster for        static method     def getCluster name                       static factory method  should be in Cluster class         returns a cluster object for the given name                     for cls in Cluster   subclasses                  if cls  is cluster for name                   return cls       getCluster   staticmethod getCluster    Also observe that this is a good example for using a classmethod and a static method  The static method clearly belongs to the class  since it uses the class Cluster internally  The classmethod only needs information about the class  and no instance of the object   Another benefit of making the  is cluster for method a classmethod is so a subclass can decide to change it s implementation  maybe because it is pretty generic and can handle more than one type of cluster  so just checking the name of the class would not be enough

User · Answer

One pretty important practical difference occurs when subclassing  If you don t mind  I ll hijack  unutbu s example  class A       def foo self  x            print  quot executing foo  s   s  quot     self  x           classmethod     def class foo cls  x            print  quot executing class foo  s   s  quot     cls  x          staticmethod      def static foo x            print  quot executing static foo  s  quot    x   class B A       pass  In class foo  the method knows which class it is called on  A class foo 1      gt  executing class foo  lt class    main   A  gt   1  B class foo 1      gt  executing class foo  lt class    main   B  gt   1   In static foo  there is no way to determine whether it is called on A or B  A static foo 1      gt  executing static foo 1  B static foo 1      gt  executing static foo 1   Note that this doesn t mean you can t use other methods in a staticmethod  you just have to reference the class directly  which means subclasses  staticmethods will still reference the parent class  class A       classmethod     def class qux cls  x           print f quot executing class qux  cls    x   quot             classmethod     def class bar cls  x           cls class qux x        staticmethod     def static bar x           A class qux x   class B A       pass  A class bar 1      gt  executing class qux  lt class    main   A  gt   1  B class bar 1      gt  executing class qux  lt class    main   B  gt   1  A static bar 1      gt  executing class qux  lt class    main   A  gt   1  B static bar 1      gt  executing class qux  lt class    main   A  gt   1

User · Answer

A quick hack-up ofotherwise identical methods in iPython reveals that  staticmethod yields marginal performance gains  in the nanoseconds   but otherwise it seems to serve no function  Also  any performance gains will probably be wiped out by the additional work of processing the method through staticmethod   during compilation  which happens prior to any code execution when you run a script    For the sake of code readability I d avoid  staticmethod unless your method will be used for loads of work  where the nanoseconds count

User · Answer

Maybe a bit of example code will help  Notice the difference in the call signatures of foo  class foo and static foo   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     Below is the usual way an object instance calls a method  The object instance  a  is implicitly passed as the first argument   a foo 1    executing foo  lt   main   A object at 0xb7dbef0c gt  1      With classmethods  the class of the object instance is implicitly passed as the first argument instead of self   a class foo 1    executing class foo  lt class    main   A  gt  1    You can also call class foo using the class  In fact  if you define something to be a classmethod  it is probably because you intend to call it from the class rather than from a class instance  A foo 1  would have raised a TypeError  but A class foo 1  works just fine   A class foo 1    executing class foo  lt class    main   A  gt  1    One use people have found for class methods is to create inheritable alternative constructors     With staticmethods  neither self  the object instance  nor  cls  the class  is implicitly passed as the first argument  They behave like plain functions except that you can call them from an instance or the class   a static foo 1    executing static foo 1   A static foo  hi     executing static foo hi    Staticmethods are used to group functions which have some logical connection with a class to the class     foo is just a function  but when you call a foo you don t just get the function  you get a  partially applied  version of the function with the object instance a bound as the first argument to the function  foo expects 2 arguments  while a foo only expects 1 argument   a is bound to foo  That is what is meant by the term  bound  below   print a foo     lt bound method A foo of  lt   main   A object at 0xb7d52f0c gt  gt    With a class foo  a is not bound to class foo  rather the class A is bound to class foo   print a class foo     lt bound method type class foo of  lt class    main   A  gt  gt    Here  with a staticmethod  even though it is a method  a static foo just returns a good  ole function with no arguments bound  static foo expects 1 argument  and a static foo expects 1 argument too   print a static foo     lt function static foo at 0xb7d479cc gt    And of course the same thing happens when you call static foo with the class A instead   print A static foo     lt function static foo at 0xb7d479cc gt

User · Answer

Instance Method    Can modify object instance state   Can modify class state Class Method  - Can t modify object instance state   Can modify class state Static Method  - Can t modify object instance state - Can t modify class state class MyClass               Instance method has a mandatory first attribute self which represent the instance itself       Instance method must be called by a instantiated instance              def method self           return  instance method called   self                  Class method has a mandatory first attribute cls which represent the class itself       Class method can be called by an instance or by the class directly       Its most common using scenario is to define a factory method               classmethod     def class method cls           return  class method called   cls                  Static method doesn   t have any attributes of instances or the class       It also can be called by an instance or by the class directly       Its most common using scenario is to define some helper or utility functions which are closely relative to the class               staticmethod     def static method            return  static method called    obj   MyClass   print obj method    print obj class method      MyClass class method   print obj static method      MyClass static method    output    instance method called    lt   main   MyClass object at 0x100fb3940 gt     class method called    lt class    main   MyClass  gt   static method called  The instance method we actually had access to the object instance   right so this was an instance off a my class object whereas with the class method we have access to the class itself  But not to any of the objects   because the class method doesn t really care about an object existing  However you can both call a class method and static method on an object instance  This is going to work it doesn t really make a difference  so again when you call static method here it s going to work and it s going to know which method you want to call  The Static methods are used to do some utility tasks  and class methods are used for factory methods  The factory methods can return class objects for different use cases  And finally  a short example for better understanding  class Student      def   init   self  first name  last name           self first name   first name         self last name   last name       classmethod     def get from string cls  name string  str           first name  last name   name string split           if Student validate name first name  and Student validate name last name               return cls first name  last name          else              print  Invalid Names         staticmethod     def validate name name           return len name   lt   10   stackoverflow student   Student get from string  Name Surname   print stackoverflow student first name    Name print stackoverflow student last name    Surname

User · Answer

You might want to consider the difference between   class A      def foo       no self parameter  no decorator         pass  and class B       staticmethod     def foo       no self parameter         pass  This has changed between python2 and python3  python2   gt  gt  gt  A foo   TypeError  gt  gt  gt  A   foo   TypeError  gt  gt  gt  B foo    gt  gt  gt  B   foo    python3   gt  gt  gt  A foo    gt  gt  gt  A   foo   TypeError  gt  gt  gt  B foo    gt  gt  gt  B   foo    So using   staticmethod for methods only called directly from the class has become optional in python3  If you want to call them from both class and instance  you still need to use the  staticmethod decorator  The other cases have been well covered by unutbus answer

User · Answer

Another consideration with respect to staticmethod vs classmethod comes up with inheritance   Say you have the following class  class Foo object        staticmethod     def bar            return  quot In Foo quot   And you then want to override bar   in a child class  class Foo2 Foo        staticmethod     def bar            return  quot In Foo2 quot   This works  but note that now the bar   implementation in the child class  Foo2  can no longer take advantage of anything specific to that class   For example  say Foo2 had a method called magic   that you want to use in the Foo2 implementation of bar    class Foo2 Foo        staticmethod     def bar            return  quot In Foo2 quot       staticmethod     def magic            return  quot Something useful you d like to use in bar  but now can t quot    The workaround here would be to call Foo2 magic   in bar    but then you re repeating yourself  if the name of Foo2 changes  you ll have to remember to update that bar   method   To me  this is a slight violation of the open closed principle  since a decision made in Foo is impacting your ability to refactor common code in a derived class  ie it s less open to extension    If bar   were a classmethod we d be fine  class Foo object        classmethod     def bar cls           return  quot In Foo quot   class Foo2 Foo        classmethod     def bar cls           return  quot In Foo2  quot    cls magic        classmethod     def magic cls           return  quot MAGIC quot   print Foo2   bar    Gives  In Foo2 MAGIC Also  historical note  Guido Van Rossum  Python s creator  once referred to staticmethod s as  quot an accident quot   https   mail python org pipermail python-ideas 2012-May 014969 html  we all know how limited static methods are   They re basically an accident -- back in the Python 2 2 days when I was inventing new-style classes and descriptors  I meant to implement class methods but at first I didn t understand them and accidentally implemented static methods first  Then it was too late to remove them and only provide class methods   Also  https   mail python org pipermail python-ideas 2016-July 041189 html  Honestly  staticmethod was something of a mistake -- I was trying to do something like Java class methods but once it was released I found what was really needed was classmethod  But it was too late to get rid of staticmethod

User · Answer

staticmethod just disables the default function as method descriptor   classmethod wraps your function in a container callable that passes a reference to the owning class as first argument    gt  gt  gt  class C object        pass       gt  gt  gt  def f         pass       gt  gt  gt  staticmethod f    get   None  C   lt function f at 0x5c1cf0 gt   gt  gt  gt  classmethod f    get   None  C   lt bound method type f of  lt class    main   C  gt  gt    As a matter of fact  classmethod has a runtime overhead but makes it possible to access the owning class   Alternatively I recommend using a metaclass and putting the class methods on that metaclass    gt  gt  gt  class CMeta type        def foo cls         print cls       gt  gt  gt  class C object          metaclass     CMeta       gt  gt  gt  C foo    lt class    main   C  gt

User · Answer

Official python docs    classmethod     A class method receives the class as   implicit first argument  just like an   instance method receives the instance    To declare a class method  use this   idiom   class C       classmethod     def f cls  arg1  arg2                   The  classmethod form is a function   decorator     see the description of   function definitions in Function   definitions for details       It can be called either on the class    such as C f    or on an instance    such as C   f     The instance is   ignored except for its class  If a   class method is called for a derived   class  the derived class object is   passed as the implied first argument       Class methods are different than C     or Java static methods  If you want   those  see staticmethod   in this   section     staticmethod     A static method does not receive an   implicit first argument  To declare a   static method  use this idiom   class C       staticmethod     def f arg1  arg2                   The  staticmethod form is a function   decorator     see the description of   function definitions in Function   definitions for details       It can be called either on the class    such as C f    or on an instance    such as C   f     The instance is   ignored except for its class       Static methods in Python are similar   to those found in Java or C    For a   more advanced concept  see   classmethod   in this section

User · Answer

classmethod   can be used to create a shared global access to all the instances created of that class      like updating a record by multiple users     I particulary found it use ful when creating singletons as well       static method   has nothing to do with the class or instance being associated with    but for readability can use static method

User · Answer

I think giving a purely Python version of staticmethod and classmethod would help to understand the difference between them at language level   Both of them are non-data descriptors  It would be easier to understand them if you are familiar with descriptors first    class StaticMethod object        Emulate PyStaticMethod Type   in Objects funcobject c       def   init   self  f           self f   f      def   get   self  obj  objtype None           return self f   class ClassMethod object        Emulate PyClassMethod Type   in Objects funcobject c      def   init   self  f           self f   f      def   get   self  obj  cls None           def inner  args    kwargs               if cls is None                  cls   type obj              return self f cls   args    kwargs          return inner

User · Answer

I will try to explain the basic difference using an example   class A object       x   0      def say hi self           pass       staticmethod     def say hi static            pass       classmethod     def say hi class cls           pass      def run self self           self x    1         print self x   outputs 1         self say hi           self say hi static           self say hi class         staticmethod     def run static            print A x    outputs 0           A say hi      wrong         A say hi static           A say hi class         classmethod     def run class cls           print cls x   outputs 0           cls say hi      wrong         cls say hi static           cls say hi class     1 - we can directly call static and classmethods without initializing    A run self      wrong A run static   A run class     2- Static method cannot call self method but can call other static and classmethod  3- Static method belong to class and will not use object at all   4- Class method are not bound to an object but to a class

User · Answer

A staticmethod is a method that knows nothing about the class or instance it was called on  It just gets the arguments that were passed  no implicit first argument  It is basically useless in Python -- you can just use a module function instead of a staticmethod   A classmethod  on the other hand  is a method that gets passed the class it was called on  or the class of the instance it was called on  as first argument  This is useful when you want the method to be a factory for the class  since it gets the actual class it was called on as first argument  you can always instantiate the right class  even when subclasses are involved  Observe for instance how dict fromkeys    a classmethod  returns an instance of the subclass when called on a subclass    gt  gt  gt  class DictSubclass dict           def   repr   self               return  DictSubclass        gt  gt  gt  dict fromkeys  abc     a   None   c   None   b   None   gt  gt  gt  DictSubclass fromkeys  abc   DictSubclass  gt  gt  gt

User · Answer

Static Methods    Simple functions with no self argument   Work on class attributes  not on instance attributes  Can be called through both class and instance  The built-in function staticmethod  is used to create them    Benefits of Static Methods    It localizes the function name in the classscope It moves the function code closer to where it is used More convenient to import versus module-level functions since each method does not have to be specially imported   staticmethod def some static method  args    kwds       pass    Class Methods    Functions that have first argument as classname  Can be called through both class and instance  These are created with classmethod in-built function     classmethod  def some class method cls   args    kwds        pass

User · Answer

staticmethod has no access to attibutes of the object  of the class  or of parent classes in the inheritance hierarchy  It can be called at the class directly  without creating an object    classmethod has no access to attributes of the object  It however can access attributes of the class and of parent classes in the inheritance hierarchy  It can be called at the class directly  without creating an object   If called at the object then it is the same as normal method which doesn t access self  lt attribute s  gt  and accesses self   class    lt attribute s  gt  only   Think we have a class with b 2  we will create an object and re-set this to b 4 in it  Staticmethod cannot access nothing from previous  Classmethod can access  b  2 only  via cls b  Normal method can access both   b  4 via self b and  b  2 via self   class   b   We could follow the KISS style  keep it simple  stupid   Don t use staticmethods and classmethods  don t use classes without instantiating them  access only the object s attributes self attribute s   There are languages where the OOP is implemented that way and I think it is not bad idea

User · Answer

Class methods  as the name suggests  are used to make changes to classes and not the objects  To make changes to classes  they will modify the class attributes not object attributes   since that is how you update classes  This is the reason that class methods take the class conventionally denoted by  cls   as the first argument   class A object       m 54       classmethod     def class method cls           print  m is  d    cls m   Static methods on the other hand  are used to perform functionalities that are not bound to the class i e  they will not read or write class variables  Hence  static methods do not take classes as arguments  They are used so that classes can perform functionalities that are not directly related to the purpose of the class   class X object       m 54  will not be referenced       staticmethod     def static method            print  Referencing calling a variable or function outside this class  E g  Some global variable function

User · Answer

Python comes with several built-in decorators  The big three are   classmethod  staticmethod  property   classmethod decorator can be called with with an instance of a class or directly by the class itself as its first argument   staticmethod is a way of putting a function into a class  because it logically belongs there   while indicating that it does not require access to the class  Let s consider the following class  class DecoratorTest object        def   init   self           pass      def doubler self  x           print  quot running doubler quot           return x 2       classmethod     def class doubler klass  x           print  quot running doubler   s quot    klass          return x 2       staticmethod     def static doubler x           print  quot running quad quot           return x 2  decor   DecoratorTest    Let s see how it works  print decor doubler 5     running doubler   10  print decor class doubler 5     running doubler   lt class    main   DecoratorTest  gt     10 print DecoratorTest class doubler 5     running doubler   lt class    main   DecoratorTest  gt     10  print DecoratorTest static doubler 5     running doubler    10 print decor static doubler 5     running doubler    10  print decor doubler     lt bound method DecoratorTest doubler of  lt   main   DecoratorTest object at 0x7f90e74fd150 gt  gt   print decor class doubler     lt bound method DecoratorTest class doubler of  lt class    main   DecoratorTest  gt  gt   print decor static doubler     lt function DecoratorTest static doubler at 0x7f90e7447440 gt

User · Answer

My contribution demonstrates the difference amongst  classmethod   staticmethod  and instance methods  including how an instance can indirectly call a  staticmethod  But instead of indirectly calling a  staticmethod from an instance  making it private may be more  pythonic   Getting something from a private method isn t demonstrated here but it s basically the same concept     python3  from os import system system  cls                                                                                    class DemoClass object         instance methods need a class instance and       can access the instance through  self      def instance method 1 self           return  called from inside the instance method 1         def instance method 2 self             an instance outside the class indirectly calls the static method         return self static method       via instance method 2           class methods don t need a class instance  they can t access the       instance  self  but they have access to the class itself via  cls       classmethod     def class method cls           return  called from inside the class method           static methods don t have access to  cls  or  self   they work like       regular functions but belong to the class  namespace      staticmethod     def static method            return  called from inside the static method                                                                                       works even if the class hasn t been instantiated print DemoClass class method       n       called from inside the class method          works even if the class hasn t been instantiated print DemoClass static method       n       called from inside the static method                                                                                           gt  gt  gt  gt  gt  all methods types can be called on a class instance  lt  lt  lt  lt  lt    instantiate the class democlassObj   DemoClass      call instance method 1   print democlassObj instance method 1       n       called from inside the instance method 1            indirectly call static method through instance method 2    there s really no use   for this since a  staticmethod can be called whether the class has been   instantiated or not print democlassObj instance method 2       n       called from inside the static method   via instance method 2          call class method   print democlassObj class method       n        called from inside the class method          call static method   print democlassObj static method        called from inside the static method              whether the class is instantiated or not  this doesn t work print DemoClass instance method 1       n       TypeError  TypeError  unbound method instancemethod   must be called with DemoClass instance as first argument  got nothing instead

User · Answer

Only the first argument differs   normal method  the current object if automatically passed as an  additional  first argument classmethod  the class of the current object is automatically passed as an  additional  fist argument staticmethod  no extra arguments are automatically passed  What you passed to the function is what you get   In more detail    normal method When an object s method is called  it is automatically given an extra argument self as its first argument  That is  method def f self  x  y   must be called with 2 arguments  self is automatically passed  and it is the object itself  class method When the method is decorated  classmethod def f cls  x  y   the automatically provided argument is not self  but the class of self  static method When the method is decorated  staticmethod def f x  y   the method is not given any automatic argument at all  It is only given the parameters that it is called with  usages  classmethod is mostly used for alternative constructors  staticmethod does not use the state of the object  It could be a function external to a class  It only put inside the class for grouping functions with similar functionality  for example  like Java s Math class static methods   class Point     def   init   self  x  y           self x   x         self y   y       classmethod     def frompolar cls  radius  angle            quot  quot  quot The  cls  argument is the  Point  class itself quot  quot  quot          return cls radius   cos angle   radius   sin angle         staticmethod     def angle x  y            quot  quot  quot this could be outside the class  but we put it here  just because we think it is logically related to the class  quot  quot  quot          return atan y  x    p1   Point 3  2  p2   Point frompolar 3  pi 4   angle   Point angle 3  2

[python] Difference between staticmethod and classmethod

Examples related to python

Examples related to oop

Examples related to methods

Examples related to python-decorators