SuperMind Backtesting Engine

https://quant.10jqka.com.cn/view/help/12
Admin
SuperMind Backtesting Engine is a comprehensive quantitative financial platform that allows users to...
Tokens:25,691
Snippets:44
Trust Score:9.6
Update:10 months ago
Show doc for...
Tokens:
Raw
### Quant 10jqka: Mixed Stock and Futures Trading Strategy Example

Source: https://quant.10jqka.com.cn/view/help/12/index

This Python code defines a mixed strategy involving both stocks and futures. It sets up sub-portfolios for stock and future accounts, defines trading parameters like volume limits and slippage, and configures margin rates for futures. The handle_bar function calls separate stock and future trading logic, and after_trading logs account information.

```python
def init(context):
    #设立商品期货子账户,其中stock为30000，future为700000
    set_subportfolios([{"cash": 300000, "type": 'stock'},{"cash": 700000, "type": "future"}])
    set_volume_limit(0.25,0.5)
    set_slippage(PriceSlippage(0.1),'stock')
    set_slippage(FixedSlippage(0),'future')

    #设置需要交易的标的，螺纹钢
    context.ins='RB9999'
    set_margin_rate('RB',0.09,0.09)


def handle_bar(context, bar_dict):
    stock(context, bar_dict)
    future(context, bar_dict)
def after_trading(context):
    #收盘查看账户基本合约持仓情况
    log.info(context)
    pass

def stock(context, bar_dict):
    price = history(['000001.SZ'], ['close'] , 20, '1d', False, 'pre', is_panel=1)['close']
    ma20 = price.mean().values
    ma5 = price.iloc[-5:].mean().values
    if ma20<ma5 and '000001.SZ' not in context.portfolio.stock_account.positions:
       log.info('买入平安银行')
       order_target_percent('000001.SZ',1)
    elif ma20>ma5 and context.portfolio.stock_account.positions['000001.SZ'].available_amount>0:
       log.info('卖出平安银行')
       order_target('000001.SZ',0)

def future(context, bar_dict):
    #获取螺纹钢的合约代码
    g.con = get_futures_dominate('RB')
    #获取合约行情数据
    hist1 = history_future(g.con,['close'], 250,'1m',False,'pre', is_panel=1)['close']
    #计算250日，20日均线
    ma250 = hist1.mean().values
    ma20 = hist1.iloc[-20:].mean().values
    p = hist1.iloc[-1].values
    #获取当前账户的多空单数量
    short_amount = context.portfolio.future_account.positions[context.ins].short_amount
    long_amount = context.portfolio.future_account.positions[context.ins].long_amount
    #判断条件，如果价格突破250日线，且账户存在空单，则平空
    if p > ma250 and short_amount > 0:
       order_future(context.ins, 15, 'close', 'short', None)
    #判断条件，如果20日均线突破250日线，且账户没有多单，则开多
    elif ma20 > ma250 and long_amount == 0:
       order_future(context.ins, 15, 'open', 'long', None)
    #判断条件，如果价格突破跌破250日线，且账户存在多单，则平多
    elif p <= ma250 and long_amount > 0:
       order_future(context.ins, 15, 'open', 'short', None)
    #判断条件，如果20日均线跌破250日线，且账户没有空单，则开空15手，即平多头的15手
    elif ma20 <= ma250 and short_amount == 0:
       order_future(context.ins, 15, 'close', 'long', None)
```

--------------------------------

### Research Strategy Backtesting Function (Python)

Source: https://quant.10jqka.com.cn/view/help/12/index

This function is used to backtest a trading strategy. It takes the strategy's source code and various parameters such as start date, end date, capital base, frequency, market type, and benchmark. It returns the results of the backtest, allowing users to evaluate strategy performance over historical data.

```python
research_strategy(source_code, start_date='20210601', end_date='20210815', capital_base=float(10000000), frequency='TICK', stock_market='STOCK', benchmark=None)
```

--------------------------------

### Quant 10jqka: Rebar Mean Line Futures Strategy Example

Source: https://quant.10jqka.com.cn/view/help/12/index

