Adăugați în mod dinamic metode la o clasă în Python 3.0

Puteți adăuga pur și simplu funcțiile (metodele) de căutare după ce clasa este creată:

class Search:  # The class does not include the search methods, at first
    def __init__(self):
        self.conditions = {}

def make_set_condition(option):  # Factory function that generates a "condition setter" for "option"
    def set_cond(self, value):
        self.conditions[option] = value
        return self
    return set_cond

for option in ('price', 'name'):  # The class is extended with additional condition setters
    setattr(Search, option, make_set_condition(option))

Search().name("Nice name").price('$3').conditions  # Example
{'price': '$3', 'name': 'Nice name'}

PS: această clasă are o metodă __init__() care nu are parametrul family (setatorii de condiții sunt adăugați dinamic în timpul execuției, dar sunt adăugați la clasă, nu la fiecare instanță separat). Dacă trebuie create Search obiecte cu stabilitori de condiții diferiți, atunci următoarea variație a metodei de mai sus funcționează (metoda __init__() are un parametru family):

import types

class Search:  # The class does not include the search methods, at first

    def __init__(self, family):
        self.conditions = {}
        for option in family:  # The class is extended with additional condition setters
            # The new 'option' attributes must be methods, not regular functions:
            setattr(self, option, types.MethodType(make_set_condition(option), self))

def make_set_condition(option):  # Factory function that generates a "condition setter" for "option"
    def set_cond(self, value):
        self.conditions[option] = value
        return self
    return set_cond

>>> o0 = Search(('price', 'name'))  # Example
>>> o0.name("Nice name").price('$3').conditions
{'price': '$3', 'name': 'Nice name'}
>>> dir(o0)  # Each Search object has its own condition setters (here: name and price)
['__doc__', '__init__', '__module__', 'conditions', 'name', 'price']

>>> o1 = Search(('director', 'style'))
>>> o1.director("Louis L").conditions  # New method name
{'director': 'Louis L'}
>>> dir(o1)  # Each Search object has its own condition setters (here: director and style)
['__doc__', '__init__', '__module__', 'conditions', 'director', 'style']

Referință: http://docs.python.org/howto/descriptor.html#functions-and-methods

Dacă într-adevăr aveți nevoie de metode de căutare care știu despre numele atributului în care sunt stocate, îl puteți seta pur și simplu în make_set_condition() cu

       set_cond.__name__ = option  # Sets the function name

(chiar înainte de return set_cond). Înainte de a face acest lucru, metoda Search.name are următorul nume:

>>> Search.price
<function set_cond at 0x107f832f8>

după ce setați atributul __name__, obțineți un alt nume:

>>> Search.price
<function price at 0x107f83490>

Setarea numelui metodei în acest fel face posibile mesaje de eroare care implică metoda mai ușor de înțeles.

În primul rând, nu adăugați nimic la clasă, o adăugați la instanță.

În al doilea rând, nu trebuie să accesați dict. self.__dict__[opt] = self.__Set__ este mai bine făcut cu setattr(self, opt, self.__Set__).

În al treilea rând, nu folosiți __xxx__ ca nume de atribute. Acestea sunt rezervate pentru uz intern Python.

În al patrulea rând, după cum ați observat, Python nu este ușor de păcălit. Numele intern al metodei pe care o apelați este în continuare __Set__, chiar dacă îl accesați sub un alt nume. :-) Numele este setat atunci când definiți metoda ca parte a instrucțiunii def.

Probabil doriți să creați și să setați metodele de opțiuni cu o metaclasă. De asemenea, poate doriți să creați acele metode în loc să încercați să utilizați o singură metodă pentru toate. Dacă într-adevăr doriți să utilizați doar un singur __getattr__, este calea, dar poate fi puțin greoi, vă recomand în general să nu faceți acest lucru. Lambda sau alte metode generate dinamic sunt probabil mai bune.

Iată un cod de lucru pentru a începe (nu întregul program pe care încercai să-l scrii, ci ceva care arată cum se pot potrivi părțile):

class Assign:

    def __init__(self, searchobj, key):
        self.searchobj = searchobj
        self.key = key

    def __call__(self, value):
        self.searchobj.conditions[self.key] = value
        return self.searchobj

class Book():

    def __init__(self, family):
        self.family = family
        self.options = ['price', 'name', 'author', 'genre']
        self.conditions = {}

    def __getattr__(self, key):
        if key in self.options:
            return Assign(self, key)
        raise RuntimeError('There is no option for: %s' % key)

    def execute(self):
        # XXX do something with the conditions.
        return self.conditions

b = Book('book')
print(b.price(">4.00").author('J. K. Rowling').execute())