Python中的静态类变量和方法

曾经终败给现在 2024-03-30 01:34 109阅读 0赞

## 问： ##

如何在 Python 中创建静态类变量或方法？

## 答1: ##

> huntsbot.com聚合了超过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\# 并没有太大不同，后者不能使用对实例的引用来访问静态成员。

请参阅what the Python tutorial has to say on the subject of classes and class objects。

@Steve Johnson 已经回答了关于 static methods 的问题，也记录在 “Built-in Functions” in the Python Library Reference 下。

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

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

`我只是在学习 Python，但 @classmethod 相对于 @staticmethod AFAIK 的优势在于，您始终可以获得调用该方法的类的名称，即使它是子类。例如，静态方法缺少此信息，因此它不能调用被覆盖的方法。`

`@theJollySin 常量的pythonic 方式是不为常量增长一个类。只要有一些 const.py 和 PI = 3.14，您就可以在任何地方导入它。 from const import PI`

`这个答案可能会混淆静态变量问题。首先，i = 3 不是一个静态变量，它是一个类属性，并且由于它不同于实例级属性 i 它确实 < b>not 在其他语言中的行为类似于静态变量。请参阅下面的 millerdev's answer、Yann's answer 和 my answer。`

`所以即使我创建了这个类的数百个实例，也只有一个 i（静态变量）的副本会在内存中？`

`对于@Dubslow 评论中提到的 Daniel 感兴趣的任何人，它是 millerdev (wayback machine)`

## 答2: ##

> huntsbot.com全球7大洲远程工作机会，探索不一样的工作方式

@Blair Conrad 说在类定义中声明但不在方法中声明的静态变量是类或“静态”变量：

>>> class Test(object):
    ...     i = 3
    ...
    >>> Test.i
    3

这里有一些问题。从上面的例子继续：

>>> t = Test()
    >>> t.i     # "static" variable accessed via instance
    3
    >>> t.i = 5 # but if we assign to the instance ...
    >>> Test.i  # we have not changed the "static" variable
    3
    >>> t.i     # we have overwritten Test.i on t by creating a new attribute t.i
    5
    >>> Test.i = 6 # to change the "static" variable we do it by assigning to the class
    >>> t.i
    5
    >>> Test.i
    6
    >>> u = Test()
    >>> u.i
    6           # changes to t do not affect new instances of Test
    
    # Namespaces are one honking great idea -- let's do more of those!
    >>> Test.__dict__
    {
        'i': 6, ...}
    >>> t.__dict__
    {
        'i': 5}
    >>> u.__dict__
    {
        }

请注意，当属性 i 直接在 t 上设置时，实例变量 t.i 如何与“静态”类变量不同步。这是因为 i 在 t 命名空间内重新绑定，这与 Test 命名空间不同。如果要更改“静态”变量的值，则必须在最初定义的范围（或对象）内更改它。我将“静态”放在引号中，因为 Python 并没有 C++ 和 Java 那样的静态变量。

虽然它没有具体说明静态变量或方法，但 Python tutorial 有一些关于 classes and class objects 的相关信息。

@Steve Johnson 还回答了有关静态方法的问题，也记录在 Python 库参考中的“内置函数”下。

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

@beid 还提到了 classmethod，它类似于 staticmethod。类方法的第一个参数是类对象。例子：

class Test(object):
        i = 3 # class (or static) variable
        @classmethod
        def g(cls, arg):
            # here we can use 'cls' instead of the class name (Test)
            if arg > cls.i:
                cls.i = arg # would be the same as Test.i = arg1

https://i.stack.imgur.com/xqnxe.jpg

`我建议你稍微扩展一下这个例子：如果在设置 Test.i=6 之后实例化一个新对象（例如，u=Test()），新对象将“继承”新的类值（例如， ui==6)`

`使静态变量保持同步的一种方法是使它们成为属性：class Test(object):、_i = 3、@property、def i(self)、return type(self)._i、@i.setter、def i(self,val):、type(self)._i = val。现在您可以执行 x = Test()、x.i = 12、assert x.i == Test.i。`

