我认为史蒂文实际上是对的。为了回答最初的问题，那么，为了设置一个类方法，只需假设第一个参数不是一个调用实例，然后确保只从类调用该方法。

（注意，这个答案指的是Python 3.x。在Python 2.x中，调用类本身的方法会得到一个TypeError。）

例如：

class Dog:
    count = 0 # this is a class variable
    dogs = [] # this is a class variable

    def __init__(self, name):
        self.name = name #self.name is an instance variable
        Dog.count += 1
        Dog.dogs.append(name)

    def bark(self, n): # this is an instance method
        print("{} says: {}".format(self.name, "woof! " * n))

    def rollCall(n): #this is implicitly a class method (see comments below)
        print("There are {} dogs.".format(Dog.count))
        if n >= len(Dog.dogs) or n < 0:
            print("They are:")
            for dog in Dog.dogs:
                print("  {}".format(dog))
        else:
            print("The dog indexed at {} is {}.".format(n, Dog.dogs[n]))

fido = Dog("Fido")
fido.bark(3)
Dog.rollCall(-1)
rex = Dog("Rex")
Dog.rollCall(0)

在这段代码中，“rollCall”方法假设第一个参数不是实例（如果它是由实例而不是类调用的话）。只要从类而不是实例调用“rollCall”，代码就会正常工作。如果我们尝试从实例调用“rollCall”，例如：

rex.rollCall(-1)

然而，它将导致引发异常，因为它将发送两个参数：自身和-1，而“rollCall”仅定义为接受一个参数。

顺便说一句，rex.rollCall（）将发送正确数量的参数，但也会引发异常，因为现在n将表示Dog实例（即rex），而函数期望n是数字。

这就是装饰的由来：如果我们在“rollCall”方法前面加上

@staticmethod

然后，通过显式声明该方法是静态的，我们甚至可以从实例调用它。现在

rex.rollCall(-1)

会起作用。然后，在方法定义之前插入@staticmethod会阻止实例将自身作为参数发送。

您可以通过使用或不使用注释掉的@staticmethod行尝试以下代码来验证这一点。

class Dog:
    count = 0 # this is a class variable
    dogs = [] # this is a class variable

    def __init__(self, name):
        self.name = name #self.name is an instance variable
        Dog.count += 1
        Dog.dogs.append(name)

    def bark(self, n): # this is an instance method
        print("{} says: {}".format(self.name, "woof! " * n))

    @staticmethod
    def rollCall(n):
        print("There are {} dogs.".format(Dog.count))
        if n >= len(Dog.dogs) or n < 0:
            print("They are:")
            for dog in Dog.dogs:
                print("  {}".format(dog))
        else:
            print("The dog indexed at {} is {}.".format(n, Dog.dogs[n]))


fido = Dog("Fido")
fido.bark(3)
Dog.rollCall(-1)
rex = Dog("Rex")
Dog.rollCall(0)
rex.rollCall(-1)

因此，静态方法是可以在不创建类对象的情况下调用的方法。例如：-

    @staticmethod
    def add(a, b):
        return a + b

b = A.add(12,12)
print b

在上面的示例中，add是由类名A而不是对象名调用的。

我认为史蒂文实际上是对的。为了回答最初的问题，那么，为了设置一个类方法，只需假设第一个参数不是一个调用实例，然后确保只从类调用该方法。

（注意，这个答案指的是Python 3.x。在Python 2.x中，调用类本身的方法会得到一个TypeError。）

例如：

class Dog:
    count = 0 # this is a class variable
    dogs = [] # this is a class variable

    def __init__(self, name):
        self.name = name #self.name is an instance variable
        Dog.count += 1
        Dog.dogs.append(name)

    def bark(self, n): # this is an instance method
        print("{} says: {}".format(self.name, "woof! " * n))

    def rollCall(n): #this is implicitly a class method (see comments below)
        print("There are {} dogs.".format(Dog.count))
        if n >= len(Dog.dogs) or n < 0:
            print("They are:")
            for dog in Dog.dogs:
                print("  {}".format(dog))
        else:
            print("The dog indexed at {} is {}.".format(n, Dog.dogs[n]))

fido = Dog("Fido")
fido.bark(3)
Dog.rollCall(-1)
rex = Dog("Rex")
Dog.rollCall(0)

在这段代码中，“rollCall”方法假设第一个参数不是实例（如果它是由实例而不是类调用的话）。只要从类而不是实例调用“rollCall”，代码就会正常工作。如果我们尝试从实例调用“rollCall”，例如：

rex.rollCall(-1)

然而，它将导致引发异常，因为它将发送两个参数：自身和-1，而“rollCall”仅定义为接受一个参数。

顺便说一句，rex.rollCall（）将发送正确数量的参数，但也会引发异常，因为现在n将表示Dog实例（即rex），而函数期望n是数字。

这就是装饰的由来：如果我们在“rollCall”方法前面加上

@staticmethod

然后，通过显式声明该方法是静态的，我们甚至可以从实例调用它。现在

rex.rollCall(-1)

会起作用。然后，在方法定义之前插入@staticmethod会阻止实例将自身作为参数发送。

您可以通过使用或不使用注释掉的@staticmethod行尝试以下代码来验证这一点。

