get_history(5, frequency='1d', field='close', security_list=['123084.SZ'], fq=None, include=False, fill='nan')

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每天9:23分运行集合竞价处理函数

    run_daily(context, aggregate_auction_func, time='9:23')  



def aggregate_auction_func(context):

    stock = g.security

    #最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    #涨停价

    up_limit = snapshot[stock]['up_px']

    #如果最新价不小于涨停价，买入

    if float(price) >= float(up_limit):

        order(g.security, 100, limit_price=up_limit)

    

def handle_data(context, data):

    pass

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    pass

    

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

def handle_data(context, data):

    security = g.security



    #得到十日历史价格

    df = get_history(10, '1d', 'close', security, fq=None, include=False)

	

    # 得到五日均线价格

    ma5 = round(df['close'][-5:].mean(), 3)

    

    # 得到十日均线价格

    ma10 = round(df['close'][-10:].mean(), 3)



    # 取得昨天收盘价

    price = data[security]['close']



    # 得到当前资金余额

    cash = context.portfolio.cash

    

    # 如果当前有余额，并且五日均线大于十日均线

    if ma5 > ma10:

        # 用所有 cash 买入股票

        order_value(security, cash)

        # 记录这次买入

        log.info("Buying %s" % (security))

        

    # 如果五日均线小于十日均线，并且目前有头寸

    elif ma5 < ma10 and get_position(security).amount > 0:

        # 全部卖出

        order_target(security, 0)

        # 记录这次卖出

        log.info("Selling %s" % (security))

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每3秒运行一次主函数

    run_interval(context, func, seconds=3)

      

#盘前准备历史数据

def before_trading_start(context, data):

    history = get_history(10, '1d', 'close', g.security, fq='pre', include=False)

    g.close_array = history['close'].values

    

#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

def func(context):

    

    stock = g.security

    

    #获取最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    

    # 得到五日均线价格

	days = 5

    ma5 = get_MA_day(stock, days, g.close_array[-4:], price)   

    # 得到十日均线价格

	days = 10

    ma10 = get_MA_day(stock, days, g.close_array[-9:], price)



    # 得到当前资金余额

    cash = context.portfolio.cash

    

    # 如果当前有余额，并且五日均线大于十日均线

    if ma5 > ma10:

        # 用所有 cash 买入股票

        order_value(stock, cash)

        # 记录这次买入

        log.info("Buying %s" % (stock))

        

    # 如果五日均线小于十日均线，并且目前有头寸

    elif ma5 < ma10 and get_position(stock).amount > 0:

        # 全部卖出

        order_target(stock, 0)

        # 记录这次卖出

        log.info("Selling %s" % (stock))    



#计算实时均线函数

def get_MA_day(stock,days,close_array,current_price):

    close_sum = close_array[-(days-1):].sum()

    MA = (current_price + close_sum)/days

    return MA



def handle_data(context, data):

    pass

def f_expma(N,m,EXPMA1,price):

    a = m/(N+1)

    EXPMA2 = a * price + (1 - a)*EXPMA1

    return EXPMA2 #2为后一天值



#定义macd函数，输入平滑系数参数、前一日值，输出当日值

def macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,price):

    EXPMA12_2 = f_expma(N1,m,EXPMA12_1,price)

    EXPMA26_2 = f_expma(N2,m,EXPMA26_1,price)

    DIF2 = EXPMA12_2 - EXPMA26_2

    a = m/(N3+1)

    DEA2 = a * DIF2 + (1 - a)*DEA1

    BAR2=2*(DIF2-DEA2)

    return EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2



def initialize(context):

    global init_price

    init_price = None

    # 获取沪深300股票

    g.security = get_index_stocks('000300.SS')

    #g.security = ['600570.SS']

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    set_universe(g.security)



