Question

我目前正在编写一个项目，该项目需要第三方代码，该代码使用返回其自身迭代器的方法，这是我的代码中的一个示例：

$this->load->model($this->mname.'/add_post_model');

目前这只会使我的代码变得混乱，并且在3个级别之后变得难以阅读。理想情况下，我会让它做这样的事情：

def generate():
    for x in obj.children():
        for y in x.children():
            for z in y.children():
                yield z.thing

有没有内置的方法在Python中执行此操作？

Answer 1

从python3.3开始，您可以使用yield from语法生成整个生成器表达式。

因此，您可以稍微修改一下您的函数，以获取几个参数：

def generate(obj, n):
    if n == 1:
        for x in obj.children():
            yield x.thing
    else:
        for x in obj.children():
            yield from generate(x, n - 1)

yield from表达式将产生递归调用的整个生成器表达式。

按照以下方式调用您的函数：

x = generate(obj, 3)

请注意，这会返回x.things的生成器。

根据您的特定要求，这是使用getattr的更通用的版本，可以使用任意属性。

def generate(obj, iterable_attr, attr_to_yield, n):
    if n == 1:
        for x in getattr(obj, iterable_attr):
            yield getattr(x, attr_to_yield)
    else:
        for x in getattr(obj, iterable_attr):
            yield from generate(x, iterable_attr, attr_to_yield, n - 1)

现在，将您的功能称为：

x = generate(obj, 'children', 'thing', 3)

Answer 2

上面的yield from示例很好，但我非常怀疑需要的级别/深度参数。适用于任何树的更简单/更通用的解决方案：

class Node(object):
  def __init__(self, thing, children=None):
    self.thing = thing
    self._children = children
  def children(self):
    return self._children if self._children else []

def generate(node):
  if node.thing:
    yield node.thing
  for child in node.children():
    yield from generate(child)

node = Node('mr.', [Node('derek', [Node('curtis')]), Node('anderson')])
print(list(generate(node)))

返回：

$ python3 test.py
['mr.', 'derek', 'curtis', 'anderson']

请注意，这将返回当前节点thing之前的任何子节点。（IE在行走的过程中表达了自己的意思。）如果您希望在回到路上的路上表达自己，请交换if和for语句。（DFS与BFS）但在您的情况下可能并不重要（我怀疑某个节点有thing或子节点，而不是两者都有。）

Answer 3

如果使用Python 2.7，您需要保留自己的可迭代堆栈并进行循环：

from operator import methodcaller

def recursive(obj, iterater, yielder, depth):
    iterate = methodcaller(iterater)
    xs = [iterate(obj)]
    while xs:
        try:
            x = xs[-1].next()
            if len(xs) != depth:
                xs.append(iterate(x))
            else:
                yield getattr(x, yielder)
        except StopIteration:
            xs.pop()

这是一个来自可迭代函数的更通用的递归ichain的特例：

def recursive_ichain(iterable_tree):
    xs = [iter(iterable_tree)]
    while [xs]:
        try:
            x = xs[-1].next()
            if isinstance(x, collections.Iterable):
                xs.append(iter(x))
            else:
                yield x
        except StopIteration:
            xs.pop()

还有一些测试对象：

class Thing(object):
    def __init__(self, thing):
        self.thing = thing

class Parent(object):
    def __init__(self, *kids):
        self.kids = kids

    def children(self):
        return iter(self.kids)

test_obj = Parent(
    Parent(
        Parent(Thing('one'), Thing('two'), Thing('three')),
        Parent(Thing('four')),
        Parent(Thing('five'), Thing('six')),
    ),
    Parent(
        Parent(Thing('seven'), Thing('eight')),
        Parent(),
        Parent(Thing('nine'), Thing('ten')),
    )
)

测试它：

>>>for t in recursive(test_obj, 'children', 'thing', 3):
>>>    print t
one
two
three
four
five
six
seven
eight
nine
ten

Personnaly我倾向于将yield getattr(x, yielder)更改为yield x以访问叶子对象本身并显式访问该事物。即。

for leaf in recursive(test_obj, 'children', 3):
    print leaf.thing

递归调用返回其自身迭代器的对象方法

3 个答案: