Comment passer un argument par défaut de la valeur d'un membre de l'instance à une méthode?

On ne peut pas vraiment définir ce que la valeur par défaut, puisque la valeur par défaut est évaluée lorsque la méthode est définie, qui est avant tout des instances existent. Le schéma habituel est de faire quelque chose comme ceci à la place:

class C:
    def __init__(self, format):
        self.format = format

    def process(self, formatting=None):
        if formatting is None:
            formatting = self.format
        print(formatting)

self.format ne sera utilisé que si formatting est None.

Pour démontrer le point de la façon dont les valeurs par défaut de travail, voir cet exemple:

def mk_default():
    print("mk_default has been called!")

def myfun(foo=mk_default()):
    print("myfun has been called.")

print("about to test functions")
myfun("testing")
myfun("testing again")

Et la sortie de ici:

mk_default has been called!
about to test functions
myfun has been called.
myfun has been called.

Avis comment mk_default a été appelé qu'une seule fois, et c'est arrivé avant que la fonction n'a jamais été appelé!

Puisque vous souhaitez utiliser self.format comme un argument par défaut ce qui implique que la méthode doit être l'instance spécifique (à savoir qu'il n'est pas possible de définir ce au niveau de la classe). Au lieu de cela, vous pouvez définir la méthode spécifique au cours de la classe de __init__ par exemple. C'est là que vous avez accès à l'instance des attributs particuliers.

Une approche consiste à utiliser functools.partielle afin d'obtenir une mise à jour (spécifique) de la version de la méthode:

from functools import partial


class C:
    def __init__(self, format):
        self.format = format
        self.process = partial(self.process, formatting=self.format)

    def process(self, formatting):
        print(formatting)


c = C('default')
c.process()
# c.process('custom')  # Doesn't work!
c.process(formatting='custom')

À noter qu'avec cette approche, vous pouvez seulement passer l'argument correspondant par mot-clé, puisque si vous les avez fournies par la position, ce serait de créer un conflit dans partial.

Une autre approche est de définir et d'appliquer la méthode dans __init__:

from types import MethodType


class C:
    def __init__(self, format):
        self.format = format

        def process(self, formatting=self.format):
            print(formatting)

        self.process = MethodType(process, self)


c = C('test')
c.process()
c.process('custom')
c.process(formatting='custom')

Cela permet également de passage de l'argument par la position, cependant, la méthode de résolution de l'ordonnance devient moins apparente (ce qui peut affecter l'IDE d'inspection par exemple, mais je suppose qu'il y IDE les solutions spécifiques pour que).

Une autre approche serait de créer un type personnalisé pour ce genre de "instance d'attribut par défaut" en combinaison avec un décorateur qui effectue le correspondant getattr argument de remplissage:

import inspect


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


def decorator(method):
    signature = inspect.signature(method)

    def wrapper(self, *args, **kwargs):
        bound = signature.bind(*((self,) + args), **kwargs)
        bound.apply_defaults()
        bound.arguments.update({k: getattr(self, v.name) for k, v in bound.arguments.items()
                                if isinstance(v, Attribute)})
        return method(*bound.args, **bound.kwargs)

    return wrapper


class C:
    def __init__(self, format):
        self.format = format

    @decorator
    def process(self, formatting=Attribute('format')):
        print(formatting)


c = C('test')
c.process()
c.process('custom')
c.process(formatting='custom')

Vous ne pouvez pas accéder à l'autonomie dans la définition de la méthode. Ma solution est-ce -

class Test:
  def __init__(self):
    self.default_v = 20

  def test(self, v=None):
    v = v or self.default_v
    print(v)

Test().test()
> 20

Test().test(10)
> 10