我有多个(python)模块，在这些模块中我使用相同的输入数据，并且变量也具有相同的名称。

我创建了一个模块 data_loading.py，其中实例化了变量。然后我在 data_analysis_xx 模块中导入我需要的变量。

例如，

" Module data_analysis_1 " 
from data_loading import var_1, var_2,…, var_k  
 
" Module data_analysis_2 " 
from data_loading import var_1, var_3

通过这种方式，我避免了在每个模块中复制和粘贴相同的 200 行代码来加载相同或部分相同的数据集

第一个问题:

使用单一源模块加载数据是否正确？是否有标准方法或更好的方法在多个模块中导入相同的变量？

问题:

然而，当我导入 data_loading 时，其中的所有变量都会被加载/处理，即使我实际上只导入了一个或几个变量。这可能很耗时，尤其是因为在 data_loading 中我还进行了一些基本的数据操作(检查、拆分、剪切、排序等)

第二个问题:

如何让 data_loading 模块工作，使得只有真正需要加载/处理的变量才被实际处理？

可能的解决方案

在多个子模块中拆分 data_loading --> 稍微减少了问题但增加了要加载的文件数量:复杂性、caos、容易出错。不好
创建一个处理数据加载的类并通过该类仅加载变量？如何实际做到这一点？那我该如何导入变量呢？ “from data_loading import Loader.var_1 as var_1 …, Loader.var_k as var_k”？
实现延迟加载 --> 我的许多变量都是处理实际数据加载(从文件中检索数据)的类。因此，延迟加载将有助于减少时间方面的总成本。

引用资料:
- How to lazy load a data structure (python)
- 通过描述符缓存函数(描述符:https://docs.python.org/3/howto/descriptor.html#descriptor-protocol)
- https://github.com/pallets/werkzeug/blob/10b4b8b6918a83712170fdaabd3ec61cf07f23ff/werkzeug/utils.py
- https://stackoverflow.com/a/6849299/7074426

请您参考如下方法:

处理所有问题的一种方法是创建一个工厂，该工厂将按需创建单例。

通过这两种设计模式，您可以实例化类并仅在需要时创建变量(工厂)，并且您可以重用它们而无需在多个模块中再次计算它们(单例)

编辑1

这是一个带有伪代码示例的实用应用程序。

在我的脚本中，我需要变量来计算一些东西。这些变量是:具有定义的 float 的 pi、数个数的斐波那契和素数。

我创建了一个带有函数的脚本来计算我需要的每个变量，但每个函数都有一个缓存来捕获计算值。

#compute_variables.py 
 
def pi(n): 
    pass 
 
def fibonaci(n): 
    pass 
 
def prime_number(n): 
    pass

所有这些函数都是计算密集型的，每个变量应该只计算一次。

现在我需要一个类，它将在一个单例中返回所需的 vaibales allready 计算(每次只返回一个对象)

#variables.py 
 
class Calculus1: 
 
    def __new__(cls): 
        #singleton logic 
 
    def __init__(self, a, b, c): 
        self.a = a 
        self.b = b 
        self.c = c 
 
    def var1(self): 
        return pi(self.a) 
 
    def var2(self): 
        return fibonaci(self.b) 
 
    def var3(self): 
        return prime_number(self.c)    
 
class Calculus2: 
 
    def __new__(cls): 
        #singleton logic 
 
    def __init__(self, a, b, e): 
        self.a = a 
        self.b = b 
        self.e = e 
 
    def var1(self): 
         return pi(self.a) 
 
    def var2(self): 
        return fibonaci(self.b) 
 
    def var3(self): 
        return prime_number(self.e)

我有熊骨，知道我需要一个返回变量类单例的工厂。

# factory_meth.py 
 
def  factory(var_class_name): 
    # Factory logic here  
    myVars = CalculusX(x, y, z) 
    return myVars

最后我在我的应用程序中使用了所有这些实现。

from  factory_meth import factory 
 
def fancy_something_1(f, g): 
    vars = factory("Calculus2") 
    return      (f * vars.vars1 / (vars.vars2 + vars.vars3))**g 
 
def fancy_something_2(z ,h): 
    vars = factory("Calculus2") 
    return  z + vars.vars1 vars.vars2 + vars.vars3 + h

在这个逻辑下，所有的变量只会在需要的时候被调用和计算(工厂)，即使一个变量被调用，也不会因为它返回相同的对象而进行计算(单例)。

注意事项

上述架构是实现延迟加载和按需调用的一种方式，但设计可能会根据您的需要进行调整。

python之如何(惰性)数据从多个 python 模块加载相同的大数据集