# coding:gbk

import time





class G():

    pass





g = G()





def init(ContextInfo):

    g.hsa = [item for item in ContextInfo.get_stock_list_in_sector('沪深A股') if not item.endswith('BJ')]

    g.vol_dict = {}

    for stock in g.hsa:

        g.vol_dict[stock] = ContextInfo.get_last_volume(stock)

    ContextInfo.run_time("execution", "1nSecond", "2019-10-14 13:20:00")





def execution(ContextInfo):

    t0 = time.time()

    full_tick = ContextInfo.get_full_tick(g.hsa)

    total_market_value = 0

    total_ratio = 0

    count = 0

    for stock in g.hsa:

        if full_tick[stock]['lastClose'] == 0:

            continue

        ratio = full_tick[stock]['lastPrice'] / full_tick[stock]['lastClose'] - 1

        rise_price = round(full_tick[stock]['lastClose'] * 1.2, 2) if stock[0] == '3' or stock[:3] == '688' else round(

            full_tick[stock]['lastClose'] * 1.1, 2)

        # 如果要打印涨停品种

        if abs(full_tick[stock]['lastPrice'] - rise_price) <0.01:

            print(f"涨停股票 {stock} {ContextInfo.get_stock_name(stock)}")



        market_value = full_tick[stock]['lastPrice'] * g.vol_dict[stock]

        total_ratio += ratio * market_value

        total_market_value += market_value

        count += 1

    # print(count)

    total_ratio /= total_market_value

    total_ratio *= 100

    print(f'A股加权涨幅 {round(total_ratio, 2)}% 函数运行耗时{round(time.time() - t0, 5)}秒')

code_list = ['113578.SS','123014.SZ'] # 股票池，这里可以填几千个股票也没问题的

zz_df_price = get_price(code_list, start_date=None, end_date=None, frequency='1d', fields='close', fq=None, count=1)

yesterday_price_dict = zz_df_price.iloc[0].to_json()

zz_df_price.iloc[0].to_json()

index      113578.SS	123014.SZ

2023-07-14	93.036	 118.36

'{"113578.SS":93.036,"123014.SZ":118.36}'

def initialize(context):

    g.security = "600570.SS"

    set_universe(g.security)



def before_trading_start(context, data):

    g.count = 0



def handle_data(context, data):

    if g.count == 0:

        # 对持仓内的贝斯进行转股操作

        debt_to_stock_order("123075.SZ", -1000)

        g.count += 1

    # 查看委托状态

    log.info(get_orders())

    g.count += 1

#coding:gbk

c = True

account = '11111111' # 个人账户

def init(ContextInfo):

    pass

    

def handlebar(ContextInfo):

	if not ContextInfo.is_last_bar():

		#历史k线不应该发出实盘信号 跳过

		return



    if c:

        passorder(80,1101,account,s,5,0,-100,'1',2,'tzbz',ContextInfo) 

        c=False

		

量化新人用QMT+chat GPT快速上手量化策略（一）QMT基础介绍



量化新人用QMT+chat GPT快速上手量化策略（二）QMT均线盘后选股



量化新人用QMT+chat GPT快速上手量化策略（三）一个基本的回测策略代码



量化新人用QMT+chat GPT快速上手量化策略（四） QMT运行一个策略的整体流程



量化新人用QMT+chat GPT快速上手量化策略（五）  获取股票数据



量化新人用QMT+chat GPT快速上手量化策略（六） tablib计算指标



量化新人用QMT+chat GPT快速上手量化策略（七） 下单代码编写

1. 涨停板；依赖ptrade的高速行情自动配合手动；
2. 两融账户的股票日内做T，持有底仓；
3. 股票小市值轮动+多因子
4. 可转债多因子（有N个版本+不同的排除因子 组合）
5. 可转债日内高频
6. 股票趋势动量
7. ETF轮动套利
8. 脉冲卖出扫描

担保品卖出指的是融资融券交易当中，用自有资金进行买卖的行为

