python实现规则引擎_用Python实现简易可拓展的规则引擎

用Python实现简易可拓展的规则引擎

做这个规则引擎的初衷是用来实现一个可序列号为json，容易拓展的条件执行引擎，用在类似工作流的场景中，最终实现的效果希望是这样的：

![]

简单整理下需求

执行结果最终返回=true= or false

支持四则运算，逻辑运算以及自定义函数等

支持多级规则组合，级别理论上无限(Python递归调用深度限制)

序列化成json

实现

json没有条件判断和流程控制，且不可引用对象，是不好序列化规则的，除非用树来保存，但这样又过于臃肿不好阅读。

在苦苦思索的时候，突然灵光一闪~曾经我用过一个自动装机系统-- razor ,

它使用一种tag语法来匹配机器并打标签，他的语法是这样的：

["or",

["=", ["fact", "macaddress"], "de:ea:db:ee:f0:00"]

["=", ["fact", "macaddress"], "de:ea:db:ee:f0:01"]]

这表示匹配目标机器的Mac地址等于=de:ea:db:ee:f0:00=或=de:ea:db:ee:f0:00=，这种表达既简洁，又足够灵活这种灵活体现在理论上可以无限嵌套，也可以随意自定义操作函数(这里的=、fact)

这灵感来自于古老的=Lisp=，完全可以实现我们的想法~并且简单、好用，还非常非常灵活！就它了！

因此我就使用这种基于=Json Array=的语法来实现我们的规则引擎。

最后实现的语法规则是这样的：

规则语法基本语法： ["操作符", "参数1", "参数2", ...]

多条判断语句可组合，如:

["操作符",

["操作符1", "参数1", "参数2", ...],["操作符2", "参数1", "参数2", ...]

]

["and",

[">", 0 , 0.05],

[">", 3, 2]

]

*支持的操作符： * 比较运算符：

=, !=, >, =, <=

逻辑运算符：

and, or, not, in

四则运算：

+, -, *, /

数据转换：

int, str, upper, lower

其他特殊操作符：

可自定义操作符，例如get，从某http服务获取数据

代码

class RuleParser(object):

def __init__(self, rule):

if isinstance(rule, basestring):

self.rule = json.loads(rule)

else:

self.rule = rule

self.validate(self.rule)

class Functions(object):

ALIAS = {

'=': 'eq',

'!=': 'neq',

'>': 'gt',

'>=': 'gte',

'

'<=': 'lte',

'and': 'and_',

'in': 'in_',

'or': 'or_',

'not': 'not_',

'str': 'str_',

'int': 'int_',

'+': 'plus',

'-': 'minus',

'*': 'multiply',

'/': 'divide'

}

def eq(self, *args):

return args[0] == args[1]

def neq(self, *args):

return args[0] != args[1]

def in_(self, *args):

return args[0] in args[1:]

def gt(self, *args):

return args[0] > args[1]

def gte(self, *args):

return args[0] >= args[1]

def lt(self, *args):

return args[0] < args[1]

def lte(self, *args):

return args[0] <= args[1]

def not_(self, *args):

return not args[0]

def or_(self, *args):

return any(args)

def and_(self, *args):

return all(args)

def int_(self, *args):

return int(args[0])

def str_(self, *args):

return unicode(args[0])

def upper(self, *args):

return args[0].upper()

def lower(self, *args):

return args[0].lower()

def plus(self, *args):

return sum(args)

def minus(self, *args):

return args[0] - args[1]

def multiply(self, *args):

return args[0] * args[1]

def divide(self, *args):

return float(args[0]) / float(args[1])

def abs(self, *args):

return abs(args[0])

@staticmethod

def validate(rule):

if not isinstance(rule, list):

raise RuleEvaluationError('Rule must be a list, got {}'.format(type(rule)))

if len(rule) < 2:

raise RuleEvaluationError('Must have at least one argument.')

def _evaluate(self, rule, fns):

"""

递归执行list内容

"""

def _recurse_eval(arg):

if isinstance(arg, list):

return self._evaluate(arg, fns)

else:

return arg

r = map(_recurse_eval, rule)

r[0] = self.Functions.ALIAS.get(r[0]) or r[0]

func = getattr(fns, r[0])

return func(*r[1:])

def evaluate(self):

fns = self.Functions()

ret = self._evaluate(self.rule, fns)

if not isinstance(ret, bool):

logger.warn('In common usage, a rule must return a bool value,'

'but get {}, please check the rule to ensure it is true' )

return ret

解析

这里Functions这个类，就是用来存放操作符方法的，由于有些操作符不是合法的Python变量名，所以需要用ALIAS做一次转换。

当需要添加新的操作，只需在Functions中添加方法即可。由于始终使用array来存储，所以方法接收的参数始终可以用args[n]来访问到，这里没有做异常处理，如果想要更健壮的话可以拓展validate方法，以及在每次调用前检查参数。

整个规则引擎的核心代码其实就是=~evaluate~=这个10行不到的方法，在这里会递归遍历列表，从最里层的列表开始执行，然后层层往外执行，最后执行完毕返回一个Boolean值，当然这里也可以拓展改成允许返回任何值，然后根据返回值来决定后续走向，这便可以成为一个工作流中的条件节点了。

结束语

东西简单粗陋，希望能给大家带来一些帮助或者一些启发~