class Dog:
    count = 0 # this is a class variable
    dogs = [] # this is a class variable

    def __init__(self, name):
        self.name = name #self.name is an instance variable
        Dog.count += 1
        Dog.dogs.append(name)

    def bark(self, n): # this is an instance method
        print("{} says: {}".format(self.name, "woof! " * n))

    @staticmethod
    def rollCall(n):
        print("There are {} dogs.".format(Dog.count))
        if n >= len(Dog.dogs) or n < 0:
            print("They are:")
            for dog in Dog.dogs:
                print("  {}".format(dog))
        else:
            print("The dog indexed at {} is {}.".format(n, Dog.dogs[n]))


fido = Dog("Fido")
fido.bark(3)
Dog.rollCall(-1)
rex = Dog("Rex")
Dog.rollCall(0)
rex.rollCall(-1)

您实际上不需要使用@staticmethoddecorator。只需声明一个方法（不需要self参数）并从类中调用它。装饰器仅在您希望能够从实例调用它时才存在（这不是您想要做的）

大多数情况下，你只是使用函数。。。

是的，使用静态方法装饰器：

class MyClass(object):
    @staticmethod
    def the_static_method(x):
        print(x)

MyClass.the_static_method(2)  # outputs 2

注意，一些代码可能使用旧的定义静态方法的方法，使用staticmethod作为函数而不是修饰符。仅当您必须支持Python的早期版本（2.2和2.3）时，才应使用此选项：

class MyClass(object):
    def the_static_method(x):
        print(x)
    the_static_method = staticmethod(the_static_method)

MyClass.the_static_method(2)  # outputs 2

这与第一个示例（使用@staticmethod）完全相同，只是没有使用漂亮的decorator语法。

最后，谨慎使用静态方法！在Python中很少有静态方法是必需的，而且我已经多次看到它们被使用，而单独的“顶级”函数会更清晰。

以下是文件中的逐字内容：

静态方法不接收隐式第一个参数。要声明静态方法，请使用以下习惯用法：C类：@静态方法定义f（arg1，arg2，…）：。。。@staticmethod表单是一个函数装饰器–有关详细信息，请参阅函数定义中的函数定义描述。它既可以在类（如C.f（））上调用，也可以在实例（如C（）.f（））中调用。除了它的类之外，该实例将被忽略。Python中的静态方法与Java或C++中的方法类似。有关更高级的概念，请参阅classmethod（）。有关静态方法的更多信息，请参阅标准类型层次结构中有关标准类型层次的文档。2.2版中的新增功能。在版本2.4中进行了更改：添加了函数修饰符语法。

总结其他人的回答并补充，在python中声明静态方法或变量有很多种方法。

使用staticmethod（）作为装饰符：可以简单地在声明的方法（函数）上方放置一个修饰符，使其成为静态方法。例如。

class Calculator:
    @staticmethod
    def multiply(n1, n2, *args):
        Res = 1
        for num in args: Res *= num
        return n1 * n2 * Res

print(Calculator.multiply(1, 2, 3, 4))              # 24

使用staticmethod（）作为参数函数：此方法可以接收函数类型的参数，并返回传递函数的静态版本。例如。

class Calculator:
    def add(n1, n2, *args):
        return n1 + n2 + sum(args)

Calculator.add = staticmethod(Calculator.add)
print(Calculator.add(1, 2, 3, 4))                   # 10

使用classmethod（）作为装饰符：@classmethod对函数的影响与@staticmethod类似，但是这一次，需要在函数中接受一个额外的参数（类似于实例变量的self参数）。例如。

class Calculator:
    num = 0
    def __init__(self, digits) -> None:
        Calculator.num = int(''.join(digits))

    @classmethod
    def get_digits(cls, num):
        digits = list(str(num))
        calc = cls(digits)
        return calc.num

print(Calculator.get_digits(314159))                # 314159

使用classmethod（）作为参数函数：@classmethod也可以用作参数函数，以防不想修改类定义。例如。

class Calculator:
    def divide(cls, n1, n2, *args):
        Res = 1
        for num in args: Res *= num
        return n1 / n2 / Res

Calculator.divide = classmethod(Calculator.divide)

print(Calculator.divide(15, 3, 5))                  # 1.0

直接申报在所有其他方法外部但在类内部声明的方法/变量自动是静态的。

class Calculator:   
    def subtract(n1, n2, *args):
        return n1 - n2 - sum(args)

print(Calculator.subtract(10, 2, 3, 4))             # 1

整个计划

class Calculator:
    num = 0
    def __init__(self, digits) -> None:
        Calculator.num = int(''.join(digits))
    
    
    @staticmethod
    def multiply(n1, n2, *args):
        Res = 1
        for num in args: Res *= num
        return n1 * n2 * Res


    def add(n1, n2, *args):
        return n1 + n2 + sum(args)
    

    @classmethod
    def get_digits(cls, num):
        digits = list(str(num))
        calc = cls(digits)
        return calc.num


    def divide(cls, n1, n2, *args):
        Res = 1
        for num in args: Res *= num
        return n1 / n2 / Res


    def subtract(n1, n2, *args):
        return n1 - n2 - sum(args)
    



Calculator.add = staticmethod(Calculator.add)
Calculator.divide = classmethod(Calculator.divide)

print(Calculator.multiply(1, 2, 3, 4))              # 24
print(Calculator.add(1, 2, 3, 4))                   # 10
print(Calculator.get_digits(314159))                # 314159
print(Calculator.divide(15, 3, 5))                  # 1.0
print(Calculator.subtract(10, 2, 3, 4))             # 1

有关掌握Python中的OOP，请参阅Python文档。