Alternativa alla proprietà sulla funzione in Python?

Questo sembra un lavoro per il polimorfismo.

Si desidera associare controlli e messaggi senza collegarli al codice log_check . Questa è una buona idea.

Sei riluttante a usare una classe perché la classe sarebbe senza stato. A quello dico: Feh! Gli oggetti stateless stanno perfettamente bene.

Un oggetto è un sacco di funzioni che si muovono insieme. Lo stato è solo qualcosa che cambia anche il comportamento di quelle funzioni insieme.

Gli oggetti apolidi hanno avuto una cattiva reputazione in OO perché alcuni amici di pallacanestro hanno pensato che i metodi stateless dovevano essere statici. No, è indietro.

log_check( fruits = fruits, ripe(), delicious(7) )

Qualsiasi motivo non dovrebbe essere così semplice?

Se ad es. non voglio riscrivere un gruppo di funzioni esistenti solo per allegare messaggi a loro, puoi farlo esternamente:

CHECKS = {
  (check_ripeness, 'This ain\'t no ripe enough'),
  (check_taste, 'deliciousness does not conform to the standards'),
  # etc
}

# somewhere in your method
for (predicate, message) in CHECKS:
  if not predicate(fruit):
    log(message)

L'utilizzo di classi con __call__ otterrebbe lo stesso risultato, solo in modo meno diretto.

Crea un tipo che contiene il messaggio e la funzione di controllo. Usa namedtuple o una classe.

from collections import namedtuple
Check = namedtuple('Check', ('message', 'checker'))

Ora puoi creare oggetti che contengono sia il messaggio sia una funzione per controllare la frutta.

ripe = Check(message = "is not ripe", lambda fruit: fruit.tastiness < 5)

Quindi scrivi una funzione generica

def log_fruits(fruits, checker):
    for fruit in fruits:
        if checker(fruit):
            print("Fruit: ", fruit, checker.message)

Usa una classe. Anche il comportamento fa parte dello stato se si utilizza il polimorfismo, ma in questo caso potrebbe non essere necessario il polimorfismo "formale": basta utilizzare una classe per tutti i controlli, con il messaggio e il predicato come parametri.

In aggiunta:

• Dato che stai usando una classe, può essere una buona idea passare un predicato che controlli un singolo frutto e lasciare che la classe gestisca il controllo di un elenco di essi.
• Per rendere la sintassi più gradevole, puoi utilizzare un decoratore.

Quindi, avrei fatto qualcosa di simile:

log = print


class Fruit(object):
    def __init__(self, name, **kwargs):
        self.name = name
        for k, v in kwargs.items():
            setattr(self, k, v)

# Single class, receives predicate as parameter
class Check(object):
    def __init__(self, predicate, message):
        self.predicate = predicate
        self.message = message

    def check(self, fruits, *args, **kwargs):
        """ Run the predicate on a list of checks """
        for fruit in fruits:
            if self.predicate(fruit, *args, **kwargs):
                yield fruit

    def log(self, fruits, *args, **kwargs):
        """ Check a list of fruits, logging the results """
        for fruit in self.check(fruits, *args, **kwargs):
            log(self.message.format(**fruit.__dict__))


def check(message):
    """ Helper decorator to ease the creationg of Check objects """
    def wrapper(func):
        return Check(func, message)
    return wrapper


@check(message="The fruit {name} was not delicious enough.")
def not_delicious(fruit, limit):
    return fruit.tastyness < limit


@check(message="The fruit {name} was not ripe")
def not_ripe(fruit):
    return not fruit.ripe


fruits = [Fruit("Yellow Banana", ripe=True, tastyness=10),
          Fruit("Green Banana", ripe=False, tastyness=0),
          Fruit("Grapefruit", ripe=True, tastyness=-float('inf'))]


not_delicious.log(fruits, limit=7)
not_ripe.log(fruits)