This Python code implements a futures trading strategy for 'RB9999' (rebar) based on moving averages. It initializes the trading environment, subscribes to the futures contract, and in the handle_bar function, calculates 5-day and 20-day moving averages to determine buy/sell/close signals based on price action and existing positions. The after_trading function logs the account's holdings.

```python
def init(context):
    #设立商品期货账户
    set_subportfolios([{"cash": 0, "type": 'stock'},{"cash": 200000, "type": "future"}])
    #设置需要交易的标的，螺纹钢
    context.ins = 'RB9999'
    #订阅需要交易的期货品种
    subscribe('RB9999')
def handle_bar(context, bar_dict):
    #获取螺纹钢的合约代码
    g.con = get_futures_dominate('RB')
    #获取合约行情数据
    date = get_datetime().strftime('%Y%m%d %H%M')
    if date[-1] == '0' or date[-1] == '5':
        hist1 = get_price_future(g.con,None,date,'1d',['close'],bar_count = 20)
        #计算5日，20日均线
        ma20 = hist1.mean().values
        ma5 = hist1.iloc[-5:].mean().values
        p = hist1.iloc[-1].values
        #获取当前账户的多空单数量
        short_amount = context.portfolio.future_account.positions[context.ins].short_amount
        long_amount = context.portfolio.future_account.positions[context.ins].long_amount

        #判断条件，如果价格突破20日线，且账户存在空单，则平空
        if p > ma20 and short_amount > 0:
           order_future(context.ins, short_amount, 'close', 'short', None)
        #判断条件，如果5日均线突破20日线，且账户没有多单，则开多
        elif ma5 > ma20 and long_amount == 0:
           order_future(context.ins, 15, 'open', 'long', None)
        #判断条件，如果价格突破跌破20日线，且账户存在多单，则平多
        elif p <= ma20 and long_amount > 0:
           order_future(context.ins, long_amount, 'close', 'long', None)
        #判断条件，如果5日均线跌破20日线，且账户没有空单，则开空
        elif ma5 <= ma20 and short_amount == 0:
           order_future(context.ins, 15, 'open', 'short', None)
def after_trading(context):
    #收盘查看账户基本合约持仓情况
    log.info('收盘查看账户基本合约持仓情况')
    log.info(context)
```

--------------------------------

### Initialize and Trade Funds - Python

Source: https://quant.10jqka.com.cn/view/help/12/index

Initializes trading environment, sets subportfolios, discount rates, and dividend modes. Demonstrates fund subscription and redemption logic with daily order execution and logging.

```python
def init(context):
    # 设置3个子账户，股票，期货，场外基金初始资金都为100000
    set_subportfolios([{'cash': 100000, 'type': 'fund'}, {'cash': 100000, 'type': 'future'}, {'cash': 100000, 'type': 'stock'}])

    # 设置申购折扣率
    set_discount_rate(0.2)

    # 设置分红模式
    set_dividend_mode('cash')

    # 000717发行日为20141218，封闭期20150114-20150226,申购起始日期20150227，买入赎回确认日为T+1，资金到账确认日T+7
    context.ins = '000717.OF'
    context.day = 1

def handle_bar(context, bar_dict):
    if context.day == 1:
        # 获取当前可交易的所有基金列表
        fund_list = get_available_fund()
        log.info(fund_list, len(fund_list))

        # 第一天下单10000元
        order_id = order_fund(context.ins, 50000)
        log.info('买入', order_id)
    elif context.day == 2:
        # 第二天买入确认
        pass
    elif context.day == 3:
        # 第三天赎回1000份
        order_id = redeem_fund(context.ins, 10000)
        log.info('赎回', order_id)
    elif context.day == 4:
        # 第四天赎回确认
        pass

def after_trading(context):
    context.day += 1


```

--------------------------------

### Initialize Trading Context and Subscribe to Stock Data (Python)

Source: https://quant.10jqka.com.cn/view/help/12/index

This snippet shows how to initialize the trading context and subscribe to real-time data for a specific stock. The `init` function is called once at the beginning of the strategy, and `subscribe` is used to fetch data for the specified stock symbol. Dependencies include the Quant 10jqka trading environment.

```python
def init(context):
    subscribe('000001.SZ')
```

--------------------------------