def handle_data(context, data):

    # 获取历史数据，这里只获取了2天的数据，如果希望最终MACD指标结果更准确最好是获取

    # 从股票上市至今的所有历史数据，即增加获取的天数

    close_price = get_history(2, '1d', field='close', security_list=g.security)

    #如果是停牌不进行计算

    for security in g.security:

        if data[security].is_open >0:

            global init_price,EXPMA12_1,EXPMA26_1,EXPMA12_2,EXPMA26_2,DIF1,DIF2,DEA1,DEA2

            if init_price is None:

                init_price = close_price[security].mean()#nan和N-1个数，mean为N-1个数的均值

                EXPMA12_1 = init_price

                EXPMA26_1 = init_price

                DIF1 = init_price

                DEA1 = init_price

            # m用于计算平滑系数a=m/(N+1)

            m = 2.0

            #设定指数平滑基期数

            N1 = 12

            N2 = 26

            N3 = 9

            EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2 = macd(N1,N2,N3,m,EXPMA12_1,EXPMA26_1,DEA1,close_price[security][-1])

            # 取得当前价格

            current_price = data[security].price

            # 取得当前的现金

            cash = context.portfolio.cash

            # DIF、DEA均为正，DIF向上突破DEA，买入信号参考

            if DIF2 > 0 and DEA2 > 0 and DIF1 < DEA1 and DIF2 > DEA2:

                # 计算可以买多少只股票

                number_of_shares = int(cash/current_price)

                # 购买量大于0时，下单

                if number_of_shares > 0:

                    # 以市单价买入股票，日回测时即是开盘价

                    order(security, +number_of_shares)

                    # 记录这次买入

                    log.info("Buying %s" % (security))

            # DIF、DEA均为负，DIF向下突破DEA，卖出信号参考

            elif DIF2 < 0 and DEA2 < 0 and DIF1 > DEA1 and DIF2 < DEA2 and get_position(security).amount > 0:

                # 卖出所有股票,使这只股票的最终持有量为0

                order_target(security, 0)

                # 记录这次卖出

                log.info("Selling %s" % (security))

            # 将今日的值赋给全局变量作为下一次前一日的值

            DEA1 = DEA2

            DIF1 = DIF2

            EXPMA12_1 = EXPMA12_2

            EXPMA26_1 = EXPMA26_2

order_target 接口通过持仓数量比较将入参的目标数量转换成需要交易的成交，传入 order

接口



order_value 接口通过 金额/限价 或者 金额/默认最新价 两种方式转换成需要交易的数量，

传入 order 接口



order_target_value 接口通过持仓金额比较得到需要交易的金额， 金额/限价 或者 金额/默

认最新价 两种方式转换成需要交易的数量，传入 order 接口

order 接口：

一、

先判断 limit_price 是否传入，传入则用传入价格限价，不传入则最新价代替，都是

限价方式报单。

二、

判断隔夜单和交易时间，交易时间（9:10（系统可配）~15:00）范围的订单会马上

加入未处理订单队列，其他订单先放到一个队列，等时间到交易时间就放到未处理订单

队列

三、

未处理订单队列的订单会进行限价判断，如果没有传入限价就按当前最新价处理，

然后报柜台

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每天9:23分运行集合竞价处理函数

    run_daily(context, aggregate_auction_func, time='9:23')  



def aggregate_auction_func(context):

    stock = g.security

    #最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    #涨停价

    up_limit = snapshot[stock]['up_px']

    #如果最新价不小于涨停价，买入

    if float(price) >= float(up_limit):

        order(g.security, 100, limit_price=up_limit)

    

def handle_data(context, data):

    pass

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每天9:23分运行集合竞价处理函数

    run_daily(context, aggregate_auction_func, time='9:23')

def aggregate_auction_func(context):

    stock = g.security

    #最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    #涨停价

    up_limit = snapshot[stock]['up_px']

    #如果最新价不小于涨停价，买入

    if float(price) >= float(up_limit):

        order(g.security, 100, limit_price=up_limit)

order-按数量买卖

order(security, amount, limit_price=None)

买卖标的。



注意：



由于下述原因，回测中实际买入或者卖出的股票数量有时候可能与委托设置的不一样，针对上述内容调整，系统会在日志中增加警告信息：



根据委托买入数量与价格经计算后的资金数量，大于当前可用资金；

委托卖出数量大于当前可用持仓数量；

每次交易数量只能是100的整数倍，但是卖出所有股票时不受此限制；

股票停牌、股票未上市或者退市、股票不存在；

回测中每天结束时会取消所有未完成交易；

order_target(security, amount, limit_price=None)

买卖股票，直到股票最终数量达到指定的amount。



注意：该函数在委托股票时取整100股，委托可转债时取整100张。



参数

security: 股票代码(str)；



amount: 期望的最终数量(int)；



limit_price：买卖限价(float)；



返回

Order对象中的id或者None。如果创建订单成功，则返回Order对象的id，失败则返回None(str)。

