Python 如果脚本需要第一个函数，如何执行脚本中的第二个函数？

我认为这是基本的，我已经看到了我所问问题的多个版本，尽管它们都不是我所面临的

我有一个脚本，目前有两个函数，我希望能够调用第二个函数，但它需要运行第一个函数。我的脚本仍然凌乱，因此我使用了一个示例：

def func1(input):    # Does something with input data
    my_list = []
    for i in input:
        my_list.append(i)
    return my_list  # Returns a list

func1_list = func1(x) # Save the result from func1 into a variable

def func2(func1_list):   
    my_final_list = []       # This function just edits the first list          
    for val in my_list:       # Results from func2 are needed later on         
        temp = val**3
        my_final_list.append(temp)
    return my_final_list

是否有一种方法可以在导入脚本时执行第二个函数而不必调用第一个函数？我不知道在func2中在哪里输入func1_list变量，这样任何人都可以直接进入func2并运行它（并且它将自动执行func1）

编辑：

---

func1和func2都应该能够单独执行-func2依赖于func1。两者都将显示信息（func2仅显示修改后的信息）。示例：func1将运行一些输入并显示原始结果，而func2将获取该原始结果并对其进行修改。如果需要，我希望能够查看原始和修改的结果。

如果希望

func1\u list=func1（x）

仅在直接执行脚本时调用，则需要稍微修改脚本，以便从模块调用时忽略它。您将使用这样的if条件：

if __name__ == '__main__':
    func1_list = func1(x) # Save the result from func1 into a variable

func1_results = None

def func1(input):
    # do some magic to my_list with input
    func1_results = my_list
    return my_list

def func2(input):
    if not func1_results:
        func1(input) # this will only run if func1 hasn't been called yet
    # do some magic to make func2's my_list
    return my_list  # you could similarly make a construct to save these results   

\uuuu name\uuuuuu

仅在直接调用脚本时才等于

\uuuuuu main\uuuuuuu

，因此从模块调用脚本时不会执行

---

---

有关其工作原理的详细说明，请参见。

如果您试图导入脚本，则必须遵循最佳实践和约定

在不开始构建完整包的情况下，您至少需要确保不执行导入模块时未请求的代码

要么将代码包装到

类中

，要么从模块根中删除函数调用，并提供一个

init_function（）

，必须调用该函数来准备环境

使用init_函数（）并不羞耻，很多库都是这样做的

但是，我建议您在中构造代码。

函数manager.py的示例：

class FunctionsManager:
    def __init__(self):  
        self.func1_list = self.func1(x) # Save the result from func1 into a variable

    def func1(self, input):    # Does something with input data
        my_list = []
        for i in input:
            my_list.append(i)
        return my_list  # Returns a list

    def func2(self, func1_list):   
        my_final_list = []       # This function just edits the first list          
        for val in my_list:       # Results from func2 are needed later on         
            temp = val**3
            my_final_list.append(temp)
        return my_final_list

然后在主代码中：

from FunctionsManager import FunctionsManager

manager = FunctionsManager() # Calls __init__() and so func1()
result = manager.func2(yourlist)

请注意，您的问题基本上是要求提供一个关于。你最好仔细阅读一下。它与语言无关——它对Java的应用和对Python的应用一样好

有几种不同的方法可供选择；最佳选择取决于您的需求以及相关功能的功能（这就是我在评论中问所有问题的原因）

您正在寻找的最简单的形式就是让一个函数调用另一个函数。（COLDSPEED提到了这一点。）：

在这种情况下，func1和func2都可以被调用。导入代码不必担心在func2之前调用func1-这由func2负责

在讨论其他选项之前，您提到了这两个函数都输出信息。将计算结果与输出结果分开是一种很好的做法。所以，不要这样做：

def func1(input):
    # do some magic to my_list with input
    print("func1: Stuff from my list...")
    return my_list

def func2(input):
    func1_list = func1(input)
    print("func2: Stuff from my list...")
    # do some magic to make func2's my_list
    return my_list

因为调用
func2
会打印出“func1”行和“func2”行。相反，将逻辑与输出分开。它可能看起来更复杂，但它为您提供了更多的构建块：

def func1(input):
    # do some magic to my_list with input
    return my_list

def func2(input):
    func1_list = func1(input)
    # do some magic to make func2's my_list
    return my_list

def output_func1(input):
    func1_list = func1(input)
    print("func1_list stuff")

def output_func2(input):
    func2_list = func2(input)
    print("func2_list stuff")

现在你有了很多可重用的函数，它们不会产生很多噪音

这是一个很好的步骤，您可以轻松地使用它。如果运行
func1
需要一个小时，会发生什么情况？如果已经运行过，则不希望再次运行它。然后您需要使用模块变量来保存状态。大概是这样的：

if __name__ == '__main__':
    func1_list = func1(x) # Save the result from func1 into a variable

func1_results = None

def func1(input):
    # do some magic to my_list with input
    func1_results = my_list
    return my_list

def func2(input):
    if not func1_results:
        func1(input) # this will only run if func1 hasn't been called yet
    # do some magic to make func2's my_list
    return my_list  # you could similarly make a construct to save these results   

现在，只有在需要时，代码才会调用其依赖项。我们正在好转。但我们将输入传递到func2，我们只关心func1中的输入。您可以创建func1引用的模块变量
input
，导入代码可以在调用任何func之前进行设置：

input = None
def func1():
    # do some magic to my_list with module variable input

并将其作为：

import my_funcs
my_funcs.input = "Happy happy input!"
my_funcs.func1() # or just my_funcs.func2(), etc.

这可能很好，但很危险-如果导入代码没有设置
输入
，该怎么办？解决这个问题的方法是Fabien提到的关于拥有一个类：

class FuncRunner(object):
    def __init__(self, input):
        self.input = input
        self.func1_results = None
    def func1(self):
        # do some magic to local my_list with input
        self.func1_results = my_list
        return my_list
    def func2(self):
        if not self.func1_results:
            self.func1()
        # do some magic to make func2's my_list
        # maybe save the result as self.func2_results ?
        return my_list

这将被调用为：

from my_funcs import FuncRunner
runner = FuncRunner("Happy happy input!")
foo = runner.func1()  # or foo = runner.func2(), as per your needs

这样做的好处是不允许您在不构建对象的情况下运行函数，而且按照
\uuuu init\uuuu
的结构，如果不传递
输入，就无法创建对象。由
func1
找到的结果存储在对象中，因此它们总是关联在一起。在您的情况下，这可能是实现所需功能的最干净的方法。
从代码的模块范围中删除
func1\u list=func1（x）
，然后您可以导入而无需调用
func1
。编写一个执行
func1\u list=func1（x）的包装器
在调用
func2
之前，函数是闭包，因此您可以简单地从函数中删除
func1\u列表
参数（并将my\u列表中val的
更改为
func1\u列表中val的
或更好：
返回[val**3用于func1\u列表中的val]
。或者你可以让
func2
调用
func1
。我认为你需要退一步，解释一下你真正想做的事情。这个问题没有太多意义，而且很难理解你想解决的根本问题。如果你最终调用
func2
，
我的列表
将给出一个
名称错误
哦，我听说过这个，从来没有真正理解过。但是当你说它是直接调用的时候，这意味着什么？我导入了我的脚本，所以它不是被直接调用的吗？我也只是尝试将变量放入函数中，这似乎有效，但我不确定这是否有效最佳实践。如果文件名为
A.py
，则运行
python A.py
将导致执行该行。但在
B.py中执行
导入A