Ich bin in Python auf einen ungebundenen Methodenfehler mit dem Code gestoßen

import random

class Sample(object):
'''This class defines various methods related to the sample'''

    def drawSample(samplesize,List):
        sample=random.sample(List,samplesize)
        return sample

Choices=range(100)
print Sample.drawSample(5,Choices)

Nachdem ich hier viele hilfreiche Beiträge gelesen hatte, überlegte ich, wie ich @staticmethodoben hinzufügen könnte , damit der Code funktioniert. Ich bin ein Python-Neuling. Kann jemand bitte erklären, warum man statische Methoden definieren möchte? Oder warum sind nicht alle Methoden als statische Methoden definiert?

Statische Methoden können nur eingeschränkt verwendet werden, da sie keinen Zugriff auf die Attribute einer Instanz einer Klasse haben (wie dies bei einer regulären Methode der Fall ist) und keinen Zugriff auf die Attribute der Klasse selbst haben (wie dies bei einer Klassenmethode der Fall ist) ).

Daher sind sie für alltägliche Methoden nicht nützlich.

Sie können jedoch nützlich sein, um einige Dienstprogrammfunktionen zusammen mit einer Klasse zu gruppieren - z. B. eine einfache Konvertierung von einem Typ in einen anderen -, für die außer den angegebenen Parametern (und möglicherweise einigen für das Modul globalen Attributen) kein Zugriff auf Informationen erforderlich ist. )

Sie könnten außerhalb der Klasse platziert werden, aber eine Gruppierung innerhalb der Klasse kann sinnvoll sein, wenn sie nur dort anwendbar sind.

Sie können die Methode auch über eine Instanz oder die Klasse anstatt über den Modulnamen referenzieren, um dem Leser zu helfen, zu verstehen, auf welche Instanz die Methode bezogen ist.

Ausführliche Erläuterungen finden Sie in diesem Artikel .

TL; DR

1. Es beseitigt die Verwendung von selfArgumenten.

2. Es reduziert die Speichernutzung, da Python nicht für jedes instanziierte Objekt eine gebundene Methode instanziieren muss:

>>>RandomClass().regular_method is RandomClass().regular_method
False
>>>RandomClass().static_method is RandomClass().static_method
True
>>>RandomClass.static_method is RandomClass().static_method
True

3. Es verbessert die Lesbarkeit des Codes und bedeutet, dass die Methode nicht vom Status des Objekts selbst abhängt.

4. Es ermöglicht das Überschreiben von Methoden, da eine Unterklasse diese Methode nicht überschreiben könnte, wenn die Methode auf Modulebene (dh außerhalb der Klasse) definiert würde.

Dies ist nicht ganz der Punkt Ihrer eigentlichen Frage, aber da Sie gesagt haben, dass Sie ein Python-Neuling sind, wird es vielleicht hilfreich sein, und niemand anderes ist ganz herausgekommen und hat es explizit gesagt.

Ich hätte den obigen Code niemals repariert, indem ich die Methode zu einer statischen Methode gemacht hätte. Ich hätte entweder die Klasse verlassen und nur eine Funktion geschrieben:

def drawSample(samplesize,List):
    sample=random.sample(List,samplesize)
    return sample

Choices=range(100)
print drawSample(5,Choices)

Wenn Sie viele verwandte Funktionen haben, können Sie diese in einem Modul gruppieren, dh alle in derselben Datei ablegen, die sample.pybeispielsweise benannt ist. dann

import sample

Choices=range(100)
print sample.drawSample(5,Choices)

Oder ich hätte __init__der Klasse eine Methode hinzugefügt und eine Instanz mit nützlichen Methoden erstellt:

class Sample(object):
'''This class defines various methods related to the sample'''

    def __init__(self, thelist):
        self.list = thelist

    def draw_sample(self, samplesize):
        sample=random.sample(self.list,samplesize)
        return sample

choices=Sample(range(100))
print choices.draw_sample(5)

(Ich habe auch die Fallkonventionen im obigen Beispiel geändert, um sie an den von PEP 8 empfohlenen Stil anzupassen.)

Einer der Vorteile von Python ist, dass Sie nicht gezwungen werden, Klassen für alles zu verwenden. Sie können sie nur verwenden, wenn Daten oder Status vorhanden sind, die den Methoden zugeordnet werden sollen. Dafür sind Klassen vorgesehen. Andernfalls können Sie Funktionen verwenden, für die Funktionen vorgesehen sind.

Warum sollte man statische Methoden definieren wollen ?

Angenommen , wir haben ein classgenannt Mathdann

Niemand wird ein Objekt erstellen class Math
und dann Methoden wie ceilund floorund darauf aufrufen fabswollen.