order_value - 指定目标价值买卖

order_value(security, value, limit_price=None)

买卖指定价值为value的股票。



注意：该函数在委托股票时取整100股，委托可转债时取整100张。

order_target_value - 指定持仓市值买卖

order_target_value(security, value, limit_price=None)

调整股票仓位到value价值



注意：该函数在委托股票时取整100股，委托可转债时取整100张。

order_market - 按市价进行委托

order_market(security, amount, market_type=None, limit_price=None)

可以使用多种市价类型进行委托。



注意：该函数仅在股票交易模块可用。

tick_data（可选）

tick_data(context, data)

该函数会每隔3秒执行一次。



注意 ：



该函数仅在交易模块可用。



该函数在9:30之后才能执行。



该函数中只能使用order_tick进行对应的下单操作。

order_tick(sid, amount, priceGear='1', limit_price=None)

买卖股票下单，可设定价格档位进行委托



注意：该函数仅在交易模块可用。



参数

sid：股票代码(str)；



amount：交易数量，正数表示买入，负数表示卖出(int)



priceGear：盘口档位，level1:1~5买档/-1~-5卖档，level2:1~10买档/-1~-10卖档(str)



limit_price：买卖限价，当输入参数中也包含priceGear时，下单价格以limit_price为主(float)；

def initialize(context):

    g.security = "600570.SS"

    set_universe(g.security)



def tick_data(context,data):

    security = g.security

    current_price = eval(data[security]['tick']['bid_grp'][0])[1][0]

    if current_price > 56 and current_price < 57:

        # 以买一档下单

        order_tick(g.security, -100, "1")

        # 以卖二档下单

        order_tick(g.security, 100, "-2")

        # 以指定价格下单

        order_tick(g.security, 100, limit_price=56.5)



def handle_data(context, data):

    pass

import time



def initialize(context):

	g.flag = False

	log.info("initialize g.flag=" + str(g.flag) )



def before_trading_start(context, data):

	g.flag = False

	log.info("before_trading_start g.flag=" + str(g.flag) )

    

def handle_data(context, data):

	if not g.flag and time.strftime("%H:%M:%S", time.localtime()) > '09:35:00':

		# 自动打新

		log.info("自动打新")

		ipo_stocks_order()

		g.flag = True



def on_order_response(context, order_list):

	# 该函数会在委托回报返回时响应

	log.info(order_list)

def initialize(context):

    # 初始化策略

    g.code_mapper = date_code_mapper()

    log.info(g.code_mapper)

    g.error_set=set()

    

def last_n_day(date,n,origin_fmt,target_fmt):

    return (datetime.datetime.strptime(date, origin_fmt) - datetime.timedelta(days=n)).strftime(target_fmt)



def post_fix(code):

    return code + '.SZ' if code.startswith('12') else code + '.SS'

    

def handle_data(context, data):

    date=context.blotter.current_dt.strftime('%Y%m%d')

    if date not in g.code_mapper:

        return

    

    security_list=g.code_mapper.get(date)



    for code in security_list:

        code=post_fix(code)

        try:

            df = get_history(1, frequency='1m', field=['open' ,'high','low','close'], security_list=code, fq='pre',include=False)

        except Exception as e:

            if code not in g.error_set:

                log.info(e)

                log.info('代码获取数据 出错{}'.format(code))

                g.error_set.add(code)

            continue

        df['ticker']=code

        g.result.append(df)

    

def after_trading_end(context, data):

    #engine = DBS

    db = DBSelector()

    conn = db.get_engine()

    date=context.blotter.current_dt.strftime('%Y%m%d%H%M')

    if len(g.result)==0:

        return

        

    df = pd.concat(g.result)

    try:

        df.to_sql('minute_info',con=conn,if_exists='append')

    except Exception as e:

        log.info(e)

    

    g.result=



def before_trading_start(context, data):

    g.result=

    def query_offset(self,start,count):

        sqlite_str = 'select code,open,current from {} limit {},{}'.format(self.table_name,start,count)

        cursor = self.db.cursor()

        with lock:

            try:

                cursor.execute(sqlite_str)

            except Exception as e:

                log.info(e)

                self.db.rollback()

            else:

                return cursor.fetchall()

get_history(5, frequency='1d', field='close', security_list=['123084.SZ'], fq=None, include=False, fill='nan')