用面向对象的方法导入Python

这个问题涉及到什么时候应该为Python模块导入，以及当您试图采用面向对象的方法来实现所做的工作时，这些模块是如何相互作用的

假设我们有以下模块：

ClassA.py：

class Class_A:

    def doSomething(self):
        #doSomething

B.py类

class Class_B:

    def doSomethingElse(self):
        #doSomethingElse

c.py类

class Class_C:

    def __init__(self, ClassAobj, ClassBobj):
        self.a = ClassAobj
        self.b = ClassBobj

    def doTheThing(self):
        self.a.doSomething()
        self.b.doSomethingElse()

Main.py：

from ClassA import Class_A
from ClassB import Class_B
from ClassC import Class_C

a = Class_A()
b = Class_B()
c = Class_C(a,b)

在这里，

Class_C

使用

Class_A

和

Class_B

的对象，但是它没有这些类的导入语句。你认为这会造成错误吗？还是这样好？这样做是不好的做法吗

在

Class\u C

内部为

Class\u A

和

Class\u B

导入会不会导致整个程序使用更多内存，因为它会同时为

Main.py

和

ClassC.py

导入它们？或者Python编译器会看到那些模块已经被导入并跳过它们吗

---

我只是想弄清楚Python作为一种语言，在导入和使用模块方面是如何起作用的。基本上，如果在程序的最顶层（您的主功能），如果您在那里导入所有内容，那么其他模块中的导入语句是否冗余？

C

不需要

导入
语句；它只使用一对对象句柄（即指针）。只要它不尝试访问这些对象的任何方法或属性，纯赋值就可以了。如果确实需要此类添加，则需要
import
语句

这不会在已导入的
Main
：Python检查（与大多数语言一样）包中导致额外的内存使用，并且不会多次导入一个。请注意，这有时意味着您必须注意包的依赖关系和导入顺序。
导入模块需要做两件事：它执行存储在模块中的代码，并向进行导入的模块添加名称绑定
ClassC.py
不需要导入
ClassA
或
ClassB
，因为它不知道或不关心
ClassC.\uuu init\uuuu
的参数有哪些类型，只要它们在使用时行为正常。任何一个对象所需的对代码的引用都存储在对象本身中。
您不需要在类C中直接使用类A或类B，因此不需要将它们导入其中

额外的导入实际上并不使用额外的内存，内存中只有每个模块的一个实例。导入只是在当前模块命名空间中为模块创建一个名称

在Python中，每个文件只有一个类不是惯用的做法。在同一个文件中有密切相关的类是正常的。模块名“ClassA”看起来很傻，这是一个类的名称，而不是一个模块的名称

您只能在另一个模块中使用导入的模块。例如，Python启动后，
sys
模块可能已经在内存中，因为很多东西都在使用它，包括import语句

import foo
语句执行两件事：


如果
foo
模块还没有在内存中，它将被加载、解析、执行，然后放入
sys.modules['foo']
中
将创建一个本地名称
foo
，该名称也引用
sys.modules
中的模块

因此，如果您在模块中（不是在函数中）说了一个
print（）
，那么这只会在第一次导入模块时执行

然后，导入之后的语句可以使用
foo
，比如
foo.somefunc（）
或
print（foo.\uuu name\uuuu）
，这就是它的意义所在。解释器不关心
ClassAobj
是什么-它只关心该类提供您对该对象调用的方法（例如，当您调用
self.a.doSomething（）
时，则必须为此实例定义此方法）。抱歉，我刚刚进行了编辑，因为
Class_C
应该调用
Class_A
和
Class_B
中的方法。至于“不要每个模块放一个类”，是的，我理解。：）