我发现最好的方法是使用另一个类。您可以创建一个对象，然后将其用于其他对象。

class staticFlag:
    def __init__(self):
        self.__success = False
    def isSuccess(self):
        return self.__success
    def succeed(self):
        self.__success = True

class tryIt:
    def __init__(self, staticFlag):
        self.isSuccess = staticFlag.isSuccess
        self.succeed = staticFlag.succeed

tryArr = []
flag = staticFlag()
for i in range(10):
    tryArr.append(tryIt(flag))
    if i == 5:
        tryArr[i].succeed()
    print tryArr[i].isSuccess()

通过上面的示例，我创建了一个名为staticFlag的类。

此类应显示静态变量__success（私有静态变量）。

tryIt类表示我们需要使用的常规类。

现在我为一个标志（staticFlag）创建了一个对象。此标志将作为对所有常规对象的引用发送。

所有这些对象都被添加到列表tryArr中。

此脚本结果：

False
False
False
False
False
True
True
True
True
True

用这种方式，静态变量是在用户定义的类出现时创建的，

class Student:

    the correct way of static declaration
    i = 10

    incorrect
    self.i = 10

在类定义中声明但不在方法中声明的变量是类或静态变量：

>>> class MyClass:
...     i = 3
...
>>> MyClass.i
3 

正如@millerdev所指出的，这会创建一个类级别i变量，但这与任何实例级别i变量都不同，因此您可以

>>> m = MyClass()
>>> m.i = 4
>>> MyClass.i, m.i
>>> (3, 4)

这与C++和Java不同，但与C#没有太大区别，在C#中，不能使用对实例的引用来访问静态成员。

看看Python教程对类和类对象的主题有什么看法。

@Steve Johnson已经回答了静态方法的问题，也在Python库参考中的“内置函数”中进行了说明。

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

@beidy推荐classmethods而不是staticmethod，因为该方法随后会接收类类型作为第一个参数。

就我个人而言，每当我需要静态方法时，我都会使用类方法。主要是因为我把课堂当作一个论点。

class myObj(object):
   def myMethod(cls)
     ...
   myMethod = classmethod(myMethod) 

或使用装饰器

class myObj(object):
   @classmethod
   def myMethod(cls)

对于静态财产。。是时候查一下python的定义了。。变量始终可以更改。有两种类型是可变的和不可变的。。此外，还有类属性和实例属性。。没有什么东西真正像java&c意义上的静态属性++

为什么要使用Python意义上的静态方法，如果它与类没有任何关系！如果我是你，我要么使用classmethod，要么定义独立于类的方法。

@数据类定义提供用于定义实例变量和初始化方法__init__（）的类级名称。如果要在@dataclass中使用类级变量，则应使用typeing.ClassVar类型提示。ClassVar类型的参数定义类级别变量的类型。

from typing import ClassVar
from dataclasses import dataclass

@dataclass
class Test:
    i: ClassVar[int] = 10
    x: int
    y: int
    
    def __repr__(self):
        return f"Test({self.x=}, {self.y=}, {Test.i=})"

用法示例：

> test1 = Test(5, 6)
> test2 = Test(10, 11)

> test1
Test(self.x=5, self.y=6, Test.i=10)
> test2
Test(self.x=10, self.y=11, Test.i=10)

关于这个答案，对于常量静态变量，可以使用描述符。下面是一个示例：

class ConstantAttribute(object):
    '''You can initialize my value but not change it.'''
    def __init__(self, value):
        self.value = value

    def __get__(self, obj, type=None):
        return self.value

    def __set__(self, obj, val):
        pass


class Demo(object):
    x = ConstantAttribute(10)


class SubDemo(Demo):
    x = 10


demo = Demo()
subdemo = SubDemo()
# should not change
demo.x = 100
# should change
subdemo.x = 100
print "small demo", demo.x
print "small subdemo", subdemo.x
print "big demo", Demo.x
print "big subdemo", SubDemo.x

导致。。。

small demo 10
small subdemo 100
big demo 10
big subdemo 10

如果您不喜欢忽略设置值（上面的传递），您总是可以引发异常。如果您正在寻找C++、Java风格的静态类变量：

class StaticAttribute(object):
    def __init__(self, value):
        self.value = value

    def __get__(self, obj, type=None):
        return self.value

    def __set__(self, obj, val):
        self.value = val

请查看此答案和HOWTO官方文件，以了解有关描述符的更多信息。