Python: Erstellen einer Klasseninstanz ohne Aufruf des Initialisierers

Gibt es eine Möglichkeit, zu vermeiden, fordern __init__ auf eine Klasse während der Initialisierung ist es, wie aus einer Methode der Klasse?

Ich versuche ein Gehäuse zu konstruieren und Satzzeichen, Kleinschreibung string-Klasse in Python zur effizienten Vergleich Zwecke, aber ich habe Probleme bei der Erstellung einer neuen Instanz ohne Aufruf __init__.

>>> class String:

    def __init__(self, string):
        self.__string = tuple(string.split())
        self.__simple = tuple(self.__simple())

    def __simple(self):
        letter = lambda s: ''.join(filter(lambda s: 'a' <= s <= 'z', s))
        return filter(bool, map(letter, map(str.lower, self.__string)))

    def __eq__(self, other):
        assert isinstance(other, String)
        return self.__simple == other.__simple

    def __getitem__(self, key):
        assert isinstance(key, slice)
        string = String()
        string.__string = self.__string[key]
        string.__simple = self.__simple[key]
        return string

    def __iter__(self):
        return iter(self.__string)

>>> String('Hello, world!')[1:]
Traceback (most recent call last):
  File "<pyshell#2>", line 1, in <module>
    String('Hello, world!')[1:]
  File "<pyshell#1>", line 17, in __getitem__
    string = String()
TypeError: __init__() takes exactly 2 positional arguments (1 given)
>>>

Was sollte ich ersetzen string = String(); string.__string = self.__string[key]; string.__simple = self.__simple[key] mit initialisiert das neue Objekt mit den Scheiben?

EDIT:

Als inspiriert durch die Antwort unten geschrieben, die Initialisierung der bearbeitet wurde, um schnell zu überprüfen, für die keine Argumente.

def __init__(self, string=None):
    if string is None:
        self.__string = self.__simple = ()
    else:
        self.__string = tuple(string.split())
        self.__simple = tuple(self.__simple())

InformationsquelleAutor der Frage Noctis Skytower | 2010-01-30

24

Wenn möglich, lassen __init__ aufgerufen (und tätigen Sie den Anruf ganz harmlos durch die passenden Argumente) vorzuziehen ist. Allerdings sollte das zu viel verlangt von einer Verdrehung, haben Sie eine alternative, so lange wie Sie vermeiden, die katastrophale Wahl, old-style-Klassen, (es gibt keine guten Grund für die Verwendung von old-style-Klassen in den neuen code, und mehrere gute Gründe nicht)...:
```
   class String(object):
      ...

   bare_s = String.__new__(String)
```
Dieses idiom ist allgemein in classmethods, die gemeint sind, um Arbeit als "alternative Konstruktoren", so werden Sie in der Regel finden Sie es in einer Weise, wie...:
```
@classmethod 
def makeit(cls):
    self = cls.__new__(cls)
    # etc etc, then
    return self
```
(auf diese Weise die classmethod werden richtig vererbt werden und erzeugen Unterklasse-Instanzen aufgerufen, wenn auf eine Unterklasse, anstatt sich auf die Basis-Klasse).

InformationsquelleAutor der Antwort Alex Martelli

Einen trick, die standard Gurke und kopieren Sie Module verwenden, ist eine leere Klasse erstellen, instanziieren Sie das Objekt verwenden, und weisen Sie dann diese Instanz ist __class__ zu den "echten" Klasse. z.B.

>>> class MyClass(object):
...     init = False
...     def __init__(self):
...         print 'init called!'
...         self.init = True
...     def hello(self):
...         print 'hello world!'
... 
>>> class Empty(object):
...     pass
... 
>>> a = MyClass()
init called!
>>> a.hello()
hello world!
>>> print a.init
True
>>> b = Empty()
>>> b.__class__ = MyClass
>>> b.hello()
hello world!
>>> print b.init
False

Aber beachten Sie, dieser Ansatz ist sehr selten notwendig. Unter Umgehung der __init__ kann einige unerwartete Nebenwirkungen, besonders wenn Sie nicht vertraut mit der ursprünglichen Klasse, so stellen Sie sicher, Sie wissen, was Sie tun.

InformationsquelleAutor der Antwort Cerin

Mithilfe einer Metaklasse bietet eine schöne Lösung in diesem Beispiel. Die Metaklasse hat begrenzte Nutzung, aber funktioniert gut.

>>> class MetaInit(type):

    def __call__(cls, *args, **kwargs):
        if args or kwargs:
            return super().__call__(*args, **kwargs)
        return cls.__new__(cls)

>>> class String(metaclass=MetaInit):

    def __init__(self, string):
        self.__string = tuple(string.split())
        self.__simple = tuple(self.__simple())

    def __simple(self):
        letter = lambda s: ''.join(filter(lambda s: 'a' <= s <= 'z', s))
        return filter(bool, map(letter, map(str.lower, self.__string)))

    def __eq__(self, other):
        assert isinstance(other, String)
        return self.__simple == other.__simple

    def __getitem__(self, key):
        assert isinstance(key, slice)
        string = String()
        string.__string = self.__string[key]
        string.__simple = self.__simple[key]
        return string

    def __iter__(self):
        return iter(self.__string)

>>> String('Hello, world!')[1:]
<__main__.String object at 0x02E78830>
>>> _._String__string, _._String__simple
(('world!',), ('world',))
>>>

InformationsquelleAutor der Antwort Noctis Skytower

Pass ein weiteres argument für den Konstruktor, wie folgt:

def __init__(self, string, simple = None):
    if simple is None:
        self.__string = tuple(string.split())
        self.__simple = tuple(self.__simple())
    else:
        self.__string = string
        self.__simple = simple

Dann können Sie es so nennen:

def __getitem__(self, key):
    assert isinstance(key, slice)
    return String(self.__string[key], self.__simple[key])

Auch, ich bin nicht sicher, es ist möglich das der name das Feld, und die Methode __simple. Wenn nur zur besseren Lesbarkeit sollten Sie das ändern.

InformationsquelleAutor der Antwort Thomas

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.