En Python comment puis-je utiliser une méthode de classe, sans passer par une instance?

Donc, j'ai un module commun qui contient des fonctions de traitement pour les nombres et les types de données que j'utilise. Je veux être en mesure de l'inclure comme from common import common (ou encore mieux,import common) et d'utiliser des fonctions comme common.howLongAgo(unixTimeStamp)

Ce qui est nécessaire pour ce faire, dans mon module commun?. Commune est un module composé d'une classe "ordinaire".

Pourquoi ces fonctions sur une classe à la première place? Si ils n'ont pas besoin self, pourquoi ne pas mettre à la portée de module?
Pour les faire sortir de mon principal fichier python
Pour ce faire, vous n'avez pas besoin de les mettre dans une classe. Il suffit de déplacer un module et de les laisser au niveau du module.

OriginalL'auteur Supernovah | 2012-03-29

  1. 29

    Façons d'exposer des méthodes dans un module python:

    module 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"

    maintenant, l'importation:

    >>> 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'

    Si vous voulez faire de la méthode de classe de plus utile, de l'importation de la classe:

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

    Vous pouvez également import ... as ... pour le rendre plus lisible:

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

    Ceux que vous devriez utiliser est un peu une question de goût. Ma règle personnelle de base est:

    • Utilitaire Simple des fonctions qui agissent généralement sur des choses comme les collections, ou d'effectuer de calcul, ou d'aller chercher de la ressource doit être le module de méthodes
    • Fonctions liées à une classe, mais qui ne nécessitent pas une classe ou une instance doit être statique méthodes
    • Les fonctions qui sont liées à une classe, et auront besoin de la classe à des fins de comparaison, ou à l'accès variable de classe devraient être les méthodes de la classe.
    • Fonctions qui agissent sur une instance devrait être la méthode d'instance.
    Est-il fréquent code de pratique pour avoir les méthodes exposées à la portée de module de ce genre? Quel que soit - il a travaillé donc merci.
    La décoration de votre les méthodes de la classe avec @classmethod est beaucoup plus propre
    C'est assez commun. La bibliothèque standard a quelques exemples. le os module de l'être.
    Je préfère utiliser @staticmethod je vais modifier. Afin de refléter les trois options.
    Je pense que staticmethod est rarement utile en Python. Il ne peut pas accéder à une classe, ni une instance, alors pourquoi est-ce la méthode dans une classe? Je sais qu'il existe des cas d'utilisation, mais ils sont assez exceptionnelles.

    OriginalL'auteur brice

  2. 2

    si vous avez le module common.py et la fonction est dans la classe commune

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

    alors vous devez changer votre méthode à méthode statique de pentecôte décorateur @staticmethod

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

    De cette façon, vous n'avez pas besoin de changer toute la classe, et vous pouvez toujours utiliser l'auto.howLongAgo dans la classe

    OriginalL'auteur Luka Rahne

  3. -1
    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

    Ci-dessus est la façon habituelle de faire classmethods en utilisant des objets Python, pas le vieux-classes de style.

    Alternativement, vous pourriez dire un staticmethod:

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

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

    Utilisez celui qui fait plus de sens pour vous, pour votre problème. Staticmethods doit généralement être séparés dans leur propre fonctionnalité, l'utilisation d'une classe est superflu.

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

    Oui mais le problème c'est qu'en faisant test = Test() vous êtes la création d'une instance. C'est ce que je veux éviter.

    OriginalL'auteur Chris Allen