Sind statische Klassen-Variablen möglich?

Deklarierten Variablen innerhalb der definition der Klasse, aber nicht innerhalb einer Methode werden der Klasse oder statischen Variablen:

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

Als @millerdev Punkte raus, das wird eine Klasse-level - i variable, aber dies unterscheidet sich von einer beliebigen Instanz-Ebene i variable, so dass Sie haben könnte

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

Dies ist anders als bei C++ und Java, aber nicht so Verschieden von C#, wo ein statisches Element kann nicht zugegriffen werden, mithilfe einer Referenz auf eine Instanz.

Sehen was die Python-tutorial zu sagen hat zum Thema Klassen und Objekte der Klasse.

@Steve Johnson bereits beantwortet hat bezüglich statische Methoden, ebenfalls dokumentiert unter "Built-in-Funktionen" in der Python Library Reference.

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

@beidy empfiehlt classmethods über staticmethod, wie die Methode erhält dann den Klasse Typ wie das erste argument, aber ich bin immer noch ein wenig verschwommen auf die Vorteile, die dieser Ansatz über staticmethod. Wenn Sie auch sind, dann ist es wahrscheinlich egal.

InformationsquelleAutor Blair Conrad

Statische und Klassenmethoden

Als die anderen Antworten haben darauf hingewiesen, statische und Klassenmethoden werden leicht erreicht mit dem eingebauten Dekorateure:

class Test(object):

    # regular instance method:
    def MyMethod(self):
        pass

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

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

Als üblich, das erste argument MyMethod() ist gebunden an die Klasse-Instanz-Objekt. Im Gegensatz dazu, das erste argument MyClassMethod() ist an das class-Objekt selbst (z.B. in diesem Fall Test). Für MyStaticMethod() keines der Argumente gebunden sind, und dass Argumente ist optional.

"Statische Variablen"

Aber die Umsetzung von "statische Variablen" (veränderlich statische Variablen, sowieso, wenn das nicht ein Widerspruch in sich...) ist nicht als geradlinig. Als millerdev zeigte in seiner Antwort, das problem ist, dass Python die class-Attribute sind nicht wirklich "statische Variablen". Bedenken Sie:

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

Dies ist da die Grenze x.i = 12 hat eine neue Instanz Attribut i zu x anstelle der änderung des Wertes der Test Klasse i Attribut.

Teilweise erwartet statische Variablen Verhalten, d.h., die Synchronisierung des Attributs zwischen mehreren Instanzen (aber nicht mit der Klasse selbst; siehe "gotcha" weiter unten), kann erreicht werden, durch drehen des class-Attributs in eine Immobilie:

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)

Können Sie jetzt tun:

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

Die statische variable wird nun synchron bleiben zwischen allen Instanzen der Klasse.

(HINWEIS: Das ist, es sei denn, eine Klasse Instanz entscheidet, zu definieren, seine eigene version von _i! Aber wenn jemand sich entscheidet DAS zu tun, Sie verdienen, was Sie bekommen, nicht wahr???)

Beachten Sie, dass technisch gesehen, ist i ist noch nicht eine 'statische variable' überhaupt; es ist eine property, die eine Besondere Form von Deskriptoren. Jedoch, die property Verhalten ist nun äquivalent zu a (veränderlich) statische variable synchronisieren, die alle Instanzen der Klasse.

Unveränderlich "Statische Variablen"

Für unveränderliche statische Variablen Verhalten, einfach weglassen, die 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)

Nun versuchen, die Instanz i Attribut zurück AttributeError:

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

Eine Gotcha Bewusst sein,

Beachten Sie, dass die oben genannten Methoden funktionieren nur mit Instanzen Ihrer Klasse - Sie wird nicht Arbeit bei der Verwendung der Klasse selbst. So zum Beispiel:

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'

Die Linie assert Test.i == x.i einen Fehler produziert, weil die i Attribut Test und x sind zwei verschiedene Objekte.

