从实例调用类方法作为方法是一种不好的形式吗？

Question

前任。

如果我有这样的东西：

class C(object):
    @classmethod
    def f(cls, x):
       return x + x

这会起作用：

c = C()

c.f(2)
4

但这是不好的形式吗？ 我应该只调用

C.f()

or

c.__class__.f()

显然，这只有在 f 不与 self/cls 交互并期望它是类的情况下才有意义。

？

Answer 1

如果您想从实例调用类方法，您可能不需要类方法。

在示例中，由于您最后的评论（没有 self/cls 交互），您给出的静态方法将更合适。

class C(object):
    @staticmethod
    def f(x):
       return x + x

是“良好的形式”

c = C()
c.f(2)

这样，两者兼而有之

C.f(2)

Answer 2

我不记得在类外部使用过这样的类方法，但是实例方法本身调用类方法当然是可以的（例如 self.foo() where foo< /code> 是一个类方法）。 这可以确保继承按预期运行，并将在正确的子类而不是基类中调用 .foo() 。

Answer 3

主要是看起来很混乱。 如果我在使用你的课程并看到这个，它会让我想知道里面还有什么其他惊喜，它看起来像是糟糕的设计。

它不仅仅是静态方法有什么原因吗？

Answer 4

Cf() 比 c_instance.f() 更清晰，而 c_instance.__class__.f() 则很丑陋。 由于清晰和美观是 python 社区深受喜爱的特性，因此我倾向于说 Cf() 是最好的路线。

您是否有任何特殊原因想要以其他方式调用它？

Answer 5

我在从非类方法调用一些类方法（需要是类方法，以便我仍然可以引用该类）时遇到了这个问题，如下所示。

class A:
  def a(self, number):
    print("a", self, number)
    self.b(number)

  @classmethod
  def b(cls, number):
    print("b", cls, number + 1)
    cls.c(number)

  @classmethod
  def c(cls, number):
    print("c", cls, number * 2)



b = A()
b.a(3) 

上面的代码产生以下结果：

a <__main__.A object at 0x000001FAC09FE358> 3
b <class '__main__.A'> 4
c <class '__main__.A'> 6

我并不是说这是最好的约定，但它不会破坏 Python 3.6 中的任何内容

Answer 6

如果您已经有一个 C 实例，为什么需要 f() 作为类方法？ 这不仅是不好的形式，而且通常没有必要。 网上有人说：“这很糟糕，因为它给人的印象是对象中的某些实例变量被使用了，但事实并非如此。”

不过，学习的第 484 页python 指出，您可以以任何一种方式调用该方法，只要传入相同的实例，它就会完全相同。

Answer 7

我认为问题在于风格，也就是说，如果你想要一个类方法，你应该将其称为类方法MyClass.my_func()，还是作为实例方法myinst.my_func()。 记录对@classmethod<的解释/code> 装饰器的优点是它允许您像调用实例方法一样调用类方法。 我在下面提供了一个示例来说明这一点。

至于风格，我认为无论如何都不应该让人们感到困惑，它实际上是方法实现细节。 如果您在实例的上下文中调用类方法（即作为类实例对象的用户，或在类实例方法内部），那么将类方法作为另一个实例方法调用是完全可以的，甚至可能更愿意不这样做突出显示有关被调用方法的一些实现细节。

我该怎么办？ 如果我将实例属性传递给类方法，我可能会在 MyClass.my_func(self.some_value) 中调用类方法，而不是调用 self.my_func(self.some_value) 因为看到后者让我想知道为什么 my_func 不读取 self.some_value 本身，而不是让我传递它。 否则我真的不介意任何一种形式。

当然，类是用来实例化的，最大的错误是程序员将它们用作无状态方法的某种命名空间。

class A:
    value = 2

    def __init__(self, value):
        self.value = value
    
    def add_instance(self, number):
        self.value += number


    @classmethod
    def add_class(cls, number):
        cls.value += number


    def add_class_via_instance(self, number):
        self.add_class(number)

    def add_class_via_class(self, number):
        A.add_class(number)

    def add_class_via_sneak(self, number):
        self.__class__.value += number



a = A(1)
print(f'{A.value=} {a.value=}')
a.add_instance(3)
print(f'{A.value=} {a.value=}')
A.add_class(3)
print(f'{A.value=} {a.value=}')
a.add_class_via_class(3)
print(f'{A.value=} {a.value=}')
a.add_class_via_instance(3)
print(f'{A.value=} {a.value=}')
a.add_class_via_sneak(3)
print(f'{A.value=} {a.value=}')

回报

A.value=2 a.value=1 # expect class and instance have different value values
A.value=2 a.value=4 # adding to the instance
A.value=5 a.value=4 # adding to the class
A.value=8 a.value=4 # calling the function as a class method works on the class attribute
A.value=11 a.value=4 # calling the function as a instance method works on the class attribute as well
A.value=14 a.value=4 # instance methods can access class values and therefore can behave as a classmethod if they want.