Also machen wir sie static.

Zum Beispiel tun

>> Math.floor(3.14)

ist viel besser als

>> mymath = Math()
>> mymath.floor(3.14)

Sie sind also irgendwie nützlich. Sie müssen keine Instanz einer Klasse erstellen, um sie zu verwenden.

Warum sind nicht alle Methoden als statische Methoden definiert? ?

Sie haben keinen Zugriff auf Instanzvariablen.

class Foo(object):
    def __init__(self):
        self.bar = 'bar'

    def too(self):
        print self.bar

    @staticmethod
    def foo():
        print self.bar

Foo().too() # works
Foo.foo() # doesn't work

Deshalb machen wir nicht alle Methoden statisch.

Wenn Sie ein Funktionsobjekt von einer Objektinstanz aus aufrufen, wird es zu einer gebundenen Methode und das Instanzobjekt selbst wird als erstes Argument übergeben.

Wenn Sie ein classmethodObjekt (das ein Funktionsobjekt umschließt) für eine Objektinstanz aufrufen , wird die Klasse des Instanzobjekts als erstes Argument übergeben.

Wenn Sie ein staticmethodObjekt aufrufen (das ein Funktionsobjekt umschließt), wird kein implizites erstes Argument verwendet.

class Foo(object):

    def bar(*args):
        print args

    @classmethod
    def baaz(*args):
        print args

    @staticmethod
    def quux(*args):
        print args

>>> foo = Foo()

