Es gibt eine große Anzahl von Methoden mit ähnlichen Strukturen in einer Python3-Klasse. Können Modifikatoren verwendet werden, um das mechanische Umschreiben einer großen Anzahl von Generierungsmethoden zu vermeiden?

Question

class Classname(object):
    def __init__(self, p1, p2=''):
        self.p1 = p1
        self.p2 = p2

    # @Classname.decorator
    def method_one(self, p_list):
        return function_one(p_list)

    def method_one(self, p_list):
        return function_two(p_list)

    def method_one(self, p_list):
        return function_three(p_list)

Ein Großteil des Codes sieht so ausmethod_one调用funciton_one,但是现在要根据用户是否传入p2来改变调用function_xxx的方法,希望改成这个样子
function_xxxIch kann ihn nicht ändern.

    def method_two(self, p_list):
        if self.p2:
            return function_two(self.p2, p_list)
        else:
            return function_two(p_list)

Ich habe darüber nachgedacht, einen Dekorator zu verwenden, um damit umzugehen, aber es scheint, dass die Verwendung eines Dekorators nur eine Ebene außerhalb der Funktion umschließen kann, aber die aufrufende Methode nicht aufdringlich ändern kann.
Wenn Sie sie noch benötigen Zukunft Es ist möglich, die aufrufende Methode basierend auf self.p3 self.p4 zu ändern

Answer 1

你可以使用元类魔改类，这里放出个例子

def function_one(*args):
    print(1, args)

def function_two(*args):
    print(2, args)

def make_method(func):
    # 此处填逻辑
    def _method(self, plist):
        func(plist)
        
    return _method

# 元类工厂方法，传入包含 function_xxx 的模块对象
def meta(mod):
    class Meta(type):
        def __new__(cls, name, bases, attrs):
            fnames = attrs.get('FUNCTIONS', [])
            for n in fnames:
                func = getattr(mod, 'function_' + n)
                attrs['method_'+n] = make_method(func)
            return super(Meta, cls).__new__(cls, name, bases, attrs)
    return Meta

import sys

myself = sys.modules[__name__]

class Class(metaclass=meta(myself)): 
    FUNCTIONS = ['one', 'two']

obj = Class()
obj.method_one('one')
obj.method_two('two')