`所以我可以说所有变量最初都是静态的，然后访问实例会在运行时生成实例变量？`

`也许这很有趣：如果您在 Test 中定义一个更改 Test.i 的方法，这将同时影响 Test.i 和 ti 值。`

`@millerdev，就像你提到的那样，Python 没有 C++ 或 JAVA 那样的静态变量。所以可以说，Test.i 更像是一个类变量而不是一个静态变量吗？`

## 答3: ##

> 保持自己快人一步,享受全网独家提供的一站式外包任务、远程工作、创意产品订阅服务–huntsbot.com

静态和类方法

正如其他答案所指出的，静态和类方法可以使用内置装饰器轻松完成：

class Test(object):
    
        # regular instance method:
        def my_method(self):
            pass
    
        # class method:
        @classmethod
        def my_class_method(cls):
            pass
    
        # static method:
        @staticmethod
        def my_static_method():
            pass

像往常一样，my\_method() 的第一个参数绑定到类实例对象。相反，my\_class\_method() 的第一个参数绑定到类对象本身（例如，在本例中为 Test）。对于 my\_static\_method()，没有任何参数是绑定的，并且完全有参数是可选的。

“静态变量”

然而，实现“静态变量”（好吧，可变静态变量，无论如何，如果这在术语上不矛盾的话…）并不那么简单。作为 millerdev pointed out in his answer，问题在于 Python 的类属性并不是真正的“静态变量”。考虑：

class Test(object):
        i = 3  # This is a class attribute
    
    x = Test()
    x.i = 12   # Attempt to change the value of the class attribute using x instance
    assert x.i == Test.i  # ERROR
    assert Test.i == 3    # Test.i was not affected
    assert x.i == 12      # x.i is a different object than Test.i

这是因为行 x.i = 12 已将新实例属性 i 添加到 x，而不是更改 Test 类 i 属性的值。

部分预期的静态变量行为，即多个实例之间的属性同步（但不与类本身同步；参见下面的“gotcha”），可以通过将类属性转换为属性来实现：

class Test(object):
    
        _i = 3
    
        @property
        def i(self):
            return type(self)._i
    
        @i.setter
        def i(self,val):
            type(self)._i = val
    
    ## ALTERNATIVE IMPLEMENTATION - FUNCTIONALLY EQUIVALENT TO ABOVE ##
    ## (except with separate methods for getting and setting i) ##
    
    class Test(object):
    
        _i = 3
    
        def get_i(self):
            return type(self)._i
    
        def set_i(self,val):
            type(self)._i = val
    
        i = property(get_i, set_i)

现在你可以这样做：

x1 = Test()
    x2 = Test()
    x1.i = 50
    assert x2.i == x1.i  # no error
    assert x2.i == 50    # the property is synced

静态变量现在将在所有类实例之间保持同步。

（注意：也就是说，除非类实例决定定义自己的 \_i 版本！但如果有人决定这样做，他们应该得到他们得到的，不是吗？？？）

请注意，从技术上讲，i 仍然根本不是“静态变量”；它是一个property，它是一种特殊类型的描述符。但是，property 行为现在等效于跨所有类实例同步的（可变）静态变量。

不可变的“静态变量”

对于不可变的静态变量行为，只需省略 property 设置器：

class Test(object):
    
        _i = 3
    
        @property
        def i(self):
            return type(self)._i
    
    ## ALTERNATIVE IMPLEMENTATION - FUNCTIONALLY EQUIVALENT TO ABOVE ##
    ## (except with separate methods for getting i) ##
    
    class Test(object):
    
        _i = 3
    
        def get_i(self):
            return type(self)._i
    
        i = property(get_i)

现在尝试设置实例 i 属性将返回 AttributeError：

x = Test()
    assert x.i == 3  # success
    x.i = 12         # ERROR

需要注意的一个问题

