Qu'est-ce qu'un exemple d'utilisation pour une méthode de classe Python?

Question

J'ai lu Quelles sont les méthodes de classe en Python? mais les exemples de ce post sont complexes. Je recherche un exemple clair, simple et simple d'un cas d'utilisation particulier pour les méthodes de classe en Python.

Pouvez-vous nommer un petit exemple d'utilisation spécifique dans lequel une méthode de classe Python serait le bon outil pour le travail?

Answer 1

méthodes d'assistance pour l'initialisation

 class MyStream(object):

    @classmethod
    def from_file(cls, filepath, ignore_comments=False,):

        with open(filepath, 'r') as fileobj:
            for obj in cls(fileobj, ignore_comments):
                yield obj

    @classmethod
    def from_socket(cls,socket,ignore_comments = False
        raise NotImplemented # Placeholder until implemented




    def __init__(self, iterable, ignore_comments=False,):
     ....
 

Answer 2

Well __new__ est une méthode de classe assez importante. C'est d'où viennent généralement les instances

donc dict() appels dict.__new__ bien sûr, mais il existe un autre moyen pratique de créer des dict: la méthode de classe dict.fromkeys()

par exemple.

 >>> dict.fromkeys("12345")
{'1': None, '3': None, '2': None, '5': None, '4': None}
 

Answer 3

Je ne sais pas, quelque chose comme les méthodes de constructeur nommé?

 class UniqueIdentifier(object):

    value = 0

    def __init__(self, name):
        self.name = name

    @classmethod
    def produce(cls):
        instance = cls(cls.value)
        cls.value += 1
        return instance

class FunkyUniqueIdentifier(UniqueIdentifier):

    @classmethod
    def produce(cls):
        instance = super(FunkyUniqueIdentifier, cls).produce()
        instance.name = "Funky %s" % instance.name
        return instance
 

Usage:

 >>> x = UniqueIdentifier.produce()
>>> y = FunkyUniqueIdentifier.produce()
>>> x.name
0
>>> y.name
Funky 1
 

Answer 4

Je trouve que j'ai le plus souvent utiliser @classmethod pour associer un morceau de code avec une classe, afin d'éviter de créer une fonction globale, pour les cas où je n'ai pas besoin d'une instance de la classe à utiliser le code.

Par exemple, je pourrais avoir une structure de données qui ne considère qu'un clé valide que si elle est conforme à un modèle. Je souhaiterez peut-être utiliser ce de l'intérieur et à l'extérieur de la classe. Cependant, je ne veux pas créer encore une autre fonction globale:

def foo_key_is_valid(key):
    # code for determining validity here
    return valid

Je préfère de loin le groupe le présent code avec la classe il est associé à:

class Foo(object):

    @classmethod
    def is_valid(cls, key):
        # code for determining validity here
        return valid

    def add_key(self, key, val):
        if not Foo.is_valid(key):
            raise ValueError()
        ..

# lets me reuse that method without an instance, and signals that
# the code is closely-associated with the Foo class
Foo.is_valid('my key')