Viele Leute finden das überraschend. Es sollte jedoch nicht sein. Wenn wir zurück gehen und prüfen unsere Test definition der Klasse (die zweite version), wir beachten Sie diese Zeile:

    i = property(get_i) 

Klar, das Mitglied i von Test muss ein property Objekt, das den Typ des Objekts zurückgegeben, die von der property Funktion.

Wenn Sie die oben verwirrend, Sie sind wahrscheinlich immer noch denken, über den es aus der Sicht anderer Sprachen (z.B. Java oder c++). Sie sollten gehen Studie der property - Objekt über die Reihenfolge, in der Python-Attribute zurückgegeben werden, der Deskriptor-Protokoll, und die Methode resolution order (MRO).

Präsentiere ich eine Lösung zu den oben genannten 'gotcha' (unten); allerdings würde ich vorschlagen - heftig -, dass Sie nicht versuchen, etwas zu tun, wie die folgenden, bis - mindestens - Sie gründlich zu verstehen, warum assert Test.i = x.i einen Fehler verursacht.

REAL, tatsächlich Statische Variablen - Test.i == x.i

Präsentiere ich die (Python 3) Lösung unten dienen nur zu Informationszwecken. Ich bin nicht befürworten, es als eine "gute Lösung". Ich habe meine Zweifel, ob die statische variable emuliert das Verhalten der anderen Sprachen in Python ist eigentlich immer notwendig. Doch unabhängig davon, ob es tatsächlich sinnvoll ist, das unten sollte helfen, das Verständnis fördern, wie Python funktioniert.

UPDATE: dieser Versuch ist wirklich furchtbar; wenn Sie darauf bestehen, etwas wie das zu tun (Tipp: bitte nicht; Python ist eine sehr elegante Sprache und Schuh-horning es in sich wie eine andere Sprache ist einfach nicht notwendig), verwenden Sie den code in Ethan Furman Antwort statt.

Statische variable emuliert das Verhalten der anderen Sprachen mit einer Metaklasse

Eine Metaklasse ist die Klasse einer Klasse. Die Standard-Metaklasse für alle Klassen in Python (d.h., der "new style" - Klassen, post-Python-2.3 glaube ich) ist type. Zum Beispiel:

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

Können Sie jedoch definieren Sie Ihre eigene Metaklasse wie diese:

class MyMeta(type): pass

Und wenden Sie es auf Ihrer eigenen Klasse, wie dieses (Python 3):

class MyClass(metaclass = MyMeta):
    pass

type(MyClass)  # class MyMeta

Unten ist eine Metaklasse, die ich erstellt habe, die versucht zu emulieren "statische variable" Verhalten der anderen Sprachen. Es funktioniert im Grunde durch das ersetzen der Standard-getter -, setter-und deleter mit Versionen, die prüfen, um zu sehen, ob das Attribut angefordert wird, ist eine "statische variable".

Einen Katalog der "statische Variablen" gespeichert ist in die StaticVarMeta.statics Attribut. Alle Attribut-Anforderungen sind zunächst versucht gelöst zu werden, mit einem Ersatz-Auflösung um. Ich nannte das die "static resolution order", oder "SRO". Dies geschieht, indem für das angeforderte Attribut in der Sammlung "statische Variablen" für eine bestimmte Klasse (oder deren übergeordneten Klassen). Wenn das Attribut erscheint nicht in der "SRO", das-Klasse fallen zurück auf die default-Attribut get/set/delete-Verhalten (d.h., "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

InformationsquelleAutor Rick Teachey

Persönlich würde ich eine classmethod, Wann immer ich brauchte eine statische Methode. Vor allem, weil ich die Klasse als argument.

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

oder verwenden Sie einen Dekorateur

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

Für statische Eigenschaften.. Seine Zeit, die Sie nach oben schauen einige python-definition.. variable kann sich jederzeit ändern. Es gibt zwei Arten von Ihnen mutable und immutable.. Außerdem gibt es Klassen-Attribute Instanz-Attribute.. Nichts wirklich wie statische Attribute im Sinne von java & c++

Warum verwenden die statische Methode in pythonic Sinn, wenn es keine Beziehung was auch immer auf die Klasse an! Wenn ich du wäre, würde ich entweder classmethod, oder definieren Sie die Methode unabhängig von der Klasse.

InformationsquelleAutor emb

Statische Methoden in python genannt werden classmethods. Werfen Sie einen Blick auf den folgenden code

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 "<stdin>", line 1, in <module>
TypeError: unbound method myInstanceMethod() must be called [...]

>>> MyClass.myStaticMethod()
output from a static method

Beachten Sie, dass, wenn wir die Methode aufrufen myInstanceMethod, bekommen wir einen Fehler. Dies ist, weil es erfordert, dass die Methode, die aufgerufen werden, auf eine Instanz dieser Klasse. Die Methode myStaticMethod als classmethod mit der Dekorateur @classmethod.

Nur für kicks und kichert, wir nennen konnte myInstanceMethod auf die Klasse, indem Sie übergeben eine Instanz der Klasse, etwa so:

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

InformationsquelleAutor willurd

Könnten Sie erzwingen auch eine Klasse statisch zu sein mit 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

Dann, wenn durch Zufall Sie versuchen zu initialisieren MyClass erhalten Sie eine StaticClassError.

InformationsquelleAutor Bartosz Ptaszynski

Einen sehr interessanten Punkt, über Python-Attribut-lookup ist, dass es kann verwendet werden, um zu erstellen "virtuelle Variablen":

class A(object):

  label="Amazing"

  def __init__(self,d): 
      self.data=d

  def say(self): 
      print("%s %s!"%(self.label,self.data))

class B(A):
  label="Bold"  # overrides A.label

A(5).say()      # Amazing 5!
B(3).say()      # Bold 3!

Normal, es gibt keine Zuordnungen, um diese, nachdem Sie geschaffen werden. Beachten Sie, dass die lookup verwendet self da, obwohl label ist statisch in dem Sinn, nicht im Zusammenhang mit einer insbesondere Instanz, der Wert hängt immer noch von der (Klasse der) Instanz.

InformationsquelleAutor Davis Herring

Absolut Ja,
Python selbst habe keine statischen Daten-member explizit, aber Wir können so tun,

class A:
    counter =0
    def callme (self):
        A.counter +=1
    def getcount (self):
        return self.counter  
>>> x=A()
>>> y=A()
>>> print(x.getcount())
>>> print(y.getcount())
>>> x.callme() 
>>> print(x.getcount())
>>> print(y.getcount())

Ausgabe

0
0
1
1

Erklärung

here object (x) alone increment the counter variable
from 0 to 1 by not object y. But result it as "static counter"

InformationsquelleAutor Mari Selvan

Der beste Weg den ich gefunden ist die Verwendung einer anderen Klasse. Sie können ein Objekt erstellen und dann verwenden Sie es auf andere Objekte.

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

Mit dem obigen Beispiel habe ich eine Klasse namens staticFlag.

Diese Klasse soll die static var __success (Private Static Var).

tryIt Klasse repräsentiert die reguläre Klasse, die wir verwenden müssen.

Nun habe ich ein Objekt für eine fahne (staticFlag). Dieses flag wird gesendet als Referenz für alle der normale Objekte.

Alle diese Objekte werden der Liste Hinzugefügt tryArr.

Dieses Skript Ergebnisse:

False
False
False
False
False
True
True
True
True
True

InformationsquelleAutor Tomer Zait

Statische Variablen in der Klasse factory Python ist3.6

Für jeden, der ein Klasse Werk mit Python ist3.6 und verwenden die nonlocal Schlüsselwort, um zum Bereich hinzufügen /Kontext der Klasse wird wie folgt erstellt:

>>> def SomeFactory(some_var=None):
...     class SomeClass(object):
...         nonlocal some_var
...         def print():
...             print(some_var)
...     return SomeClass
... 
>>> SomeFactory(some_var="hello world").print()
hello world

InformationsquelleAutor jmunsch