### Python Backtesting Strategy Implementation

Source: https://quant.10jqka.com.cn/view/help/12/index

This Python code demonstrates the structure for implementing a trading strategy within the backtesting framework. It includes an initialization function `init()` for setting up global variables and contract subscriptions, and a `handle_bar()` function which is called at each time step to define trading logic based on historical data and calculate moving averages for buy and sell signals. It also shows how to place orders and log trade information.

```python
#初始化账户   
def init(context):
    #设置要交易的合约(AuT+D合约)   
    g.contract = 'AUTD'   
    subscribe('AUTD')

#设置买卖条件，每个交易频率（日/分钟/tick）调用一次   
def handle_bar(context, bar_dict):
    #获取合约过去20日的收盘价数据   
    close = history_td(g.contract, fields=['close'], bar_count=20, fre_step='1d', is_panel=0)   
    #计算五日均线价格   
    MA5 = close[g.contract].values[-5:].mean()   
    #计算二十日均线价格   
    MA20 = close[g.contract].values.mean()   
    #如果五日均线大于二十日均线   
    if MA5 > MA20:   
        #计算所有可用资金可开仓手数(1000为合约乘数, 8.4%为保证金比例)   
        num=int(context.portfolio.accounts['METAL'].available_cash /(close[g.contract].values[-1]*1000*0.084))
        if num > 0:   
            #使用所有可用资金开多进场   
            order_td(g.contract, num, 'buy', 'open')   
            #记录这次开仓   
            log.info("买入 {0}手 {1}".format(num, g.contract))
    #如果五日均线小于二十日均线，并且目前有头寸   
    if (MA5 < MA20) and (context.portfolio.accounts['METAL'].positions[g.contract].buy_quantity > 0):
        #获取可平持仓   
        num = context.portfolio.accounts['METAL'].positions[g.contract].buy_quantity   
        #平多离场   
        order_td(g.contract, num, 'sell', 'close', close_today=True)
        #记录这次平仓   
        log.info("卖出 {0}手 {1}".format(num, g.contract))


```

```python
#初始化账户   
def init(context):
    #设置要交易的合约(AuT+D合约)   
    g.contract = 'AUTD'   
    subscribe('AUTD')

#设置买卖条件，每个交易频率（日/分钟/tick）调用一次   
def handle_bar(context, bar_dict):
    #获取合约过去20日的收盘价数据   
    close = history_td(g.contract, fields=['close'], bar_count=20, fre_step='1d', is_panel=0)   
    #计算五日均线价格   
    MA5 = close[g.contract].values[-5:].mean()   
    #计算二十日均线价格   
    MA20 = close[g.contract].values.mean()   
    #如果五日均线大于二十日均线   
    if MA5 > MA20:   
        #计算所有可用资金可开仓手数(1000为合约乘数, 9.8%为保证金比例)   
        num=int(context.portfolio.accounts['METAL'].available_cash /(close[g.contract].values[-1]*1000*0.098))
        if num > 0:   
            #使用所有可用资金开多进场   
            order_td(g.contract, num, 'buy', 'open')   
            #记录这次开仓   
            log.info("买入 {0}手 {1}".format(num, g.contract))
    #如果五日均线小于二十日均线，并且目前有头寸   
    if (MA5 < MA20) and (context.portfolio.accounts['METAL'].positions[g.contract].buy_quantity > 0):
        #获取可平持仓   
        num = context.portfolio.accounts['METAL'].positions[g.contract].buy_quantity   
        #平多离场   
        order_td(g.contract, num, 'sell', 'close', close_today=True)
        #记录这次平仓   
        log.info("卖出 {0}手 {1}".format(num, g.contract))


    margin=context.portfolio.accounts['METAL'].margin
    log.info(margin)
    record(margin=margin)


```

--------------------------------

### Python 策略示例：均线交叉交易逻辑

Source: https://quant.10jqka.com.cn/view/help/12/index

展示了如何使用Python编写一个简单的股票交易策略，该策略基于5日均线和20日均线的交叉来决定买入和卖出。策略包含初始化函数 `init` 和交易逻辑函数 `handle_bar`。

