Python 处理大量常量的最有效方法

我正在编写一个程序，它根据Excel表中的特定值进行API调用。将检查表中的两个条件：

• 语言
• 提供者

根据这两个值，API调用需要一组不同的常量：

def run_workflow(provider, language, workflow):

    if provider == 'xxxx' and language == 0:

    wf_ready = provider_ready
    wf_unverified = provider_unverified
    wf_active = provider_active
    wf_another = provider_another
    wf_closed = provider_closed
    wf_wrongid = provider_wrongid

    elif provider == 'yyyy' and language == 0:

    wf_ready = provider_ready
    wf_unverified = provider_unverified
    wf_active = provider_active
    wf_another = provider_another
    wf_closed = provider_closed
    wf_wrongid = provider_wrongid

    elif ...


    if workflow == 'ready':
    response = requests.post(API + wf_ready),headers=header, data=json.dumps(conversation))

    elif workflow == 'unverified':
    response = requests.post(API + wf_unverified),headers=header, data=json.dumps(conversation))

    elif ...

有2种提供程序和7种不同的语言，我正在尝试找出处理此场景的最有效（和python方式），并为每种语言创建了一个类：

class Workflow_Language():

  def english(self):

    self.provider_unverified = 1112
    self.provider_ready = 1113
    self.provider_active = 1114
    self.provider_vip = 1115

  def russian(self):

    self.provider_unverified = 1116
    self.provider_ready = 1117
    self.provider_active = 1118
    self.provider_vip = 1119

  def ...

---

是否有更好的方法来处理此问题？

一种方法是将常量映射到适当的处理程序：

class LanguageData:
    def __init__(self, unverified, ready, active, vip):
        self.unverified = unverified
        self.ready = ready
        self.active = active
        self.vip = vip

def english():
    return LanguageData(1,2,3,4)

def russian():
    return LanguageData(5,6,7,8)

LANGUAGE_MAP = {'en': english, 'ru': russian}

为了清晰起见，我编了

'en'，ru'

值。你的情况似乎是

0

？还要注意的是，

英语

和

俄语

是独立的功能。最后，

LanguageData

类不是必需的，您只需从这些函数返回字典即可。但是使用属性而不是字符串键似乎更容易维护

然后在代码中：

def run_workflow(provider, language, workflow):
    lang_data = LANGUAGE_MAP[language]()
    if workflow == 'ready':
        url = API + data.ready
    elif workflow == 'unverified':
        url = API + data.unverified
    response = requests.post(url, headers=header, data=json.dumps(conversation))

当然，如果有两个以上的可能值，则可以用类似的方式包装

工作流

类似地，对于
提供程序
。除非该操作同时依赖于
提供者
和
语言
，否则在这种情况下，您需要一个双重映射：

LANG_PROV_MAP = {
    ('en', 'xxxx'): first,
    ('ru', 'yyyy'): second,
}
def run_workflow(provider, language, workflow):
    data = LANG_PROV_MAP[(provider, language)]()
    ...

原始代码可以通过一个复杂的修饰来简化：

LANGUAGE_MAP = {}
def language_handler(lang):
    def wrapper(fn):
        LANGUAGE_MAP[lang] = fn
        return fn
    return wrapper

@language_handler('en')
def handler():
    return LanguageData(1,2,3,4)

@language_handler('ru')
def handler():
    return LanguageData(5,6,7,8)

还请注意，如果数据是“常量”（即不依赖于上下文），则可以完全省略可调用项，以使一切更加简单：

LANGUAGE_MAP = {
    'en': LanguageData(1,2,3,4),
    'ru': LanguageData(5,6,7,8),
}
def run_workflow(provider, language, workflow):
    data = LANGUAGE_MAP[language]
    ...

一种方法是将常量映射到适当的处理程序：

class LanguageData:
    def __init__(self, unverified, ready, active, vip):
        self.unverified = unverified
        self.ready = ready
        self.active = active
        self.vip = vip

def english():
    return LanguageData(1,2,3,4)

def russian():
    return LanguageData(5,6,7,8)

LANGUAGE_MAP = {'en': english, 'ru': russian}

为了清晰起见，我编了
'en'，ru'
值。你的情况似乎是
0
？还要注意的是，
英语
和
俄语
是独立的功能。最后，
LanguageData
类不是必需的，您只需从这些函数返回字典即可。但是使用属性而不是字符串键似乎更容易维护

