金融数据分析| 动量策略 & 反转策略| 羊驼交易法则

 

 

1. 动量策略 & 反转策略

计算股票池中所有股票在前一段时间的收益率
选择收益率最大（最小）的N只股票调仓

动量策略：如果某只股票在前一段时期表现较好，那么下一段时期该股票仍将有良好表现。
反转策略：如果某只股票在前一段时期表现不好，那么下一段时期该股票将会反转，即表现变好。

 

import jqdata
import math
import numpy as np
import pandas as pd  
import datetime

def initialize(context):
    set_option('use_real_price', True)
    set_order_cost(OrderCost(open_tax=0, close_tax=0.001,open_commission=0.0003, close_commission=0.0003, min_commission=5), type='stock')
    g.benchmark = '000300.XSHG' #沪深300
    g.N = 10
    set_benchmark(g.benchmark)
    run_monthly(handle, 1)
    
def handle(context):
    stocks = get_index_stocks('000300.XSHG')
    df_close = history(30, field = 'close', security_list = list(stocks)).T
    #print(df_close)
    df_close['ret'] = (df_close.iloc[:,-1]-df_close.iloc[:,0]) / df_close.iloc[:,0]
    sorted_stocks = df_close.sort_values(by = 'ret', ascending = True).index #True就是反转策略


    tohold = sorted_stocks[:g.N]
    
    for stock in context.portfolio.positions:
        if stock not in tohold:
            order_target(stock, 0)
    tobuy = [stock for stock in tohold if stock not in context.portfolio.positions]
    
    if len(tobuy) > 0:
        print('Buying')
        cash = context.portfolio.available_cash
        cash_per_stock = cash / len(tobuy)
        for stock in tobuy:
            order_value(stock, cash_per_stock)

  

 

 

2. 羊驼交易法则

    起始时随机买入N只股票，每天卖掉收益率最差的M只，再随机买入剩余股票池的M只。
    随机选股，周期调仓。

改进策略：

　　买入历史收益率最低的N只股票，调仓日留下反转程度大的股票，卖掉表现最差的M只股票，再买入收益率最低的M只股票。

import jqdata
import pandas as pd
def initialize(context):
    set_option('use_real_price', True)
    set_order_cost(OrderCost(open_tax=0, close_tax=0.001,open_commission=0.0003, close_commission=0.0003, min_commission=5), type='stock')
    set_benchmark('000300.XSHG') #沪深300
    
    g.security = get_index_stocks('000300.XSHG')
    g.period = 30
    g.N = 10
    g.change = 1
    g.init = True
    
    run_monthly(handle, 1)

def get_sorted_stocks(context, stocks):
    df = history(g.period, field='close',security_list=stocks).T
    print(df)
    df['ret'] = (df.iloc[:,len(df.columns)-1] - df.iloc[:,0]) / df.iloc[:,0]
    df = df.sort_values(by = 'ret', ascending = False)
    return df.index.values
def handle(context):
    if g.init:
        stocks = get_sorted_stocks(context,g.security)[:g.N]
        cash = context.portfolio.available_cash * 0.9 / len(stocks)
    
        for stock in stocks:
            order_value(stock, cash)
        g.init = False
    return
    stocks = get_sorted_stocks(context, context.portfolio.positions.key)
    
    for stock in stocks[-g.change:]:
        order_target(stock, 0)
    stocks = get_sorted_stocks(context,g.security)
    for stock in stocks:
        if len(context.portfolio.positions) >= g.N:
            break
        if stock not in context.portfolio.positions:
            order_value(stock, context.portfolio.available_cash * 0.9)