blocks|key|1767951|text|初始化的帮助器方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1767952|class+MyStream(object):

++++@classmethod
++++def+from_file(cls,+filepath,+ignore_comments=False):++++
++++++++with+open(filepath,+'r')+as+fileobj:
++++++++++++for+obj+in+cls(fileobj,+ignore_comments):
++++++++++++++++yield+obj

++++@classmethod
++++def+from_socket(cls,+socket,+ignore_comments=False):
++++++++raise+NotImplemented+#+Placeholder+until+implemented

++++def+__init__(self,+iterable,+ignore_comments=False):
+++++++...|code-block|syntax|javascript|1767953|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Helper methods for initialization:

<pre><code>class MyStream(object):

 @classmethod
 def from_file(cls, filepath, ignore_comments=False): 
 with open(filepath, 'r') as fileobj:
 for obj in cls(fileobj, ignore_comments):
 yield obj

 @classmethod
 def from_socket(cls, socket, ignore_comments=False):
 raise NotImplemented # Placeholder until implemented

 def __init__(self, iterable, ignore_comments=False):
 ...
</code></pre>

blocks|key|1981588|text|__new__是一个非常重要的类方法。它是实例通常来自的地方|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1981589|所以dict()当然会调用dict.__new__，但有时还有另一种方便的方法来编写字典，那就是类方法dict.fromkeys()|1981590|例如：|1981591|>>>+dict.fromkeys("12345")
{'1':+None,+'3':+None,+'2':+None,+'5':+None,+'4':+None}|code-block|syntax|javascript|1981592|entityMap^0|0|7|0|2|6|D|C|1F|F|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|11|8|@]|D|@]|E|$M|N]]|$1|O|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|P|$]]

Well <code>__new__</code> is a pretty important classmethod. It's where instances usually come from

so <code>dict()</code> calls <code>dict.__new__</code> of course, but there is another handy way to make dicts sometimes which is the classmethod <code>dict.fromkeys()</code>

eg.

<pre><code>&gt;&gt;&gt; dict.fromkeys("12345")
{'1': None, '3': None, '2': None, '5': None, '4': None}
</code></pre>

blocks|key|1767845|text|我不知道，比如命名构造函数方法？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1767846|class+UniqueIdentifier(object):

++++value+=+0

++++def+__init__(self,+name):
++++++++self.name+=+name

++++@classmethod
++++def+produce(cls):
++++++++instance+=+cls(cls.value)
++++++++cls.value+%2B=+1
++++++++return+instance

class+FunkyUniqueIdentifier(UniqueIdentifier):

++++@classmethod
++++def+produce(cls):
++++++++instance+=+super(FunkyUniqueIdentifier,+cls).produce()
++++++++instance.name+=+"Funky+%25s"+%25+instance.name
++++++++return+instance|code-block|syntax|javascript|1767847|用法：|1767848|>>>+x+=+UniqueIdentifier.produce()
>>>+y+=+FunkyUniqueIdentifier.produce()
>>>+x.name
0
>>>+y.name
Funky+1|1767849|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

I don't know, something like named constructor methods?

<pre><code>class UniqueIdentifier(object):

 value = 0

 def __init__(self, name):
 self.name = name

 @classmethod
 def produce(cls):
 instance = cls(cls.value)
 cls.value += 1
 return instance

class FunkyUniqueIdentifier(UniqueIdentifier):

 @classmethod
 def produce(cls):
 instance = super(FunkyUniqueIdentifier, cls).produce()
 instance.name = "Funky %s" % instance.name
 return instance
</code></pre>

Usage:

<pre><code>&gt;&gt;&gt; x = UniqueIdentifier.produce()
&gt;&gt;&gt; y = FunkyUniqueIdentifier.produce()
&gt;&gt;&gt; x.name
0
&gt;&gt;&gt; y.name
Funky 1
</code></pre>

blocks|key|1981750|text|使用@classmethod的最大原因是在一个旨在被继承的替代构造函数中。这在多态中非常有用。举个例子：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1981751|class+Shape(object):
++++#+this+is+an+abstract+class+that+is+primarily+used+for+inheritance+defaults
++++#+here+is+where+you+would+define+classmethods+that+can+be+overridden+by+inherited+classes
++++@classmethod
++++def+from_square(cls,+square):
++++++++#+return+a+default+instance+of+cls
++++++++return+cls()|code-block|syntax|javascript|1981752|请注意，Shape是一个定义类方法from_square的抽象类，由于Shape并未真正定义，因此它并不真正知道如何从Square派生自身，因此它只是返回该类的默认实例。|1981753|然后允许继承的类定义该方法的自己的版本：|1981754|class+Square(Shape):
++++def+__init__(self,+side=10):
++++++++self.side+=+side

++++@classmethod
++++def+from_square(cls,+square):
++++++++return+cls(side=square.side)


class+Rectangle(Shape):
++++def+__init__(self,+length=10,+width=10):
++++++++self.length+=+length
++++++++self.width+=+width

++++@classmethod
++++def+from_square(cls,+square):
++++++++return+cls(length=square.side,+width=square.side)


class+RightTriangle(Shape):
++++def+__init__(self,+a=10,+b=10):
++++++++self.a+=+a
++++++++self.b+=+b
++++++++self.c+=+((a*a)+%2B+(b*b))**(.5)

++++@classmethod
++++def+from_square(cls,+square):
++++++++return+cls(a=square.length,+b=square.width)


class+Circle(Shape):
++++def+__init__(self,+radius=10):
++++++++self.radius+=+radius

++++@classmethod
++++def+from_square(cls,+square):
++++++++return+cls(radius=square.length/2)|1981755|用法允许您以多态方式处理所有这些未实例化的类|1981756|square+=+Square(3)
for+polymorphic_class+in+(Square,+Rectangle,+RightTriangle,+Circle):
++++this_shape+=+polymorphic_class.from_square(square)|1981757|你可能会说，这一切都很好，但是为什么我不能直接使用@staticmethod来完成同样的多态行为：|1981758|class+Circle(Shape):
++++def+__init__(self,+radius=10):
++++++++self.radius+=+radius

++++@staticmethod
++++def+from_square(square):
++++++++return+Circle(radius=square.length/2)|1981759|答案是您可以这样做，但是您没有获得继承的好处，因为必须在方法中显式地调用Circle。这意味着如果我从继承的类调用它而不重写，我仍然会每次都得到Circle。|1981760|请注意，当我定义另一个实际上没有任何自定义from_square逻辑的shape类时，会得到什么：|1981761|class+Hexagon(Shape):
++++def+__init__(self,+side=10):
++++++++self.side+=+side

++++#+note+the+absence+of+classmethod+here,+this+will+use+from_square+it+inherits+from+shape|1981762|在这里，您可以不定义@classmethod，它将使用来自Shape.from_square的逻辑，同时保留cls是谁，并返回适当的形状。|1981763|square+=+Square(3)
for+polymorphic_class+in+(Square,+Rectangle,+RightTriangle,+Circle,+Hexagon):
++++this_shape+=+polymorphic_class.from_square(square)|1981764|entityMap^0|2|C|0|0|4|5|H|B|Z|5|1N|6|0|0|0|0|0|P|D|0|0|10|6|20|6|0|0|0|A|C|T|H|1I|3|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|1N|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|1O|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|1P|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|1Q|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1R|8|@$9|1S|A|1T|B|C]]|D|@]|E|$]]|$1|W|3|X|5|H|7|1U|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|6|7|1V|8|@$9|1W|A|1X|B|C]|$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|10|3|11|5|6|7|20|8|@]|D|@]|E|$]]|$1|12|3|13|5|H|7|21|8|@]|D|@]|E|$I|J]]|$1|14|3|15|5|6|7|22|8|@$9|23|A|24|B|C]|$9|25|A|26|B|C]|$9|27|A|28|B|C]]|D|@]|E|$]]|$1|16|3|17|5|H|7|29|8|@]|D|@]|E|$I|J]]|$1|18|3|-4|5|6|7|2A|8|@]|D|@]|E|$]]]|19|$]]

The biggest reason for using a <code>@classmethod</code> is in an alternate constructor that is intended to be inherited. This can be very useful in polymorphism. An example:
<pre><code>class Shape(object):
 # this is an abstract class that is primarily used for inheritance defaults
 # here is where you would define classmethods that can be overridden by inherited classes
 @classmethod
 def from_square(cls, square):
 # return a default instance of cls
 return cls()
</code></pre>
Notice that <code>Shape</code> is an abstract class that defines a classmethod <code>from_square</code>, since <code>Shape</code> is not really defined, it does not really know how to derive itself from a <code>Square</code> so it simply returns a default instance of the class.
Inherited classes are then allowed to define their own versions of this method:
<pre><code>class Square(Shape):
 def __init__(self, side=10):
 self.side = side

 @classmethod
 def from_square(cls, square):
 return cls(side=square.side)


class Rectangle(Shape):
 def __init__(self, length=10, width=10):
 self.length = length
 self.width = width

 @classmethod
 def from_square(cls, square):
 return cls(length=square.side, width=square.side)


class RightTriangle(Shape):
 def __init__(self, a=10, b=10):
 self.a = a
 self.b = b
 self.c = ((a*a) + (b*b))**(.5)

 @classmethod
 def from_square(cls, square):
 return cls(a=square.length, b=square.width)


class Circle(Shape):
 def __init__(self, radius=10):
 self.radius = radius

 @classmethod
 def from_square(cls, square):
 return cls(radius=square.length/2)
</code></pre>
The usage allows you to treat all of these uninstantiated classes polymorphically
<pre><code>square = Square(3)
for polymorphic_class in (Square, Rectangle, RightTriangle, Circle):
 this_shape = polymorphic_class.from_square(square)
