Question

我是一个python新手，刚刚在python中实现了我的第一个ID3，我的规则就像这样的dict形式

{'a' : {'b': 'no', 'c': 'no', 'd': {'z': {'q': 'no', 'y': 'yes'}}}}

我现在想把它输出为

<a = b >---> 'no'
<a = c >---> 'no'
<a = d > AND <z = q >---> 'no'
<a = d > AND <z = y >---> 'yes'

我似乎无法把它弄好

这是我的代码：假设将所有内容作为由逗号分隔的单个字符串

返回

def printer(a):
    keys = a.keys()
    for i in keys:
        rules = ""
        for j in a[i].keys():
            tulip = "< Attribute " + str(i) + " = "
            tulip += str(j)
            tulip += " > "
            if type(a[i][j]) == str:
                tulip += "--->" + str(a[i][j]) 
                rules += tulip
                rules += ","
            else:
                tulip += "AND " 
                tulip += str(printer(a[i][j]))
            rules += tulip    

    return rules

Answer 1

<强> 更新

对于使用任意嵌套打印这些规则的递归函数，您可以使用以下命令：

更新了字典和功能

rules = {4: {'s': 'No', 'a': 'e', 'p': 'No', 'c': 'No', 'l': 'e', 'f': 'No', 'm': 'No', 'n': {19: {'o': 'e', 'r': 'No', 'b': 'e', 'h': 'e', 'w': {21: {'p': 'e', 'w': 'e', 'd': {1: {'s': 'e', 'f': 'No', 'y': 'No'}}, 'g': 'e', 'l': {2: {'c': 'e', 'w': 'No', 'n': 'e', 'y': 'No'}}}}, 'k': 'e', 'n': 'e', 'y': 'e'}}, 'y': 'No'}}
string_rules = [] # to keep them in a list


def print_nested_count(myDict, parent=None, out=[], count=0):
    for key, value in myDict.items():
        if isinstance(value, dict):
            count += 1  # signifies recursion level
            if parent and count % 2 == 0:
                out.append("<{} = {}> AND ".format(parent, key))
            count = print_nested_count(value, key, out, count=count)
        else:
            if count:
                string_rules.append("".join(out).lstrip() + "<{} = {}> ----> {}".format(parent, key, value))
    if count % 2 == 0 and out:
        out.pop()
    count -= 1
    return count

更新输出：

通过调用此函数并在string_rules中打印每一行：

if __name__ == "__main__":
    print_nested_count(rules)
    for line in string_rules: print(line)

输入格式：

{4: {'a': 'e',
     'c': 'No',
     'f': 'No',
     'l': 'e',
     'm': 'No',
     'n': {19: {'b': 'e',
                'h': 'e',
                'k': 'e',
                'n': 'e',
                'o': 'e',
                'r': 'No',
                'w': {21: {'d': {1: {'f': 'No', 's': 'e', 'y': 'No'}},
                           'g': 'e',
                           'l': {2: {'c': 'e', 'n': 'e', 'w': 'No', 'y': 'No'}},
                           'p': 'e',
                           'w': 'e'}},
                'y': 'e'}},
     'p': 'No',
     's': 'No',
     'y': 'No'}}

输出格式：

<4 = s> ----> No
<4 = a> ----> e
<4 = l> ----> e
<4 = y> ----> No
<4 = p> ----> No
<4 = n> AND <19 = y> ----> e
<4 = n> AND <19 = w> AND <21 = p> ----> e
<4 = n> AND <19 = w> AND <21 = w> ----> e
<4 = n> AND <19 = w> AND <21 = d> AND <1 = s> ----> e
<4 = n> AND <19 = w> AND <21 = d> AND <1 = f> ----> No
<4 = n> AND <19 = w> AND <21 = d> AND <1 = y> ----> No
<4 = n> AND <19 = w> AND <21 = l> AND <2 = y> ----> No
<4 = n> AND <19 = w> AND <21 = l> AND <2 = w> ----> No
<4 = n> AND <19 = w> AND <21 = l> AND <2 = c> ----> e
<4 = n> AND <19 = w> AND <21 = l> AND <2 = n> ----> e
<4 = n> AND <19 = w> AND <21 = g> ----> e
<4 = n> AND <19 = h> ----> e
<4 = n> AND <19 = k> ----> e
<4 = n> AND <19 = r> ----> No
<4 = n> AND <19 = n> ----> e
<4 = n> AND <19 = o> ----> e
<4 = n> AND <19 = b> ----> e
<4 = f> ----> No
<4 = c> ----> No
<4 = m> ----> No

Answer 2

更短的：

# recursive build up the prefix for the current level
def format(rule, start=True, prefix=""):
    for (key, value) in rule.iteritems():
        if isinstance(value, type({})):
            format(value, not start, ("{0}<{1} = " if start else "{0}{1}> AND ").format(prefix, key))
        else:
            print "{0}{1}> ----> {2}".format(prefix, key, value)

因此，在更大的规则/递归序列上测试它：

rules2 = {4: {'a': 'e',
     'c': 'No',
     'f': 'No',
     'l': 'e',
     'm': 'No',
     'n': {19: {'b': 'e',
                'h': 'e',
                'k': 'e',
                'n': 'e',
                'o': 'e',
                'r': 'No',
                'w': {21: {'d': {1: {'f': 'No', 's': 'e', 'y': 'No'}},
                           'g': 'e',
                           'l': {2: {'c': 'e', 'n': 'e', 'w': 'No', 'y': 'No'}},
                           'p': 'e',
                           'w': 'e'}},
                'y': 'e'}},
     'p': 'No',
     's': 'No',
     'y': 'No'}}

format(rules2)

收益率作为产出：

<4 = a> ----> e
<4 = p> ----> No
<4 = c> ----> No
<4 = f> ----> No
<4 = y> ----> No
<4 = s> ----> No
<4 = m> ----> No
<4 = l> ----> e
<4 = n> AND <19 = b> ----> e
<4 = n> AND <19 = w> AND <21 = p> ----> e
<4 = n> AND <19 = w> AND <21 = w> ----> e
<4 = n> AND <19 = w> AND <21 = d> AND <1 = y> ----> No
<4 = n> AND <19 = w> AND <21 = d> AND <1 = s> ----> e
<4 = n> AND <19 = w> AND <21 = d> AND <1 = f> ----> No
<4 = n> AND <19 = w> AND <21 = g> ----> e
<4 = n> AND <19 = w> AND <21 = l> AND <2 = y> ----> No
<4 = n> AND <19 = w> AND <21 = l> AND <2 = c> ----> e
<4 = n> AND <19 = w> AND <21 = l> AND <2 = w> ----> No
<4 = n> AND <19 = w> AND <21 = l> AND <2 = n> ----> e
<4 = n> AND <19 = y> ----> e
<4 = n> AND <19 = h> ----> e
<4 = n> AND <19 = k> ----> e
<4 = n> AND <19 = r> ----> No
<4 = n> AND <19 = o> ----> e
<4 = n> AND <19 = n> ----> e

递归获取Dictionary中的所有嵌套元素

2 个答案:

<强> 更新