PTrade交易程序代码——从零到实盘19

已于 2023-10-04 08:12:44 修改
阅读量1w 收藏 71
点赞数 13
分类专栏： 从零到实盘 文章标签： python 量化 PTrade
于 2022-02-19 19:38:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46603114/article/details/123022672
版权

如题，本文将介绍PTrade实盘交易程序的代码。

如何在PTrade中部署策略，可以参见前文中“PTrade部署策略过程”部分内容，然后把本文的代码粘贴到PTrade，就能完成“双神穿多线”策略的部署。

我们将对程序的各个函数依次进行介绍。

初始化函数

def initialize(context):

该函数为PTrade的业务流程框架的必选函数，实现初始化功能，用于初始化一些全局变量。策略启动后，该函数仅会被调用一次。

  • 参数context为Context对象，存放有当前的账户及持仓信息。
    run_interval(context, interval_handle, seconds = 3)

这里以设定时间间隔（单位为秒）周期性运行指定函数interval_handle，这里我们设置seconds = 3，也就是每隔3秒调用一次函数interval_handle，该函数用于处理买卖逻辑，将在后文中定义实现。
需要注意的是，seconds设置最小时间间隔为3秒，小于3秒默认设定为3秒，也就是我们每次处理交易的最小时间间隔为3秒。

    g.limit_value = 5000

设置资金少于limit_value则不买入，这里注意到全局变量均已g.开头。

    g.limit_stock_num = 3

设置持仓股票只数限制，根据回测结果我们设置最多持有3张股票。

    g.limit_hold_days = 6

设置持股天数限制，根据回测结果我们设置单只股票最多持有6天。

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

设置要操作的股票池，这里我们添加沪深300。

盘前初始化函数

def before_trading_start(context, data):

该函数会在每天开始交易前被调用，此处添加每天都要初始化的信息。

  • 参数context为Context对象，存放有当前的账户及持仓信息
  • 参数data为保留字段暂无数据
    在该函数中，我们会将待监测和交易的股票添加到股票池，读取股票的买点、卖点数据，以及判断股票是否达到持股天数限制，需要立即卖出。
    g.buy_submitted_set = set()

当日提交买单的股票代码集合，用于避免同一股票的买单被重复提交。

    file_path = get_research_path() + 'upload_file/trade_data.csv'
    g.db_df = pd.read_csv(file_path, encoding='utf-8', converters={'code': str})

通过前面文章的设置，我们将待交易数据自动上传到研究目录下upload_file文件夹下，这里读取待交易数据，供实盘使用。

    g.db_df['code_ptrade'] = g.db_df['code'].map(lambda x: x + '.SS' if '6' == x[0] else x + '.SZ')

由于PTrade的股票代码是在数字后添加.SS或者.SZ，这里我们对股票代码进行格式转换，以便后续PTrade使用。

    g.to_trade_df = g.db_df[1 == g.db_df['to_trade']]

获取待交易数据，待交易数据的to_trade字段值均为1。

    g.to_buy_df = g.to_trade_df[g.to_trade_df['date_buy'].isna()]
    g.to_buy_stock_list = g.to_buy_df['code_ptrade'].tolist()

获取待买入数据，如果date_buy字段为空，表示该股票尚未买入，需实盘监测是否触发买入。

    g.buy_point_dict = g.to_buy_df[['code_ptrade', 'buy_point']].set_index('code_ptrade').to_dict(into=OrderedDict)['buy_point']
    log.info('买点字典：{}'.format(g.buy_point_dict))

生成买点字典，字典的key为股票代码，value为股票的买点价格。

    g.to_sell_df = g.to_trade_df[(~g.to_trade_df['date_buy'].isna()) & (g.to_trade_df['hold_days'] <= g.limit_hold_days)]
    g.to_sell_stock_list = g.to_sell_df['code_ptrade'].tolist()

获取待止盈、止损卖出数据，此类股票的date_buy字段不为空，表示已经买入，并且持有天数没有达到上限，这样需要对此类股票的价格进行监测，观察是否会达到止盈或止损价格，来决定是否需要卖出。

    g.to_sell_immi_df = g.to_trade_df[(~g.to_trade_df['date_buy'].isna()) & (g.to_trade_df['hold_days'] > g.limit_hold_days)]
    g.to_sell_immi_list = g.to_sell_immi_df['code_ptrade'].tolist()
    g.sell_immi_done = False

获取待立刻卖出股票，此类股票date_buy字段不为空，且已经达到持股天数上限，开盘需立即卖出。

    g.take_profit_dict = g.to_sell_df[['code_ptrade', 'price_take_profit']].set_index('code_ptrade').to_dict()['price_take_profit']
    log.info('止盈字典：{}'.format(g.take_profit_dict))
    g.stop_loss_dict = g.to_sell_df[['code_ptrade', 'price_stop_loss']].set_index('code_ptrade').to_dict()['price_stop_loss']
    log.info('止损字典：{}'.format(g.stop_loss_dict))

生成止盈、止损字典，字典的key为股票代码，value分别为股票的止盈价和止损价。

    g.security =  g.to_trade_df['code_ptrade'].tolist()
    set_universe(g.security)

设置待交易股票，将待交易股票添加到股票池。

    g.ipo_done = False
    log.info('当前可用资金：{}'.format(context.portfolio.cash))

重置ipo标识，每日固定时间进行一次新股申购。

    log.info('盘前持股{}只：{}'.format(get_position_count(context), get_position_list(context)))
    log.info('单只股票买入金额：{}'.format(value_per_stock(context)))

打印盘前信息。

判断资金余额是否充足函数

def enough_cash(context, limit_value):

该函数用于判断资金余额是否充足。

  • 参数context为Context对象，存放有当前的账户及持仓信息
  • 参数limit_value为资金限制，当前账户余额需大于等于该值，才判断为余额充足
    if context.portfolio.cash < limit_value:
        log.info('余额不足')        
        return False
    else:
        return True

当资金充足则返回True，否则返回False。

获取当前已买股票函数

def bought_stock_set(context):

该函数用于获取已买股票的集合，包含已提交买单的股票和持仓股票。

  • 参数context为Context对象，存放有当前的账户及持仓信息
    return g.buy_submitted_set | set(get_position_list(context))

对已提交买入的股票代码的集合、持仓股票代码的集合求并集，达到已买股票的集合。

获取当前可买股票只数函数

def available_position_count(context):

该函数用于计算当前可买的股票只数。

  • 参数context为Context对象，存放有当前的账户及持仓信息
    return g.limit_stock_num - len(bought_stock_set(context))

对已提交买入的股票代码的集合、持仓股票代码的集合求并集，再用持股只数限制减去上面并集中元素的个数，即为当前可买的股票只数 。

获取单只股票买入金额函数

def value_per_stock(context):

该函数用于计算单只股票买入金额。

  • 参数context为Context对象，存放有当前的账户及持仓信息
    available_count = available_position_count(context)

计算当前可买的股票只数。

    if 0 == available_count:
        return 0.0

当可买的股票只数为0时返回0.0。

    return context.portfolio.cash / available_count

如果可买入股票的只数不为0，则用资金余额除以当前可买的股票只数得到单只股票可买入金额，供后续下买单使用。

获取当前持股列表函数

def get_position_list(context):

该函数用于获取当前持股列表。

  • 参数context为Context对象，存放有当前的账户及持仓信息
    return [x for x in context.portfolio.positions if context.portfolio.positions[x].amount != 0]

context.portfolio.positions包含持股信息，但需要通过amount!=0来获取真实持股。因为当股票卖出成功时，当日清仓的股票信息仍会保存在context.portfolio.positions中，只是amount等于0。

获取当前持股只数函数

def get_position_count(context):

该函数用于获取当前持股只数。

  • 参数context为Context对象，存放有当前的账户及持仓信息
    return len(get_position_list(context))

调用get_position_list获取当前持有股票的代码列表，使用len获取持股只数。

处理卖出函数

def handle_sell(context):

该函数用于处理卖出逻辑，每3秒会被调用一次。

  • 参数context为Context对象，存放有当前的账户及持仓信息
    if not g.sell_immi_done:
        for stock in g.to_sell_immi_list:
            snapshot = get_snapshot(stock)
            order_target(stock, 0, limit_price=round(snapshot[stock]['last_px'] * 0.982, 2))
            g.sell_immi_done = True
            log.info('{}持仓天数限制卖单提交'.format(stock))

处理到达持仓天数限制的股票，用当前价下跌1.8%提交卖单，确保卖出。

    for stock in g.to_sell_stock_list.copy():

遍历待卖出股票。

        snapshot = get_snapshot(stock)

获取实时行情快照，快照包含股票的实时价格等信息。

        trade_status = snapshot[stock]['trade_status']
        if trade_status == 'STOPT':
            log.info(stock, '该股为停盘状态，不进行交易判断')
            continue