def initialize(context):

    g.security = '600570.SS'

    set_universe(g.security)



def handle_data(context, data):

    # 以系统最新价委托

    margin_trade(g.security, 100)

    # 以72块价格下一个限价单

    margin_trade(g.security, 100, limit_price=72)

    # 以最优五档即时成交剩余撤销委托

    margin_trade(g.security, 200, market_type=4)

security：股票代码(str)；



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



limit_price：买卖限价(float)；



market_type：市价委托类型，上证非科创板股票支持参数1、4，上证科创板股票支持参数0、1、2、4，深证股票支持参数0、2、3、4、5(int)；



0：对手方最优价格；

1：最优五档即时成交剩余转限价；

2：本方最优价格；

3：即时成交剩余撤销；

4：最优五档即时成交剩余撤销；

5：全额成交或撤单；

#encoding:gbk



def init(ContextInfo):

    print('hello world')

    

def handlebar(ContextInfo):

    #计算当前主图的cci

    print("handle bar")

（3）Handlebar



handlebar 是整个 Python 模型中的核心执行函数。当模型从数据层获取到运行所需要的数据之后，会对数据集上的每一根 bar，调用一次 handlebar 函数，处理当前这根 bar 上的数据。也就是说，用户模型的核心逻辑都是写在该函数中的，如获取数据，设置下单条件等。在 handlebar 中处理完数据后，用户可以通过 paint 方法将需要绘图输出的结果返回给界面。界面会将输出结果如实的展示出来。

（4）ContextInfo



ContextInfo 是整个 Python 框架中的一个核心对象。它包含了各种与 Python 底层框架交互的 API 方法，也是一个全局的上下文环境，可以在 init 以及 handlebar 这两个函数中自由地传递用户创建的各种自定义数据。

def init(ContextInfo):

    pass

    

def handlebar(ContextInfo):

    pass

# encoding:gbk

import logging

from datetime import datetime, timedelta

from decimal import Decimal as D

from decimal import InvalidOperation



logging.basicConfig(level=logging.INFO)



# 挂单失败后的等待时长，以秒计

TIMEOUT_ON_FAIL_SEC = 30

# 等待account_callback的时长

# RUN_TIME_DELAY = 30



# how is this not defined in package??

MORNING_START = datetime.strptime(datetime.now().strftime('%Y%m%d') + '093000', '%Y%m%d%H%M%S')

MORNING_END = datetime.strptime(datetime.now().strftime('%Y%m%d') + '113000', '%Y%m%d%H%M%S')

NOON_START = datetime.strptime(datetime.now().strftime('%Y%m%d') + '130000', '%Y%m%d%H%M%S')

NOON_END = datetime.strptime(datetime.now().strftime('%Y%m%d') + '153000', '%Y%m%d%H%M%S')



# for SH only

TRANS_COST_1D = D('5e-6')

TRANS_COST_LONG = D('1.5e-7')

TRANS_COST_MAX = 100



# ORDER LIMITS

SH_UPPER = 1e7

SH_LOWER = 1e5

SZ_UPPER = 1e8

SZ_LOWER = 1e3



# ASSET NAME DICT

SH_REV_REPO = {'上交所1天': '204001.SH', '上交所2天': '204002.SH', '上交所3天': '204003.SH',

               '上交所4天': '204004.SH', '上交所7天': '204007.SH', '上交所14天': '204014.SH',

               '上交所28天': '204028.SH', '上交所91天': '204091.SH', '上交所182天': '204182.SH',

               }



SZ_REV_REPO = {'深交所3天': '131800.SZ', '深交所7天': '131801.SZ', '深交所14天': '131802.SZ',

               '深交所28天': '131803.SZ', '深交所91天': '131805.SZ', '深交所182天': '131806.SZ',

               '深交所4天': '131809.SZ', '深交所1天': '131810.SZ', '深交所2天': '131811.SZ',

               }





