Python 中是否可以使用静态类变量?

Python 中是否可以有静态类变量或方法? 执行此操作需要什么语法?

Static and Class Methods

As the other answers have noted, static and class methods are easily accomplished using the built-in decorators:

class Test(object):
# regular instance method:
def MyMethod(self):
    pass

# class method:
@classmethod
def MyClassMethod(klass):
    pass

# static method:
@staticmethod
def MyStaticMethod():
    pass

As usual, the first argument to MyMethod() is bound to the class instance object. In contrast, the first argument to MyClassMethod() is bound to the class object itself (e.g., in this case, Test). For MyStaticMethod(), none of the arguments are bound, and having arguments at all is optional.

"Static Variables"

However, implementing "static variables" (well, mutable static variables, anyway, if that's not a contradiction in terms...) is not as straight forward. As millerdev pointed out in his answer, the problem is that Python's class attributes are not truly "static variables". Consider:

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

This is because the line x.i = 12 has added a new instance attribute i to x instead of changing the value of the Test class i attribute.

Partial expected static variable behavior, i.e., syncing of the attribute between multiple instances (but not with the class itself; see "gotcha" below), can be achieved by turning the class attribute into a property:

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)

Now you can do:

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

The static variable will now remain in sync between all class instances.

(NOTE: That is, unless a class instance decides to define its own version of _i! But if someone decides to do THAT, they deserve what they get, don't they???)

Note that technically speaking, i is still not a 'static variable' at all; it is a property, which is a special type of descriptor. However, the property behavior is now equivalent to a (mutable) static variable synced across all class instances.

Immutable "Static Variables"

For immutable static variable behavior, simply omit the property setter:

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)

Now attempting to set the instance i attribute will return an AttributeError:

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

One Gotcha to be Aware of

Note that the above methods only work with instances of your class - they will not work when using the class itself. So for example:

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’

The line assert Test.i == x.i produces an error, because the i attribute of Test and x are two different objects.

Many people will find this surprising. However, it should not be. If we go back and inspect our Test class definition (the second version), we take note of this line:

    i = property(get_i) 

Clearly, the member i of Test must be a property object, which is the type of object returned from the property function.

If you find the above confusing, you are most likely still thinking about it from the perspective of other languages (e.g. Java or c++). You should go study the property object, about the order in which Python attributes are returned, the descriptor protocol, and the method resolution order (MRO).

I present a solution to the above 'gotcha' below; however I would suggest - strenuously - that you do not try to do something like the following until - at minimum - you thoroughly understand why assert Test.i = x.i causes an error.

REAL, ACTUAL Static Variables - Test.i == x.i

I present the (Python 3) solution below for informational purposes only. I am not endorsing it as a "good solution". I have my doubts as to whether emulating the static variable behavior of other languages in Python is ever actually necessary. However, regardless as to whether it is actually useful, the below should help further understanding of how Python works.

UPDATE: this attempt is really pretty awful; if you insist on doing something like this (hint: please don't; Python is a very elegant language and shoe-horning it into behaving like another language is just not necessary), use the code in Ethan Furman's answer instead.

Emulating static variable behavior of other languages using a metaclass

A metaclass is the class of a class. The default metaclass for all classes in Python (i.e., the "new style" classes post Python 2.3 I believe) is type. For example:

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

However, you can define your own metaclass like this:

class MyMeta(type): pass

And apply it to your own class like this (Python 3 only):

class MyClass(metaclass = MyMeta):
    pass

type(MyClass) # class MyMeta

Below is a metaclass I have created which attempts to emulate "static variable" behavior of other languages. It basically works by replacing the default getter, setter, and deleter with versions which check to see if the attribute being requested is a "static variable".

A catalog of the "static variables" is stored in the StaticVarMeta.statics attribute. All attribute requests are initially attempted to be resolved using a substitute resolution order. I have dubbed this the "static resolution order", or "SRO". This is done by looking for the requested attribute in the set of "static variables" for a given class (or its parent classes). If the attribute does not appear in the "SRO", the class will fall back on the default attribute get/set/delete behavior (i.e., "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

</div>

You can also add class variables to classes on the fly

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

And class instances can change class variables

class X:
  l = []
  def __init__(self):
    self.l.append(1)

print X().l
print X().l

>python test.py
[1]
[1, 1]

</div>

Personally I would use a classmethod whenever I needed a static method. Mainly because I get the class as an argument.

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

or use a decorator

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

For static properties.. Its time you look up some python definition.. variable can always change. There are two types of them mutable and immutable.. Also, there are class attributes and instance attributes.. Nothing really like static attributes in the sense of java & c++

Why use static method in pythonic sense, if it has no relation whatever to the class! If I were you, I'd either use classmethod or define the method independent from the class.

One special thing to note about static properties & instance properties, shown in the example below:

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

This means before assigning the value to instance property, if we try to access the property thru' instance, the static value is used. Each property declared in python class always has a static slot in memory.

You could also enforce a class to be static using metaclass.

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

Then whenever by accident you try to initialize MyClass you'll get an StaticClassError.

The best way I found is to use another class. You can create an object and then use it on other objects.

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()

With the example above, I made a class named staticFlag.

This class should present the static var __success (Private Static Var).

tryIt class represented the regular class we need to use.

Now I made an object for one flag (staticFlag). This flag will be sent as reference to all the regular objects.

All these objects are being added to the list tryArr.


This Script Results:

False
False
False
False
False
True
True
True
True
True
</div>