What is the purpose of class methods

Question

I m teaching myself Python and my most recent lesson was that Python is not Java  and so I ve just spent a while turning all my Class methods into functions   I now realise that I don t need to use Class methods for what I would done with static methods in Java  but now I m not sure when I would use them   All the advice I can find about Python Class methods is along the lines of newbies like me should steer clear of them  and the standard documentation is at its most opaque when discussing them   Does anyone have a good example of using a Class method in Python or at least can someone tell me when Class methods can be sensibly used

User · Answer

Alternative constructors are the classic example

User · Answer

This is an interesting topic  My take on it is that python classmethod operates like a singleton rather than a factory  which returns a produced an instance of a class   The reason it is a singleton is that there is a common object that is produced  the dictionary  but only once for the class but shared by all instances   To illustrate this here is an example  Note that all instances have a reference to the single dictionary  This is not Factory pattern as I understand it  This is probably very unique to python   class M      classmethod  def m cls  arg        print  arg was    getattr cls   arg    None        cls arg   arg      print  arg is    cls arg   M m 1      prints arg was None arg is 1  M m 2      prints arg was 1 arg is 2  m1   M    m2   M     m1 m 3     prints arg was 2 arg is 3    m2 m 4     prints arg was 3 arg is 4  lt  lt  this breaks the factory pattern theory   M m 5      prints arg was 4 arg is 5

User · Answer

What just hit me  coming from Ruby  is that a so-called class method and a so-called instance method is just a function with semantic meaning applied to its first parameter  which is silently passed when the function is called as a method of an object  i e  obj meth      Normally that object must be an instance but the  classmethod method decorator changes the rules to pass a class  You can call a class method on an instance  it s just a function  - the first argument will be its class    Because it s just a function  it can only be declared once in any given scope  i e  class definition   If follows therefore  as a surprise to a Rubyist  that you can t have a class method and an instance method with the same name   Consider this   class Foo      def foo x       print x    You can call foo on an instance   Foo   foo    lt   main   Foo instance at 0x7f4dd3e3bc20 gt    But not on a class   Foo foo   Traceback  most recent call last     File   lt stdin gt    line 1  in  lt module gt  TypeError  unbound method foo   must be called with Foo instance as first argument  got nothing instead    Now add  classmethod   class Foo       classmethod   def foo x       print x    Calling on an instance now passes its class   Foo   foo     main   Foo   as does calling on a class   Foo foo     main   Foo   It s only convention that dictates that we use self for that first argument on an instance method and cls on a class method  I used neither here to illustrate that it s just an argument  In Ruby  self is a keyword   Contrast with Ruby   class Foo   def foo       puts  instance method   self     end   def self foo       puts  class method   self     end end  Foo foo   class method Foo  Foo new foo   instance method   lt Foo 0x000000020fe018 gt    The Python class method is just a decorated function and you can use the same techniques to create your own decorators  A decorated method wraps the real method  in the case of  classmethod it passes the additional class argument   The underlying method is still there  hidden but still accessible     footnote  I wrote this after a name clash between a class and instance method piqued my curiosity  I am far from a Python expert and would like comments if any of this is wrong

User · Answer

Think about it this way  normal methods are useful to hide the details of dispatch  you can type myobj foo   without worrying about whether the foo   method is implemented by the myobj object s class or one of its parent classes  Class methods are exactly analogous to this  but with the class object instead  they let you call MyClass foo   without having to worry about whether foo   is implemented specially by MyClass because it needed its own specialized version  or whether it is letting its parent class handle the call   Class methods are essential when you are doing set-up or computation that precedes the creation of an actual instance  because until the instance exists you obviously cannot use the instance as the dispatch point for your method calls  A good example can be viewed in the SQLAlchemy source code  take a look at the dbapi   class method at the following link   https   github com zzzeek sqlalchemy blob ab6946769742602e40fb9ed9dde5f642885d1906 lib sqlalchemy dialects mssql pymssql py L47  You can see that the dbapi   method  which a database backend uses to import the vendor-specific database library it needs on-demand  is a class method because it needs to run before instances of a particular database connection start getting created     but that it cannot be a simple function or static function  because they want it to be able to call other  supporting methods that might similarly need to be written more specifically in subclasses than in their parent class  And if you dispatch to a function or static class  then you  forget  and lose the knowledge about which class is doing the initializing

User · Answer

