Python 调用转换函数的最佳方式

Question

I'm creating a transformative function that takes two lists.

one list has the values that I want to transform and the second list has a list of functions that I want to send the values to in order.

def directing_function(value_list, func_list):
    value = None
    transformed = []
    for x in value_list:
        value = func_list[0](x)
        for y in func_list[1:]:
            value = y(value)
        transformed.append(value)
    return transformed

Granted this is a mockup as I haven't written it exactly. I'm trying to figure out the best way to reference the possible functions. I considered Enum, a dictionary for case...

Have any of you ran into this type of issue before? What do you feel might be the best way to approach this from an organizational and ease of use standpoint?

If the order of functions needed was static obviously it would be easier, but they will change and repeat and change based on need.

EDIT: The code is more psudo code, I'm more concerned with how to reference the functions as the list of functions itself may be both long and repetitive.

Also fixed the psudo for clarity.

Answer 1

I would use a dictionary, and depending on the broader problem at hand I would use either of these approaches:

As far as I see if, there is no real reason to intermediate your function objects with an Enum (or similar). That's just adding 1 more layer of complexity that is not needed in Python.

Approach 1: Flat dictionary w/ tuple keys

This approach is ideal if you're only ever interested in selecting the result of 1 func/value pair at a time. If you want to select all outputs with the same function (or likewise, all outputs that share a specific value), I may reach for one of the below approaches.

from itertools import product

def directing_function(value_list, func_list):
    transformed = {}
    for func, v in product(func_list, value_list):
        transformed[func, v] = func(v)
    return transformed

def hello(x):
    return x + 1

def world(x):
    return x ** 2

out = directing_function([1, 2, 4, 8], [hello, world])

print(out)
# {
#    (<function hello at 0x7f765c017c10>, 1): 2,
#    (<function hello at 0x7f765c017c10>, 2): 3,
#    ...
#    (<function world at 0x7f765c017160>, 4): 16,
#    (<function world at 0x7f765c017160>, 8): 64
# }

print(out[hello, 2]) # 3
print(out[world, 4]) # 16

Approach 2: Nested dictionary w/ func as outer layer

from collections import defaultdict

def directing_function(value_list, func_list):
    transformed = defaultdict(dict)
    for func in func_list:
        transformed[func] = {v: func(v) for v in value_list} 
    return transformed

def hello(x):
    return x + 1

def world(x):
    return x ** 2

out = directing_function([1, 2, 4, 8], [hello, world])

print(out)
# defaultdict(dict,
#             {<function __main__.hello(x)>: {1: 2, 2: 3, 4: 5, 8: 9},
#              <function __main__.world(x)>: {1: 1, 2: 4, 4: 16, 8: 64}})

print(out[world])    # {1: 1, 2: 4, 4: 16, 8: 64}
print(out[world][4]) # 16
print(out[hello][2]) # 3

Approach 2.1: Nested dictionary w/ value as outer layer

Pretty much the same as above, but swap the layers of the nested dictionary

from collections import defaultdict

def directing_function(value_list, func_list):
    transformed = defaultdict(dict)
    for v in value_list:
        transformed[v] = {func: func(v) for func in func_list} 
    return transformed

Answer 2

Given:

l = [1, 2, 3, 4]
f1 = lambda x: x+1
f2 = lambda x: x*2
f3 = lambda x: x**3
funcs = [f1, f2, f3]

Doing:

# Iterate through your functions.
    # Use map to easily apply a function 
    # to every element in a list.

for f in funcs:
    l = map(f, l)

l = list(l)
print(l)
 
# Output:
[64, 216, 512, 1000]