Python：静态scop中Map类的函数

Question

我想在静态范围内标记对类函数的引用，例如：

class MyClass:

    func_mapping = {
        'key_1': func_1,  # Not accessible in this scope
        'key_2': func_2
    }

    def func_1(self):     # instance's functions
        # Do something

    def func_2(self):
       # Do other things

我怎样才能像这样映射我的函数？你知道吗

基于用例，我想要的类结构如下：

class PlanTravel:
    travel_mapping = {
        'country_1': {
             'precondtion': ['condition_1', 'condition_2'],
             'planner': _travel_contry_1
            },
        'country_2': {
             'precondtion': ['condition_1', 'condition_2'],
             'planner': _travel_contry_2
            }
        }


    def __init__(self, conditions, country):
         self.conditions = conditions
         self.country = country

    def _verify_precondition(self):
        preconditions = PlanTravel.travel_mapping[self.country]['precondtion']
        for condition in preconditions:
            if condition not in self.conditions:
                raise Exception('You can not plan travel:', condition)

    def travel(self):
        self._verify_precondition()
        travel_func = PlanTravel.travel_mapping[self.country]['planner'] 
        travel_func()

    def _travel_contry_1(self):
        # Somthing

    def _travel_contry_2(self):
        # Somthing else        

编辑：如@vaultah所述，我可以首先定义函数，然后将它们映射到dict，因为这样它们就可以在范围内使用了。但我想在开课的时候说。如果将来有人想浏览我的代码，那么他们可以在一开始就看到映射，并且知道引用哪个函数。你知道吗

Answer 1

我目前唯一能想到的另一种方法是通过名称解析将其添加到lambda中，并在查找过程中使用额外的函数调用：

func_mapping = {
    'key_1': lambda: MyClass.func_1, 
    'key_2': lambda: MyClass.func_2,
}

现在，必须通过以下方式进入：

MyClass.func_mapping['key_1']()

另一个选项，将其包装在函数中，仅在执行期间查找名称，而不在编译期间查找名称：

def func_mapping(key):
    func_mapping = {
        'key_1': MyClass.func_1, 
        'key_2': MyClass.func_2,
    }
    return func_mapping[key]

这对眼睛有点好，但你确实得到了额外的功能作为负担。你知道吗

Answer 2

实现所需行为的直接方法是在类的__init__方法中定义func_mapping。当然，每次创建实例时都会重新定义它，那又怎样？这只是一本小字典。你知道吗

下面是一个在python2和python3上工作的演示。你知道吗

class MyClass(object):
    def __init__(self, mode):
        func_mapping = {
            'key_1': self.func_1,
            'key_2': self.func_2,
        }
        self.func = func_mapping[mode]

    def func_1(self):
        return 'one'

    def func_2(self):
       return 'two'

a = MyClass('key_1')
print(a.func())

b = MyClass('key_2')
print(b.func())

输出

one
two

Answer 3

您的代码几乎可以正常工作，您只需要在映射之前定义方法，也不需要通过类名引用它们，因为它还没有定义：

In [2]: class MyClass:
   ...:     def func_1(self):
   ...:         pass
   ...:     def func_2(self):
   ...:         pass
   ...:     func_mapping = {
   ...:         'key_1': func_1,
   ...:         'key_2': func_2
   ...:     }
   ...:     

In [3]: 

In [3]: MyClass.func_mapping
Out[3]: 
{'key_1': <function __main__.MyClass.func_1>,
 'key_2': <function __main__.MyClass.func_2>}