I recently wanted a very light-weight logging class that would output varying amounts of output depending on the logging level that could be programmatically set   But I didn t want to instantiate the class every time I wanted to output a debugging message or error or warning   But I also wanted to encapsulate the functioning of this logging facility and make it reusable without the declaration of any globals   So I used class variables and the  classmethod decorator to achieve this   With my simple Logging class  I could do the following   Logger  level   Logger DEBUG   Then  in my code  if I wanted to spit out a bunch of debugging information  I simply had to code  Logger debug   this is some annoying message I only want to see while debugging      Errors could be out put with   Logger error   Wow  something really awful happened       In the  production  environment  I can specify   Logger  level   Logger ERROR   and now  only the error message will be output   The debug message will not be printed   Here s my class   class Logger           Handles logging of debugging and error messages           DEBUG   5     INFO    4     WARN    3     ERROR   2     FATAL   1      level   DEBUG      def   init    self             Logger  level   Logger DEBUG       classmethod     def isLevel  cls  level             return cls  level  gt   level       classmethod     def debug  cls  message             if cls isLevel  Logger DEBUG                 print  DEBUG       message       classmethod     def info  cls  message             if cls isLevel  Logger INFO                 print  INFO        message       classmethod     def warn  cls  message             if cls isLevel  Logger WARN                 print  WARN        message       classmethod     def error  cls  message             if cls isLevel  Logger ERROR                 print  ERROR       message       classmethod     def fatal  cls  message             if cls isLevel  Logger FATAL                 print  FATAL       message   And some code that tests it just a bit   def logAll         Logger debug   This is a Debug message         Logger info    This is a Info  message         Logger warn    This is a Warn  message         Logger error   This is a Error message         Logger fatal   This is a Fatal message      if   name         main           print  Should see all DEBUG and higher      Logger  level   Logger DEBUG     logAll        print  Should see all ERROR and higher      Logger  level   Logger ERROR     logAll

User · Answer

if you are not a  quot programmer by training quot   this should help  I think I have understood the technical explanations above and elsewhere on the net  but I was always left with a question  quot Nice  but why do I need it  What is a practical  use case  quot   and now life gave me a good example that clarified all  I am using it to control the global-shared variable that is shared among instances of a class instantiated by multi-threading module  in humane language  I am running multiple agents that create examples for deep learning IN PARALLEL   imagine multiple players playing ATARI game at the same time and each saving the results of their game to one common repository  the SHARED VARIABLE   I instantiate the players agents with the following code  in Main Execution Code   a3c workers    A3C Worker self master model  self optimizer  i  self env name  self model dir  for i in range multiprocessing cpu count       it creates as many players as there are processor cores on my comp A3C Worker - is a class that defines the agent a3c workers - is a list of the instances of that class  i e  each instance is one player agent   now i want to know how many games have been played across all players agents thus within the A3C Worker definition I define the variable to be shared across all instances  class A3C Worker threading Thread      global shared total episodes across all workers   0  now as the workers finish their games they increase that count by 1 each for each game finished at the end of my example generation i was closing the instances but the shared variable had assigned the total number of games played  so when I was re-running it again my initial total number of episodes was that of the previous total  but i needed that count to represent that value for each run individually to fix that i specified   class A3C Worker threading Thread        classmethod     def reset cls           A3C Worker global shared total episodes across all workers   0  than in the execution code i just call  A3C Worker reset    note that it is a call to the CLASS overall not any INSTANCE of it individually  thus it will set my counter to 0 for every new agent I initiate from now on  using the usual method definition def play self    would require us to reset that counter for each instance individually  which would be more computationally demanding and difficult to track

User · Answer

I used to work with PHP and recently I was asking myself  whats going on with this classmethod  Python manual is very technical and very short in words so it wont help with understanding that feature  I was googling and googling and I found answer -  http   code anjanesh net 2007 12 python-classmethods html   If you are lazy to click it  My explanation is shorter and below      in PHP  maybe not all of you know PHP  but this language is so straight forward that everybody should understand what I m talking about  we have static variables like this    class A        static protected  inner var   null       static public function echoInnerVar                 echo self   inner var   n              static public function setInnerVar  v                self   inner var    v            class B extends A      A  setInnerVar 10   B  setInnerVar 20    A  echoInnerVar    B  echoInnerVar      The output will be in both cases 20   However in python we can add  classmethod decorator and thus it is possible to have output 10 and 20 respectively  Example    class A object       inner var   0       classmethod     def setInnerVar cls  value           cls inner var   value       classmethod     def echoInnerVar cls           print cls inner var   class B A       pass   A setInnerVar 10  B setInnerVar 20   A echoInnerVar   B echoInnerVar     Smart  ain t

User · Answer

Factory methods  alternative constructors  are indeed a classic example of class methods   Basically  class methods are suitable anytime you would like to have a method which naturally fits into the namespace of the class  but is not associated with a particular instance of the class   As an example  in the excellent unipath module   Current directory   Path cwd     Return the actual current directory  e g   Path   tmp my temp dir    This is a class method    chdir     Make self the current directory     As the current directory is process wide  the cwd method has no particular instance with which it should be associated   However  changing the cwd to the directory of a given Path instance should indeed be an instance method   Hmmm    as Path cwd   does indeed return a Path instance  I guess it could be considered to be a factory method

User · Answer