请注意，上述方法仅适用于您的类的实例——它们在使用类本身时不起作用。例如：

x = Test()
    assert x.i == Test.i  # ERROR
    
    # x.i and Test.i are two different objects:
    type(Test.i)  # class 'property'
    type(x.i)     # class 'int'

assert Test.i == x.i 行会产生错误，因为 Test 和 x 的 i 属性是两个不同的对象。

许多人会对此感到惊讶。但是，它不应该。如果我们返回并检查我们的 Test 类定义（第二个版本），我们会注意到这一行：

i = property(get_i)

显然，Test 的成员 i 必须是 property 对象，它是从 property 函数返回的对象类型。

如果您觉得以上内容令人困惑，那么您很可能仍在从其他语言（例如 Java 或 c++）的角度来考虑它。您应该研究 property 对象，了解 Python 属性的返回顺序、描述符协议和方法解析顺序 (MRO)。

我在下面提出了上述“问题”的解决方案；但是，我强烈建议您不要尝试执行以下操作，直到您至少完全理解 assert Test.i = x.i 导致错误的原因。

真实的，实际的静态变量 - Test.i == xi

我在下面提供（Python 3）解决方案仅供参考。我不认可它是一个“好的解决方案”。我怀疑在 Python 中模拟其他语言的静态变量行为是否真的有必要。但是，不管它是否真的有用，下面的内容应该有助于进一步理解 Python 的工作原理。

更新：这个尝试真的很糟糕；如果您坚持做这样的事情（提示：请不要这样做；Python 是一种非常优雅的语言，没有必要硬着头皮让它表现得像另一种语言），请改用 Ethan Furman’s answer 中的代码。

使用元类模拟其他语言的静态变量行为

元类是类的类。 Python 中所有类的默认元类（即，我相信 Python 2.3 之后的“新样式”类）是 type。例如：

type(int)  # class 'type'
    type(str)  # class 'type'
    class Test(): pass
    type(Test) # class 'type'

但是，您可以像这样定义自己的元类：

class MyMeta(type): pass

并将其应用到您自己的类中（仅限 Python 3）：

class MyClass(metaclass = MyMeta):
        pass
    
    type(MyClass)  # class MyMeta

下面是我创建的一个元类，它试图模拟其他语言的“静态变量”行为。它基本上通过将默认的 getter、setter 和 deleter 替换为检查请求的属性是否是“静态变量”的版本来工作。

“静态变量”的目录存储在 StaticVarMeta.statics 属性中。最初尝试使用替代解析顺序来解析所有属性请求。我称其为“静态解决顺序”或“SRO”。这是通过在给定类（或其父类）的“静态变量”集中查找请求的属性来完成的。如果该属性未出现在“SRO”中，则该类将回退到默认的属性获取/设置/删除行为（即“MRO”）。

