递归地从字典中获取所有嵌套元素

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

较短：

# 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)

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

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

Answer 2

更新：

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

更新了Dict和函数

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