Python中是否可以有无需初始化类即可调用的静态方法，例如：
ClassName.static_method()
#1楼
我认为史蒂文实际上是对的 。 为了回答最初的问题，然后，为了建立一个类方法，只需假设第一个参数不会成为调用实例，然后确保仅从类中调用该方法。
（请注意，此答案是针对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为数字时，现在n将表示Dog实例（即rex）。
这是装饰的来源：如果我们在“ 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)
#2楼
除了静态方法对象的行为方式的特殊性之外，在组织模块级代码时，还可以利用它们带来某种美感。
# garden.py
def trim(a):
pass
def strip(a):
pass
def bunch(a, b):
pass
def _foo(foo):
pass
class powertools(object):
"""
Provides much regarded gardening power tools.
"""
@staticmethod
def answer_to_the_ultimate_question_of_life_the_universe_and_everything():
return 42
@staticmethod
def random():
return 13
@staticmethod
def promise():
return True
def _bar(baz, quux):
pass
class _Dice(object):
pass
class _6d(_Dice):
pass
class _12d(_Dice):
pass
class _Smarter:
pass
class _MagicalPonies:
pass
class _Samurai:
pass
class Foo(_6d, _Samurai):
pass
class Bar(_12d, _Smarter, _MagicalPonies):
pass
...
# tests.py
import unittest
import garden
class GardenTests(unittest.TestCase):
pass
class PowertoolsTests(unittest.TestCase):
pass
class FooTests(unittest.TestCase):
pass
class BarTests(unittest.TestCase):
pass
...
# interactive.py
from garden import trim, bunch, Foo
f = trim(Foo())
bunch(f, Foo())
...
# my_garden.py
import garden
from garden import powertools
class _Cowboy(garden._Samurai):
def hit():
return powertools.promise() and powertools.random() or 0
class Foo(_Cowboy, garden.Foo):
pass
现在，它变得更加直观和具有自文档说明性，在这种情况下，应使用某些组件，并且它非常适合命名不同的测试用例，并提供一种简单的方法来将测试模块映射到测试中的实际模块以供纯粹主义者使用。
我经常发现将这种方法应用于组织项目的实用程序代码是可行的。 人们经常会急忙创建一个utils软件包，并最终得到9个模块，其中一个模块有120个LOC，其余模块最多是两个十几个LOC。 我更喜欢从此开始并将其转换为包，并仅为真正应得的野兽创建模块：
# utils.py
class socket(object):
@staticmethod
def check_if_port_available(port):
pass
@staticmethod
def get_free_port(port)
pass
class image(object):
@staticmethod
def to_rgb(image):
pass
@staticmethod
def to_cmyk(image):
pass
#3楼
也许最简单的选择就是将这些函数放在类之外：
class Dog(object):
def __init__(self, name):
self.name = name
def bark(self):
if self.name == "Doggy":
return barking_sound()
else:
return "yip yip"
def barking_sound():
return "woof woof"
使用此方法，可以将修改或使用内部对象状态（具有副作用）的函数保留在类中，并且将可重用的实用程序函数移到外部。
假设此文件称为dogs.py 要使用这些功能，您可以调用dogs.barking_sound()而不是dogs.Dog.barking_sound 。
如果确实需要静态方法作为类的一部分，则可以使用staticmethod装饰器。
#4楼
Python中的静态方法？
Python中是否可以有静态方法，所以我可以在不初始化类的情况下调用它们，例如：
ClassName.StaticMethod()
是的，可以这样创建静态方法（尽管使用下划线而不是CamelCase的方法有点Pythonic ）：
class ClassName(object):
@staticmethod
def static_method(kwarg1=None):
'''return a value that is a function of kwarg1'''
上面使用了装饰器语法。 此语法等效于
class ClassName(object):
def static_method(kwarg1=None):
'''return a value that is a function of kwarg1'''
static_method = staticmethod(static_method)
可以像您描述的那样使用：
ClassName.static_method()
静态方法的内置示例是Python 3中的str.maketrans() ，它是Python 2中string模块中的函数。
您可以使用的另一个选择是classmethod ，不同之处在于classmethod将类作为隐式第一个参数获取，如果将其继承，则将子类作为隐式第一个参数获取。
class ClassName(object):
@classmethod
def class_method(cls, kwarg1=None):
'''return a value that is a function of the class and kwarg1'''
注意， cls不是第一个参数的必需名称，但是如果您使用其他任何东西，大多数有经验的Python编码人员都会认为它做得不好。
这些通常用作替代构造函数。
new_instance = ClassName.class_method()
内置示例是dict.fromkeys() ：
new_dict = dict.fromkeys(['key1', 'key2'])
#5楼
我不时遇到这个问题。 我喜欢的用例和示例是：
jeffs@jeffs-desktop:/home/jeffs $ python36
Python 3.6.1 (default, Sep 7 2017, 16:36:03)
[GCC 6.3.0 20170406] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import cmath
>>> print(cmath.sqrt(-4))
2j
>>>
>>> dir(cmath)
['__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atanh', 'cos', 'cosh', 'e', 'exp', 'inf', 'infj', 'isclose', 'isfinite', 'isinf', 'isnan', 'log', 'log10', 'nan', 'nanj', 'phase', 'pi', 'polar', 'rect', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau']
>>>
创建cmath类的对象没有任何意义，因为cmath对象中没有任何状态。 但是，cmath是所有以某种方式相关的方法的集合。 在上面的示例中，cmath中的所有函数都以某种方式作用于复数。