判断是否停盘，停盘则跳过。

        high_price = snapshot[stock]['high_px']
        low_price = snapshot[stock]['low_px']
        current_price = snapshot[stock]['last_px']

从快照中获取股票最高价、最低价、当前价。

        limit_price = round(current_price * 0.982, 2)

限价，该价格将用于卖出股票。创业板和科创板有价格笼子限制，卖出申报价格不得低于卖出基准价格的98%。我们将限价同一设置为当前价格下跌1.8%，以确保能够成功卖出（极端情况可能仍无法卖出）。

        if high_price >= g.take_profit_dict[stock] or low_price <= g.stop_loss_dict[stock]:
            log.info('{}到达卖点'.format(stock))

如果达到止盈或者止损条件，则股票达到卖点。

            order_target(stock, 0, limit_price=limit_price)

以限价下指定市值卖单，清空该股票。

            g.to_sell_stock_list.remove(stock)
            log.info('{}卖单提交'.format(stock))

在待卖出股票列表中删除该股票。

处理买入函数

def handle_buy(context):

该函数用于处理买入逻辑，每3秒会被调用一次。

  • 参数context为Context对象，存放有当前的账户及持仓信息
    if context.portfolio.cash < g.limit_value:        
        return

判断剩余资金是否大于最小买入金额限制，单只股票买入金额太小，没有意义。

    if available_position_count(context) <= 0:
        return

判断如果已达最大持股只数，则不买入。

    for stock in g.to_buy_stock_list.copy():

遍历每只候选买入股票。

        if available_position_count(context) <= 0:
            return

判断如果已达最大持股只数，则不买入。

        if stock in bought_stock_set(context):
            continue

不重复买入股票。

        snapshot = get_snapshot(stock)

获取实时行情快照。

        trade_status = snapshot[stock]['trade_status']
        if trade_status == 'STOPT':
            log.info((stock, '该股为停盘状态，不进行交易判断'))
            continue

判断是否停盘，停盘则跳过。

        low_price = snapshot[stock]['low_px']
        current_price = snapshot[stock]['last_px']

获取股票最低价和当前价。

        target_value = value_per_stock(context)

获取计算单只股票买入金额。

        if target_value < current_price * 100 * 1.0003: 
            continue

如果余额不足买1手，则跳过该股票。

        limit_price = round(current_price * 1.018, 2)

计算限价，创业板和科创板有价格笼子限制，买入申报价格不得高于买入基准价格的102%，我们这里将限价设置为当前价上涨1.8%，用于后续下买单。

        if (low_price <= g.buy_point_dict[stock]) and (limit_price / g.buy_point_dict[stock] <= 1.0382):
            log.info('{}到达买点'.format(stock))

当最低价低于买点，表示股票已经到达买点。此外约束limit_price不超过买点的3.82%，再下买单，避免有股票卖出后，余额充足后买入新股票的价格过高。

            g.buy_submitted_set.add(stock)

将股票代码添加到已提交买单字典，避免后续重复提交该股票买单。

            log.info('targe_value={}, limit_price={}'.format(target_value, limit_price))
            order_target_value(stock, target_value, limit_price=limit_price)

下指定市值买单，用限价提交，order_target_value函数会实现以限价调整股票仓位到value价值。

            g.to_buy_stock_list.remove(stock)
            log.info('{}买单提交'.format(stock))

在待买入股票列表中删除该股票，后续不再判断是否还需买入。

处理打新函数

def handle_ipo():

该函数用于处理打新。

    if not g.ipo_done and datetime.datetime.now().time() >= datetime.time(11, 13, 0):

如果尚未申购，获取当前时间，在11:13进行申购。

        ipo_stocks_order(market_type=0)

申购上证普通新股。

        ipo_stocks_order(market_type=2)

申购深证普通新股。

        ipo_stocks_order(market_type=3)

申购上证普通新股。

        g.ipo_done = True

标记当日已申购。

周期处理函数

def interval_handle(context):

该函数为周期处理函数，每3秒被调用一次，依次调用前文实现的函数处理买入、卖出及打新申购。

  • 参数context为Context对象，存放有当前的账户及持仓信息
    handle_sell(context)

先处理卖出。

    handle_buy(context)

再处理买入。

    handle_ipo()

最后处理打新。

委托响应函数

def on_order_response(context, order_list):

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

  • 参数context为Context对象，存放有当前的账户及持仓信息
  • 参数order_list是一个列表，当前委托单发生变化时，发生变化的委托单列表。委托单以字典形式展现，内容包括：‘entrust_no’(委托单号), ‘order_time’(委托时间), ‘stock_code’(股票代码), ‘amount’(委托数量), ‘price’(委托价格), ‘business_amount’(成交数量), ‘status’(委托状态), ‘order_id’(委托订单号), ‘entrust_type’(委托类别), ‘entrust_prop’(委托属性)
    for order in order_list:
        bs = '买入' if order['amount'] > 0 else '卖出'
        info = '订单提交，股票代码：{}，数量：{}{:.0f}'.format(order['stock_code'], bs, abs(order['amount']))
        log.info(info)

打印委托数据。

成交响应函数

def on_trade_response(context, trade_list):

该函数会在成交回报返回时响应。

  • 参数context为Context对象，存放有当前的账户及持仓信息
  • 参数trade_list是一个列表，当前成交单发生变化时，发生变化的成交单列表。成交单以字典形式展现，内容包括：‘entrust_no’(委托单号), ‘business_time’(成交时间), ‘stock_code’(股票代码), ‘entrust_bs’(成交方向), ‘business_amount’(成交数量), ‘business_price’(成交价格), ‘business_balance’(成交额), ‘business_id’(成交编号), ‘status’(委托状态)
    for trade in trade_list:
        bs = '买入' if trade['business_amount'] > 0 else '卖出'    
        info = '订单成交，股票代码：{}，数量：{}{:.0f}'.format(trade['stock_code'], bs, abs(trade['business_amount']))
        log.info(info)

打印成交数据。

盘后总结函数

def after_trading_end(context, data):

该函数会在每天交易结束之后调用，用来处理每天收盘后的操作。

  • 参数context为Context对象，存放有当前的账户及持仓信息
  • 参数data为保留字段暂无数据
    log.info('盘后持股{}只：{}'.format(get_position_count(context), get_position_list(context)))

打印盘后持股数据。

小结

本文完成了PTrade交易程序代码的介绍。我们的全自动化交易也只差最后一步，将在下一篇文章中介绍。下一篇文章也将是“从零到实盘”系列文章的最后一篇。

PTrade交易程序的全部代码如下：

import pandas as pd
import datetime
from collections import OrderedDict 


def initialize(context):
    """初始化，启动程序后只调用一次
    
    :param context: Context对象，存放有当前的账户及持仓信息
    :return: None
    """
    
    # 定义一个周期处理函数，每3秒执行一次
    run_interval(context, interval_handle, seconds = 3)
    # 资金少于limit_value则不买入
    g.limit_value = 5000
    # 持仓股票只数限制
    g.limit_stock_num = 3
    # 持股天数限制
    g.limit_hold_days = 6
    g.security = '000300.SS'
    set_universe(g.security)
    

def before_trading_start(context, data):
    """在每天开始交易前被调用，此处添加每天都要初始化的信息
    
    :param context: Context对象，存放有当前的账户及持仓信息
    :param data: 保留字段暂无数据
    :return: None    
    """
    
    # 当日提交买单的股票代码集合
    g.buy_submitted_set = set() 
    
    # 读取数据库文件
    file_path = get_research_path() + 'upload_file/trade_data.csv'
    g.db_df = pd.read_csv(file_path, encoding='utf-8', converters={'code': str})
    
    # code转换
    g.db_df['code_ptrade'] = g.db_df['code'].map(lambda x: x + '.SS' if '6' == x[0] else x + '.SZ')
    
    # 获取待交易数据
    g.to_trade_df = g.db_df[1 == g.db_df['to_trade']]
    
    # 获取待买入数据    
    g.to_buy_df = g.to_trade_df[g.to_trade_df['date_buy'].isna()]
    g.to_buy_stock_list = g.to_buy_df['code_ptrade'].tolist()
    
    # 生成买点字典
    g.buy_point_dict = g.to_buy_df[['code_ptrade', 'buy_point']].set_index('code_ptrade').to_dict(into=OrderedDict)['buy_point']
    log.info('买点字典：{}'.format(g.buy_point_dict))
    
    # 获取待止盈、止损卖出数据
    g.to_sell_df = g.to_trade_df[(~g.to_trade_df['date_buy'].isna()) & (g.to_trade_df['hold_days'] <= g.limit_hold_days)]
    g.to_sell_stock_list = g.to_sell_df['code_ptrade'].tolist()
    
    # 获取待立刻卖出股票
    g.to_sell_immi_df = g.to_trade_df[(~g.to_trade_df['date_buy'].isna()) & (g.to_trade_df['hold_days'] > g.limit_hold_days)]
    g.to_sell_immi_list = g.to_sell_immi_df['code_ptrade'].tolist()
    g.sell_immi_done = False
    
    # 生成止盈、止损字典
    g.take_profit_dict = g.to_sell_df[['code_ptrade', 'price_take_profit']].set_index('code_ptrade').to_dict()['price_take_profit']
    log.info('止盈字典：{}'.format(g.take_profit_dict))
    g.stop_loss_dict = g.to_sell_df[['code_ptrade', 'price_stop_loss']].set_index('code_ptrade').to_dict()['price_stop_loss']
    log.info('止损字典：{}'.format(g.stop_loss_dict))
    
    # 设置待交易股票    
    g.security =  g.to_trade_df['code_ptrade'].tolist()
    set_universe(g.security)
    
    # 重置ipo标识
    g.ipo_done = False
    log.info('当前可用资金：{}'.format(context.portfolio.cash))
    
    # 盘前信息
    log.info('盘前持股{}只：{}'.format(get_position_count(context), get_position_list(context)))
    log.info('单只股票买入金额：{}'.format(value_per_stock(context)))


def enough_cash(context, limit_value):
    """判断资金余额是否充足

    :param context: Context对象，存放有当前的账户及持仓信息
    :param limit_value: 资金限制，当前账户余额需大于等于该值，才判断为余额充足
    :return: 资金充足则返回True，否则返回False        
    """
    
    if context.portfolio.cash < limit_value:
        log.info('余额不足')        
        return False
    else:
        return True    


def bought_stock_set(context):
    """已买股票的集合
    
    对已提交买入的股票代码的集合、持仓股票代码的集合求并集
    
    :param context: Context对象，存放有当前的账户及持仓信息
    :return: 已买股票的集合
    """
    return g.buy_submitted_set | set(get_position_list(context))
    

def available_position_count(context):
    """计算当前可买的股票只数
    
    对已提交买入的股票代码的集合、持仓股票代码的集合求并集
    再用持股只数限制减去上面并集中元素的个数，即为当前可买的股票只数 
    
    :param context: Context对象，存放有当前的账户及持仓信息
    :return: 当前可买的股票只数
    """
    
    return g.limit_stock_num - len(bought_stock_set(context))
    

def value_per_stock(context):
    """计算单只股票买入金额
    
    资金余额除以当前可买的股票只数
    当可买的股票只数为0时返回0.0
    
    :param context: Context对象，存放有当前的账户及持仓信息
    :return: 单只股票买入金额，当可买的股票只数为0时返回0.0
    """
    
    # 计算当前可买的股票只数
    available_count = available_position_count(context)
    
    # 当可买的股票只数为0时返回0.0
    if 0 == available_count:
        return 0.0
        
    return context.portfolio.cash / available_count
    
    
def get_position_count(context):
    """获取当前持股只数
    
    调用get_position_list获取当前持有股票的代码列表
    使用len获取持股只数
    
    :param context: 存放有当前的账户及持仓信息
    :return: 当前持有股票的只数
    """
    
    return len(get_position_list(context))

    
def get_position_list(context):
    """获取当前持股列表
    
    context.portfolio.positions包含持股信息，但需要通过amount!=0来获取真实持股
    因为当股票卖出成功时，当日清仓的股票信息仍会保存在context.portfolio.positions中，只是amount等于0

    :param context: 存放有当前的账户及持仓信息
    :return: 当前持有股票的代码列表
    """
    
    return [x for x in context.portfolio.positions if context.portfolio.positions[x].amount != 0]


