python模块，调用模块中的主类

这是我的主模块，我可以用它调用其他模块的函数：

#main.py
from module_1 import module_1

class APP:
    def option(self):
        print("[1]:.....\n[2]:.......")
        option = int(input(":"))
    
        if (option == 1):
            module_1().do_something_1()     #I called module_1
APP().option()

假设用户选择了第一个选项，程序将调用模块_1中的函数

#module_1.py

class module_1:
    def do_something_1(self):
        #.........................
        again = input("Do you wanna start again?")
        if (again == "Y"):
            #what I'm trying to do is here, I want to return the option function again in main.py
        else:
            #................

用户想重新启动程序，并向Y询问，程序如何返回main.py（APP（）.option（））？

---

[UPTADE\u 1]

我原以为循环导入在这里对我有效，但出现了一个错误

main.py：

#main.py
from module_1 import module_1

class APP:
    def option(self):
        print("[1]:.....\n[2]:.......")
        option = int(input(":"))

        if (option == 1):
            module_1().do_something_1()     #I called module_1
APP().option()

from File import*
class Options:
    def __init__(self):
        #...................
    def ask(self):
        try:
            option=int(input("==>"))
        except Exception as error:
            #......................................
            return Options().ask()

        if option==1:
            File().delete_all_files_extension()
        elif option==2:
            #.........
        elif option==3:
            #.........
        elif option==4:
           #..........
        elif option==5:
            #.........
        elif option==6:
            sys.exit()

Options().ask()

模块_1.py：

from main import APP
class module_1:
    def do_something_1(self):
        print(".........")
        again = input("Do you wanna start again?")

        if again=="Y":
            return APP().option()
        else:
            #.......

我收到这个错误：

.............................
from main import APP
ImportError: cannot import name 'APP' from partially initialized module 'main' (most likely due to a circular import)
.............................

---

[UPTADE_2]（之后）

main.py：

#main.py
from module_1 import module_1

class APP:
    def option(self):
        print("[1]:.....\n[2]:.......")
        option = int(input(":"))

        if (option == 1):
            module_1().do_something_1()     #I called module_1
APP().option()

from File import*
class Options:
    def __init__(self):
        #...................
    def ask(self):
        try:
            option=int(input("==>"))
        except Exception as error:
            #......................................
            return Options().ask()

        if option==1:
            File().delete_all_files_extension()
        elif option==2:
            #.........
        elif option==3:
            #.........
        elif option==4:
           #..........
        elif option==5:
            #.........
        elif option==6:
            sys.exit()

Options().ask()

假设用户选择了第一个选项，程序将调用文件中的函数

import sys
import os
class File:
    def __init__(self):
        
        self.deleted_files_number = 0
        self.deleted_files_extension_number = 0
    
    def delete_all_files(self):

        try:
            path = input("[+]Path:")
        except Exception as error:
            print("ERROR:%s"%error)
            #.....................
            #I want to return the option function again in main.py

        try:
            file = open("log[delete_all_files].txt","w")
            if (os.path.exists(path)==True):
                for r,d,f in os.walk(path):
                    for file in f:
                        time.sleep(0.001)
                        print("[*]%s" %os.path.join(r,file))
                        os.remove(os.path.join(r,file))
                        open("log[delete_all_files].txt","a+").write(str(os.path.join(r,file)+"\n"))
                        self.deleted_files_number +=1

                print("[*]Deleted %s file" %self.deleted_files_number)
                again=input("[+]Do you wanna start again?[Y/N]").upper()
                if (again=="Y"):
                    #here it is, the program has to go back to main.py so it can show what can be selected again.
                else:
                    exit()

---

我的意思是，如果模块内发生错误或其他情况，程序将返回，而不是在模块完成其工作后返回。

在您的示例中，在

main.py

中，您调用

APP.option（）

APP.option（）

调用

module_1（）.do_1（）

，其中

module_1

是从

module_1

导入的类

您需要

module_1（）。执行某些操作，然后再次调用
APP.option（）
（在特定条件下）

几句话：