def init(ContextInfo):

    ContextInfo.accID = account

    ContextInfo.set_account(ContextInfo.accID)

    ContextInfo.use_all_cap = False if ALL_CAP == '否' else True



    # global trading control, set to False if detected error on user's side

    # stop() does not halt strat

    ContextInfo.order_control = False



    if not ContextInfo.use_all_cap:

        try:

            ContextInfo.dollar_vol = float(D(DOLLAR_VOL))

        except InvalidOperation:

            ContextInfo.order_control = True

            raise ValueError('读取资金量失败')

    else:

        if DOLLAR_VOL != '':

            logging.warning('已设定使用全部账户资金，忽略所设置资金量')



    try:

        ContextInfo.start_time = datetime.strptime(datetime.now().strftime('%Y%m%d') + str(START_TIME), '%Y%m%d%H%M%S')

        ContextInfo.asset_name = SH_REV_REPO[ASSET_NAME]

    except KeyError:

        ContextInfo.asset_name = SZ_REV_REPO[ASSET_NAME]

    except ValueError as error:

        if 'unconverted data remains' in str(error):

            ContextInfo.order_control = True

            raise ValueError('读取挂单时间失败')



    if not (MORNING_END > ContextInfo.start_time >= MORNING_START) \

            and not (NOON_END > ContextInfo.start_time >= NOON_START):

        ContextInfo.order_control = True

        raise ValueError('挂单时间不在可交易时间内')



    ContextInfo.can_order = False

    ContextInfo.order_done = False



    if not ContextInfo.order_control:

        ContextInfo.run_time("place_order", "{0}nSecond".format(TIMEOUT_ON_FAIL_SEC),

                             ContextInfo.start_time.strftime('%Y-%m-%d %H:%M:%S'), 'SH')





