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)

class a():

	pass

A = a()

class A():

	pass

a = A()

class GlobalCls():

    pass

    

g = GlobalCls()

文件编码声明： #coding:gbk 是指定源文件的编码格式为GBK。在Python 3中，通常使用UTF-8作为文件编码格式，因此可以将该行删除或更改为#coding:utf-8。



类名和函数名： 根据PEP 8命名约定，类名应该使用大写字母开头的驼峰命名法（例如A改为A）。同样，函数名应该使用小写字母开头的小写命名法（例如init改为init，f改为f）。



类和实例： 在代码中定义了一个空类a，但没有给它任何属性或方法。如果不需要这个类，可以将其删除。



缩进和代码格式： Python非常依赖于正确的缩进，以指示代码块的层次结构。请确保代码的缩进是一致的，并使用适当的缩进级别（通常是4个空格）。



代码注释： 代码中有一些注释，但是大部分是被注释掉的。良好的注释可以增加代码的可读性和可维护性，建议在关键部分添加更多有用的注释。



异常处理： 代码中没有包含任何异常处理机制。在实际应用中，建议对可能引发异常的操作进行适当的异常处理，以提高代码的健壮性。

		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)

#-*-coding:gbk-*-

import time

start = False

ACCOUNT = ''



def init(ContextInfo):

    now = time.ctime()

    print(now)

    ContextInfo.run_time("execution","30nSecond","2023-04-14 13:20:00")





def execution(ContextInfo):

    data = ContextInfo.get_stock_list_in_sector('沪深A股')

    print(len(data))



def handlebar(ContextInfo):

    pass

【2023-10-25 15:18:45.533】  start trading mode

【2023-10-25 15:18:45.533】  Wed Oct 25 15:18:45 2023



【2023-10-25 15:18:45.533】  5074

['000001.SZ', '000002.SZ', '000004.SZ', '000005.SZ', '000006.SZ', '000007.SZ', '000008.SZ', '000009.SZ', '000010.SZ', '000011.SZ', '000012.SZ', '000014.SZ', '000016.SZ', '000017.SZ', '000019.SZ', '000020.SZ', '000021.SZ', '000023.SZ', '000025.SZ', '000026.SZ', '000027.SZ', '000028.SZ', '000029.SZ', '000030.SZ', '000031.SZ', '000032.SZ', '000034.SZ', '000035.SZ', '000036.SZ', '000037.SZ', '000039.SZ', '000040.SZ', '000042.SZ', '000045.SZ', '000046.SZ', '000048.SZ', '000049.SZ', '000050.SZ', '000055.SZ', '000056.SZ', '000058.SZ', '000059.SZ', '000060.SZ', '000061.SZ', '000062.SZ', '000063.SZ', '000065.SZ', '000066.SZ', '000068.SZ', '000069.SZ', '000070.SZ', '000078.SZ', '000088.SZ', '000089.SZ', '000090.SZ', '000096.SZ', '000099.SZ', '000100.SZ', '000151.SZ', '000153.SZ', '000155.SZ', '000156.SZ', '000157.SZ', '000158.SZ', '000159.SZ', '000166.SZ', '000301.SZ', '000333.SZ', '000338.SZ', '000400.SZ', '000401.SZ', '000402.SZ', '000403.SZ', '000404.SZ', '000407.SZ', '000408.SZ', '000409.SZ', '000410.SZ', '000411.SZ', '000413.SZ', '000415.SZ', '000416.SZ', '000417.SZ', '000419.SZ', '000420.SZ', '000421.SZ', '000422.SZ', '000423.SZ', '000425.SZ', '000426.SZ',

up_px:涨停价格(str:float)；

down_px:跌停价格(str:float)；

使用场景

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



接口说明

该接口用于标识当日股票的涨跌停情况。



注意事项：



无



参数

security：单只股票代码或者多只股票代码组成的列表，必填字段(list[str]/str)；



返回

正常返回一个dict类型数据，包含每只股票代码的涨停状态。多只股票代码查询时其中部分股票代码查询异常则该代码返回既不涨停也不跌停状态0。(dict[str:int])



涨跌停状态说明：



2：触板涨停（已经是涨停价格，但还有卖盘）；

1：涨停；

0：既不涨停也不跌停；

-1：跌停；

-2：触板跌停（已经是跌停价格，但还有买盘）；

def initialize(context):

    g.security = '600570.SS'

    set_universe(g.security)



def handle_data(context, data):

    # 代码涨跌停状态

    stock_flag = check_limit(g.security)

    log.info(stock_flag)

    def modify_code(self, x):

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

为贯彻落实7月24日中央政治局会议精神和国务院相关会议部署，进一步活跃资本市场，提振投资者信心，形成推动经济持续回升向好的工作合力，证监会指导上海证券交易所、深圳证券交易所、北京证券交易所自8月28日起进一步降低证券交易经手费。沪深交易所此次将A股、B股证券交易经手费从按成交金额的0.00487%双向收取下调为按成交金额的0.00341%双向收取，降幅达30%；北交所在2022年12月调降证券交易经手费50%的基础上，再次将证券交易经手费标准降低50%，由按成交金额的0.025%双边收取下调至按成交金额的0.0125%双边收取。同时，将引导证券公司稳妥做好与客户合同变更及相关交易参数的调整，依法降低经纪业务佣金费率，切实将此次证券交易经手费下降的政策效果传导至广大投资者
 

import pandas as pd

import datetime





def get_tick(code, start_time, end_time, period='tick'):

    from xtquant import xtdata



    xtdata.download_history_data(code, period=period, start_time=start_time, end_time=end_time)

    data = xtdata.get_local_data(field_list=, stock_code=

, period=period, count=10)

    result_list = data

    df = pd.DataFrame(result_list)



    df['time_str'] = df['time'].apply(lambda x: datetime.datetime.fromtimestamp(x / 1000.0))

    return df





def process_timestamp(df, filename):

    df = df.set_index('time_str')

    result = df.resample('3S').first().ffill()

    result = result[(result.index >= '2022-07-20 09:30') & (result.index <= '2022-07-20 15:00')]

    result = result.reset_index()

    result.to_csv(filename + '.csv')





def dump_single_code_tick():

    # 导出单个转债的tick数据

    code='128022'

    start_date = '20210113'

    end_date = '20210130'



    post_fix = 'SZ' if code.startswith('12') else 'SH'

    code = '{}.{}'.format(code,post_fix)

    filename = '{}'.format(code)

    df = get_tick(code, start_date, end_date)



dump_single_code_tick()

from xtquant import xtdata

data = xtdata.get_market_data(field_list=['time', 'open', 'close', 'high', 'low', 'volume', 'amount'], stock_list=['603000.SH'], period='1d', start_time='20230101')

print(data)