Question

我试图使用递归来实现这个函数，该函数接受一个函数参数f，当传递一个值时，它将返回true或false。它应该检查列表中的所有值并将所有真值存储在列表中，并将false值存储在另一个列表中，并将它们返回到元组中。

def divL(f, l):

     if not l:
          return ([],[])


     else:
          a = list()
          b = list()
          for i in range(len(l)):

               if f(l[i]):
                    a.append(l[i])

               else:
                    b.append(l[i])

          return (a, b)

Answer 1

要递归地解决这个问题，那么你可以从：

开始

def div_l(fn, elements):
    if not elements:
        return ([], [])
    else:
        trues, falses = div_l(fn, elements[1:])
        if fn(elements[0]):
            trues.append(elements[0])
        else:
            falses.append(elements[0])
        return (trues, falses)

有关您的代码需要注意的一点是，目前还没有递归调用。在上面的代码中，我们的基本情况是元素列表为空（if not elements）。然后，我们会不断检查列表的第一个元素，看它是否满足fn，并将其适当地附加到trues或falses。然后我们将列表中除了第一个（elements[1:]）之外的所有元素再次传递给函数，并重复直到列表为空。

话虽如此，问题本质上似乎并不是递归的。为什么不使用list comprehensions：

a = [element for element in l if f(element)]
b = [element for element in l if not f(element)]

此外，a，b，l和f这样的名称并不是很好，因为他们没有说明他们的真实含义。

关于到目前为止编写代码的方式，迭代遍历列表元素的Pythonic方法与C / C ++ / Java /等语言不同;你应该很少需要使用他们的索引来获取列表项。相反，您可以按如下方式重新编写for statement：

for element in l:
   if f(element):
        a.append(element)

   else:
        b.append(element)

P.S。我还没有测试过上面的代码，但它应该是一个合理的起点。

Answer 2

递归版。

但我同意其他人的看法，如果没有递归，最好这样做。

def divL(f, l):

    if not l:
        return ([],[])
    else:
        a, b = divL(f,l[1:])

        if f(l[0]):
            a.insert(0, l[0])
        else:
            b.insert(0, l[0])

        return (a, b)

#-- test ---

def f(x): return x > 0

divL(f,[1,-2,3,4,2,-5])

([1, 3, 4, 2], [-2, -5])

Answer 3

将拆分列表作为参数的递归函数：

def _R(f, l, ts, fs):
  if not l:
    return ts, fs
  if f(l[0]):
    return _R(f, l[1:], ts + l[:1], fs)
  return _R(f, l[1:], ts, fs + l[:1])

def R(f, l):
  return _R(f, l, [], [])

print R( lambda x: x > 10, range(20) )

使用递归划分列表

3 个答案: