Question

我知道这是超级基本的，我一直在寻找，但我仍然对我所看到的一切感到困惑，并且我不确定最好的方法来做到这一点并且我很难绕过它

我有一个脚本，我有多个功能。我希望第一个函数将它的输出传递给第二个，然后第二个函数将它的输出传递给第三个，等等。每个函数在整个过程中执行它自己的步骤到开始数据集。

例如，非常简化的名称不好，但这只是获得基本结构：

#!/usr/bin/python
# script called process.py
import sys
infile = sys.argv[1]

def function_one():
    do things
    return function_one_output

def function_two():
    take output from function_one, and do more things
    return function_two_output

def function_three():
    take output from function_two, do more things
    return/print function_three_output

我希望它作为一个脚本运行并将输出/写入打印到新文件或我知道如何操作的任何内容。目前还不清楚如何将每个函数的中间输出传递给下一个等等。

infile - ＆gt; function_one - ＆gt; （intermediate1） - ＆gt; function_two - ＆gt; （中间2） - ＆gt; function_three - ＆gt;最终结果/文件

我知道我需要使用return，但我不确定如何在最后调用它以获得我的最终输出

独立？

function_one(infile)
function_two()
function_three()

或彼此之间？

function_three(function_two(function_one(infile)))

或在实际功能中？

def function_one():
    do things
    return function_one_output

def function_two():
    input_for_this_function = function_one()

# etc etc etc

谢谢各位朋友，我过度复杂，需要一种非常简单的方法来理解它。

Answer 1

正如ZdaR所提到的，你可以运行每个函数并将结果存储在一个变量中，然后将其传递给下一个函数。

def function_one(file):
    do things on file
    return function_one_output

def function_two(myData):
    doThings on myData
    return function_two_output

def function_three(moreData):
    doMoreThings on moreData
    return/print function_three_output

def Main():
    firstData = function_one(infile)
    secondData = function_two(firstData)
    function_three(secondData)

这假设你的function_three会写入文件或者不需要返回任何内容。如果这三个函数总是一起运行，另一种方法是在function_three中调用它们。例如......

def function_three(file):
    firstStep = function_one(file)
    secondStep = function_two(firstStep)
    doThings on secondStep
    return/print to file

然后你要做的就是在main中调用function_three并传递文件。

Answer 2

为了安全，可读性和调试方便，我会暂时存储每个功能的结果。

def function_one():
    do things
    return function_one_output

def function_two(function_one_output):
    take function_one_output and do more things
    return function_two_output

def function_three(function_two_output):
    take function_two_output and do more things
    return/print function_three_output

result_one = function_one()
result_two = function_two(result_one)
result_three = function_three(result_two)

此处的额外好处是您可以检查每个功能是否正确。如果最终结果不符合您的预期，只需打印您获得的结果或执行其他检查以验证它们。（如果你在解释器上运行，它们将在脚本结束后保留在命名空间中，以便您以交互方式测试它们）

result_one = function_one()
print result_one
result_two = function_two(result_one)
print result_two
result_three = function_three(result_two)
print result_three

注意：我使用了多个结果变量，但是作为注释中的PM 2Ring注释，您可以反复重复使用名称结果。如果结果是大变量，这将特别有用。

Answer 3

总是更好（为了可读性，可测试性和可维护性）使您的功能尽可能地解耦，并且编写它们以使输出仅在可能的情况下取决于输入。

因此，在您的情况下，最好的方法是独立编写每个函数，即：

def function_one(arg):
    do_something()
    return function_one_result

def function_two(arg):    
    do_something_else()
    return function_two_result

def function_three(arg):    
    do_yet_something_else()
    return function_three_result

一旦你在那里，你当然可以直接链接电话：

result = function_three(function_two(function_one(arg)))

但是如果需要记录/调试/错误处理等，你也可以使用中间变量和try / except块：

r1 = function_one(arg)
logger.debug("function_one returned %s", r1)
try:
    r2 = function_two(r1)
except SomePossibleExceptio as e:
    logger.exception("function_two raised %s for %s", e, r1)
    # either return, re-reraise, ask the user what to do etc
    return 42 # when in doubt, always return 42 !
else:
   r3 = function_three(r2)
   print "Yay ! result is %s" % r3

作为额外奖励，您现在可以在任何地方重复使用这三个功能，每个功能都可以在任何顺序上使用。

注意：当然有些情况下，从另一个函数调用函数是有意义的......比如，如果你最终写的话：

result = function_three(function_two(function_one(arg)))

代码中的任何地方并且它不是偶然的重复，可能是时候将整体包装在一个函数中了：

def call_them_all(arg):
    return function_three(function_two(function_one(arg)))

请注意，在这种情况下，分解通话可能会更好，因为您将发现何时需要调试它...

Answer 4

我这样做：

def function_one(x):
    # do things
    output = x ** 1
    return output

def function_two(x):
    output = x ** 2
    return output

def function_three(x):
    output = x ** 3
    return output

请注意，我已修改函数以接受单个参数x，并为每个参数添加基本操作。

这具有以下优点：每个功能独立于其他功能（松散耦合），这允许它们以其他方式重用。在上面的示例中，function_two()返回其参数的平方，并function_three()返回其参数的多维数据集。每个都可以独立于代码中的其他地方进行调用，而不会被纠缠在一些硬编码的调用链中，例如，如果从另一个函数调用一个函数，则会被调用。

你仍然可以像这样打电话给他们：

>>> x = function_one(3)
>>> x
3
>>> x = function_two(x)
>>> x
9
>>> x = function_three(x)
>>> x
729

正如其他人指出的那样，

有助于错误检查。

或者像这样：

>>> function_three(function_two(function_one(2)))
64

如果您确定这样做是安全的。

如果您想计算数字的方形或立方体，可以直接调用function_two()或function_three()（当然，您可以恰当地命名这些函数）。

Answer 5

您可以定义数据流辅助函数

from functools import reduce

def flow(seed, *funcs):
    return reduce(lambda arg, func: func(arg), funcs, seed)

flow(infile, function_one, function_two, function_three)

#for example
flow('HELLO', str.lower, str.capitalize, str.swapcase)
#returns 'hELLO'

Answer 6

使用d6tflow，您可以轻松地将复杂的数据流链接在一起并执行它们。您可以快速加载每个任务的输入和输出数据。它使您的工作流程非常清晰直观。

import d6tlflow

class Function_one(d6tflow.tasks.TaskCache):
    function_one_output = do_things()
    self.save(function_one_output) # instead of return

@d6tflow.requires(Function_one)
def Function_two(d6tflow.tasks.TaskCache):
    output_from_function_one = self.inputLoad() # load function input
    function_two_output = do_more_things()
    self.save(function_two_output)

@d6tflow.requires(Function_two)
def Function_three():
    output_from_function_two = self.inputLoad()
    function_three_output = do_more_things()
    self.save(function_three_output)
    
d6tflow.run(Function_three()) # executes all functions

function_one_output = Function_one().outputLoad() # get function output
function_three_output = Function_three().outputLoad()

它具有许多有用的功能，例如参数管理，持久性，智能工作流管理。参见https://d6tflow.readthedocs.io/en/latest/

Answer 7

这种方式function_three(function_two(function_one(infile)))是最好的，你不需要全局变量，每个函数完全独立于另一个。

编辑添加：

我还会说function3不应该打印任何东西，如果你想打印返回的结果使用：

print function_three(function_two(function_one(infile)))

或类似的东西：

output = function_three(function_two(function_one(infile)))
print output

Answer 8

使用参数传递值：

def function1():
    foo = do_stuff()
    return function2(foo)

def function2(foo):
    bar = do_more_stuff(foo)
    return function3(bar)

def function3(bar):
    baz = do_even_more_stuff(bar)
    return baz

def main():
    thing = function1()
    print thing

Python - 多个函数 - 输出一个到下一个

8 个答案: