Was ist der Zweck der inneren Klassen von Python?

Gibt es etwas, das kann nicht erreicht werden ohne Sie?

Nicht. Sie sind absolut äquivalent zu der Definition der Klasse, die normalerweise auf der obersten Ebene, und dann kopieren einer Referenz in der äußeren Klasse.

Ich glaube nicht, dass es einen speziellen Grund, verschachtelte Klassen "erlaubt", außer es macht keinen besonderen Sinn, explizit "verbieten".

Wenn Sie sich für eine Klasse, besteht innerhalb des Lebenszyklus von außen/von der Eigentümer-Objekt und hat immer eine Referenz auf eine Instanz der äußeren Klasse innere Klassen, wie Java funktioniert es – dann-Python-geschachtelte Klassen sind nicht das Ding. Aber Sie hacken kann, etwas wie das Ding:

import weakref, new

class innerclass(object):
    """Descriptor for making inner classes.

    Adds a property 'owner' to the inner class, pointing to the outer
    owner instance.
    """

    # Use a weakref dict to memoise previous results so that
    # instance.Inner() always returns the same inner classobj.
    #
    def __init__(self, inner):
        self.inner= inner
        self.instances= weakref.WeakKeyDictionary()

    # Not thread-safe - consider adding a lock.
    #
    def __get__(self, instance, _):
        if instance is None:
            return self.inner
        if instance not in self.instances:
            self.instances[instance]= new.classobj(
                self.inner.__name__, (self.inner,), {'owner': instance}
            )
        return self.instances[instance]


# Using an inner class
#
class Outer(object):
    @innerclass
    class Inner(object):
        def __repr__(self):
            return '<%s.%s inner object of %r>' % (
                self.owner.__class__.__name__,
                self.__class__.__name__,
                self.owner
            )

>>> o1= Outer()
>>> o2= Outer()
>>> i1= o1.Inner()
>>> i1
<Outer.Inner inner object of <__main__.Outer object at 0x7fb2cd62de90>>
>>> isinstance(i1, Outer.Inner)
True
>>> isinstance(i1, o1.Inner)
True
>>> isinstance(i1, o2.Inner)
False

(Diese verwendet die Klasse Dekorateure, die neues in Python 2.6 und 3.0. Sonst müsste man sagen "Innen= innerclass(Innen)" nach der definition der Klasse.)

InformationsquelleAutor der Antwort

Verschachteln von Klassen innerhalb von Klassen:

• Geschachtelte Klassen aufblasen der definition der Klasse, was es immer schwieriger macht, um zu sehen, was Los ist.

• Geschachtelte Klassen erstellen können, die Kupplung, das würde die Prüfung zu erschweren.

• In Python können Sie mehr als eine Klasse in einer Datei/module, im Gegensatz zu Java, so dass die Klasse bleibt noch immer die Nähe der top-level-Klasse und konnte sogar den Namen der Klasse mit dem Präfix "_" zu helfen, bestätigen, dass Sie das andere nicht benutzen sollte.

Den Ort, wo geschachtelte Klassen können als nützlich erweisen, ist innerhalb der Funktionen

def some_func(a, b, c):
   class SomeClass(a):
      def some_method(self):
         return b
   SomeClass.__doc__ = c
   return SomeClass

Die Klasse erfasst die Werte der Funktion können Sie dynamisch erstellen Sie eine Klasse wie template metaprogramming in C++

InformationsquelleAutor der Antwort

Den Haupt-use-case-ich benutze diese für die Verhinderung der proliferation von kleinen Modulen und zu verhindern namespace-Verschmutzung, wenn einzelne Module nicht benötigt werden. Wenn ich die Erweiterung einer vorhandenen Klasse, aber, dass die bestehenden Klassen müssen auf eine andere Unterklasse, die sollte immer gekoppelt werden. Zum Beispiel, kann ich einen utils.py Modul, das hat viele Helfer-Klassen, die nicht notwendigerweise miteinander gekoppelt, aber ich verstärken wollen Kupplung für einige diese helper-Klassen. Zum Beispiel, wenn ich implementieren https://stackoverflow.com/a/8274307/2718295

:utils.py:

import json, decimal

class Helper1(object):
    pass

class Helper2(object):
    pass

# Here is the notorious JSONEncoder extension to serialize Decimals to JSON floats
class DecimalJSONEncoder(json.JSONEncoder):

    class _repr_decimal(float): # Because float.__repr__ cannot be monkey patched
        def __init__(self, obj):
            self._obj = obj
        def __repr__(self):
            return '{:f}'.format(self._obj)

    def default(self, obj): # override JSONEncoder.default
        if isinstance(obj, decimal.Decimal):
            return self._repr_decimal(obj)
        # else
        super(self.__class__, self).default(obj)
        # could also have inherited from object and used return json.JSONEncoder.default(self, obj) 

Dann können wir:

>>> from utils import DecimalJSONEncoder
>>> import json, decimal
>>> json.dumps({'key1': decimal.Decimal('1.12345678901234'), 
... 'key2':'strKey2Value'}, cls=DecimalJSONEncoder)
{"key2": "key2_value", "key_1": 1.12345678901234}

Natürlich, wir hätten vermied Erben json.JSONEnocder insgesamt und nur überschreiben (default):

:

import decimal, json

class Helper1(object):
    pass

def json_encoder_decimal(obj):
    class _repr_decimal(float):
        ...

    if isinstance(obj, decimal.Decimal):
        return _repr_decimal(obj)

    return json.JSONEncoder(obj)


>>> json.dumps({'key1': decimal.Decimal('1.12345678901234')}, default=json_decimal_encoder)
'{"key1": 1.12345678901234}'

Manchmal aber auch nur für die convention, die Sie wollen utils aus Klassen für die Erweiterbarkeit.

Hier ist ein anderer Anwendungsfall: ich möchte eine Fabrik für mutables in meinem OuterClass zimmerreserviereung, ohne das Sie aufrufen copy:

class OuterClass(object):

    class DTemplate(dict):
        def __init__(self):
            self.update({'key1': [1,2,3],
                'key2': {'subkey': [4,5,6]})


    def __init__(self):
        self.outerclass_dict = {
            'outerkey1': self.DTemplate(),
            'outerkey2': self.DTemplate()}



obj = OuterClass()
obj.outerclass_dict['outerkey1']['key2']['subkey'].append(4)
assert obj.outerclass_dict['outerkey2']['key2']['subkey'] == [4,5,6]

Ziehe ich diese Muster über die @staticmethod Dekorateur, die Sie sonst verwenden würde für eine factory-Funktion.

InformationsquelleAutor der Antwort