from functools import wraps
    
    class StaticVarsMeta(type):
        '''A metaclass for creating classes that emulate the "static variable" behavior
        of other languages. I do not advise actually using this for anything!!!
        
        Behavior is intended to be similar to classes that use __slots__. However, "normal"
        attributes and __statics___ can coexist (unlike with __slots__). 
        
        Example usage: 
            
            class MyBaseClass(metaclass = StaticVarsMeta):
                __statics__ = {
        'a','b','c'}
                i = 0  # regular attribute
                a = 1  # static var defined (optional)
                
            class MyParentClass(MyBaseClass):
                __statics__ = {
        'd','e','f'}
                j = 2              # regular attribute
                d, e, f = 3, 4, 5  # Static vars
                a, b, c = 6, 7, 8  # Static vars (inherited from MyBaseClass, defined/re-defined here)
                
            class MyChildClass(MyParentClass):
                __statics__ = {
        'a','b','c'}
                j = 2  # regular attribute (redefines j from MyParentClass)
                d, e, f = 9, 10, 11   # Static vars (inherited from MyParentClass, redefined here)
                a, b, c = 12, 13, 14  # Static vars (overriding previous definition in MyParentClass here)'''
        statics = {
        }
        def __new__(mcls, name, bases, namespace):
            # Get the class object
            cls = super().__new__(mcls, name, bases, namespace)
            # Establish the "statics resolution order"
            cls.__sro__ = tuple(c for c in cls.__mro__ if isinstance(c,mcls))
                            
            # Replace class getter, setter, and deleter for instance attributes
            cls.__getattribute__ = StaticVarsMeta.__inst_getattribute__(cls, cls.__getattribute__)
            cls.__setattr__ = StaticVarsMeta.__inst_setattr__(cls, cls.__setattr__)
            cls.__delattr__ = StaticVarsMeta.__inst_delattr__(cls, cls.__delattr__)
            # Store the list of static variables for the class object
            # This list is permanent and cannot be changed, similar to __slots__
            try:
                mcls.statics[cls] = getattr(cls,'__statics__')
            except AttributeError:
                mcls.statics[cls] = namespace['__statics__'] = set() # No static vars provided
            # Check and make sure the statics var names are strings
            if any(not isinstance(static,str) for static in mcls.statics[cls]):
                typ = dict(zip((not isinstance(static,str) for static in mcls.statics[cls]), map(type,mcls.statics[cls])))[True].__name__
                raise TypeError('__statics__ items must be strings, not {
        0}'.format(typ))
            # Move any previously existing, not overridden statics to the static var parent class(es)
            if len(cls.__sro__) > 1:
                for attr,value in namespace.items():
                    if attr not in StaticVarsMeta.statics[cls] and attr != ['__statics__']:
                        for c in cls.__sro__[1:]:
                            if attr in StaticVarsMeta.statics[c]:
                                setattr(c,attr,value)
                                delattr(cls,attr)
            return cls
        def __inst_getattribute__(self, orig_getattribute):
            '''Replaces the class __getattribute__'''
            @wraps(orig_getattribute)
            def wrapper(self, attr):
                if StaticVarsMeta.is_static(type(self),attr):
                    return StaticVarsMeta.__getstatic__(type(self),attr)
                else:
                    return orig_getattribute(self, attr)
            return wrapper
        def __inst_setattr__(self, orig_setattribute):
            '''Replaces the class __setattr__'''
            @wraps(orig_setattribute)
            def wrapper(self, attr, value):
                if StaticVarsMeta.is_static(type(self),attr):
                    StaticVarsMeta.__setstatic__(type(self),attr, value)
                else:
                    orig_setattribute(self, attr, value)
            return wrapper
        def __inst_delattr__(self, orig_delattribute):
            '''Replaces the class __delattr__'''
            @wraps(orig_delattribute)
            def wrapper(self, attr):
                if StaticVarsMeta.is_static(type(self),attr):
                    StaticVarsMeta.__delstatic__(type(self),attr)
                else:
                    orig_delattribute(self, attr)
            return wrapper
        def __getstatic__(cls,attr):
            '''Static variable getter'''
            for c in cls.__sro__:
                if attr in StaticVarsMeta.statics[c]:
                    try:
                        return getattr(c,attr)
                    except AttributeError:
                        pass
            raise AttributeError(cls.__name__ + " object has no attribute '{0}'".format(attr))
        def __setstatic__(cls,attr,value):
            '''Static variable setter'''
            for c in cls.__sro__:
                if attr in StaticVarsMeta.statics[c]:
                    setattr(c,attr,value)
                    break
        def __delstatic__(cls,attr):
            '''Static variable deleter'''
            for c in cls.__sro__:
                if attr in StaticVarsMeta.statics[c]:
                    try:
                        delattr(c,attr)
                        break
                    except AttributeError:
                        pass
            raise AttributeError(cls.__name__ + " object has no attribute '{0}'".format(attr))
        def __delattr__(cls,attr):
            '''Prevent __sro__ attribute from deletion'''
            if attr == '__sro__':
                raise AttributeError('readonly attribute')
            super().__delattr__(attr)
        def is_static(cls,attr):
            '''Returns True if an attribute is a static variable of any class in the __sro__'''
            if any(attr in StaticVarsMeta.statics[c] for c in cls.__sro__):
                return True
            return False