>>> Foo.bar(1,2,3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unbound method bar() must be called with Foo instance as first argument (got int instance instead)
>>> Foo.baaz(1,2,3)
(<class 'Foo'>, 1, 2, 3)
>>> Foo.quux(1,2,3)
(1, 2, 3)

>>> foo.bar(1,2,3)
(<Foo object at 0x1004a4510>, 1, 2, 3)
>>> foo.baaz(1,2,3)
(<class 'Foo'>, 1, 2, 3)
>>> foo.quux(1,2,3)
(1, 2, 3)

statische Methoden sind großartig, da Sie keine Instanz des Objekts deklarieren müssen, zu dem die Methode gehört.

Auf der Python-Website finden Sie eine hervorragende Dokumentation zu statischen Methoden:
http://docs.python.org/library/functions.html#staticmethod

Die Alternativen zu a staticmethodsind: classmethod, instancemethod, und function. Wenn Sie nicht wissen, um was es sich handelt, scrollen Sie zum letzten Abschnitt. Ob a staticmethodbesser ist als eine dieser Alternativen, hängt davon ab, zu welchem ​​Zweck es geschrieben wurde.

Vorteile der statischen Python-Methode

• Wenn Sie keinen Zugriff auf die Attribute oder Methoden der Klasse oder Instanz benötigen, staticmethodist a besser als a classmethododer instancemethod. Auf diese Weise wird (vom @staticmethodDekorateur) klar, dass der Status der Klasse und der Instanz nicht gelesen oder geändert wird. Die Verwendung von a functionmacht diese Unterscheidung jedoch noch deutlicher (siehe Nachteile).
• Die Rufsignatur von a staticmethodist die gleiche wie die von a classmethododer instancemethod, nämlich <instance>.<method>(<arguments>). Daher kann es leicht durch eines der drei ersetzt werden, wenn dies später oder in einer abgeleiteten Klasse benötigt wird. Mit einem einfachen kann man das nicht machen function.
• A staticmethodkann anstelle von a verwendet werden function, um zu verdeutlichen, dass es subjektiv zu einer Klasse gehört, und um Namespace-Konflikte zu vermeiden.

Nachteile der statischen Python-Methode

• Es kann nicht auf Attribute oder Methoden der Instanz oder Klasse zugreifen.
• Die Rufsignatur von a staticmethodist die gleiche wie die von a classmethododer instancemethod. Dies maskiert die Tatsache, dass das staticmethodObjekt keine Objektinformationen liest oder ändert. Dies erschwert das Lesen von Code. Warum nicht einfach ein verwenden function?
• A staticmethodist schwer wiederzuverwenden, wenn Sie es jemals von außerhalb der Klasse / Instanz aufrufen müssen, in der es definiert wurde. Wenn die Möglichkeit einer Wiederverwendung besteht, functionist a die bessere Wahl.
• Das staticmethodwird selten verwendet, daher kann es etwas länger dauern, bis Benutzer Code lesen, der einen enthält.

Alternativen zu einer statischen Methode in Python

Um die Vorteile der zu diskutieren staticmethod, müssen wir wissen, welche Alternativen es gibt und wie sie sich voneinander unterscheiden.

• Der staticmethodgehört zu einer Klasse, kann jedoch nicht auf Instanz- oder Klasseninformationen zugreifen oder diese ändern.

Es gibt drei Alternativen dazu:

• Der classmethodhat Zugriff auf die Klasse des Anrufers.
• Der instancemethodhat Zugriff auf die Instanz des Aufrufers und seine Klasse.
• Das functionhat nichts mit Unterricht zu tun. Es ist der Fähigkeit am nächsten staticmethod.

So sieht das im Code aus:

# function
# has nothing to do with a class
def make_cat_noise(asker_name):
    print('Hi %s, mieets mieets!' % asker_name)

# Yey, we can make cat noises before we've even defined what a cat is!
make_cat_noise('JOey')  # just a function

class Cat:
    number_of_legs = 4

    # special instance method __init__
    def __init__(self, name):
        self.name = name

    # instancemethod
    # the instance (e.g. Cat('Kitty')) is passed as the first method argument
    def tell_me_about_this_animal(self, asker_name):
        print('Hi %s, This cat has %d legs and is called %s'
              % (asker_name, self.number_of_legs, self.name))

    # classmethod
    # the class (e.g. Cat) is passed as the first method argument
    # by convention we call that argument cls
    @classmethod
    def tell_me_about_cats(cls, asker_name):
        print("Hi %s, cats have %d legs."
              % (asker_name, cls.number_of_legs))
        # cls.name  # AttributeError because only the instance has .name
        # self.name  # NameError because self isn't defined in this namespace

    # staticmethod
    # no information about the class or the instance is passed to the method
    @staticmethod
    def make_noise(asker_name):
        print('Hi %s, meooow!' % asker_name)
        # class and instance are not accessible from here

# one more time for fun!
make_cat_noise('JOey')  # just a function

# We just need the class to call a classmethod or staticmethod:
Cat.make_noise('JOey')  # staticmethod
Cat.tell_me_about_cats('JOey')  # classmethod
# Cat.tell_me_about_this_animal('JOey')  # instancemethod -> TypeError

# With an instance we can use instancemethod, classmethod or staticmethod
mycat = Cat('Kitty')  # mycat is an instance of the class Cat
mycat.make_noise('JOey')  # staticmethod
mycat.tell_me_about_cats('JOey')  # classmethod
mycat.tell_me_about_this_animal('JOey')  # instancemethod

Weil Namespace-Funktionen nett sind (wie bereits erwähnt):

1. Wenn ich explizit auf Methoden eingehen möchte, die den Status des Objekts nicht ändern, verwende ich statische Methoden. Dies entmutigt die Mitarbeiter meines Teams, die Attribute des Objekts in diesen Methoden zu ändern.

2. Wenn ich wirklich faulen Code umgestalte, versuche ich zunächst, so viele Methoden @staticmethodwie möglich zu erstellen . Dadurch kann ich diese Methoden dann in eine Klasse extrahieren - obwohl ich damit einverstanden bin, ist dies selten etwas, das ich verwende, es hat sich jedoch einige Male als hilfreich erwiesen.

Nach meiner Einschätzung gibt es keinen einzigen Leistungsvorteil der Verwendung von @staticmethods im Vergleich zur Definition der Funktion außerhalb und getrennt von der Klasse, von der es sonst wäre @staticmethod.

Das einzige, was ich sagen würde, um ihre Existenz zu rechtfertigen, ist Bequemlichkeit. Statische Methoden sind in anderen gängigen Programmiersprachen üblich. Warum also nicht Python? Wenn Sie eine Funktion mit einem Verhalten erstellen möchten, das sehr eng mit der Klasse verknüpft ist, für die Sie sie erstellen, aber nicht auf die internen Daten einer Instanz der Klasse zugreifen / diese ändern, so dass die Konzeptualisierung als typisch gerechtfertigt ist Methode dieser Klasse schlagen @staticmethodSie dann ein darüber und jeder, der Ihren Code liest, wird sofort viel über die Natur der Methode und ihre Beziehung zur Klasse lernen.

Eine Sache, die ich gelegentlich gerne mache, ist das Platzieren von Funktionen, die meine Klasse intern häufig verwendet, in privaten @staticmethods. Auf diese Weise überfalle ich die von meinem Modul bereitgestellte API nicht mit Methoden, die niemand, der mein Modul verwendet, jemals sehen müsste, geschweige denn verwenden würde.

Statische Methoden haben in Python fast keinen Grund. Sie verwenden entweder Instanzmethoden oder Klassenmethoden.

def method(self, args):
    self.member = something

@classmethod
def method(cls, args):
    cls.member = something

@staticmethod
def method(args):
    MyClass.member = something
    # The above isn't really working
    # if you have a subclass