实现一个命令分发器

要求：

　　程序员可以方便的注册函数到某个命令，用户输入命令时，路由到注册的函数，如果没有此命令，执行默认函数，用户输入input

分析：

'''实现一个命令分发器'''

# 初步实现
commands = {} # 命令字典

def reg(cmd, fn):
    commands[cmd] = fn

# 默认函数
def defaultfn():
    print('Unkonw cmd')

# 函数
def foo1():
    print('1')

def foo2():
    print('2')

# 注册（但是要有判断，不同用户或同一个用户，注册时使用的名字一样，会冲突，会覆盖
# 1、每个用户有自己的commands
# 2、加判断条件
reg('mag',foo1)
reg('py',foo2)


def dispatcher():
    while True:
        cmd = input('>>')
        if cmd == '':
            print('bye')
            break
        commands.get(cmd, defaultfn)() #  拿到的是defaultfn对象，所以还要加一个括号

dispatcher()
print(commands)

# 输出：
# >>ds
# Unkonw cmd
# >>mag
# 1
# >>py
# 2
# >>
# bye
# {'mag': <function foo1 at 0x0000000001E5C620>, 'py': <function foo2 at 0x0000000001E5C6A8>}


# 添加装饰器：现在的顺序是由上至下
commands = {} # 命令字典

def reg(cmd):
    def _reg(fn):
        commands[cmd] = fn
        return fn
    return  _reg


# # 默认函数
def defaultfn():
    print('Unkonw cmd')

# 函数
@reg('mag') # foo1 = reg('mag')(add) = _reg(add)
#从装饰器的定义出发，先程序由上到下，到此处时，先执行foo1=reg('mag')(foo1),创建foo1函数对象，此时已经注册好了
def foo1():
    print('1')
@reg('py')
def foo2():
    print('2')


def dispatcher():
    while True:
        cmd = input('>>')
        if cmd == '':
            print('bye')
            break
        commands.get(cmd, defaultfn)() #  拿到的是defaultfn对象，所以还要加一个括号
        print(commands)
dispatcher()
print(commands)

# 封装：
def cmds_dispatcher():
    commands = {} # 命令字典

    def reg(cmd):
        def _reg(fn):
            commands[cmd] = fn
            return fn
        return  _reg


    # 默认函数
    def defaultfn():
        print('Unkonw cmd')

    def dispatcher():
        while True:
            cmd = input('>>')
            if cmd == '':
                print('bye')
                break
            commands.get(cmd, defaultfn)() #  拿到的是defaultfn对象，所以还要加一个括号
            print(commands)
    return reg,dispatcher

reg,run = cmds_dispatcher()

# 函数
@reg('mag') # foo1 = reg('mag')(add) = _reg(add)
#从装饰器的定义出发，先程序由上到下，到此处时，先执行foo1=reg('mag')(foo1),创建foo1函数对象，此时已经注册好了
def foo1():
    print('1')
@reg('py')
def foo2():
    print('2')

run()

 使用类封装实现命令分发器

########################### 命令分发器#################################
# 简单实现 函数注册，并且传入参数
class Dispatcher:
    def __init__(self):
        pass

    def reg(self, cmd, fn):
        setattr(self, cmd, fn)

    def run(self, *args, **kwargs):
        while True:
            cmd = input('>>>').strip()
            if cmd == '':
                break
            else:
                getattr(self, cmd, lambda :print('unkonw'))(*args, **kwargs)

def add(x, y):
    print(x + y)

def sub(x, y):
    print(x - y)

dis = Dispatcher()
dis.reg('add', add)
dis.reg('sub', sub)
dis.run(4, y = 5)

# # 实现函数注册，并且传入参数
class Dispatcher:
    def __init__(self):
        # self.commands = {}
        pass

    def reg(self, cmd):# 风险，万一人家实例本身有相同的属性名，这样就会冲突，覆盖，最好的方式是使用一个字典存
        def wrapper(fn):
            setattr(self, cmd, fn)
            return fn
        return wrapper

    def run(self, *args, **kwargs):
        while True:
            cmd = input('>>>').strip()
            if cmd == '':
                break
            else:
                getattr(self, cmd, lambda :print('unkonw'))(*args, **kwargs)

dis = Dispatcher()

# 这样的话，加载的时候，函数已经被注册进去了，运行的时候，根据cmd直接调用
@dis.reg('add') # add = dis.reg('add')(add)
def add(x, y):
    print(x + y)

@dis.reg('sub') # add = dis.reg('add')(add)
def sub(x, y):
    print(x - y)

dis.run(4, y = 5)