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

Question

我有多个(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 模块工作，使得只有真正需要加载/处理的变量才被实际处理？

可能的解决方案

1. 在多个子模块中拆分 data_loading --> 稍微减少了问题但增加了要加载的文件数量:复杂性、caos、容易出错。不好

2. 创建一个处理数据加载的类并通过该类仅加载变量？如何实际做到这一点？那我该如何导入变量呢？“from data_loading import Loader.var_1 as var_1 …, Loader.var_k as var_k”？

3. 实现延迟加载 -->我的许多变量都是处理实际数据加载(从文件中检索数据)的类。因此，延迟加载将有助于减少时间方面的总成本。

   引用资料:

   • 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

Answer 1

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

• factory
• singleton

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

编辑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   

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

注意事项

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