然后在代码中：

def run_workflow(provider, language, workflow):
    lang_data = LANGUAGE_MAP[language]()
    if workflow == 'ready':
        url = API + data.ready
    elif workflow == 'unverified':
        url = API + data.unverified
    response = requests.post(url, headers=header, data=json.dumps(conversation))

当然，如果有两个以上的可能值，则可以用类似的方式包装
工作流

类似地，对于
提供程序
。除非该操作同时依赖于
提供者
和
语言
，否则在这种情况下，您需要一个双重映射：

LANG_PROV_MAP = {
    ('en', 'xxxx'): first,
    ('ru', 'yyyy'): second,
}
def run_workflow(provider, language, workflow):
    data = LANG_PROV_MAP[(provider, language)]()
    ...

原始代码可以通过一个复杂的修饰来简化：

LANGUAGE_MAP = {}
def language_handler(lang):
    def wrapper(fn):
        LANGUAGE_MAP[lang] = fn
        return fn
    return wrapper

@language_handler('en')
def handler():
    return LanguageData(1,2,3,4)

@language_handler('ru')
def handler():
    return LanguageData(5,6,7,8)

还请注意，如果数据是“常量”（即不依赖于上下文），则可以完全省略可调用项，以使一切更加简单：

LANGUAGE_MAP = {
    'en': LanguageData(1,2,3,4),
    'ru': LanguageData(5,6,7,8),
}
def run_workflow(provider, language, workflow):
    data = LANGUAGE_MAP[language]
    ...

语言和提供者的组合可以组成方法名，调用将被动态调用

例如：

import sys

def provider1_lang2():
    pass

def provider2_lang4():
    pass

 # get the provider / lang and call the method dynamically
 provider = 'provider2'
 lang = 'lang4' 
 method_name = '{}_{}'.format(provider,lang)
 method =  getattr(sys.modules[__name__], method_name)
 method()

语言和提供者的组合可以组成方法名，调用将被动态调用

例如：

import sys

def provider1_lang2():
    pass

def provider2_lang4():
    pass

 # get the provider / lang and call the method dynamically
 provider = 'provider2'
 lang = 'lang4' 
 method_name = '{}_{}'.format(provider,lang)
 method =  getattr(sys.modules[__name__], method_name)
 method()

可能从某种配置文件中读取这些值。可能从某种配置文件中读取这些值。@Brunodesshuilliers我在回答中添加了使用字典的可能性。但是使用字符串键通常比使用属性更难。我建议使用课堂。对于初学者来说，现在大多数IDE都很好地支持类，而不是任意的字典。类在现代暗示和静态分析中也发挥了很好的作用。事实上，dict可以更容易地作为关键字args或请求的参数（get或post）传递。现在你当然也可以在类中添加一个
to_dict
方法…@非常感谢！这已经帮了我很多忙了。但是，我没有提到我必须同时检查语言和提供者。因此，我有2个提供者，对于每个提供者，每种语言都有2组工作流（常量）。仍然不确定哪种可能是这种情况下的最佳解决方案。目前我认为简单地使用两个映射（LANGUAGE_MAP_PROVIDER1和LANGUAGE_MAP_PROVIDER2）可能是最好的？由于数据是恒定的，我会跳过上一个示例中显示的可调用项，但如果有两个映射，那么？@Brunodesshuilliers我在回答中补充说，使用字典是可能的。但是使用字符串键通常比使用属性更难。我建议使用课堂。对于初学者来说，现在大多数IDE都很好地支持类，而不是任意的字典。类在现代暗示和静态分析中也发挥了很好的作用。事实上，dict可以更容易地作为关键字args或请求的参数（get或post）传递。现在你当然也可以在类中添加一个
to_dict
方法…@非常感谢！这已经帮了我很多忙了。但是，我没有提到我必须同时检查语言和提供者。因此，我有2个提供者，对于每个提供者，每种语言都有2组工作流（常量）。仍然不确定哪种可能是这种情况下的最佳解决方案。目前我认为简单地使用两个映射（LANGUAGE_MAP_PROVIDER1和LANGUAGE_MAP_PROVIDER2）可能是最好的？由于数据是恒定的，我会跳过上一个示例中显示的可调用项，但是如果有两个映射，那么？最好使用dict-更明确、更不容易出错、更易于阅读和维护等。最好使用dict-更明确、更不容易出错、更易于阅读和维护等。