def account_callback(ContextInfo, accountInfo):

    if not ContextInfo.can_order:

        ContextInfo.can_order = True

        if ContextInfo.use_all_cap:

            ContextInfo.dollar_vol = accountInfo.m_dAvailable

        else:

            if ContextInfo.dollar_vol > accountInfo.m_dAvailable:

                ContextInfo.order_control = True

                raise ValueError('下单额度大于账户可用资金')



        # check if order satisfies lower limit for each exchange

        if ('SH' in ContextInfo.asset_name and ContextInfo.dollar_vol < SH_LOWER) \

                or ('SZ' in ContextInfo.asset_name and ContextInfo.dollar_vol < SZ_LOWER):

            ContextInfo.order_control = True

            raise ValueError('下单额度低于交易所最低限额')



        # checks dollar_vol and rounds the total amount

        if 'SH' in ContextInfo.asset_name and ContextInfo.dollar_vol % SH_LOWER != 0:

            ContextInfo.dollar_vol = (ContextInfo.dollar_vol // SH_LOWER) * SH_LOWER

            logging.warning('下单额度已规整为：{0}'.format(ContextInfo.dollar_vol))

        elif 'SZ' in ContextInfo.asset_name and ContextInfo.dollar_vol % SZ_LOWER != 0:

            ContextInfo.dollar_vol = (ContextInfo.dollar_vol // SZ_LOWER) * SZ_LOWER

            logging.warning('下单额度已规整为：{0}'.format(ContextInfo.dollar_vol))



        '''

        if 'SH' in ContextInfo.asset_name:

            num_batch_order = int(ContextInfo.dollar_vol // SH_UPPER)

            remain_order = ContextInfo.dollar_vol - num_batch_order * SH_UPPER

            if ContextInfo.asset_name == '204001.SH':

                transaction_cost = TRANS_COST_MAX * num_batch_order + remain_order * TRANS_COST_1D

            else:

                transaction_cost = TRANS_COST_MAX * num_batch_order + remain_order * TRANS_COST_LONG

            if transaction_cost + ContextInfo.dollar_vol > accountInfo.m_dAvailable:

                ContextInfo.order_control = True

                raise ValueError('可用资金不足以垫付交易金额与手续费')

       '''



        ContextInfo.remain_vol = ContextInfo.dollar_vol





def handlebar(ContextInfo):

    return





def place_order(ContextInfo):

    if not ContextInfo.can_order or ContextInfo.order_control:

        return



    if not ContextInfo.order_done:

        if 'SH' in ContextInfo.asset_name:

            num_batch_order = int(ContextInfo.remain_vol // SH_UPPER)

            remain_order = ContextInfo.remain_vol - num_batch_order * SH_UPPER

            for _ in range(num_batch_order):

                order_remark = '国债逆回购：尝试报单{0}元 {1}'.format(SH_UPPER, ContextInfo.asset_name)

                passorder(24, 1102, ContextInfo.accID, ContextInfo.asset_name, 5, -1, SH_UPPER, order_remark, 1,

                          order_remark, ContextInfo)

        else:

            num_batch_order = int(ContextInfo.remain_vol // SZ_UPPER)

            remain_order = ContextInfo.remain_vol - num_batch_order * SZ_UPPER

            for _ in range(num_batch_order):

                order_remark = '国债逆回购：尝试报单{0}元 {1}'.format(SZ_UPPER, ContextInfo.asset_name)

                passorder(24, 1102, ContextInfo.accID, ContextInfo.asset_name, 5, -1, SZ_UPPER, order_remark, 1,

                          order_remark, ContextInfo)



        order_remark = '国债逆回购：尝试报单{0}元 {1}'.format(remain_order, ContextInfo.asset_name)

        passorder(24, 1102, ContextInfo.accID, ContextInfo.asset_name, 5, -1, remain_order, order_remark, 1,

                  order_remark, ContextInfo)



        ContextInfo.remain_vol = 0

        ContextInfo.order_done = True





def order_callback(ContextInfo, orderInfo):

    curr_remark = orderInfo.m_strRemark

    curr_status = orderInfo.m_nOrderStatus



    if '国债逆回购' in curr_remark and ContextInfo.asset_name in curr_remark and curr_status == 57:

        ContextInfo.order_done = False

        # up the leftover dollar vol by failed amount

        # logging.info('reported trade amount:{0}, reported_trade_volume:{1}'.format(orderInfo.m_dTradeAmount, orderInfo.m_nVolumeTotal))

        # 单张100元

        ContextInfo.remain_vol += orderInfo.m_nVolumeTotal * 100

        if '交易时间不合法' in orderInfo.m_strCancelInfo:

            ContextInfo.order_control = True

            raise ValueError('国债逆回购：未能在交易时间内完成下单，停止报单。余量{0}元未报'.format(ContextInfo.remain_vol))

        logging.warning('国债逆回购：报单废单，原因：\"{0}\"，尝试重报'.format(orderInfo.m_strCancelInfo))

    elif '国债逆回购' in curr_remark and ContextInfo.asset_name in curr_remark and curr_status == 50:

        logging.info('国债逆回购：报单{0}元成功'.format(orderInfo.m_nVolumeTotal * 100))

    return









待续，不定期更新

使用场景

该函数在交易模块可用



接口说明

该接口用于获取当日分时成交行情数据。



注意事项：



1、沪深市场都有分时成交数据；



2、分时成交数据需开通level2行情才有数据推送，否则无数据返回；

返回

返回一个OrderedDict对象，包含每只代码的分时成交行情数据。(OrderedDict([(),()...]))



返回结果字段介绍：



time_stamp: 时间戳毫秒级(str:numpy.int64)；

hq_px: 价格(str:numpy.float64)；

hq_px64: 价格(str:numpy.int64)(行情暂不支持，返回均为0)；

business_amount: 成交数量(str:numpy.int64)；

business_balance: 成交金额(str:numpy.int64)；

business_count: 成交笔数(str:numpy.int64)；

business_direction: 成交方向（0：卖，1：买，2：平盘)(str:numpy.int64)；

amount: 持仓量(str:numpy.int64)(行情暂不支持，返回均为0)；

start_index: 分笔关联的逐笔开始序号(str:numpy.int64)(行情暂不支持，返回均为0)；

end_index: 分笔关联的逐笔结束序号(str:numpy.int64)(行情暂不支持，返回均为0)；

def initialize(context):

    g.security = '000001.SZ'

    set_universe(g.security)



def handle_data(context, data):

    #获取000001.SZ的分时成交数据

    direction_data = get_tick_direction(g.security)

    log.info(direction_data)

    #获取指定股票列表分时成交数据

    direction_data = get_tick_direction(['000002.SZ','000032.SZ'])

    log.info(direction_data)

    #获取成交量

    business_amount = direction_data['000002.SZ']['business_amount']

    log.info('分时成交的成交量为：%s' % business_amount)

1. 国信证券iQuant策略交易平台精简版是指国信证券iQuant策略交易平台更专业快速且简洁的版本，满足股票、期货、期权、基金等全品种交易需求。
2. 风险等级：R4
 投资期限：0-1年
投资品种：权益类投资品种如股票、混合型基金、偏股型基金、股票型基金等。
3. 平台使用不收取费用。

 

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

    def initialize(context):

 2    # 初始化此策略

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

 4    g.security = '600570.SS'

 5    set_universe(g.security)

 6    pass

 7

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

 9 def handle_data(context, data):

10    security = g.security

11

12    #得到十日历史价格

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

14

15    # 得到五日均线价格

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

17

18    # 得到十日均线价格

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

20

21    # 取得昨天收盘价

22    price = data[security]['close']

23

24    # 得到当前资金余额

25    cash = context.portfolio.cash

26

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

28    if ma5 > ma10:

29        # 用所有 cash 买入股票

30        order_value(security, cash)

31        # 记录这次买入

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

33

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

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

36        # 全部卖出

37        order_target(security, 0)

38        # 记录这次卖出

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

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

 2    a = m/(N+1)

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

 4    return EXPMA2 #2为后一天值

 5

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

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

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

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

10    DIF2 = EXPMA12_2 - EXPMA26_2

11    a = m/(N3+1)

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

13    BAR2=2*(DIF2-DEA2)

14    return EXPMA12_2,EXPMA26_2,DIF2,DEA2,BAR2

15

16  def initialize(context):

17    global init_price

18    init_price = None

19    # 获取沪深300股票

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

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

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

23    set_universe(g.security)

24

25  def handle_data(context, data):

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

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

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

29    #如果是停牌不进行计算

30    for security in g.security:

31        if data[security].is_open >0:

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

33            if init_price is None:

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

35                EXPMA12_1 = init_price

36                EXPMA26_1 = init_price

37                DIF1 = init_price

38                DEA1 = init_price

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

40            m = 2.0

41            #设定指数平滑基期数

42            N1 = 12

43            N2 = 26

44            N3 = 9

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

46            # 取得当前价格

47            current_price = data[security].price

48            # 取得当前的现金

49            cash = context.portfolio.cash

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

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

52                # 计算可以买多少只股票

53                number_of_shares = int(cash/current_price)

54                # 购买量大于0时，下单

55                if number_of_shares > 0:

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

57                    order(security, +number_of_shares)

58                    # 记录这次买入

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

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

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

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

63                order_target(security, 0)

64                # 记录这次卖出

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

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

67            DEA1 = DEA2

68            DIF1 = DIF2

69            EXPMA12_1 = EXPMA12_2

70            EXPMA26_1 = EXPMA26_2

获取 排除满足强赎天数剩余N天的可转债，排除强赎可转债。



比如：DAY=4 ，那么假设强赎满足天数为15天，那么返回市场上强赎强赎倒数天数大于4天的可转债，即返回小于或者等于11天以下的转债。把满足条件还差4天的转债排除掉了，当然，已经公告强赎的也会被排除。







import requests



URL = 'http://11.11.11.11/api/redeem/'

# DAY 强赎倒数剩余天数小于 DAY （4）天， 已经公告强赎的也是被排除的

DAY = 4



SIGN = '私信星主获取' # sign和以前一致



data = {'day': DAY,

        'sign': SIGN}

r = requests.post(URL, data=data)



print(r.json())

#获取当日的股票池

g.stock_list = get_Ashares(g.current_date)

get_history(70, '1d', ['close','volume'], g.stock_list, fq='dypre', include=False)

from  setting import get_mysql_conn,get_engine

import pandas as pd

import pymongo

from pyecharts import Geo,Style,Map

engine = get_engine('db_stock',local='local')

# 堆叠图

from pyecharts import Bar

df = pd.read_sql('tb_bond_jisilu',con=engine)



result ={}

for name,grades in df.groupby('评级'):

#     print(name,grades[['可转债名称','可转债价格']])

    for each in grades['可转债价格']:

        result.setdefault(name,)

        result[name].append(each)

        

        

# 确定价格的范围



value = [str(i) for i in range(85,140)]

ret = [0]*len(value)

ret1 = dict(zip(value,ret))



ret_A_add = ret1.copy()

for item in result['A+']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            ret_A_add[k]+=1

            

retAA_ = ret1.copy()

for item in result['']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAA_[k]+=1



retAA = ret1.copy()

for item in result['AA']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAA[k]+=1

            

retAA_add = ret1.copy()

for item in result['AA+']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAA_add[k]+=1

            

retAAA = ret1.copy()

for item in result['AAA']:

    for k in ret1:

        if float(k)+0.5>item and float(k)-0.5<=item:

            retAAA[k]+=1



bar = Bar('可转债价格分布')

bar.add('A+',value,list(ret_A_add.values()),is_stack=True,yaxis_max=11)

bar.add('',value,list(retAA_.values()),is_stack=True,yaxis_max=11)

bar.add('AA',value,list(retAA.values()),is_stack=True,yaxis_max=11)

bar.add('AA+',value,list(retAA_add.values()),is_stack=True,yaxis_max=11)

bar.add('AAA',value,list(retAAA.values()),is_stack=True,yaxis_max=11)

def initialize(context):

    pass



def handle_data(context, data):

    df = get_cb_info()

    log.info(df)

2024-11-20 10:22:00 - ERROR - 用户策略执行异常

2024-11-20 10:22:00 - ERROR - Exception: Traceback (most recent call last):

  File /home/fly/sim_backtest/result/29fa7074-a6e6-11ef-b05b-c40778d9af27/user_strategy.py, line 6 in handle_data

    df = get_cb_info()

    --> data = BarDict(600570.SS)

    --> context = <StrategyContext {'recorded_vars': {}, 'commission': <Commission {'cost': 0.0003, 'min_trade_cost': 5.0, 'tax': 0.001}>, 'blotter': <Blotter {'current_dt': date ...

NameError: name 'get_cb_info' is not defined

def hit_limit_recent():

    # 选出最近N天正股有涨停的可转债

    N =10

    scale = 5

    latest_price = 160

    bond_name_dict, bond_zg_dict = get_all_bond_info(scale=scale,latest_price=latest_price)

    zg_list = list(bond_zg_dict.values())

    panel_info = get_history(N, frequency='1d', field=['close','high_limit'], security_list=zg_list, fq='pre', include=False, fill='nan')

    df = panel_info.swapaxes("minor_axis", "items")

    target_list = []

    for code in zg_list:

        stock_df = df[code]



        hit_high = stock_df[stock_df['close']==stock_df['high_limit']]

        if len(hit_high) > 0:

            # print(hit_high.index)

            target_list.append(code)



    zz_target_list = []

    for code,zg_code in bond_zg_dict.items():

        if zg_code in target_list:

            print(code, bond_name_dict[code])

            zz_target_list.append(code)



    return zz_target_list

import datetime



target_list = [

'600000.SS', 

'000333.SZ'

]



def execution(context, data):

    now = context.current_dt.strftime('%H:%M')

	for code in target_list:

        tick_info = data[code]

        price = tick_info['price']

        print('now: {} code : {} price:{}'.format(now,code ,price))

        







# 标准

def initialize(context):

    log.info("公众号：可转债量化分析 ---- start ----")





def handle_data(context, data):

    execution(context, data)

2024-09-20 14:42:00 - INFO - now: 14:42 code : 000333.SZ price:66.22

2024-09-20 14:43:00 - INFO - now: 14:43 code : 000333.SZ price:66.26

2024-09-20 14:44:00 - INFO - now: 14:44 code : 000333.SZ price:66.19

2024-09-20 14:45:00 - INFO - now: 14:45 code : 000333.SZ price:66.2

2024-09-20 14:46:00 - INFO - now: 14:46 code : 000333.SZ price:66.19

2024-09-20 14:47:00 - INFO - now: 14:47 code : 000333.SZ price:66.18

2024-09-20 14:48:00 - INFO - now: 14:48 code : 000333.SZ price:66.14

2024-09-20 14:49:00 - INFO - now: 14:49 code : 000333.SZ price:66.25

2024-09-20 14:50:00 - INFO - now: 14:50 code : 000333.SZ price:66.19

2024-09-20 14:51:00 - INFO - now: 14:51 code : 000333.SZ price:66.18

2024-09-20 14:52:00 - INFO - now: 14:52 code : 000333.SZ price:66.19

2024-09-20 14:53:00 - INFO - now: 14:53 code : 000333.SZ price:66.2

2024-09-20 14:54:00 - INFO - now: 14:54 code : 000333.SZ price:66.19

2024-09-20 14:55:00 - INFO - now: 14:55 code : 000333.SZ price:66.25

2024-09-20 14:56:00 - INFO - now: 14:56 code : 000333.SZ price:66.27

2024-09-20 14:57:00 - INFO - now: 14:57 code : 000333.SZ price:66.28

2024-09-20 14:58:00 - INFO - now: 14:58 code : 000333.SZ price:66.28

2024-09-20 14:59:00 - INFO - now: 14:59 code : 000333.SZ price:66.28

2024-09-20 15:00:00 - INFO - now: 15:00 code : 000333.SZ price:66.06

get_sort_msg(sort_type_grp=None, sort_field_name=None, sort_type=1, data_count=100)

import datetime

START_TIME = (datetime.datetime.now() + datetime.timedelta(minutes=1)).strftime('%H:%M')





def execution(context):

    #获取XBHS.GN的概念排名信息

    sort_data = get_sort_msg(sort_type_grp='XBHS.GN', sort_field_name='px_change_rate', sort_type=1, data_count=100)



    for data in sort_data:

        log.info('板块： {} '.format(data['prod_name']))

        for sub_stock in data['rise_first_grp']:

            log.info('{} 涨幅 ：{}'.format(sub_stock['prod_name'],sub_stock['px_change_rate']))

        

        log.info('\n')





def initialize(context):

    # 初始化策略

    run_daily(context, execution, time=START_TIME)  # 扫描

    log.info("公众号：可转债量化分析\n")



def handle_data(context, data):

    pass

prod_code: 行业代码(str:str)；

prod_name: 行业名称(str:str)；

hq_type_code: 行业板块代码(str:str)；

time_stamp: 时间戳毫秒级(str:int)；

trade_mins: 交易分钟数(str:int)；

trade_status: 交易状态(str:str)；

preclose_px: 昨日收盘价(str:float)；

open_px: 今日开盘价(str:float)；

last_px: 最新价(str:float)；

high_px: 最高价(str:float)；

low_px: 最低价(str:float)；

wavg_px: 加权平均价(str:float)；

business_amount: 总成交量(str:int)；

business_balance: 总成交额(str:int)；

px_change: 涨跌额(str:float)；

amplitude: 振幅(str:int)；

px_change_rate: 涨跌幅(str:float)；

circulation_amount: 流通股本(str:int)；

total_shares: 总股本(str:int)；

market_value: 市值(str:int)；

circulation_value: 流通市值(str:int)；

vol_ratio: 量比(str:float)；

shares_per_hand: 每手股数(str:int)；

rise_count: 上涨家数(str:int)；

fall_count: 下跌家数(str:int)；

member_count: 成员个数(str:int)；

rise_first_grp: 领涨股票(其包含以下五个字段)(str:list[dict{str:int,str:str,str:str,str:float,str:float},...])；

prod_code: 股票代码(str:str)；

prod_name: 证券名称(str:str)；

hq_type_code: 类型代码(str:str)；

last_px: 最新价(str:float)；

px_change_rate: 涨跌幅(str:float)；

fall_first_grp: 领跌股票(其包含以下五个字段)(str:list[dict{str:int,str:str,str:str,str:float,str:float},...])；

prod_code: 股票代码(str:str)；

prod_name: 证券名称(str:str)；

hq_type_code: 类型代码(str:str)；

last_px: 最新价(str:float)；

px_change_rate: 涨跌幅(str:float)；

def initialize(context):

    # 初始化策略

    engine = DBSelector().get_engine()

    df = pd.read_sql('select * from tb_holding_stock_list', con=engine)

    df['code']=df['code'].astype(str)

    result = {}

    for index, row in df.iterrows():

        code = add_code_postfix(row['code'])

        result[code] = {'name': row['name'], 'source': row['source']}

    g.holding_stock_dict = result

    g.holding_stock_list = list(result.keys())

    g.__cache = Cache()



    run_interval(context, execution, seconds=INTERVAL)  # 扫描





def handle_data(context, data):

    pass





def tick_data(context, data):

    pass



def before_trading_start(context, data):

    '''

    盘前

    '''

    if DEBUG:

        log.info('盘前运行开始', str(context.blotter.current_dt))





def after_trading_end(context, data):

    '''

    盘后

    '''

    if DEBUG:

        log.info('盘后时间 ', str(context.blotter.current_dt))

def execution(context):

    tick_info = get_snapshot(g.holding_stock_list)

    for code, tick in tick_info.items():

        px_change_rate = tick['px_change_rate']

        if px_change_rate > abs(HIT_TARGET):

            if g.__cache.check(code):

                # 通知

                name = g.holding_stock_dict.get(code)['name']

                source = g.holding_stock_dict.get(code)['source']

                msg = '{}-{} 涨幅-{},{}'.format(code,

                                              name, px_change_rate, source)

                send_message_via_wechat(msg)

7、该接口只能获取2005年后的数据。

test_data = data = get_price(security='000001.SS',start_date='20050201',end_date='20050630',frequency='1d')

def initialize(context):

    run_daily(context, event, '09:38')





def handle_data(context, data):

    pass





def event(context):

    his60 = get_history(60, '1d', ['close'],  ['515220.SS'], fq='pre', include=False)

    print(his60)

import datetime 

import time



RUN_TIME = '09:24'



def execution(context):



    while 1:

        current_second = datetime.datetime.now().strftime('%S')

        if current_second >= '58':

            break

        time.sleep(0.1)



    do_something()



def initialize(context):

    # 初始化策略

    run_daily(context, execution, RUN_TIME)



def handle_data(context, data):

    pass

 2023-10-18 09:25:12 - ERROR - 全局对象g持久化对象保存失败，对象名：TARGET_STOCK_CODE，错误原因：Traceback (most recent call last):
  File "./fly_docker/IQEngine/utils/global_variable.py", line 50, in save
_pickle.PicklingError: Can't pickle <class 'IQEngine.user_module.PositionManager'>: attribute lookup PositionManager on IQEngine.user_module failed