Python开发中如何优雅的处理多重if...elif...判断

回眸那年，懵懂的我以为学会了if判断，就能轻易判断世间所有逻辑进行处理。时至今日，我依然为我当年的想法所骄傲。工作中多重if...elif...经常会遇到，我也像如下的方式写了N+1次，内容如下：

use_standing = "diamond_user"

if use_standing == "normal_user":  # 普通用户
    discount = 0.95
    # 大量的逻辑代码
    print("normal_user")
elif use_standing == "gold_user":  # 黄金用户
    discount = 0.9
    # 大量的逻辑代码
    print("gold_user")
elif use_standing == "platinum_user":  # 铂金用户
    discount = 0.85
    # 大量的逻辑代码
    print("platinum_user")
elif use_standing == "diamond_user":  # 钻石用户
    discount = 0.8
    # 大量的逻辑代码
    print("diamond_user")
elif use_standing == "starlight_user":  #  星耀用户
    discount = 0.7
    # 大量的逻辑代码
    print("starlight_user")
elif use_standing == "superior_user":  # 至尊用户
    discount = 0.6
    # 大量的逻辑代码
    print("superior_user")
else:
    print("The user type does not exist。")

通过判断不同的用户类型，进而针对不同的用户要进行大量的业务逻辑处理，这样的代码经常会有几百行乃至更多。慢慢的我开始厌烦这种代码，哪怕之前是我自己写的，过段时间再修改里面的业务逻辑我都很难受，更何况看到别人写这种，心里就只有MMP。

于是，以后再遇到多重判断逻辑必须优化。

方式1：使用字典的方式。

# 普通用户
def normal_user(type):
    """大量的逻辑代码"""
    return type

# 黄金用户
def gold_user(type):
    """大量的逻辑代码"""
    return type

# 铂金用户
def platinum_user(type):
    """大量的逻辑代码"""
    return type

# 钻石用户
def diamond_user(type):
    """大量的逻辑代码"""
    return type

# 星耀用户
def starlight_user(type):
    """大量的逻辑代码"""
    return type

# 至尊用户
def superior_user(type):
    """大量的逻辑代码"""
    return type

def inexistence_user(type):
    return f"The user type {type} does not exist。"

user_dict= {
    "normal_user": normal_user,
    "gold_user": gold_user,
    "platinum_user": platinum_user,
    "diamond_user": diamond_user,
    "starlight_user": starlight_user,
    "superior_user": superior_user,
}

user_type = "platinum_user"
print(user_dict.get(user_type, inexistence_user)(user_type))

通过将不同的用户类型封装到不同的函数中，进而使用字典键值对获取调用。

方式2：使用EdgeDB中的轮子

代码地址：https://github.com/edgedb/edgedb/blob/master/edb/common/value_dispatch.py

我们直接拿来使用即可，示例如下：

源码文件名为value_dispatch.py，直接放在同目录或指定目录下调用就！源码如下：

#
# This source file is part of the EdgeDB open source project.
#
# Copyright 2021-present MagicStack Inc. and the EdgeDB authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

from __future__ import annotations
from typing import *

import functools
import inspect
import types


_T = TypeVar("_T")


class _ValueDispatchCallable(Generic[_T], Protocol):
    registry: types.MappingProxyType[Any, Callable[..., _T]]

    def register(
        self,
        val: Any,
    ) -> Callable[[Callable[..., _T]], Callable[..., _T]]:
        ...

    def register_for_all(
        self,
        val: Iterable[Any],
    ) -> Callable[[Callable[..., _T]], Callable[..., _T]]:
        ...

    def __call__(__self, *args: Any, **kwargs: Any) -> _T:
        ...


def value_dispatch(func: Callable[..., _T]) -> _ValueDispatchCallable[_T]:
    """Like singledispatch() but dispatches by value of the first arg.

    Example:

      @value_dispatch
      def eat(fruit):
          return f"I don't want a {fruit}..."

      @eat.register('apple')
      def _eat_apple(fruit):
          return "I love apples!"

      @eat.register('eggplant')
      @eat.register('squash')
      def _eat_what(fruit):
          return f"I didn't know {fruit} is a fruit!"

    An alternative to applying multuple `register` decorators is to
    use the `register_for_all` helper:

      @eat.register_for_all({'eggplant', 'squash'})
      def _eat_what(fruit):
          return f"I didn't know {fruit} is a fruit!"
    """

    registry: dict[Any, Callable[..., _T]] = {}

    @functools.wraps(func)
    def wrapper(arg0: Any, *args: Any, **kwargs: Any) -> _T:
        try:
            delegate = registry[arg0]
        except KeyError:
            pass
        else:
            return delegate(arg0, *args, **kwargs)

        return func(arg0, *args, **kwargs)

    def register(
        value: Any,
    ) -> Callable[[Callable[..., _T]], Callable[..., _T]]:
        if inspect.isfunction(value):
            raise TypeError(
                "value_dispatch.register() decorator requires a value")

        def wrap(func: Callable[..., _T]) -> Callable[..., _T]:
            if value in registry:
                raise ValueError(
                    f'@value_dispatch: there is already a handler '
                    f'registered for {value!r}'
                )
            registry[value] = func
            return func
        return wrap

    def register_for_all(
        values: Iterable[Any],
    ) -> Callable[[Callable[..., _T]], Callable[..., _T]]:
        def wrap(func: Callable[..., _T]) -> Callable[..., _T]:
            for value in values:
                if value in registry:
                    raise ValueError(
                        f'@value_dispatch: there is already a handler '
                        f'registered for {value!r}'
                    )
                registry[value] = func
            return func
        return wrap

    wrapper.register = register
    wrapper.register_for_all = register_for_all
    return wrapper

使用如下： 

from value_dispatch import value_dispatch


@value_dispatch
def get_user_type(type):
    """处理不存在的情况"""
    return f'等级 {type} 不存在'

# 普通用户
@get_user_type.register("normal_user")
def normal_user(type):
    """大量的逻辑代码"""
    return type

# 黄金用户
@get_user_type.register("gold_user")
def gold_user(type):
    """大量的逻辑代码"""
    return type

# 铂金用户
@get_user_type.register("platinum_user")
def platinum_user(type):
    """大量的逻辑代码"""
    return type

# 钻石用户
@get_user_type.register("diamond_user")
def diamond_user(type):
    """大量的逻辑代码"""
    return type

# 星耀用户
@get_user_type.register("starlight_user")
def starlight_user(type):
    """大量的逻辑代码"""
    return type

# 至尊用户
@get_user_type.register("superior_user")
def superior_user(type):
    """大量的逻辑代码"""
    return type


if __name__ == '__main__':
    print(get_user_type("diamond_user"))

至此，是不是觉得自己的编码逻辑又进了一步，拜拜！