`我尝试使用您的方式，但遇到了问题，请在此处查看我的问题stackoverflow.com/questions/29329850/get-static-variable-value`

`@RickTeachey：我想您通常应该将您在类 Instance Test 上所做的任何事情（在将其用于实例化实例之前）视为属于元编程领域？例如，您通过执行 Test.i = 0 更改类行为（这里您只需完全销毁属性对象）。我猜“属性机制”只在类实例的属性访问中起作用（除非你使用元类作为中间体来改变底层行为，也许）。顺便说一句，请完成这个答案:-)`

`@RickTeachey 谢谢 :-) 最后你的元类很有趣，但实际上对我来说有点太复杂了。在绝对需要这种机制的大型框架/应用程序中，它可能很有用。无论如何，这说明如果真的需要新的（复杂的）非默认元行为，Python 使之成为可能:)`

`@OleThomsenBuus：检查 my answer 以获得更简单的元类来完成这项工作。`

`@taper你是对的；我已经编辑了解决问题的答案（不敢相信它已经错了这么久！）。对困惑感到抱歉。`

## 答4: ##

> 保持自己快人一步,享受全网独家提供的一站式外包任务、远程工作、创意产品订阅服务–huntsbot.com

您还可以动态地将类变量添加到类中

>>> class X:
    ...     pass
    ... 
    >>> X.bar = 0
    >>> x = X()
    >>> x.bar
    0
    >>> x.foo
    Traceback (most recent call last):
      File "", line 1, in 
    AttributeError: X instance has no attribute 'foo'
    >>> X.foo = 1
    >>> x.foo
    1

并且类实例可以改变类变量

class X:
      l = []
      def __init__(self):
        self.l.append(1)
    
    print X().l
    print X().l
    
    >python test.py
    [1]
    [1, 1]

`即使将类导入另一个模块，新的类变量也会保留吗？`

`是的。类实际上是单例，无论您从哪个名称空间调用它们。`

`@Gregory您说“并且类实例可以更改类变量”实际上这个示例称为访问而不是修改。修改是由对象本身通过其自己的 append() 函数完成的。`

## 答5: ##

> 一个优秀的自由职业者，应该有对需求敏感和精准需求捕获的能力，而huntsbot.com提供了这个机会

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

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

或使用装饰器

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

对于静态属性…是时候查找一些python定义了…变量总是可以改变的。它们有可变和不可变两种类型。此外，还有类属性和实例属性。在 java 和 c++ 的意义上，没有什么像静态属性那样

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

`变量不是可变的或不可变的；对象是。 （然而，一个对象可以在不同程度上成功地尝试阻止分配给它的某些属性。）`

`Java 和 C++ 使用静态（错误使用这个词，恕我直言），就像您使用实例与类属性一样。类属性/方法在 Java 和 C++ 中是静态的，没有区别，只是在 Python 中，类方法调用的第一个参数是类。`

## 答6: ##

> 与HuntsBot一起，探索全球自由职业机会–huntsbot.com

关于静态属性和实例属性的一件特别需要注意的事情，如下例所示：

class my_cls:
      my_prop = 0
    
    #static property
    print my_cls.my_prop  #--> 0
    
    #assign value to static property
    my_cls.my_prop = 1 
    print my_cls.my_prop  #--> 1
    
    #access static property thru' instance
    my_inst = my_cls()
    print my_inst.my_prop #--> 1
    
    #instance property is different from static property 
    #after being assigned a value
    my_inst.my_prop = 2
    print my_cls.my_prop  #--> 1
    print my_inst.my_prop #--> 2

这意味着在将值分配给实例属性之前，如果我们尝试通过实例访问属性，则使用静态值。在 python 类中声明的每个属性在内存中总是有一个静态槽。