When a user logs in on my website  a User   object is instantiated from the username and password   If I need a user object without the user being there to log in  e g  an admin user might want to delete another users account  so i need to instantiate that user and call its delete method    I have class methods to grab the user object   class User         lots of code                more code       classmethod     def get by username cls  username           return cls query cls username    username  get         classmethod     def get by auth id cls  auth id           return cls query cls auth id    auth id  get

User · Answer

Class methods provide a  semantic sugar   don t know if this term is widely used  - or  semantic convenience    Example  you got a set of classes representing objects  You might want to have the class method all   or find   to write User all   or User find firstname  Guido    That could be done using module level functions of course

User · Answer

Classes and Objects concepts are very useful in organizing things  It s true that all the operations that can be done by a method can also be done using a static function  Just think of a scenario  to build a Students Databases System to maintain student details  You need to have details about students  teachers and staff  You need to build functions to calculate fees  salary  marks  etc  Fees and marks are only applicable for students  salary is only applicable for staff and teachers  So if you create separate classes for every type of people  the code will be organized

User · Answer

I think the most clear answer is AmanKow s one  It boils down to how u want to organize your code  You can write everything as module level functions which are wrapped in the namespace of the module i e  module py  file 1  --------- def f1     pass def f2     pass def f3     pass   usage py  file 2  -------- from module import   f1   f2   f3   def f4   pass  def f5   pass  usage1 py  file 3  ------------------- from usage import f4 f5 f4   f5     The above procedural code is not well organized  as you can see after only 3 modules it gets confusing  what is each method do   You can use long descriptive names for functions like in java  but still  your code gets unmanageable very quick   The object oriented way is to break down your code into manageable blocks i e Classes  amp  objects and functions can be associated with objects instances or with classes    With class functions you gain another level of division in your code compared with module level functions  So you can group related functions within a class to make them more specific to a task  that you assigned to that class  For example you can create a file utility class    class FileUtil       def copy source dest  pass   def move source dest  pass   def copyDir source dest  pass   def moveDir source dest  pass    usage FileUtil copy  1 txt   2 txt   FileUtil moveDir  dir1   dir2     This way is more flexible and more maintainable  you group functions together and its more obvious to what each function do  Also you prevent name conflicts  for example the function copy may exist in another imported module for example network copy  that you use in your code  so when you use the full name FileUtil copy   you remove the problem and both copy functions can be used side by side

User · Answer

A class defines a set of instances  of course   And the methods of a class work on the individual instances   The class methods  and variables  a place to hang other information that is related to the set of instances over all   For example if your class defines a the set of students you might want class variables or methods which define things like the set of grade the students can be members of   You can also use class methods to define tools for working on the entire set   For example Student all of em   might return all the known students   Obviously if your set of instances have more structure than just a set you can provide class methods to know about that structure   Students all of em grade  juniors    Techniques like this tend to lead to storing members of the set of instances into data structures that are rooted in class variables   You need to take care to avoid frustrating the garbage collection then

User · Answer

Class methods are for when you need to have methods that aren t specific to any particular instance  but still involve the class in some way  The most interesting thing about them is that they can be overridden by subclasses  something that s simply not possible in Java s static methods or Python s module-level functions   If you have a class MyClass  and a module-level function that operates on MyClass  factory  dependency injection stub  etc   make it a classmethod  Then it ll be available to subclasses

User · Answer

Honestly   I ve never found a use for staticmethod or classmethod   I ve yet to see an operation that can t be done using a global function or an instance method   It would be different if python used private and protected members more like Java does   In Java  I need a static method to be able to access an instance s private members to do stuff   In Python  that s rarely necessary   Usually  I see people using staticmethods and classmethods when all they really need to do is use python s module-level namespaces better

User · Answer

classmethod can be useful for easily instantiating objects of that class from outside resources  Consider the following   import settings  class SomeClass       classmethod     def from settings cls           return cls settings settings       def   init   self  settings None           if settings is not None              self x   settings  x               self y   settings  y     Then in another file   from some package import SomeClass  inst   SomeClass from settings     Accessing inst x will give the same value as settings  x

User · Answer

I was asking myself the same question few times  And even though the guys here tried hard to explain it  IMHO the best answer  and simplest  answer I have found is the description of the Class method in the Python Documentation   There is also reference to the Static method  And in case someone already know instance methods  which I assume   this answer might be the final piece to put it all together     Further and deeper elaboration on this topic can be found also in the documentation  The standard type hierarchy  scroll down to Instance methods section

User · Answer

It allows you to write generic class methods that you can use with any compatible class   For example    classmethod def get name cls       print cls name  class C      name    tester   C get name   get name   call it  C get name     If you don t use  classmethod you can do it with self keyword but it needs an instance of Class   def get name self       print self name  class C      name    tester   C get name   get name   call it  C   get name     lt -note the its an instance of class C

[python] What is the purpose of class methods?

Examples related to python

Examples related to class-method