def handle_sell(context):
    """处理卖出逻辑
    
    :param context: Context对象，存放有当前的账户及持仓信息
    :return: None
    """
    
    # 处理到达持仓天数限制的股票，用当前价下跌1.8%提交卖单，确保卖出
    if not g.sell_immi_done:
        for stock in g.to_sell_immi_list:
            snapshot = get_snapshot(stock)
            order_target(stock, 0, limit_price=round(snapshot[stock]['last_px'] * 0.982, 2))
            g.sell_immi_done = True
            log.info('{}持仓天数限制卖单提交'.format(stock))
            
    # 遍历待卖出股票
    for stock in g.to_sell_stock_list.copy():
        
        # 获取实时行情快照
        snapshot = get_snapshot(stock)
        
        # 判断是否停盘，停盘则跳过
        trade_status = snapshot[stock]['trade_status']
        if trade_status == 'STOPT':
            log.info(stock, '该股为停盘状态，不进行交易判断')
            continue
            
        # 获取股票最高价、最低价、当前价
        high_price = snapshot[stock]['high_px']
        low_price = snapshot[stock]['low_px']
        current_price = snapshot[stock]['last_px']
        
        # 限价，创业板和科创板有价格笼子限制，卖出申报价格不得低于卖出基准价格的98%
        limit_price = round(current_price * 0.982, 2)
        
        # 如果达到止盈或者止损条件，则挂限价卖出
        if high_price >= g.take_profit_dict[stock] or low_price <= g.stop_loss_dict[stock]:
            log.info('{}到达卖点'.format(stock))
            
            # 下指定市值卖单
            order_target(stock, 0, limit_price=limit_price)
            
            # 在待卖出股票列表中删除该股票
            g.to_sell_stock_list.remove(stock)
            log.info('{}卖单提交'.format(stock))
            
            
def handle_buy(context):
    """处理买入逻辑
    
    :param context: Context对象，存放有当前的账户及持仓信息
    :return: None
    """
    
    # 判断剩余资金是否大于最小买入金额限制，单只股票买入金额太小，没有意义
    if context.portfolio.cash < g.limit_value:        
        return
        
    # 判断如果已达最大持股只数，则不买入
    if available_position_count(context) <= 0:
        return
   

    # 遍历每只候选买入股票    
    for stock in g.to_buy_stock_list.copy():
        
        # 判断如果已达最大持股只数，则不买入
        if available_position_count(context) <= 0:
            return
            
        # 不重复买入股票
        if stock in bought_stock_set(context):
            continue
        
        # 获取实时行情快照
        snapshot = get_snapshot(stock)

        # 判断是否停盘，停盘则跳过
        trade_status = snapshot[stock]['trade_status']
        if trade_status == 'STOPT':
            log.info((stock, '该股为停盘状态，不进行交易判断'))
            continue
            
        # 获取股票最低价和当前价
        low_price = snapshot[stock]['low_px']
        current_price = snapshot[stock]['last_px']
        
        # 获取计算单只股票买入金额
        target_value = value_per_stock(context)
        
        # 如果余额不足买1手，则跳过该股票
        if target_value < current_price * 100 * 1.0003: 
            continue
            
        # 限价，创业板和科创板有价格笼子限制，买入申报价格不得高于买入基准价格的102%
        limit_price = round(current_price * 1.018, 2)
            
        # 最低价低于买点，且limit_price不超过买点的3.82%，再下买单。避免有股票卖出后，余额充足后买入新股票的价格过高
        if (low_price <= g.buy_point_dict[stock]) and (limit_price / g.buy_point_dict[stock] <= 1.0382):
            log.info('{}到达买点'.format(stock))
            
            # 将股票代码添加到已提交买单字典
            g.buy_submitted_set.add(stock)
            
            # 下指定市值买单，用限价提交
            log.info('targe_value={}, limit_price={}'.format(target_value, limit_price))
            order_target_value(stock, target_value, limit_price=limit_price)
            
            # 在待买入股票列表中删除该股票
            g.to_buy_stock_list.remove(stock)
            log.info('{}买单提交'.format(stock))
            

def handle_ipo():
    """处理打新
    
    11:13申购
    
    :return: None
    """
    
    # 获取当前时间
    if not g.ipo_done and datetime.datetime.now().time() >= datetime.time(11, 13, 0):
        
        # 申购上证普通新股
        ipo_stocks_order(market_type=0)
        
        # 申购深证普通新股
        ipo_stocks_order(market_type=2)
        
        # 申购上证普通新股
        ipo_stocks_order(market_type=3)
        
        # 标记当日已申购
        g.ipo_done = True
    
        
def interval_handle(context):
    """周期处理函数
    
    :param context: 存放有当前的账户及持仓信息
    :return: None
    """
    
    # 卖出
    handle_sell(context)
    
    # 买入
    handle_buy(context)
    
    # 打新
    handle_ipo()
    

def on_order_response(context, order_list):
    """在委托回报返回时响应
    
    :param context: 存放有当前的账户及持仓信息
    :param order_list: 一个列表，当前委托单发生变化时，发生变化的委托单列表。委托单以字典形式展现，内容包括：'entrust_no'(委托单号), 
                       'order_time'(委托时间), 'stock_code'(股票代码), 'amount'(委托数量), 'price'(委托价格), 'business_amount'(成交数量), 
                       'status'(委托状态), 'order_id'(委托订单号), 'entrust_type'(委托类别), 'entrust_prop'(委托属性)
    :return: None
    """
    
    # 打印委托数据
    for order in order_list:
        bs = '买入' if order['amount'] > 0 else '卖出'
        info = '订单提交，股票代码：{}，数量：{}{:.0f}'.format(order['stock_code'], bs, abs(order['amount']))
        log.info(info)
    
   
def on_trade_response(context, trade_list):
    """在成交回报返回时响应
    
    :param context: 存放有当前的账户及持仓信息
    :param trade_list： 一个列表，当前成交单发生变化时，发生变化的成交单列表。成交单以字典形式展现，内容包括：'entrust_no'(委托单号),
                        'business_time'(成交时间), 'stock_code'(股票代码), 'entrust_bs'(成交方向), 'business_amount'(成交数量), 
                        'business_price'(成交价格), 'business_balance'(成交额), 'business_id'(成交编号), 'status'(委托状态)
    :return: None
    """
    
    # 打印成交数据
    for trade in trade_list:
        bs = '买入' if trade['business_amount'] > 0 else '卖出'    
        info = '订单成交，股票代码：{}，数量：{}{:.0f}'.format(trade['stock_code'], bs, abs(trade['business_amount']))
        log.info(info)
    
    
def after_trading_end(context, data):
    """在每天交易结束之后调用，用来处理每天收盘后的操作
    
    :param context: 存放有当前的账户及持仓信息
    :param data： 保留字段暂无数据
    :return: None
    """

    # 打印盘后持股数据
    log.info('盘后持股{}只：{}'.format(get_position_count(context), get_position_list(context)))

博客内容只用于交流学习，不构成投资建议，盈亏自负！

个人博客：http://coderx.com.cn/（优先更新）
项目最新代码：https://gitee.com/sl/quant_from_scratch
欢迎大家转发、留言。有微信群用于学习交流，感兴趣的读者请扫码加微信！
如果认为博客对您有帮助，可以扫码进行捐赠，感谢！

微信二维码微信捐赠二维码
在这里插入图片描述在这里插入图片描述
码农甲V
关注
专栏目录
ptrade从零开始学习量化交易第28期【ptrade获取市场信息之get_cb_list-获取可转债市场代码表】
GJ57017_wx的博客
05-30 348
​get_cb_list-获取可转债市场代码表 get_cb_list() 使用场景 该函数仅在交易模块可用 接口说明 返回当前可转债市场的所有代码列表(包含停牌代码)。 注意事项： 为减小对行情服务压力，该函数在交易模块中同一分钟内多次调用返回当前分钟首次查询的缓存数据。
Ptrade 完整策略 代码逐行解析----个人量化学习
XD1996CD的博客
08-14 652
DIF、DEA均为负，macd死叉else:# 卖出所有股票,使这只股票的最终持有量为0# 记录这次卖出完整的策略闭环就完成了：数据获取、交易信号判断、下单交易、订单记录由于篇幅有限，一些函数的更多使用方法没有展开讨论，朋友们在使用过程中任何问题可以留言。
量化交易软件（PTrade）功能介绍--概述
loong123lx的博客
09-05 747
量化交易软件PTrade(Personalise Trade)是一款为高净值、机构投资者打造的专业交易软件，提供了普通交易、日内回转交易、自动交易、算法交易、量化投研/回测/实盘等各种交易工具，满足用户的各种交易场景和需求，帮助用户提高交易效率。目前支持的算法有TWAP、VWAP、POV、IS、ICEBERG、ADAPTIVE_TWAP、ADAPTIVE_VWAP等。量化交易软件PTrade包含5个模块，行情、交易（普通交易）、工具（自动交易工具）、量化。(量化交易）、日内（日内回转交易）。
程序化交易实用技术代码
09-28
程序化交易实用技术代码，TB公式，是培训资料，价值589元
[ptrde交易实战] 策略编写！如何做持久化处理！
vv_LCJL319的博客
06-25 651
ptrade交易中如何写策略，以及策略如何做持久化！
PTrade交易数据更新——从零到实盘17
码农甲的博客
01-28 7544
在实盘交易中，我们在每日盘后更新K线数据、计算扩展指标、筛出候选股票后，需要把新的候选股票数据传递给PTrade，另外需要根据PTrade的实盘交易记录，更新存放在数据库的相关数据，记录哪些股票还需要监测进行交易，哪些股票不需要再监测。本文将完成上述PTrade交易数据的更新过程。 相关库表 在数据库中，我们保存了ptrade和ptrade_history两张与PTrade交易相关的数据表，两张表的字段完全相同，其中表ptrade保存了待监测交易的数据，表ptrade_history保存了历史监测或交易的.
[ptrade交易实战] 业务流程框架
vv_LCJL319的博客
07-01 1492
ptrade量化是以事件触发为基础，通过几个事件来完成每日交易任务的！主要可以分成4个事件，初始化事件（initialize），盘前事件（before_trading_start）、盘中事件（handle_data）、盘后事件（after_trading_end）。主要用于初始化一些全局变量，这个是必备的一个结构，是我们选择股票的事件！是在每天开始交易前被调用，是一个可选事件。
程序化交易
weixin_33693070的博客
07-16 444
2019独角兽企业重金招聘Python工程师标准>>> ...
配对交易python策略源码
09-19
配对交易（Pairs Trading）是指八十年代中期华尔街著名投行Morgan Stanley的数量交易员Nunzio Tartaglia成立的一个数量分析团队提出的一种市场中性投资策略，，其成员主要是物理学家、数学家、以及计算机学家。...
量化实盘策略报告20200210
01-07
策略说明 策略指标：均线策略 投资标的：螺蚊纲RB2005 初始资金：10000 开始日期：2020-01-14 运行天数：27 累计收益率：0.54% 策略逻辑：采用15分种K线，通过传统的双均线策略，即快均线上穿慢均线时则为开仓信号...
实盘稳定盈利的股指策略源码
04-04
一个可以实盘稳定盈利的股指策略源码！最大回撤10.82%年回报89.9%
程序化交易系统
12-13
English Version of Algorithm Trading ToolBox Which Provides useful tools for a Quant
程序化交易自动下单券商接口示例delphi源代码
04-17
程序化交易 自动下单券 券商接口 delphi源代码 银泰证券
程序化交易自动下单券商接口示例源代码
11-20
程序化交易自动下单券商接口示例源代码，有问题，可以联系qq:43299243
上期平台的程序化交易的例子（c++版）
01-24
上期平台的程序化交易的例子（c++版）CTP的交易基础版，现在分享给大家，可以下载交流
用PTrade交易软件获得竞价结束后超大单净成交额的PY代码
最新发布
09-12
PTrade是一个模拟股票交易软件，它并不是一个真实存在的交易软件，因此无法提供确切的代码来实现该软件功能。但是，如果我们假设存在这样一个软件，并且它支持某种形式的编程接口或脚本语言来获取数据，以下是一个...
简单介绍一下关于PTrade量化交易系统的使用权
Q_2037696191的博客
10-25 882
该系统采用先进的技术框架，具有功能丰富、风险控制全面、管理灵活、结构简化、高效稳定等核心优势。该功能支持键盘交易、鼠标交易、开盘交易、快速交易等多种功能选项，提高交易方便性和系统可操作性。Ptrade自身携带ETF趋势交易、网格交易、拐点交易、大股东增减持股等一系列交易工具，满足不同交易场景、不同背景客户的需求全方位的交易需求。Ptrade系统自带一系列python量化交易函数，打通了策略研究、编写、回测、仿真到实盘的全链路，可全面覆盖客户的量化交易需求，为客户提供一站式量化投资体验。
程序化交易入门（一）
qq_35495233的博客
10-31 4281
OKEX期货数据抓取 程序化交易入门（1）：概述 程序化交易就是用程序通过API和交易所连接，实现按照设计的意图自动进行比特币买卖或实现其他功能。程序化与量化不完全相同，你也可以实现一些辅助功能，如价格报警、数据统计、自动满仓、定时买入，设定价格买卖等等，利用程序化交易赚钱则是一项更困难的任务。 1. 什么是API、apiKey? API全程Application Programming ...
全球十大程序化交易系统 ( 有源码 ）
热门推荐
IAlexanderI的专栏
09-20 3万+
程序化交易系统是一种个性期货程序化交易软件，每个普通投资者或机构投资者都可以根据自己的投资经验和智慧，编写自己的交易模型，进行电脑自动交易。 据美国权威交易系统评选杂志《Futures Truth Magazine》2011 年10 月 最新发布的交易系统排名，NatGator、Catscan、DCS II 等模型的业绩。在过去一年进入了前十名榜单，前三名模型年收益率均在200%以上。 Delph...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值