</code></pre>
This is all fine and dandy you might say, but why couldn't I just use as <code>@staticmethod</code> to accomplish this same polymorphic behavior:
<pre><code>class Circle(Shape):
 def __init__(self, radius=10):
 self.radius = radius

 @staticmethod
 def from_square(square):
 return Circle(radius=square.length/2)
</code></pre>
The answer is that you could, but you do not get the benefits of inheritance because <code>Circle</code> has to be called out explicitly in the method. Meaning if I call it from an inherited class without overriding, I would still get <code>Circle</code> every time.
Notice what is gained when I define another shape class that does not really have any custom from_square logic:
<pre><code>class Hexagon(Shape):
 def __init__(self, side=10):
 self.side = side

 # note the absence of classmethod here, this will use from_square it inherits from shape
</code></pre>
Here you can leave the <code>@classmethod</code> undefined and it will use the logic from <code>Shape.from_square</code> while retaining who <code>cls</code> is and return the appropriate shape.
<pre><code>square = Square(3)
for polymorphic_class in (Square, Rectangle, RightTriangle, Circle, Hexagon):
 this_shape = polymorphic_class.from_square(square)
</code></pre>

blocks|key|1981479|text|我发现，在不需要类的实例使用代码的情况下，我最常使用@classmethod来将一段代码与一个类关联起来，以避免创建全局函数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1981480|例如，我可能有一个数据结构，它只在键符合某种模式时才认为它是有效的。我可能想要在类的内部和外部使用它。但是，我不想创建另一个全局函数：|1981481|def+foo_key_is_valid(key):
++++#+code+for+determining+validity+here
++++return+valid|code-block|syntax|javascript|1981482|我更愿意将这段代码与它关联的类进行分组：|1981483|class+Foo(object):

++++@classmethod
++++def+is_valid(cls,+key):
++++++++#+code+for+determining+validity+here
++++++++return+valid

++++def+add_key(self,+key,+val):
++++++++if+not+Foo.is_valid(key):
++++++++++++raise+ValueError()
++++++++..

#+lets+me+reuse+that+method+without+an+instance,+and+signals+that
#+the+code+is+closely-associated+with+the+Foo+class
Foo.is_valid('my+key')|1981484|entityMap^0|Q|C|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|X|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|R|$]]

I find that I most often use <code>@classmethod</code> to associate a piece of code with a class, to avoid creating a global function, for cases where I don't require an instance of the class to use the code.

For example, I might have a data structure which only considers a key valid if it conforms to some pattern. I may want to use this from inside and outside of the class. However, I don't want to create yet another global function:

<pre><code>def foo_key_is_valid(key):
 # code for determining validity here
 return valid
</code></pre>

I'd much rather group this code with the class it's associated with:

<pre><code>class Foo(object):

 @classmethod
 def is_valid(cls, key):
 # code for determining validity here
 return valid

 def add_key(self, key, val):
 if not Foo.is_valid(key):
 raise ValueError()
 ..

# lets me reuse that method without an instance, and signals that
# the code is closely-associated with the Foo class
Foo.is_valid('my key')
</code></pre>

blocks|key|1768149|text|in+class+MyClass(object):
++++'''
++++classdocs
++++'''
++++obj=0
++++x=classmethod
++++def+__init__(self):
++++++++'''
++++++++Constructor
++++++++'''
++++++++self.nom='lamaizi'
++++++++self.prenom='anas'
++++++++self.age=21
++++++++self.ville='Casablanca'
if+__name__:
++++ob=MyClass()
++++print(ob.nom)
++++print(ob.prenom)
++++print(ob.age)
++++print(ob.ville)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1768150|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>in class MyClass(object):
 '''
 classdocs
 '''
 obj=0
 x=classmethod
 def __init__(self):
 '''
 Constructor
 '''
 self.nom='lamaizi'
 self.prenom='anas'
 self.age=21
 self.ville='Casablanca'
if __name__:
 ob=MyClass()
 print(ob.nom)
 print(ob.prenom)
 print(ob.age)
 print(ob.ville)
</code></pre>

I've read <a href="https://stackoverflow.com/questions/38238/what-are-class-methods-in-python-for">What are Class methods in Python for?</a> but the examples in that post are complex. I am looking for a clear, simple, bare-bones example of a particular use case for classmethods in Python. 

Can you name a small, specific example use case where a Python classmethod would be the right tool for the job?

What's an example use case for a Python classmethod?

数据结构

Python

我读过，但那篇文章中的例子很复杂。我正在寻找一个清晰、简单的Python类方法特定用例的基本示例。你能举出一个小的，具体的示例用例，其中Python类方法将是适合这项工作的工具？

问Python类方法的示例用例是什么？
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python类方法的示例用例是什么？EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python类方法的示例用例是什么？
EN