## 答7: ##

> huntsbot.com – 高效赚钱，自由工作

python 中的静态方法称为classmethod。看看下面的代码

class MyClass:
    
        def myInstanceMethod(self):
            print 'output from an instance method'
    
        @classmethod
        def myStaticMethod(cls):
            print 'output from a static method'
    
    >>> MyClass.myInstanceMethod()
    Traceback (most recent call last):
      File "", line 1, in 
    TypeError: unbound method myInstanceMethod() must be called [...]
    
    >>> MyClass.myStaticMethod()
    output from a static method

请注意，当我们调用方法 myInstanceMethod 时，会出现错误。这是因为它要求在此类的实例上调用该方法。方法 myStaticMethod 使用 decorator @classmethod 设置为类方法。

只是为了好玩和咯咯笑，我们可以通过传入类的实例来调用类的 myInstanceMethod，如下所示：

>>> MyClass.myInstanceMethod(MyClass())
    output from an instance method

`嗯...静态方法是用 @staticmethod 制作的； @classmethod （显然）用于类方法（主要用作替代构造函数，但在紧要关头可以用作静态方法，这些方法恰好接收到对它们被调用的类的引用）。`

## 答8: ##

> huntsbot.com洞察每一个产品背后的需求与收益，从而捕获灵感

可能有 static 个类变量，但可能不值得努力。

这是用 Python 3 编写的概念证明——如果任何确切的细节有误，可以调整代码以匹配您所说的 static variable：

class Static:
        def __init__(self, value, doc=None):
            self.deleted = False
            self.value = value
            self.__doc__ = doc
        def __get__(self, inst, cls=None):
            if self.deleted:
                raise AttributeError('Attribute not set')
            return self.value
        def __set__(self, inst, value):
            self.deleted = False
            self.value = value
        def __delete__(self, inst):
            self.deleted = True
    
    class StaticType(type):
        def __delattr__(cls, name):
            obj = cls.__dict__.get(name)
            if isinstance(obj, Static):
                obj.__delete__(name)
            else:
                super(StaticType, cls).__delattr__(name)
        def __getattribute__(cls, *args):
            obj = super(StaticType, cls).__getattribute__(*args)
            if isinstance(obj, Static):
                obj = obj.__get__(cls, cls.__class__)
            return obj
        def __setattr__(cls, name, val):
            # check if object already exists
            obj = cls.__dict__.get(name)
            if isinstance(obj, Static):
                obj.__set__(name, val)
            else:
                super(StaticType, cls).__setattr__(name, val)

并在使用中：

class MyStatic(metaclass=StaticType):
        """
        Testing static vars
        """
        a = Static(9)
        b = Static(12)
        c = 3
    
    class YourStatic(MyStatic):
        d = Static('woo hoo')
        e = Static('doo wop')

和一些测试：