您最好遵循Python命名约定并命名
APP
APP
在名为
module_1
的类中包装模块
module_1
的功能似乎没有什么用处；所有这一切让你得到的是两个完全不同的实体共享相同的名称。如果您想捕获类中的功能，您可能应该给它起个名字，提醒使用它的开发人员它的功能
您正在调用
APP（）.option（）
，这意味着您每次都在实例化一个新对象，每次都使用一个新菜单创建一个新的
APP（）
最重要的是，由于
APP.option（）
可以无限期地调用
module\u 1（）.do\u 1
，而
module\u 1（）.do\u 1
可以调用
APP.option（）
，因此您可能会创建一个应用程序，最终耗尽递归深度

面向对象的软件设计就是为你的类选择正确的范围，给它们明确的任务，封装行为和数据，使它们清晰地结合在一起；创建更易于维护和扩展的软件

应用程序
类的主要功能似乎是向用户提供选项并执行匹配功能。
模块_1
的主要功能似乎是“做点什么”，然后返回主循环。您希望再次向用户提供选项，或允许他们在“执行某些操作”后退出应用程序

从设计的角度来看，让
应用程序向用户提出“重新开始”的问题似乎更有意义-毕竟，它与
模块1中所做的事情无关。如果它确实取决于那里发生了什么，那么让
do\u something\u 1（）
方法返回一个结果并根据返回的值决定是否继续是有意义的

您甚至可以根据您向用户提出的问题来确定返回值，尽管我不喜欢这个设计决策：

if again=="Y":
    return True
else:
    # ... do something else ...
    return False

在
main.py
中：

    def option(self):
        again = True
        while again:
            print("[1]:.....\n[2]:.......")
            option = int(input(":"))

            if (option == 1):
                again = module_1().do_something_1()

另一个解决方案是创建
模块1
，将它所属的
应用程序作为所有者传递，并在对象中保留对它的引用。比如：

def __init__(self, owner):
    self.owner = owner

# ...

        if again=="Y":
            return self.owner.option()

这解决了对象创建问题，但当然仍然是循环的

您可以让模块相互导入部分，正确的方法是将它们添加到包中。但是，您仍然需要找到绕过类的循环创建的方法—如果
Class1
创建了
Class2
的实例，但是
Class2
创建
Class1
的一个实例，您可以看到它的去向

像这样的东西有什么问题：

main.py

from module_1 import Class_1

class App:
    def menu(self):
        run_menu = True
        while run_menu :
            print("[1]:.....\n[2]:.......")
            option = int(input(":"))

            if (option == 1):
                Class_1().do_something_1()

            print(".........")
            run_menu = input("Do you wanna start again?") == "Y"

App().menu()

class Class_1:
    def do_something_1():
        print('doing something')
        return

module_1.py

from module_1 import Class_1

class App:
    def menu(self):
        run_menu = True
        while run_menu :
            print("[1]:.....\n[2]:.......")
            option = int(input(":"))

            if (option == 1):
                Class_1().do_something_1()

            print(".........")
            run_menu = input("Do you wanna start again?") == "Y"

App().menu()

class Class_1:
    def do_something_1():
        print('doing something')
        return

你遇到的问题更多的是设计问题，而不是语言问题。如果您有一个功能示例，您认为循环导入是一项要求，那么您可能应该发布一个带有该示例的问题，但是您可能会被标记为循环导入问题的重复

简短的回答是：几乎总是有更好的解决方案。
第二个代码示例中的
类模块是实际的
类还是
模块？您正在从
module\u 1
导入
do\u something\u 1
，但从未导入该类。你应该像从模块导入模块一样导入它。做些什么？是吗？哦，伙计，那是我的错，我会解决的。这不是Java。你不需要把所有的东西都放在课堂上。（见鬼，即使这是Java，你也可以使用静态方法。）@user2357112supportsMonica，我知道这一点，但我不想让模块混淆，因为我要做的程序很长。你的类在这方面没有任何帮助。模块级功能会更清晰。首先，感谢您对命名的建议。回到问题上来；我制作的模块运行时出现反弹。因此，在上一个示例中，在模块完成其工作后，程序会询问是否要继续，但我尝试做的是，例如，在模块继续其工作时发生错误，模块会询问是否应该再次运行。我想我最好多分享一些我的代码。