Question

我有一堆函数存储在一个字典中，用于从更“神秘”的源中收集数据（我已经编写了访问这些数据的函数）。

在我的代码中，我想创建“可见性”，了解哪些函数/参数正在加载在类的其余部分中使用的变量。所以，我想有一个类，在init中，函数字典站起来，可以被类中的其他函数使用。我遇到的问题是，我希望只有在以后的函数从字典中检索这些函数时才能调用这些函数。我不希望在 init 上评估函数。

问题：我传入字典的一些函数是“不完整的”，因为我想通过partial传递其他参数。问题是，类的 init 会计算字典中的所有函数，而不是将它们存储为函数。部分告诉我第一个参数必须是可调用的，我得到一个错误。

这是我正在做的事情的一个例子（年龄工作，月份没有）：

from functools import partial as part

class A:

    def __init__(self):

        self.rawInput={
                        'age':lu.source('personalInfo', 'age', asArray=1)                           
                        ,'month':lu.source('employInfo', 'months_employed')
                        }

        self.outputDict={}

        self.resultsDict={}

    class output(object):

        def age(self):            

            age = A().rawInput['age']
            return len(age)

        def month(self):            

            stuff=[]

            for x in range(0,1):
                month = part(A().rawInput['month'], x=x)
                stuff.append(month)

            return stuff

解

啊，看起来像7stud的发布摘要。我刚刚将值/函数放入dict作为带有标准参数的partials，然后在函数调用中根据需要传递其他的

from functools import partial as part

def source(name, attrib, none=None):

    if none!=None:
        print 'ham'
    else:
        print 'eggs'


class A:

    def __init__(self):

        self.rawInput={
                        'age':part(source,'personalInfo', 'age')                          
                        ,'month':part(source,'employInfo', 'months_employed')
                        }

        self.outputDict={}

        self.resultsDict={}

    class output:

        def age(self):            

            A().rawInput['age']()


        def month(self):            
            x = 1
            A().rawInput['month'](x)

c = A.output()
c.age()
c.month()

eggs
ham

Answer 1

问题是看起来类的init会评估所有的字典中的函数而不是将它们存储为函数。

()是函数执行运算符。所以，当你写：

'age':lu.source('personalInfo', 'age', asArray=1)

立即执行函数lu.source，并将结果分配给字典中的"age"键。

以下是使用partial的示例：

from functools import partial

def myadd(x, y):
    return x+y

def mysubtract(x, y):
    return x-y


funcs = {}

funcs["add_3"] = partial(myadd, 3)
funcs["subtr_from_10"] = partial(mysubtract, 10)


print(
    funcs["add_3"](2)  #Note the function execution operator
)

print(
    funcs["subtr_from_10"](3)  #Note the function execution operator
)

--output:--
5
7

请注意：

funcs["add_3"] = partial(myadd, 3)

()与partial一起使用。那么为什么这样呢？它的工作原理是因为部分返回类似于函数的东西，所以你最终得到这样的东西：

funcs["add_3"] = some_func

以下是部分工作原理：

def mypartial(func, x):

    def newfunc(val):
        return x + val

    return newfunc

add_3 = mypartial(myadd, 3)  #equivalent to add_3 = newfunc
print(add_3(2))  #=>5

对评论的回应：

好的，你可以这样做：

def myadd(x, y, z):
    return x+y+z

funcs = {}

funcs["add"] = {
    "func": myadd,
    "args": (3, 4)
}


func = funcs["add"]["func"]
args = funcs["add"]["args"]
result = func(*args, z=2)

print(result)  #=> 9

但是这使得调用函数更加曲折。如果你打算用参数调用函数，那么为什么不使用partial在函数中嵌入参数？

类init中的函数Dict |关于班级召唤的功能评估

1 个答案:

类__init__中的函数Dict |关于班级召唤的功能评估

1 个答案:

类init中的函数Dict |关于班级召唤的功能评估