ms1 = MyStatic()
    ms2 = MyStatic()
    ms3 = MyStatic()
    assert ms1.a == ms2.a == ms3.a == MyStatic.a
    assert ms1.b == ms2.b == ms3.b == MyStatic.b
    assert ms1.c == ms2.c == ms3.c == MyStatic.c
    ms1.a = 77
    assert ms1.a == ms2.a == ms3.a == MyStatic.a
    ms2.b = 99
    assert ms1.b == ms2.b == ms3.b == MyStatic.b
    MyStatic.a = 101
    assert ms1.a == ms2.a == ms3.a == MyStatic.a
    MyStatic.b = 139
    assert ms1.b == ms2.b == ms3.b == MyStatic.b
    del MyStatic.b
    for inst in (ms1, ms2, ms3):
        try:
            getattr(inst, 'b')
        except AttributeError:
            pass
        else:
            print('AttributeError not raised on %r' % attr)
    ms1.c = 13
    ms2.c = 17
    ms3.c = 19
    assert ms1.c == 13
    assert ms2.c == 17
    assert ms3.c == 19
    MyStatic.c = 43
    assert ms1.c == 13
    assert ms2.c == 17
    assert ms3.c == 19
    
    ys1 = YourStatic()
    ys2 = YourStatic()
    ys3 = YourStatic()
    MyStatic.b = 'burgler'
    assert ys1.a == ys2.a == ys3.a == YourStatic.a == MyStatic.a
    assert ys1.b == ys2.b == ys3.b == YourStatic.b == MyStatic.b
    assert ys1.d == ys2.d == ys3.d == YourStatic.d
    assert ys1.e == ys2.e == ys3.e == YourStatic.e
    ys1.a = 'blah'
    assert ys1.a == ys2.a == ys3.a == YourStatic.a == MyStatic.a
    ys2.b = 'kelp'
    assert ys1.b == ys2.b == ys3.b == YourStatic.b == MyStatic.b
    ys1.d = 'fee'
    assert ys1.d == ys2.d == ys3.d == YourStatic.d
    ys2.e = 'fie'
    assert ys1.e == ys2.e == ys3.e == YourStatic.e
    MyStatic.a = 'aargh'
    assert ys1.a == ys2.a == ys3.a == YourStatic.a == MyStatic.a

## 答9: ##

> huntsbot.com全球7大洲远程工作机会，探索不一样的工作方式

在任何成员方法之外定义一些成员变量时，该变量可以是静态的或非静态的，具体取决于变量的表达方式。

CLASSNAME.var 是静态变量

INSTANCENAME.var 不是静态变量。

类中的 self.var 不是静态变量。

类成员函数里面的var没有定义。

例如：

#!/usr/bin/python
    
    class A:
        var=1
    
        def printvar(self):
            print "self.var is %d" % self.var
            print "A.var is %d" % A.var
    
    
        a = A()
        a.var = 2
        a.printvar()
    
        A.var = 3
        a.printvar()

结果是

self.var is 2
    A.var is 1
    self.var is 2
    A.var is 3

`压痕坏了。这不会执行`

## 答10: ##

> HuntsBot周刊–不定时分享成功产品案例，学习他们如何成功建立自己的副业–huntsbot.com

@dataclass 定义提供用于定义实例变量和初始化方法的类级别名称 **init**()。如果您想在 @dataclass 中使用类级变量，您应该使用 typing.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)

## 答11: ##

> huntsbot.com高效搞钱，一站式跟进超10+任务平台外包需求

您还可以使用元类强制类是静态的。

class StaticClassError(Exception):
        pass
    
    
    class StaticClass:
        __metaclass__ = abc.ABCMeta
    
        def __new__(cls, *args, **kw):
            raise StaticClassError("%s is a static class and cannot be initiated."
                                    % cls)
    
    class MyClass(StaticClass):
        a = 1
        b = 3
    
        @staticmethod
        def add(x, y):
            return x+y

然后，每当您不小心尝试初始化 MyClass 时，您都会得到一个 StaticClassError。

`如果你不打算实例化它，为什么它甚至是一个类？这感觉就像在扭曲 Python 以将其变成 Java....`

`Borg idiom 是处理此问题的更好方法。`

`@NedBatchelder 这是一个抽象类，仅用于子类化（和实例化子类）`

`我希望子类不要使用 super() 来调用其父母的 __new__ ...`

原文链接：[https://www.huntsbot.com/qa/ka86/static-class-variables-and-methods-in-python?lang=zh\_CN&from=csdn][https_www.huntsbot.com_qa_ka86_static-class-variables-and-methods-in-python_lang_zh_CN_from_csdn]

> 一个优秀的自由职业者，应该有对需求敏感和精准需求捕获的能力，而huntsbot.com提供了这个机会

[https_www.huntsbot.com_qa_ka86_static-class-variables-and-methods-in-python_lang_zh_CN_from_csdn]: https://www.huntsbot.com/qa/ka86/static-class-variables-and-methods-in-python?lang=zh_CN&from=csdn