```python
#初始化账户
def init(context):
    g.index='600519.SH'

def handle_bar(context,bar_dict):
    close = history(g.index, ['close'], 20, '1d', False, fq = 'pre', is_panel=0)
    MA5 = close['close'].values[-5:].mean()
    #计算二十日均线价格
    MA20 = close['close'].values.mean()
    #如果五日均线大于二十日均线
    if MA5 > MA20:
        #使用所有现金买入证券
        order_target_percent(g.index,1)
        #记录本次买入
        log.info("全仓买入{0}".format(g.index))
    #如果五日均线小于二十日均线
    if MA5 < MA20 :
        #卖出所有证券
        order_target_percent(g.index,0)
        #记录本次卖出
        log.info("全仓卖出{0}".format(g.index))


```

--------------------------------

### Python 策略示例：添加日志和记录

Source: https://quant.10jqka.com.cn/view/help/12/index

在基础的均线交叉交易策略中，添加了 `log.info` 用于记录交易信号，并使用 `record` 函数记录交易信号值，以便在回测中可视化。

```python
#初始化账户
def init(context):
    g.index='600519.SH'

def handle_bar(context,bar_dict):
    close = history(g.index, ['close'], 20, '1d', False, fq = 'pre', is_panel=0)
    MA5 = close['close'].values[-5:].mean()
    #计算二十日均线价格
    MA20 = close['close'].values.mean()
    #设置交易信号
    trade_signal=0
    #如果五日均线大于二十日均线
    if MA5 > MA20:
        #使用所有现金买入证券
        order_target_percent(g.index,1)
        #记录本次买入
        log.info("全仓买入{0}".format(g.index))
        #记录买入信号
        trade_signal=1
    #如果五日均线小于二十日均线
    if MA5 < MA20 :
        #卖出所有证券
        order_target_percent(g.index,0)
        #记录本次卖出
        log.info("全仓卖出{0}".format(g.index))
        #记录卖出信号
        trade_signal=-1

    log.info(trade_signal)
    record(trade_signal=trade_signal)


```

--------------------------------

### Python Futures Account Initialization

Source: https://quant.10jqka.com.cn/view/help/12/index

This Python snippet demonstrates how to initialize a futures trading account within the `init` function. It uses `set_subportfolios` to allocate initial cash to a futures account.

```python
def init(context):
  #设置子账户,股票账户0万，期货账户50万.
  set_subportfolios([{'cash':0,'type':'stock'},{'cash':500000,'type':'future'}])
```

--------------------------------

### Python Simultaneous Stock and Futures Account Initialization

Source: https://quant.10jqka.com.cn/view/help/12/index

This Python code shows how to initialize both stock and futures accounts simultaneously. The `set_subportfolios` function is used to allocate initial capital to both account types within the `init` function.

```python
def init(context):
  #设置子账户,股票账户50万，期货账户50万.
  set_subportfolios([{'cash':500000,'type':'stock'},{'cash':500000,'type':'future'}])
```

--------------------------------

### Monthly Fund Investment Strategy - Python

Source: https://quant.10jqka.com.cn/view/help/12/index

Implements a monthly fund investment (dollar-cost averaging) strategy. It initializes subportfolios, discount rates, and dividend modes, then schedules a monthly trade execution using `run_monthly`.

```python
#场外基金定投策略
def init(context):
    # 设置3个子账户，股票，期货，场外基金初始资金都为100000
    set_subportfolios([{'cash': 120000, 'type': 'fund'}])
    # 设置申购折扣率
    set_discount_rate(0.2)
    # 设置分红模式
    set_dividend_mode('invest')
    #确定定投标的景顺长城沪深300增强(000311)
    context.ins = '000311.OF'
    #每月月末买入
    run_monthly(trade,date_rule=-1)
def trade(context, bar_dict):
    order_id = order_fund(context.ins, 10000)
    log.info('申购', order_id)


```

--------------------------------

### Alpha Hedge Strategy Implementation in Python

Source: https://quant.10jqka.com.cn/view/help/12/index

This Python code implements an Alpha Hedge Strategy. It initializes portfolios, sets maximum stock holdings, and defines a trading logic. The strategy hedges stock positions with futures and rebalances stock portfolios every 20 trading days by selecting stocks based on ROIC, PB, and PS_TTM ratios, applying factor normalization and scoring for optimal stock selection. It ensures that the futures hedging value does not exceed the stock holding value and that there are available funds for futures trading.

```python
import pandas as pd
import numpy as np
import datetime
def init(context):
    #设立期货账户
    set_subportfolios([{"cash": 7000000, "type": 'stock'},{"cash": 3000000, "type": "future"}])
    # 设置最大持股数
    context.max_stocks = 10 
    #记录天数，隔20个交易日调仓
    g.day = 0
def handle_bar(context, bar_dict):
    #期货对冲市值小于股票多头市值，且期货账户有可用资金，则开空单对冲
    if abs(context.portfolio.future_account.market_value) <= context.portfolio.stock_account.total_value and context.portfolio.future_account.available_cash > 0:
        code = get_futures_dominate('IF')
        subscribe(code)
        num = int(context.portfolio.stock_account.total_value/1000000)
        order_future(code,num,"open","short",limit_price=None)
    #股票调仓
    if g.day%20 !=0:
        return None
    g.day =  g.day +1
    # 每个调仓日先清仓持有的股票
    for security in list(context.portfolio.positions.keys()):
        order_target(security, 0)
    # 首先获得当前日期
    time = get_datetime()
    date = time.strftime('%Y%m%d')
    # 获得股票池列表
    sample = get_index_stocks('000300.SH',date)
    # 创建字典用于存储因子值
    df = {'security':[], 1:[], 2:[], 3:[], 'score':[]}
    # 因子选择
    for security in sample:
        q=query(
            profit.roic,# 投资回报率
            valuation.pb,# 市净率
            valuation.ps_ttm,# 市销率
        ).filter(
            profit.symbol==security
        )

        # 缺失值填充为0
        fdmt = get_fundamentals(q, date=date).fillna(0)

        # 判断是否有数据
        if (not (fdmt['profit_roic'].empty or
                fdmt['valuation_pb'].empty or
                fdmt['valuation_ps_ttm'].empty)):
            # 计算并填充因子值
            df['security'].append(security)
            df[1].append(fdmt['profit_roic'][0])# 因子1：投资回报率
            df[2].append(fdmt['valuation_pb'][0])# 因子2：市净率
            df[3].append(fdmt['valuation_ps_ttm'][0])#因子3：市销率

    for i in range(1, 4):
        # 因子极值处理，中位数去极值法
        m = np.mean(df[i])
        s = np.std(df[i])
        for j in range(len(df[i])):
            if df[i][j] <= m-3*s:
                df[i][j] = m-3*s
            if df[i][j] >= m+3*s:
                df[i][j] = m+3*s
        m = np.mean(df[i])
        s = np.std(df[i])

        # 因子无量纲处理，标准化法
        for j in range(len(df[i])):
            df[i][j] = (df[i][j]-m)/s

    # 计算综合因子得分
    for i in range(len(df['security'])):
        # 等权重计算(注意因子方向)
        s = (df[1][i]-df[2][i]-df[3][i])
        df['score'].append(s)

    # 按综合因子得分由大到小排序
    df = pd.DataFrame(df).sort_values(by ='score', ascending=False)

    # 等权重分配资金
    cash = context.portfolio.available_cash/context.max_stocks

    # 买入新调仓股票
    for security in df[:context.max_stocks]['security']:
        order_target_value(security, cash)


```

--------------------------------

### Futures Backtesting: Dual Moving Average Strategy (TCL)

Source: https://quant.10jqka.com.cn/view/help/12/index

This TCL code implements a dual moving average strategy for futures backtesting. It calculates 5-day and 10-day moving averages to generate buy and sell signals. The strategy opens long positions when the 5-day MA crosses above the 10-day MA and closes them when the 5-day MA crosses below the 10-day MA, provided no position is currently held. It also handles opening short positions and closing them.

