Den Aufruf nicht-statische Methode aus statischer man in Python

Kann ich nicht finden, ob es möglich ist, rufen Sie eine nicht-statische Methode aus einer statischen eine in Python.

Dank

BEARBEITEN:
Ok. Und was ist mit static von static? Kann ich dies tun:

class MyClass(object):

    @staticmethod
    def static_method_one(cmd):
    ...

    @staticmethod
    def static_method_two(cmd):
        static_method_one(cmd)

Sicherlich kann man aufrufen einer statischen Methode von einer anderen. Ich meine, Sie müssen ,wenn Sie nicht anrufen können, nicht statisch von einem statischen.

InformationsquelleAutor legesh | 2009-09-06

oop python

Es ist durchaus möglich, aber nicht sehr aussagekräftig. Denken Sie über die folgende Klasse:

class MyClass:
    # Normal method:
    def normal_method(self, data):
        print "Normal method called with instance %s and data %s" % (self, data)

    @classmethod
    def class_method(cls, data):
        print "Class method called with class %s and data %s" % (cls, data)

    @staticmethod
    def static_method(data):
        print "Static method called with data %s" % (data)

Offensichtlich, wir nennen dies in der erwarteten Weise:

>>> instance = MyClass()
>>> instance.normal_method("Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

>>> instance.class_method("Success!")
Class method called with class __main__.MyClass and data Success!

>>> instance.static_method("Success!")
Static method called with data Success!

Aber auch dies:

>>> MyClass.normal_method(instance, "Success!")
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data Success!

Die syntax instance.normal_method() ist ziemlich einfach nur eine "Abkürzung" für MyClass.normal_method(instance). Das ist, warum gibt es diese "self" - parameter in Methoden, der pass selbst. Der name selbst ist nicht magisch, Sie können es nennen, was Sie wollen.

Den gleichen trick ist gut möglich, von innerhalb einer statischen Methode. Sie können rufen Sie die normale Methode mit einer Instanz als ersten parameter, etwa so:

    @staticmethod
    def a_cool_static_method(instance, data):
        print "Cool method called with instance %s and data %s" % (instance, data)
        MyClass.normal_method(instance, data)
        MyClass.class_method(data)
        MyClass.static_method(data)

>>> instance.a_cool_static_method(instance, "So Cool!")
Cool method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Normal method called with instance <__main__.MyClass instance at 0xb7d26bcc> and data So Cool!
Class method called with class __main__.MyClass and data So Cool!
Static method called with data So Cool!

Also die Antwort ist ja, man kann cal nicht-statische Methoden aus statischen Methoden. Aber nur, wenn du passieren kann in einer Instanz als ersten parameter. So haben Sie entweder zu generieren, die es aus dem inneren der statischen Methode (und in diesem Fall sind Sie wahrscheinlich besser dran mit einem Klasse-Methode), oder übergeben Sie es in. Aber wenn Sie pass in die Instanz, Sie können in der Regel nur machen es zu einem normalen Verfahren.

So können Sie, aber es ist ziemlich sinnlos.

Und dann stellt sich die Frage: Warum wollen Sie das?

InformationsquelleAutor Lennart Regebro

6

Nachdem die anderen Antworten und Ihr follow-up-Frage - bezüglich statische Methode aus statischer Methode: ja, Sie können:
```
>>> class MyClass(object):
    @staticmethod
    def static_method_one(x):
        return MyClass.static_method_two(x)
    @staticmethod
    def static_method_two(x):
        return 2 * x


>>> MyClass.static_method_one(5)
10
```
Und falls du neugierig bist, ja auch für die Methode der Klasse aus der class-Methode (leicht zu testen, das Zeug in die Dolmetscher - all das Ausschneiden und einfügen von Leerlauf in 2.5.2) [**EDITED to make correction in usage pointed out by others**]:
```
>>> class MyClass2(object):
    @classmethod
    def class_method_one(cls, x):
        return cls.class_method_two(x)
    @classmethod
    def class_method_two(cls, x):
        return 2 * x


>>> MyClass2.class_method_one(5)
10
```
- Zweites Beispiel nennen soll cls.class_method_two(x); das zeigt auch, warum der OP verwenden sollte classmethod, nicht staticmethod.
- Hängt davon ab, was Sie tun wollen. Wenn Sie übergeben möchten, in die richtige Unterklasse, dann eine Methode der Klasse angemessen ist. Wenn Sie immer verwenden möchten MyClass dann gibt es wenig Sinn, im Vorbeigehen in der Unterklasse (als classmethod würde).
InformationsquelleAutor Anon

Verwenden Sie Klassen-Methoden, nicht statischen Methoden. Warum sonst legte es in eine Klasse?

class MyClass(object):

    @classmethod
    def static_method_one(cls, cmd):
    ...

    @classmethod
    def static_method_two(cls, cmd):
        cls.static_method_one(cmd)

Kapselung ?

InformationsquelleAutor u0b34a0f6ae

2

Wenn in einer statischen Methode, die Sie nicht haben, eine selbst-Instanz: das, was Objekt werden Sie den Aufruf der nicht-statischen Methoden? Sicherlich, wenn Sie eine Instanz haben, die herumliegen, können Sie rufen Sie die Methoden auf.
- Ned Batchelder@ Was über den Aufruf von static von static? Was ist die syntax? Ich habe "NameError: global name 'my_static_method' ist nicht definiert" so weit.
- Gleiche syntax wie alle anderen Methoden: object_or_class.Methode(Parameter)
InformationsquelleAutor Ned Batchelder
0

Es ist nicht möglich withotut die Instanz der Klasse. Man könnte hinzufügen, ein param Ihrer Methode f(x, y, ..., me) und verwenden me als Objekt zum Aufruf der nicht-statischen Methoden.
- Es ist möglich,. Lesen Sie die oben genannten Antworten. Nur nicht einfach zu tun, aber Sie können es tun . MyClass.normal_method(Instanz-Daten)
InformationsquelleAutor Marcel Jackwerth

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.