使用for 的时候调用函数多次，导致类初始化多次，然而类的初始化参数又依赖于传参．如何改进思路．

Question

类 的定义

class AbuPickTimeWorker(AbuPickTimeWorkBase):
 
    def __init__(self, cap, kl_pd, benchmark, buy_factors, sell_factors):
        self.capital = cap
        self.kl_pd = kl_pd
        self.combine_kl_pd = ABuSymbolPd.combine_pre_kl_pd(self.kl_pd, n_folds=1                      
        self.benchmark = benchmark
        self.init_buy_factors(buy_factors)
        self.init_sell_factors(sell_factors)
        self.filter_long_task_factors()
        #不初始化
        self.orders = list()
        self.task_pg = None
        
    def _day_task(self, today):
        sell = mockTrading()
        self._task_attached_sell(today, how='day')
        for sell_factor in self.sell_factors:
            sell_factor.read_fit_day(today, self.orders)
    
        for buy_factor in self.buy_factors:
            if not buy_factor.lock_factor:
                order = buy_factor.read_fit_day(today)
                if order and order.order_deal:
                    self.orders.append(order)

函数调用类的方法，类初始化多次，如何不初始化多次，使得self.orders不初始化，使用单例模式，回导致orders一直不变，想实现每个实例初始化一次．

   def stockBuy(read_cash, buy_factors, sell_factors, choice_symbol,date,env=None):
   
        abupy.env.g_enable_ml_feature = True
        abupy.env.g_market_target = EMarketTargetType.E_MARKET_TARGET_CN
        commission_dict = {
            'buy_commission_func': buy_commission_ch,
            'sell_commission_func':sell_commission_ch}
        
        benchmark = AbuBenchmark()
        capital = AbuCapital(
            read_cash,
            benchmark,
            commission_dict)
        kl_pd_manager = AbuKLManager(benchmark, capital)
        
        kl_pd = kl_pd_manager.get_pick_time_kl_pd(choice_symbol)
        #初始化多次？？？
        time_work = stockSell(
            capital,
            kl_pd,
            benchmark,
            buy_factors,
            sell_factors)
        try:
            if date == datetime.datetime.today().strftime('%Y%m%d'):
                today_time = kl_pd[:date].iloc[-1]
                # print (today_time)
                # 调用类的方法
                time_work._day_task(today_time)
                return time_work.orders
            else:
                today_time = kl_pd[:date].iloc[-2]
                # print (today_time)
                time_work._day_task(today_time)
                return time_work.orders
        except TypeError:
            pass

调用函数

if __name__ == '__main__':
    stock_300 = pd.read_csv(
        '../src/000300closeweight.csv',
        encoding='gbk',
        dtype={
            '成分券代码Constituent Code': str})
    stock_300.sort_values(by='权重(%)Weight(%)', ascending=False, inplace=True)
    choice_symbols = stock_300[:100]['成分券代码Constituent Code'].tolist()
    choice_symbols = list(set(choice_symbols))
    print(choice_symbols)
    
    read_cash = 200000
    buy_factors = [
        {
            'fast': 5, 'slow': 20, 'class': AbuDoubleMaBuy}, {
            'xd': 60, 'class': AbuFactorBuyBreak}, {
            'xd': 42, 'class': AbuFactorBuyBreak, 'position': {
                'class': AbuKellyPosition}, }]
    sell_factors = [
        {'stop_loss_n': 1.0, 'stop_win_n': 3.0,
         'class': AbuFactorAtrNStop},
        {'class': AbuFactorPreAtrNStop, 'pre_atr_n': 1.5},
        {'class': AbuFactorCloseAtrNStop, 'close_atr_n': 1.5}]

    commission_dict = {
        'buy_commission_func': buy_commission_ch,
        'sell_commission_func': sell_commission_ch}
    benchmark = AbuBenchmark()

    capital = AbuCapital(
        read_cash,
        benchmark,
        commission_dict)
    kl_pd_manager = AbuKLManager(benchmark, capital)

    kl_pd = kl_pd_manager.get_pick_time_kl_pd(choice_symbol)

    buy = stockSell(cap, kl_pd, benchmark, buy_factors, sell_factors)
    start_day = datetime.date(2017, 6, 1)
　＃使用for 的时候调用函数多次，导致类初始化多次，然而类的初始化参数又依赖于传参．如何改进思路．
    for i in range(300):
        start_day += datetime.timedelta(days=1)
        """
        methods:
        buy.singnal_sell(code,date)
        buy.mulit_process_sell(code_list,date,n_jobs)
        """
      
        result = stockBuy(read_cash,buy_factors,sell_factors,choice_symbols[0],str(
                        start_day.strftime('%Y%m%d')),env=None)
        print ('result',[r for r in list(result) if r])

单例模式代码

def singleton(cls):
    instances = {}

    def wrapper(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]

    return wrapper

Answer 1

这种问题，把代码简化了说明比较好。
参数是变的，根本也就不存在“初始化多次”的问题，因为本身就是需要多个状态的。

# -*- coding: utf-8 -*-

class A(object):
    def __init__(self, i):
        print i

for i in range(10):
    A(i)

如上代码，如果本身需要那个变化的 i ，那么不同的 i 创建不同的 A 的实例是没有问题。（不是唯一的处理方式）