一遍又一遍地将相同的 dataframe 传递给 Python 中的不同类和函数

Question

The first step of my program is to get the data. After that I am finding myself passing this data to all the different classes (with also a config dictionary variable) over and over again.

So I am wondering if there is a better way to just store the data somewhere and make it available to all classes and functions, without passing them as a parameter.

Thank you

Edit: here is a code example

go.py

config = {
    'mode' : 'single',
    'data' : { },
    'strategy' : { },
    'view' : { }
}

stratego.start(config)

stratego.py

def start(config):

    data = dt.Data(config['data'])

    if (config['data']['type'] == 'yahoo'):
        df = data.get_yahoo_data()
    elif (config['data']['type'] == 'csv'):
        df = data.get_csv_data()
    else:
        return False

    trades = str.Strategy(df, config['strategy'])
    tradeBook = trades.run()

but then I am realising that the problem is my main function (start). If I run the main code not in a function I have all my instances available in the global. Is that right? Is it correct to do this way or it is better to wrap the program in a main function?

Answer 1

If really you don't want to pass it as an argument you could define it as a variable in a python file and import this variable where you define your fonction. You should be able to use this variable in the function without passing it in argument.

Answer 2

EDIT: Refactored code according to code update by OP

Ok since you use a strategy pattern you can actually do that using a strategy like design pattern

stratego.py

def start(*strategies):
    for strategy in strategies:
        strategy.run()

go.py

from functools import lru_cache, wraps
from abc import ABC, abstractmethod
import stratego

@lru_cache()
def get_data(filepath):
    # Load data from filepath
    data = ...
    return data

@lru_cache()
def get_data_with_config(**data_config):
    # Load data based on data_config
    data = get_data(data_config['filepath'])

    if (data_config['type'] == 'yahoo'):
        df = data.get_yahoo_data()
    elif (data_config['type'] == 'csv'):
        df = data.get_csv_data()
    ...
    return df

class Strategy(ABC):
    def __init__(self, config):
        self.config = config

    @abstractmethod
    def run(self):
        pass

class YahooStrategy(Strategy):
    def __init__(self, config):
        config = config.copy()
        config['data']['type'] = 'yahoo'
        super().__init__(config)

    def run(self):
        df = get_data_with_config(**self.config['data'])
        # Do sth with data

class CsvStrategy(Strategy):
    def __init__(self, config):
        config = config.copy()
        config['data']['type'] = 'csv'
        super().__init__(config)

    def run(self):
        df = get_data_with_config(**self.config['data'])
        # Do sth with data

class FunctionStrategy(Strategy):
    def __init__(self, config, func):
        super().__init__(config)
        self.func = func
    
    def run(self):
        return self.func(self.config)
    
def strategy_decorator(func):
    @wraps(func)
    def wrapper(config):
        return FunctionStrategy(config, func)
    return wrapper

@strategy_decorator
def some_strategy_function(config):
    df = get_data_with_config(**config['data'])
    # Do smth with data

# With one strategy
strategy = YahooStrategy({'data': {'filepath': 'data.csv', ...}})
stratego.run(strategy)

# Multiple strategies
strategies = [
    YahooStrategy({'data': {'filepath': 'data.csv', ...}}),
    CsvStrategy({'data': {'filepath': 'data2.csv', ...}}),
    some_strategy_function({'data': {'filepath': 'data4.csv', ...}})
]
stratego.run(*strategies)

Answer 3

If you're thinking pass by reference vs pass by value then I would suspect you are newer to Python. To my understanding, all variables are passed by reference. That is, you aren't copying the actual data every time you call a function with parameters.

If you're thinking more along the lines of global variables, you can do something like this:

globvar = 0

def set_globvar_to_one():
    global globvar    # Needed to modify global copy of globvar
    globvar = 1

def print_globvar():
    print(globvar)     # No need for global declaration to read value of globvar