What is class method?

[Hussein B]

Hi,
I'm familiar with static method concept, but what is the class method?
how it does differ from static method? when to use it?
--
class M:
def method(cls, x):
pass

method = classmethod(met hod)
--
Thank you for your time.

[MeTheGameMakingGuy]

On Aug 24, 6:32*pm, Hussein B <hubaghd...@gma il.comwrote:

Hi,
I'm familiar with static method concept, but what is the class method?
how it does differ from static method? when to use it?
--
class M:
*def method(cls, x):
* * pass

*method = classmethod(met hod)
--
Thank you for your time.

Firstly, don't use method = classmethod(met hod). Decorators are far
better. The following code has the same effect:

class M:
@classmethod
def method(cls, x):
pass

Far more readable, right?

Class methods are useful if you've got lots of inheritance happening.
The first argument passed in is the class calling the method. Handy
for a mix-in: it can add methods affecting the actual class it's mixed
into, rather than messing with the mix-in itself.

[Hrvoje Niksic]

Hussein B <hu********@gma il.comwrites:

Hi,
I'm familiar with static method concept, but what is the class method?
how it does differ from static method? when to use it?
--
class M:
def method(cls, x):
pass

method = classmethod(met hod)

Use it when your method needs to know what class it is called from.
This makes sense in the context of subclassing:

class M(object):
@classmethod
def method(cls, x):
print cls, x

class N(M):
pass

>>M.method(1)

<class '__main__.M'1

>>N.method(1)

<class '__main__.N'1

[castironpi]

On Aug 24, 3:35*am, MeTheGameMaking Guy <gopsychona...@ gmail.com>
wrote:

On Aug 24, 6:32*pm, Hussein B <hubaghd...@gma il.comwrote:

Hi,
I'm familiar with static method concept, but what is the class method?
how it does differ from static method? when to use it?
--
class M:
*def method(cls, x):
* * pass

*method = classmethod(met hod)
--
Thank you for your time.

Firstly, don't use method = classmethod(met hod). Decorators are far
better. The following code has the same effect:

class M:
*@classmethod
*def method(cls, x):
* pass

Far more readable, right?

Class methods are useful if you've got lots of inheritance happening.
The first argument passed in is the class calling the method. Handy
for a mix-in: it can add methods affecting the actual class it's mixed
into, rather than messing with the mix-in itself.

It is similar to:

class M: #not correct as shown
def newmaker( self, x ):
newinst= self.__class__( arg1, arg2, x )
return newinst

m1= M()
m2= m1.newmaker( 'abc' )

except you don't need the first instance to do it with. Notice you
get a new instance of whatever class m1 is an instance of, rather than
necessarily M.

class N( M ):
pass

m1= N()
m2= m1.newmaker( 'abc' )

m2 is of class N now too.

[Maric Michaud]

Le Sunday 24 August 2008 10:32:34 Hussein B, vous avez écrit*:

Hi,
I'm familiar with static method concept, but what is the class method?
how it does differ from static method? when to use it?
--
class M:
def method(cls, x):
pass

method = classmethod(met hod)

As it has been said, it adds polymorphic behavior to static method concept by
the mean of a reference to the real class that called it.

>>>[159]: class A(object) :

.....: @classmethod
.....: def factory(cls, *args) : return cls(*args)
.....:
.....:

>>>[160]: class B(A) :

.....: def __init__(self, a, b) :
.....: print a, b
.....:
.....:

>>>[161]: A.factory()

...[161]: <__main__.A object at 0x2b88d0e33710>

>>>[162]: B.factory(1, 2)

1 2
...[162]: <__main__.B object at 0x2b88d0e33bd0>

It is a common advice that staticmethod should not exist in python, as theydo
nothing compared to module level functions, and we should always use
classmethods in place of them.

--
Thank you for your time.
--
http://mail.python.org/mailman/listinfo/python-list

--
_____________

Maric Michaud

[Medardo Rodriguez (Merchise Group)]

On Sun, Aug 24, 2008 at 4:32 AM, Hussein B <hu********@gma il.comwrote:

I'm familiar with static method concept, but what is the class method?
how it does differ from static method? when to use it?

"Class Methods" are related to the meta-class concept introduced since
the first beginning of OOP but not known enough so far.
If you are capable to reason (to model) using that concept, the you
will need "classmetho d" decorator in Python.