```TCL
MA5:=MA(C,P1);  //计算5日线
MA10:=MA(C,P2);     //计算10日线

MA5>MA10 AND BKVOL=0 AND SKVOL=0,BK;    //当5日线大于10日线且当前持仓为0时，买入开仓
MA5<MA10 AND BKVOL=0 AND SKVOL=0,SK;    //当5日线小于10日线且当前持仓为0时，卖出开仓

MA5<MA10 AND BKVOL>0,SP;    //当5日线小于10日线且当前持有多头仓位时，卖出平仓
MA5>MA10 AND SKVOL>0,BP;    //当5日线大于10日线且当前持有空头仓位时，买入平仓
```

--------------------------------

### Handle Real-time Market Tick Data (Python)

Source: https://quant.10jqka.com.cn/view/help/12/index

This function processes incoming tick data for a subscribed stock. The `handle_tick` function is executed for each tick received. It accesses tick attributes like `b1` (best bid price) and `b1_v` (best bid volume) and prints them. This is useful for strategies that require high-frequency data processing.

```python
def handle_tick(context, tick):
    print(tick.b1, tick.b1_v)
```

--------------------------------

### Python T+0 交易策略示例

Source: https://quant.10jqka.com.cn/view/help/12/index

一个Python策略示例，展示了如何订阅股票、设置初始持仓、定义买卖信号以及在特定条件下执行T+0交易。该策略使用同花顺股票数据，并在满足特定时间、价格和信号条件时进行买卖操作。

```python
def init(context):
    #不设置滑点、手续费和成交比例，均为默认值
    #订阅同花顺的数据
    subscribe('300033.SZ')
    #建立初始持仓 1000股同花顺
    set_holding_stocks({'300033.SZ':1000})
    #定义买入信号'big'
    reg_signal('big',get_big)
    #定义卖出信号'sell'
    reg_signal('small',get_small)
    #设置全局变量，控制交易次数
    g.today=0


#生成买入信号
def get_big(data):
    #股价大于48.1时买入
    return data['current']>48.1

#生成卖出信号
def get_small(data):
    #股价低于48时卖出
    return data['current']<48.

#执行过程
def handle_tick(context,tick):
    #获取买入信号
    now=tick.datetime
    big=get_signal('300033.SZ',name='big')
    #当时间为9:31:12信号为True且今天未发生过交易时，市价买入100股，对手盘最优价格申报
    if now.hour==9 and now.minute==31 and now.second==12 and big==True and g.today==0:
        #开仓函数
        order_shares('300033.SZ',100)
        #记录交易次数
        g.today=1
    #获取卖出信号
    small=get_signal('300033.SZ',name='small')
    #当时间为9:31:15信号为True且今天发生过交易时，平买仓
    if now.hour==9 and now.minute==31 and now.second==15 and small==True and g.today==1:
        #平仓函数
        order_shares('300033.SZ',-100)
```

--------------------------------

### Python Futures Symbol Subscription

Source: https://quant.10jqka.com.cn/view/help/12/index

This Python code demonstrates how to subscribe to a specific futures symbol, 'RB9999', for data retrieval. This is essential for trading futures and is typically done within the `init` function after setting up the futures account.

```python
def init(context):
  #设立商品期货账户
  set_subportfolios([{"cash": 0, "type": 'stock'},{"cash": 200000, "type": "future"}])
  #订阅需要交易的期货品种
  context.ins = 'RB9999'
  subscribe(context.ins)
```

--------------------------------

### Individual Stock Weight Constraint (Mathematical)

Source: https://quant.10jqka.com.cn/view/help/12/index

This constraint defines limits on the individual weights of stocks within a portfolio (wi,t). It allows setting lower (downlimit) and upper (uplimit) bounds for each stock's weight, ensuring that the sum of all weights equals 1. This is crucial for diversification and risk management.

```mathematical
downlimit ≤wi,t≤ uplimit  and i=1∑n∣wi,t=1
```

--------------------------------

### Maximize Information Ratio Objective Function (Mathematical)

Source: https://quant.10jqka.com.cn/view/help/12/index

This formula represents the objective function for maximizing the Information Ratio. It aims to optimize portfolio weights (W) relative to a benchmark (Wb) to achieve the highest ratio of excess return to tracking error. R, W, and Sigma are defined as in MVO, with Wb representing benchmark weights.

```mathematical
target=( W−Wb)′∑(W−Wb)R∗W
```
Tokens:
Raw