Wie kann ich in Python eine Klassenmethode verwenden, ohne ihr eine Instanz zu übergeben?

Question

Ich habe also ein gemeinsames Modul, das Verarbeitungsfunktionen für Zahlen und Datentypen enthält, die ich verwende. Ich möchte es einbinden können wie from common import common (oder besser noch einfach import common ) und verwenden Funktionen wie common.howLongAgo(unixTimeStamp)

Was ist erforderlich, um dies in meinem gemeinsamen Modul zu tun? Common ist ein Modul, das aus einer Klasse 'common' besteht.

Answer 1

Möglichkeiten der Offenlegung von Methoden in einem Python-Modul:

Modul foo.py :

def module_method():
    return "I am a module method"

class ModClass:
     @staticmethod
     def static_method():
         # the static method gets passed nothing
         return "I am a static method"
     @classmethod
     def class_method(cls):
         # the class method gets passed the class (in this case ModCLass)
         return "I am a class method"
     def instance_method(self):
         # An instance method gets passed the instance of ModClass
         return "I am an instance method"

jetzt, die Einfuhr:

>>> import foo
>>> foo.module_method()
'I am a module method'
>>> foo.ModClass.static_method()
'I am a static method'
>>> foo.ModClass.class_method()
'I am a class method'
>>> instance = ModClass()
>>> instance.instance_method()
'I am an instance method'

Wenn Sie eine Klassenmethode nützlicher machen wollen, importieren Sie die Klasse direkt:

>>> from foo import ModClass
>>> ModClass.class_method()
'I am a class method'

Sie können auch import ... as ... um sie besser lesbar zu machen:

>>> from foo import ModClass as Foo
>>> Foo.class_method()
'I am a class method'

Welche Sie verwenden sollten, ist eine Frage des Geschmacks. Meine persönliche Faustregel lautet:

• Einfache Utility-Funktionen, die im Allgemeinen auf Dinge wie Sammlungen einwirken, Berechnungen durchführen oder Ressourcen abrufen, sollten Modulmethoden sein.
• Funktionen, die sich auf eine Klasse beziehen, aber weder eine Klasse noch eine Instanz benötigen, sollten statische Methoden sein.
• Funktionen, die sich auf eine Klasse beziehen und die Klasse zum Vergleich oder zum Zugriff auf Klassenvariablen benötigen, sollten Klassenmethoden sein.
• Funktionen, die auf eine Instanz wirken, sollten Instanzmethoden sein.

Answer 2

Wenn Sie das Modul common.py haben und die Funktion in der Klasse common ist

class common(object):
    def howLongAgo(self,timestamp):
          some_code

dann sollten Sie Ihre Methode in eine statische Methode mit dem Dekorator @staticmethod ändern

class common(object):
    @staticmethod
    def howLongAgo(timestamp): # self goes out
          some_code

Auf diese Weise müssen Sie nicht die gesamte Klasse ändern und können self.howLongAgo weiterhin in der Klasse verwenden

Answer 3

class Test(object):
    @classmethod
    def class_method(cls):
        return "class method"

test = Test()
print test.class_method()

[callen@odin scar]$ python ~/test.py
class method

Dies ist die Standardmethode für Klassenmethoden mit modernen Python-Objekten, nicht mit den Klassen im alten Stil.

Alternativ könnten Sie auch eine statische Methode meinen:

class Test(object):
    @staticmethod
    def static_method():
        return "static method"

test = Test()
print test.static_method()
[callen@odin scar]$ python ~/test.py
static method

Verwenden Sie das, was für Ihr Problem am sinnvollsten ist. Statische Methoden sollten in der Regel in eine eigene unabhängige Funktionalität ausgegliedert werden, die Verwendung einer Klasse ist hier überflüssig.

Vgl. http://pyvideo.org/video/880/stop-writing-classes