"Static Methods" are global operations but are declared in the
name-space context of a class; so, they are not strictly methods.

In Python everything is an object, but functions declared in the
module scope not receive the instance of the module, so they are not
module methods, they are not methods, they are global functions that
are in the name-space context of the module in this case.

Methods always receive the instance as a special argument (usually
declared as self in Python). Classes (theoretically speaking) are also
objects (dual behavior).

Let's be explicit:

#<code>
class Test(object):
def NormalMethod(se lf):
print 'Normal:', self

@staticmethod
def StaticMethod(se lf=None):
print 'Static:', self

@classmethod
def ClassMethod(sel f):
print 'Class:', self

test = Test()
test.NormalMeth od()
test.StaticMeth od()
test.ClassMetho d() # the instance "test" is coerced to it's class to
call the method.
#</code>

Regards

[Steven D'Aprano]

On Sun, 24 Aug 2008 11:09:46 +0200, Hrvoje Niksic wrote:

Hussein B <hu********@gma il.comwrites:

>Hi,
I'm familiar with static method concept, but what is the class method?
how it does differ from static method? when to use it? --
class M:
def method(cls, x):
pass

method = classmethod(met hod)

Use it when your method needs to know what class it is called from.

Ordinary methods know what class they are called from, because instances
know what class they belong to:

def method(self, *args):
print self.__class__

You use class methods when you DON'T need or want to know what instance
it is being called from, but you DO need to know what class it is called
from:

@classmethod
def cmethod(cls, *args):
print cls
Why is this useful? Consider the dict method "fromkeys". You can call it
from any dictionary, but it doesn't care which dict you call it from,
only that it is being called from a dict:

>>{}.fromkeys ([1, 2, 3])

{1: None, 2: None, 3: None}

>>{'monkey': 42}.fromkeys([1, 2, 3])

{1: None, 2: None, 3: None}
Any method that behaves like dict.fromkeys() is an excellent candidate
for classmethod.


--
Steven

[Hrvoje Niksic]

Steven D'Aprano <st***@REMOVE-THIS-cybersource.com .auwrites:

On Sun, 24 Aug 2008 11:09:46 +0200, Hrvoje Niksic wrote:

>Use [classmethod] when your method needs to know what class it is
called from.

Ordinary methods know what class they are called from

I guess I should have added "and no more". :-)

Why is this useful? Consider the dict method "fromkeys". You can
call it from any dictionary, but it doesn't care which dict you call
it from, only that it is being called from a dict:

That's also a good example of the difference between classmethod and
staticmethod, since fromkeys is smart enough to use the type
information.

>>class X(dict):

.... pass
....

>>x = X.fromkeys({1: 2})
type(x)

<class '__main__.X' # not <type 'dict'>

If 'fromkeys' were a staticmethod, it would have to be hardcoded to
always create dicts.

[Bruno Desthuilliers]

MeTheGameMaking Guy a écrit :

On Aug 24, 6:32 pm, Hussein B <hubaghd...@gma il.comwrote:

>Hi,
I'm familiar with static method concept, but what is the class method?
how it does differ from static method? when to use it?
--
class M:
def method(cls, x):
pass

method = classmethod(met hod)
--
Thank you for your time.

Firstly, don't use method = classmethod(met hod). Decorators are far
better. The following code has the same effect:

class M:
@classmethod
def method(cls, x):
pass

Far more readable, right?

Yes, but will only work with Python >= 2.4. There are cases where you
want to keep compatibility with Python 2.3...

Class methods are useful if you've got lots of inheritance happening.
The first argument passed in is the class calling the method. Handy
for a mix-in: it can add methods affecting the actual class it's mixed
into, rather than messing with the mix-in itself.

I'm not sure I get your point here.

As far as I'm concerned, classmethods are useful anywhere you need to
work on the class object itself.

[Bruno Desthuilliers]

Maric Michaud a écrit :
(snip)

>
It is a common advice that staticmethod should not exist in python, as they do
nothing compared to module level functions,

They "do" nothing more, but are accessible thru a class object instead
of being accessible thru a module object. It sometimes happens to be
useful (for a very very low value of 'sometimes' as far as I'm
concerned, but still...)