通知设置 新通知
ptrade回测结束后执行某个函数，比如保存回测结果
李魔佛 发表了文章 • 0 个评论 • 831 次浏览 • 2023-01-01 17:56
http://ptradeapi.com/#after_trading_end
官方文档只提供一个每天盘后执行的函数，没有函数可以在回测结束后，固定执行某些操作。
比如我回测过程保存的历史交易记录，收益率等，要如何保存？ 虽然可以在回测的时候，每个交易日保存一次。
但是这样就需要在回测的时候按照天打开文件，盘后写入一次。 使用一个全局对象操作，显得很啰嗦。
那么有没有办法可以做在回测结束后一次性 保存操作呢？
答案是有的。也很简单。 适用于ptrade，qmt。
https://t.zsxq.com/09yigu5dy
查看全部
官方文档只提供一个每天盘后执行的函数，没有函数可以在回测结束后，固定执行某些操作。
比如我回测过程保存的历史交易记录，收益率等，要如何保存？ 虽然可以在回测的时候，每个交易日保存一次。
但是这样就需要在回测的时候按照天打开文件，盘后写入一次。 使用一个全局对象操作，显得很啰嗦。
那么有没有办法可以做在回测结束后一次性 保存操作呢？
答案是有的。也很简单。 适用于ptrade，qmt。
https://t.zsxq.com/09yigu5dy
查看全部
http://ptradeapi.com/#after_trading_end
官方文档只提供一个每天盘后执行的函数，没有函数可以在回测结束后，固定执行某些操作。
比如我回测过程保存的历史交易记录，收益率等，要如何保存？ 虽然可以在回测的时候，每个交易日保存一次。
但是这样就需要在回测的时候按照天打开文件，盘后写入一次。 使用一个全局对象操作，显得很啰嗦。
那么有没有办法可以做在回测结束后一次性 保存操作呢？
答案是有的。也很简单。 适用于ptrade，qmt。
https://t.zsxq.com/09yigu5dy
官方文档只提供一个每天盘后执行的函数，没有函数可以在回测结束后，固定执行某些操作。
比如我回测过程保存的历史交易记录，收益率等，要如何保存？ 虽然可以在回测的时候，每个交易日保存一次。
但是这样就需要在回测的时候按照天打开文件，盘后写入一次。 使用一个全局对象操作，显得很啰嗦。
那么有没有办法可以做在回测结束后一次性 保存操作呢？
答案是有的。也很简单。 适用于ptrade，qmt。
https://t.zsxq.com/09yigu5dy
ptrade回测 获取回测当天的分时数据
李魔佛 发表了文章 • 0 个评论 • 1081 次浏览 • 2023-01-01 15:45
http://ptradeapi.com/#get_price
ptrade api的文档第3条表明，
3、数据返回内容不包括当天数据。
也就是用get_price是拿不到回测当天的数据。
比如下面的例子：
def initialize(context):
# 初始化策略
run_daily(context, execute, '09:36')
def handle_data(context, data):
pass
def execute(context):
current = context.blotter.current_dt.strftime('%Y-%m-%d')
log.info(current)
security='128025.SZ'
df = get_price(security, start_date=None, end_date=None, frequency='1m', fields=None, fq=None, count=10)
log.info(df)
返回的数据：
2023-01-01 15:31:21 开始运行回测, 策略名称: 四叶草-指定时间价格
2022-12-01 09:36:00 - INFO - 2022-12-01
2022-12-01 09:36:00 - INFO - open high low close volume \
2022-11-30 14:51:00 276.510 276.560 274.626 275.500 217510.0
2022-11-30 14:52:00 275.240 278.638 275.205 278.398 363820.0
2022-11-30 14:53:00 278.485 278.895 276.660 277.479 307570.0
2022-11-30 14:54:00 277.337 278.440 276.660 278.440 239370.0
2022-11-30 14:55:00 279.900 287.113 279.900 287.113 853170.0
2022-11-30 14:56:00 287.113 288.526 286.533 288.125 581860.0
2022-11-30 14:57:00 288.126 291.800 287.909 291.361 523580.0
2022-11-30 14:58:00 291.500 292.980 291.500 291.800 36480.0
2022-11-30 14:59:00 291.800 291.800 291.800 291.800 0.0
2022-11-30 15:00:00 292.510 292.510 292.510 292.510 421398.0
回测日期是2022-12-01日，每天09:36运行，那10根数据。
但返回的数据是昨天的收盘前的10根分时数据。并非当天9：36分开始拿10根bar。
如果把日期数据也固定，
df = get_price(security, start_date='2022-12-01', end_date=None, frequency='1m', fields=None, fq=None, count=10)
实际拿到的数据是空的，也就是无法拿到当天的数据。
正确的用法：
def initialize(context):
# 初始化策略
run_daily(context, execute, '09:36')
def handle_data(context, data):
pass
def execute(context):
current = context.blotter.current_dt.strftime('%Y-%m-%d')
log.info(current)
security='128025.SZ'
count=6
df=get_history(count, frequency='1m', field='close', security_list=security, fq=None, include=False, fill='nan')
log.info(df)
返回的数据：
欢迎关注公众号 查看全部
ptrade api的文档第3条表明，
3、数据返回内容不包括当天数据。
也就是用get_price是拿不到回测当天的数据。
比如下面的例子：
def initialize(context):
# 初始化策略
run_daily(context, execute, '09:36')
def handle_data(context, data):
pass
def execute(context):
current = context.blotter.current_dt.strftime('%Y-%m-%d')
log.info(current)
security='128025.SZ'
df = get_price(security, start_date=None, end_date=None, frequency='1m', fields=None, fq=None, count=10)
log.info(df)
返回的数据：
2023-01-01 15:31:21 开始运行回测, 策略名称: 四叶草-指定时间价格
2022-12-01 09:36:00 - INFO - 2022-12-01
2022-12-01 09:36:00 - INFO - open high low close volume \
2022-11-30 14:51:00 276.510 276.560 274.626 275.500 217510.0
2022-11-30 14:52:00 275.240 278.638 275.205 278.398 363820.0
2022-11-30 14:53:00 278.485 278.895 276.660 277.479 307570.0
2022-11-30 14:54:00 277.337 278.440 276.660 278.440 239370.0
2022-11-30 14:55:00 279.900 287.113 279.900 287.113 853170.0
2022-11-30 14:56:00 287.113 288.526 286.533 288.125 581860.0
2022-11-30 14:57:00 288.126 291.800 287.909 291.361 523580.0
2022-11-30 14:58:00 291.500 292.980 291.500 291.800 36480.0
2022-11-30 14:59:00 291.800 291.800 291.800 291.800 0.0
2022-11-30 15:00:00 292.510 292.510 292.510 292.510 421398.0
回测日期是2022-12-01日，每天09:36运行，那10根数据。
但返回的数据是昨天的收盘前的10根分时数据。并非当天9：36分开始拿10根bar。
如果把日期数据也固定，
df = get_price(security, start_date='2022-12-01', end_date=None, frequency='1m', fields=None, fq=None, count=10)
实际拿到的数据是空的，也就是无法拿到当天的数据。
正确的用法：
def initialize(context):
# 初始化策略
run_daily(context, execute, '09:36')
def handle_data(context, data):
pass
def execute(context):
current = context.blotter.current_dt.strftime('%Y-%m-%d')
log.info(current)
security='128025.SZ'
count=6
df=get_history(count, frequency='1m', field='close', security_list=security, fq=None, include=False, fill='nan')
log.info(df)
返回的数据：
欢迎关注公众号 查看全部
http://ptradeapi.com/#get_price
ptrade api的文档第3条表明，
也就是用get_price是拿不到回测当天的数据。
比如下面的例子：
返回的数据：
回测日期是2022-12-01日，每天09:36运行，那10根数据。
但返回的数据是昨天的收盘前的10根分时数据。并非当天9：36分开始拿10根bar。
如果把日期数据也固定，
实际拿到的数据是空的，也就是无法拿到当天的数据。
正确的用法：
返回的数据：
欢迎关注公众号
ptrade api的文档第3条表明，
3、数据返回内容不包括当天数据。
也就是用get_price是拿不到回测当天的数据。
比如下面的例子：
def initialize(context):
# 初始化策略
run_daily(context, execute, '09:36')
def handle_data(context, data):
pass
def execute(context):
current = context.blotter.current_dt.strftime('%Y-%m-%d')
log.info(current)
security='128025.SZ'
df = get_price(security, start_date=None, end_date=None, frequency='1m', fields=None, fq=None, count=10)
log.info(df)
返回的数据：
2023-01-01 15:31:21 开始运行回测, 策略名称: 四叶草-指定时间价格
2022-12-01 09:36:00 - INFO - 2022-12-01
2022-12-01 09:36:00 - INFO - open high low close volume \
2022-11-30 14:51:00 276.510 276.560 274.626 275.500 217510.0
2022-11-30 14:52:00 275.240 278.638 275.205 278.398 363820.0
2022-11-30 14:53:00 278.485 278.895 276.660 277.479 307570.0
2022-11-30 14:54:00 277.337 278.440 276.660 278.440 239370.0
2022-11-30 14:55:00 279.900 287.113 279.900 287.113 853170.0
2022-11-30 14:56:00 287.113 288.526 286.533 288.125 581860.0
2022-11-30 14:57:00 288.126 291.800 287.909 291.361 523580.0
2022-11-30 14:58:00 291.500 292.980 291.500 291.800 36480.0
2022-11-30 14:59:00 291.800 291.800 291.800 291.800 0.0
2022-11-30 15:00:00 292.510 292.510 292.510 292.510 421398.0
回测日期是2022-12-01日，每天09:36运行，那10根数据。
但返回的数据是昨天的收盘前的10根分时数据。并非当天9：36分开始拿10根bar。
如果把日期数据也固定，
df = get_price(security, start_date='2022-12-01', end_date=None, frequency='1m', fields=None, fq=None, count=10)
实际拿到的数据是空的，也就是无法拿到当天的数据。
正确的用法：
def initialize(context):
# 初始化策略
run_daily(context, execute, '09:36')
def handle_data(context, data):
pass
def execute(context):
current = context.blotter.current_dt.strftime('%Y-%m-%d')
log.info(current)
security='128025.SZ'
count=6
df=get_history(count, frequency='1m', field='close', security_list=security, fq=None, include=False, fill='nan')
log.info(df)
返回的数据：
欢迎关注公众号
Ptrade获取可转债强赎数据
李魔佛 发表了文章 • 0 个评论 • 1251 次浏览 • 2022-12-21 15:50
对于强赎的可转债而言，期权价值归0，叠加一个转股压力。类似于股票解禁的效果，导致转债和正股一起下跌。
所以在可转债的策略里面，把强赎的转债排除掉，是一个不错的因子。
但内置的ptrade接口数据并无提供任何转债相关的数据。
不过笔者这里提供了一个自研的数据接口。
http://ptradeapi.com/#%E5%8F%AF%E8%BD%AC%E5%80%BA%E5%BC%BA%E8%B5%8E%E4%B8%8E%E6%95%B0%E6%97%A5%E5%AD%90
方便在ptrade里面调用。
查看全部
所以在可转债的策略里面，把强赎的转债排除掉，是一个不错的因子。
但内置的ptrade接口数据并无提供任何转债相关的数据。
不过笔者这里提供了一个自研的数据接口。
http://ptradeapi.com/#%E5%8F%AF%E8%BD%AC%E5%80%BA%E5%BC%BA%E8%B5%8E%E4%B8%8E%E6%95%B0%E6%97%A5%E5%AD%90
方便在ptrade里面调用。
查看全部
对于强赎的可转债而言，期权价值归0，叠加一个转股压力。类似于股票解禁的效果，导致转债和正股一起下跌。
所以在可转债的策略里面，把强赎的转债排除掉，是一个不错的因子。
但内置的ptrade接口数据并无提供任何转债相关的数据。
不过笔者这里提供了一个自研的数据接口。
http://ptradeapi.com/#%E5%8F%AF%E8%BD%AC%E5%80%BA%E5%BC%BA%E8%B5%8E%E4%B8%8E%E6%95%B0%E6%97%A5%E5%AD%90
方便在ptrade里面调用。
所以在可转债的策略里面，把强赎的转债排除掉，是一个不错的因子。
但内置的ptrade接口数据并无提供任何转债相关的数据。
不过笔者这里提供了一个自研的数据接口。
http://ptradeapi.com/#%E5%8F%AF%E8%BD%AC%E5%80%BA%E5%BC%BA%E8%B5%8E%E4%B8%8E%E6%95%B0%E6%97%A5%E5%AD%90
方便在ptrade里面调用。
Ptrade API 文档
李魔佛 发表了文章 • 0 个评论 • 1534 次浏览 • 2022-12-18 20:18
Ptrade多策略如何编写？
李魔佛 发表了文章 • 0 个评论 • 1408 次浏览 • 2022-11-16 11:33
多策略需要解决的一个最主要的问题，就是仓位管理。
系统自带的读取仓位函数需要你重写。
目前使用一个类来管理仓位：
初始化部分：class PositionManager():
def __init__(self):
if SINGLE_FACTOR not in [1, 2, 3, 4]:
raise ValueError('策略数字有误')
self.strategy = SINGLE_FACTOR
NOTEBOOK_PATH = '/home/fly/notebook/'
# self.filename = NOTEBOOK_PATH + 'S-{}.txt'.format(self.strategy)
self.filename = NOTEBOOK_PATH + personal_define_filename
self.portfolio = self.read()
log.info(self.portfolio)
self.write()
def init_data(self):
js_data = {
'cash': CASH,
'strategy': self.strategy,
'positions': ,
'portfolio_value': None,
'positions_value': None,
'capital_used': None,
'start_date': datetime.datetime.now().strftime('%Y%m%d%H%M%S'),
'current_day': 0,
}
数据需要收盘后保存到文件，数据库也行；不过考虑到大部分ptrade（除了国盛，需要开通的可以联系公众号：可转债量化分析）都没有连接外网功能，所以最简单的方式就是写入文件，纯粹的文本文件。
目前笔者使用json存储
点击查看大图
这样存储有一个好处，就是如果你想中途修改策略持仓，可以直接修改这个文本文件。比如你的策略不小心买入了一只强赎的转债，你想手动卖掉，那么很简单，你只要在这个json文件里面把对应的持仓删除，再把他的市值加到可用资金里面去即可。 用法是相当灵活。
需要完整代码或者指导的朋友可以关注下面公众号和知识星球。
查看全部
系统自带的读取仓位函数需要你重写。
目前使用一个类来管理仓位：
初始化部分：class PositionManager():
def __init__(self):
if SINGLE_FACTOR not in [1, 2, 3, 4]:
raise ValueError('策略数字有误')
self.strategy = SINGLE_FACTOR
NOTEBOOK_PATH = '/home/fly/notebook/'
# self.filename = NOTEBOOK_PATH + 'S-{}.txt'.format(self.strategy)
self.filename = NOTEBOOK_PATH + personal_define_filename
self.portfolio = self.read()
log.info(self.portfolio)
self.write()
def init_data(self):
js_data = {
'cash': CASH,
'strategy': self.strategy,
'positions': ,
'portfolio_value': None,
'positions_value': None,
'capital_used': None,
'start_date': datetime.datetime.now().strftime('%Y%m%d%H%M%S'),
'current_day': 0,
}
数据需要收盘后保存到文件，数据库也行；不过考虑到大部分ptrade（除了国盛，需要开通的可以联系公众号：可转债量化分析）都没有连接外网功能，所以最简单的方式就是写入文件，纯粹的文本文件。
目前笔者使用json存储
点击查看大图
这样存储有一个好处，就是如果你想中途修改策略持仓，可以直接修改这个文本文件。比如你的策略不小心买入了一只强赎的转债，你想手动卖掉，那么很简单，你只要在这个json文件里面把对应的持仓删除，再把他的市值加到可用资金里面去即可。 用法是相当灵活。
需要完整代码或者指导的朋友可以关注下面公众号和知识星球。
查看全部
多策略需要解决的一个最主要的问题，就是仓位管理。
系统自带的读取仓位函数需要你重写。
目前使用一个类来管理仓位：
初始化部分：
数据需要收盘后保存到文件，数据库也行；不过考虑到大部分ptrade（除了国盛，需要开通的可以联系公众号：可转债量化分析）都没有连接外网功能，所以最简单的方式就是写入文件，纯粹的文本文件。
目前笔者使用json存储
点击查看大图
这样存储有一个好处，就是如果你想中途修改策略持仓，可以直接修改这个文本文件。比如你的策略不小心买入了一只强赎的转债，你想手动卖掉，那么很简单，你只要在这个json文件里面把对应的持仓删除，再把他的市值加到可用资金里面去即可。 用法是相当灵活。
需要完整代码或者指导的朋友可以关注下面公众号和知识星球。
系统自带的读取仓位函数需要你重写。
目前使用一个类来管理仓位：
初始化部分：
class PositionManager():
def __init__(self):
if SINGLE_FACTOR not in [1, 2, 3, 4]:
raise ValueError('策略数字有误')
self.strategy = SINGLE_FACTOR
NOTEBOOK_PATH = '/home/fly/notebook/'
# self.filename = NOTEBOOK_PATH + 'S-{}.txt'.format(self.strategy)
self.filename = NOTEBOOK_PATH + personal_define_filename
self.portfolio = self.read()
log.info(self.portfolio)
self.write()
def init_data(self):
js_data = {
'cash': CASH,
'strategy': self.strategy,
'positions': ,
'portfolio_value': None,
'positions_value': None,
'capital_used': None,
'start_date': datetime.datetime.now().strftime('%Y%m%d%H%M%S'),
'current_day': 0,
}
数据需要收盘后保存到文件，数据库也行；不过考虑到大部分ptrade（除了国盛，需要开通的可以联系公众号：可转债量化分析）都没有连接外网功能，所以最简单的方式就是写入文件，纯粹的文本文件。
目前笔者使用json存储
点击查看大图
这样存储有一个好处，就是如果你想中途修改策略持仓，可以直接修改这个文本文件。比如你的策略不小心买入了一只强赎的转债，你想手动卖掉，那么很简单，你只要在这个json文件里面把对应的持仓删除，再把他的市值加到可用资金里面去即可。 用法是相当灵活。
需要完整代码或者指导的朋友可以关注下面公众号和知识星球。
Ptrade拆单 分批下单 python代码 可转债/股票
李魔佛 发表了文章 • 0 个评论 • 1414 次浏览 • 2022-11-10 00:35
在转债市场，部分转债的流动性很差，有时候连成交100张也需要等待一段时间。
所以如果资金量大，就需要拆单操作。
交易代码部分，如果设置 SPLIT_ORDER_ENABLE = True 即进行拆单操作：
在交易部分：(省略部分不相关代码) if SPLIT_ORDER_ENABLE:
split_order(code, BUY_DIRECTION, amount)
else:
buy_price = round(buy_price, 3)
ret = order(code, amount, limit_price=buy_price)BUY_DIRECTION 为买，值是1，一个常量
SELL_DIRECTION为卖，值为-1，也是一个常量，传入拆单函数中
拆单函数提取出来：def split_order(code, direction, target_count):
'''
拆单
:param code: 股票代码
:param direction: 买：1 卖：-1
:param target_count: 总共要卖的股数
:return:
'''
count = int(target_count / EACH_ORDER_COUNT)
# 例如：560张， 200 张一单， 2次 + 最后一次160 张
remain_count = target_count % EACH_ORDER_COUNT
for i in range(count):
ret = order(code, direction * EACH_ORDER_COUNT)
time.sleep(SPLIT_ORDER_DELAY) # 拆开的单子等待一个时间，再下另外一单
if direction == 1: # 买的时候需要整数，卖则不需要
remain_count = int(remain_count / 10) * 10
if remain_count > 0:
ret = order(code, direction * remain_count)常用的操作都类似，写成模块方便下次调用。写多了就是套模块。
在可转债实盘中，拆单后每笔下单200张，就是每次200张下一次单，因为有可能不是马上成交，所以还需要一段等待延时，再去下单；不然你的拆单也变得没有意义，因为委托那里都是挂的你的单，并没有被消化掉。
可以看到实盘交易日志，即使拆单为200张一笔，外加一段延时，成交张数也是稀稀拉拉的，出现了不少的部分成交；也就是一次连200张都未成交完成；一笔200张的，部分成交10张，20张，都是有可能的，这也足以说明，可转债的流动性问题，滑点是很难被忽略的。
当然，这是轮动调仓的时候，金额较大的情况下拆单。如果高频交易下就不能这么操作了。
具体怎么写，可以关注个人公众号与知识星球。
知识星球原文：
如需要代写量化策略实盘代码，可以到个人公众号【可转债量化分析】后台留言。
查看全部
所以如果资金量大，就需要拆单操作。
交易代码部分，如果设置 SPLIT_ORDER_ENABLE = True 即进行拆单操作：
在交易部分：(省略部分不相关代码) if SPLIT_ORDER_ENABLE:
split_order(code, BUY_DIRECTION, amount)
else:
buy_price = round(buy_price, 3)
ret = order(code, amount, limit_price=buy_price)BUY_DIRECTION 为买，值是1，一个常量
SELL_DIRECTION为卖，值为-1，也是一个常量，传入拆单函数中
拆单函数提取出来：def split_order(code, direction, target_count):
'''
拆单
:param code: 股票代码
:param direction: 买：1 卖：-1
:param target_count: 总共要卖的股数
:return:
'''
count = int(target_count / EACH_ORDER_COUNT)
# 例如：560张， 200 张一单， 2次 + 最后一次160 张
remain_count = target_count % EACH_ORDER_COUNT
for i in range(count):
ret = order(code, direction * EACH_ORDER_COUNT)
time.sleep(SPLIT_ORDER_DELAY) # 拆开的单子等待一个时间，再下另外一单
if direction == 1: # 买的时候需要整数，卖则不需要
remain_count = int(remain_count / 10) * 10
if remain_count > 0:
ret = order(code, direction * remain_count)常用的操作都类似，写成模块方便下次调用。写多了就是套模块。
在可转债实盘中，拆单后每笔下单200张，就是每次200张下一次单，因为有可能不是马上成交，所以还需要一段等待延时，再去下单；不然你的拆单也变得没有意义，因为委托那里都是挂的你的单，并没有被消化掉。
可以看到实盘交易日志，即使拆单为200张一笔，外加一段延时，成交张数也是稀稀拉拉的，出现了不少的部分成交；也就是一次连200张都未成交完成；一笔200张的，部分成交10张，20张，都是有可能的，这也足以说明，可转债的流动性问题，滑点是很难被忽略的。
当然，这是轮动调仓的时候，金额较大的情况下拆单。如果高频交易下就不能这么操作了。
具体怎么写，可以关注个人公众号与知识星球。
知识星球原文：
如需要代写量化策略实盘代码，可以到个人公众号【可转债量化分析】后台留言。
查看全部
在转债市场，部分转债的流动性很差，有时候连成交100张也需要等待一段时间。
所以如果资金量大，就需要拆单操作。
交易代码部分，如果设置 SPLIT_ORDER_ENABLE = True 即进行拆单操作：
在交易部分：(省略部分不相关代码)
SELL_DIRECTION为卖，值为-1，也是一个常量，传入拆单函数中
拆单函数提取出来：
在可转债实盘中，拆单后每笔下单200张，就是每次200张下一次单，因为有可能不是马上成交，所以还需要一段等待延时，再去下单；不然你的拆单也变得没有意义，因为委托那里都是挂的你的单，并没有被消化掉。
可以看到实盘交易日志，即使拆单为200张一笔，外加一段延时，成交张数也是稀稀拉拉的，出现了不少的部分成交；也就是一次连200张都未成交完成；一笔200张的，部分成交10张，20张，都是有可能的，这也足以说明，可转债的流动性问题，滑点是很难被忽略的。
当然，这是轮动调仓的时候，金额较大的情况下拆单。如果高频交易下就不能这么操作了。
具体怎么写，可以关注个人公众号与知识星球。
知识星球原文：
如需要代写量化策略实盘代码，可以到个人公众号【可转债量化分析】后台留言。
所以如果资金量大，就需要拆单操作。
交易代码部分，如果设置 SPLIT_ORDER_ENABLE = True 即进行拆单操作：
在交易部分：(省略部分不相关代码)
if SPLIT_ORDER_ENABLE:BUY_DIRECTION 为买，值是1，一个常量
split_order(code, BUY_DIRECTION, amount)
else:
buy_price = round(buy_price, 3)
ret = order(code, amount, limit_price=buy_price)
SELL_DIRECTION为卖，值为-1，也是一个常量，传入拆单函数中
拆单函数提取出来：
def split_order(code, direction, target_count):常用的操作都类似，写成模块方便下次调用。写多了就是套模块。
'''
拆单
:param code: 股票代码
:param direction: 买：1 卖：-1
:param target_count: 总共要卖的股数
:return:
'''
count = int(target_count / EACH_ORDER_COUNT)
# 例如：560张， 200 张一单， 2次 + 最后一次160 张
remain_count = target_count % EACH_ORDER_COUNT
for i in range(count):
ret = order(code, direction * EACH_ORDER_COUNT)
time.sleep(SPLIT_ORDER_DELAY) # 拆开的单子等待一个时间，再下另外一单
if direction == 1: # 买的时候需要整数，卖则不需要
remain_count = int(remain_count / 10) * 10
if remain_count > 0:
ret = order(code, direction * remain_count)
在可转债实盘中，拆单后每笔下单200张，就是每次200张下一次单，因为有可能不是马上成交，所以还需要一段等待延时，再去下单；不然你的拆单也变得没有意义，因为委托那里都是挂的你的单，并没有被消化掉。
可以看到实盘交易日志，即使拆单为200张一笔，外加一段延时，成交张数也是稀稀拉拉的，出现了不少的部分成交；也就是一次连200张都未成交完成；一笔200张的，部分成交10张，20张，都是有可能的，这也足以说明，可转债的流动性问题，滑点是很难被忽略的。
当然，这是轮动调仓的时候，金额较大的情况下拆单。如果高频交易下就不能这么操作了。
具体怎么写，可以关注个人公众号与知识星球。
知识星球原文：
如需要代写量化策略实盘代码，可以到个人公众号【可转债量化分析】后台留言。
Ptrade里写策略坑比较多的地方（一）
李魔佛 发表了文章 • 0 个评论 • 1424 次浏览 • 2022-11-03 11:26
总结一些，给过来人少踩些坑
1. 后缀符号不统一
这个是天煞的产品涉及的问题。 好好地代码后缀，比如 深圳市场的 有时候出现 300333.SZ , 有时候结构体里面却会是 300333.XSHE，
比如返回的orders 字典，里面用的是 00333.XSHE，而仓位的结构体 position 里面用的缺失 .sz
类似这样的问题在很多函数里面都有。
2. 部分成交 的主推函数
如果一个订单，部分成交，会先触发部分成交主推； 然后最后一个部分成交，反而会触发全部成交主推。
细想，似乎也是合理的，只是，你在全部成交里面返回的成交数量，实际只是最后一次部分成交的量。
3. 想到再写
更多更新 可以参看个人知识星球或者公众号。
查看全部
1. 后缀符号不统一
这个是天煞的产品涉及的问题。 好好地代码后缀，比如 深圳市场的 有时候出现 300333.SZ , 有时候结构体里面却会是 300333.XSHE，
比如返回的orders 字典，里面用的是 00333.XSHE，而仓位的结构体 position 里面用的缺失 .sz
类似这样的问题在很多函数里面都有。
2. 部分成交 的主推函数
如果一个订单，部分成交，会先触发部分成交主推； 然后最后一个部分成交，反而会触发全部成交主推。
细想，似乎也是合理的，只是，你在全部成交里面返回的成交数量，实际只是最后一次部分成交的量。
3. 想到再写
更多更新 可以参看个人知识星球或者公众号。
查看全部
总结一些，给过来人少踩些坑
1. 后缀符号不统一
这个是天煞的产品涉及的问题。 好好地代码后缀，比如 深圳市场的 有时候出现 300333.SZ , 有时候结构体里面却会是 300333.XSHE，
比如返回的orders 字典，里面用的是 00333.XSHE，而仓位的结构体 position 里面用的缺失 .sz
类似这样的问题在很多函数里面都有。
2. 部分成交 的主推函数
如果一个订单，部分成交，会先触发部分成交主推； 然后最后一个部分成交，反而会触发全部成交主推。
细想，似乎也是合理的，只是，你在全部成交里面返回的成交数量，实际只是最后一次部分成交的量。
3. 想到再写
更多更新 可以参看个人知识星球或者公众号。
1. 后缀符号不统一
这个是天煞的产品涉及的问题。 好好地代码后缀，比如 深圳市场的 有时候出现 300333.SZ , 有时候结构体里面却会是 300333.XSHE，
比如返回的orders 字典，里面用的是 00333.XSHE，而仓位的结构体 position 里面用的缺失 .sz
类似这样的问题在很多函数里面都有。
2. 部分成交 的主推函数
如果一个订单，部分成交，会先触发部分成交主推； 然后最后一个部分成交，反而会触发全部成交主推。
细想，似乎也是合理的，只是，你在全部成交里面返回的成交数量，实际只是最后一次部分成交的量。
3. 想到再写
更多更新 可以参看个人知识星球或者公众号。
Ptrade量化交易之 拆单买入卖出操作
李魔佛 发表了文章 • 0 个评论 • 1609 次浏览 • 2022-09-30 16:20
在交易过程中，如果遇到成交量小的股票或者可转债，etf，稍微买多一些会对现价造成冲击，价格容易被你自己拉起来。所以假如你的交易量很大的话，一般最好使用拆单操作。 可以参考下面的python拆单代码：
注：代码里面针对的是可转债交易，股票的话把这一行：
remain_count=int(remain_count/10)*10 改为
remain_count=int(remain_count/100)*100 就可以了
股票100股整数倍买，转债是10张倍数买。
code,direction,target_count ： 第一个代码，第二个买卖方向，第三个是目标数目
each_order_count = 100 # 每单的股数,张数
def split_order(code,direction,target_count):
'''
拆单
:param code: 股票代码
:param direction: 买：1 卖：-1
:param target_count: 总共要卖的股数
:return:
'''
SPLIT_ORDER_DELAY =1
each_order_count = 100 # 每单的股数,张数
count = int(target_count/each_order_count)
remain_count = target_count%each_order_count
for i in range(count):
ret = order(code,direction*each_order_count)
time.sleep(SPLIT_ORDER_DELAY)
if direction==1:
remain_count=int(remain_count/10)*10 # 可转债买的时候只能10的倍数交易，
if remain_count>0:
ret = order(code,direction*each_order_count)
更多ptrade实盘代码，欢迎关注个人知识星球 查看全部
注：代码里面针对的是可转债交易，股票的话把这一行：
remain_count=int(remain_count/10)*10 改为
remain_count=int(remain_count/100)*100 就可以了
股票100股整数倍买，转债是10张倍数买。
code,direction,target_count ： 第一个代码，第二个买卖方向，第三个是目标数目
each_order_count = 100 # 每单的股数,张数
def split_order(code,direction,target_count):
'''
拆单
:param code: 股票代码
:param direction: 买：1 卖：-1
:param target_count: 总共要卖的股数
:return:
'''
SPLIT_ORDER_DELAY =1
each_order_count = 100 # 每单的股数,张数
count = int(target_count/each_order_count)
remain_count = target_count%each_order_count
for i in range(count):
ret = order(code,direction*each_order_count)
time.sleep(SPLIT_ORDER_DELAY)
if direction==1:
remain_count=int(remain_count/10)*10 # 可转债买的时候只能10的倍数交易，
if remain_count>0:
ret = order(code,direction*each_order_count)
更多ptrade实盘代码，欢迎关注个人知识星球 查看全部
在交易过程中，如果遇到成交量小的股票或者可转债，etf，稍微买多一些会对现价造成冲击，价格容易被你自己拉起来。所以假如你的交易量很大的话，一般最好使用拆单操作。 可以参考下面的python拆单代码：
注：代码里面针对的是可转债交易，股票的话把这一行：
remain_count=int(remain_count/10)*10 改为
remain_count=int(remain_count/100)*100 就可以了
股票100股整数倍买，转债是10张倍数买。
code,direction,target_count ： 第一个代码，第二个买卖方向，第三个是目标数目
each_order_count = 100 # 每单的股数,张数
更多ptrade实盘代码，欢迎关注个人知识星球
注：代码里面针对的是可转债交易，股票的话把这一行：
remain_count=int(remain_count/10)*10 改为
remain_count=int(remain_count/100)*100 就可以了
股票100股整数倍买，转债是10张倍数买。
code,direction,target_count ： 第一个代码，第二个买卖方向，第三个是目标数目
each_order_count = 100 # 每单的股数,张数
def split_order(code,direction,target_count):
'''
拆单
:param code: 股票代码
:param direction: 买：1 卖：-1
:param target_count: 总共要卖的股数
:return:
'''
SPLIT_ORDER_DELAY =1
each_order_count = 100 # 每单的股数,张数
count = int(target_count/each_order_count)
remain_count = target_count%each_order_count
for i in range(count):
ret = order(code,direction*each_order_count)
time.sleep(SPLIT_ORDER_DELAY)
if direction==1:
remain_count=int(remain_count/10)*10 # 可转债买的时候只能10的倍数交易，
if remain_count>0:
ret = order(code,direction*each_order_count)
更多ptrade实盘代码，欢迎关注个人知识星球
Ptrade挂单后撤单函数 实现
李魔佛 发表了文章 • 0 个评论 • 1445 次浏览 • 2022-09-29 16:40
在ptrade的每一笔挂单，都不一定能够保证很成功，比如刚挂了单，股票就飞了。
所以也需要有撤单，重新挂的动作。
order(code,amount) # 买入或者卖出
time.sleep(CANCEL_ORDER_TIME) # 等待片刻
cancel_order_reorder(context) # 进入撤单函数
中间需要有个等待时间。
1。 买入后，并不一定买上成交，需要一点时间消化，尤其是量大的单子，得要慢慢吃掉。
2。 成交回报并不是实时的。记住，ptrade的成交回报是有个延时，约9秒。 也就是你成交后，立即调用get_positions函数 看看你持仓，是无法看到你刚刚买入的股票数据的。
比如：
def initialize(context):
g.security = '600570.SS'
set_universe(g.security)
def handle_data(context, data):
order(g.security,100)
position = get_position(g.security)
log.info(position)这样你是无法获取的你的持仓的。
下面的示例代码，获取还在挂单的委托单子，然后逐个撤销，重新按照最新的市价下单。
def cancel_order_reorder(context):
'''
取消订单，重新下单
:return:
'''
open_orders = get_open_orders()
for _order in open_orders:
_id = _order.id
amount=_order.amount
filled=_order.filled
next_amount = amount-filled
code = _order.symbol
log.info('撤单{} - {}'.format(code,next_amount))
cancel_order(_id)
# time.sleep(1)
log.info('重新下单{} 数量{}'.format(code,next_amount))
order(code,next_amount)
后话：
很多投资者没有编程基础，学习起来会很吃力，耗费大量的时间，得不偿失。写出来的代码也是很多bug而不自知。等到实盘了用真金白银 得到了教训，还不如早期跟一两个人有经验的人学习，甚至找个代写代码就好了。
当然，能力超强，精力旺盛的大神就无视了，这个人折腾起来什么都可以搞得有模有样。
查看全部
所以也需要有撤单，重新挂的动作。
order(code,amount) # 买入或者卖出
time.sleep(CANCEL_ORDER_TIME) # 等待片刻
cancel_order_reorder(context) # 进入撤单函数
中间需要有个等待时间。
1。 买入后，并不一定买上成交，需要一点时间消化，尤其是量大的单子，得要慢慢吃掉。
2。 成交回报并不是实时的。记住，ptrade的成交回报是有个延时，约9秒。 也就是你成交后，立即调用get_positions函数 看看你持仓，是无法看到你刚刚买入的股票数据的。
比如：
def initialize(context):
g.security = '600570.SS'
set_universe(g.security)
def handle_data(context, data):
order(g.security,100)
position = get_position(g.security)
log.info(position)这样你是无法获取的你的持仓的。
下面的示例代码，获取还在挂单的委托单子，然后逐个撤销，重新按照最新的市价下单。
def cancel_order_reorder(context):
'''
取消订单，重新下单
:return:
'''
open_orders = get_open_orders()
for _order in open_orders:
_id = _order.id
amount=_order.amount
filled=_order.filled
next_amount = amount-filled
code = _order.symbol
log.info('撤单{} - {}'.format(code,next_amount))
cancel_order(_id)
# time.sleep(1)
log.info('重新下单{} 数量{}'.format(code,next_amount))
order(code,next_amount)
后话：
很多投资者没有编程基础，学习起来会很吃力，耗费大量的时间，得不偿失。写出来的代码也是很多bug而不自知。等到实盘了用真金白银 得到了教训，还不如早期跟一两个人有经验的人学习，甚至找个代写代码就好了。
当然，能力超强，精力旺盛的大神就无视了，这个人折腾起来什么都可以搞得有模有样。
查看全部
在ptrade的每一笔挂单，都不一定能够保证很成功，比如刚挂了单，股票就飞了。
所以也需要有撤单，重新挂的动作。
中间需要有个等待时间。
1。 买入后，并不一定买上成交，需要一点时间消化，尤其是量大的单子，得要慢慢吃掉。
2。 成交回报并不是实时的。记住，ptrade的成交回报是有个延时，约9秒。 也就是你成交后，立即调用get_positions函数 看看你持仓，是无法看到你刚刚买入的股票数据的。
比如：
下面的示例代码，获取还在挂单的委托单子，然后逐个撤销，重新按照最新的市价下单。
后话：
很多投资者没有编程基础，学习起来会很吃力，耗费大量的时间，得不偿失。写出来的代码也是很多bug而不自知。等到实盘了用真金白银 得到了教训，还不如早期跟一两个人有经验的人学习，甚至找个代写代码就好了。
当然，能力超强，精力旺盛的大神就无视了，这个人折腾起来什么都可以搞得有模有样。
所以也需要有撤单，重新挂的动作。
order(code,amount) # 买入或者卖出
time.sleep(CANCEL_ORDER_TIME) # 等待片刻
cancel_order_reorder(context) # 进入撤单函数
中间需要有个等待时间。
1。 买入后，并不一定买上成交，需要一点时间消化，尤其是量大的单子，得要慢慢吃掉。
2。 成交回报并不是实时的。记住，ptrade的成交回报是有个延时，约9秒。 也就是你成交后，立即调用get_positions函数 看看你持仓，是无法看到你刚刚买入的股票数据的。
比如：
def initialize(context):这样你是无法获取的你的持仓的。
g.security = '600570.SS'
set_universe(g.security)
def handle_data(context, data):
order(g.security,100)
position = get_position(g.security)
log.info(position)
下面的示例代码，获取还在挂单的委托单子，然后逐个撤销，重新按照最新的市价下单。
def cancel_order_reorder(context):
'''
取消订单，重新下单
:return:
'''
open_orders = get_open_orders()
for _order in open_orders:
_id = _order.id
amount=_order.amount
filled=_order.filled
next_amount = amount-filled
code = _order.symbol
log.info('撤单{} - {}'.format(code,next_amount))
cancel_order(_id)
# time.sleep(1)
log.info('重新下单{} 数量{}'.format(code,next_amount))
order(code,next_amount)
后话：
很多投资者没有编程基础，学习起来会很吃力，耗费大量的时间，得不偿失。写出来的代码也是很多bug而不自知。等到实盘了用真金白银 得到了教训，还不如早期跟一两个人有经验的人学习，甚至找个代写代码就好了。
当然，能力超强，精力旺盛的大神就无视了，这个人折腾起来什么都可以搞得有模有样。
Ptrade在一个循环事件里 能否不断获取股票实时价格？
李魔佛 发表了文章 • 0 个评论 • 1365 次浏览 • 2022-09-28 10:53
假设在一个事件循环里：
如：
run_daily(context, get_price, '09:44')
定义的get_price 函数，
然后get_price函数里面有一个死循环，不断地获取价格。
因为ptrade的行情切片 是每3秒更新的一次的，如果行情没更新，那么当前的价格也是过去最近的一个3s的价格。
现在问题是，在一个固定的时间里面，不断地读取价格函数，能获取到最新的价格吗 ？
我们用代码实践一下：
import time
def initialize(context):
# 初始化策略
run_daily(context, get_price, '09:44')
def handle_data(context, data):
pass
def get_price(context):
for i in range(10):
target_list =['113585.SS','123057.SZ']
bond_gear_price_target = get_gear_price(target_list)
for code in target_list:
price = bond_gear_price_target[code]['offer_grp'][1][0]
log.info('code: {} price {} '.format(code,price))
time.sleep(1)
输出的结果：
2022-09-28 10:31:00 - INFO - code: 113585.SS price 169.147
2022-09-28 10:31:00 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:01 - INFO - code: 113585.SS price 169.147
2022-09-28 10:31:01 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:02 - INFO - code: 113585.SS price 169.156
2022-09-28 10:31:02 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:03 - INFO - code: 113585.SS price 169.156
2022-09-28 10:31:03 - INFO - code: 128053.SZ price 144.8
2022-09-28 10:31:04 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:04 - INFO - code: 128053.SZ price 144.8
2022-09-28 10:31:05 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:05 - INFO - code: 128053.SZ price 144.8
2022-09-28 10:31:06 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:06 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:07 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:07 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:08 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:08 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:09 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:09 - INFO - code: 128053.SZ price 144.746
2022-09-28 10:31:10 - INFO - code: 113585.SS price 169.066
2022-09-28 10:31:10 - INFO - code: 128053.SZ price 144.746
2022-09-28 10:31:11 - INFO - code: 113585.SS price 169.066
2022-09-28 10:31:11 - INFO - code: 128053.SZ price 144.746
2022-09-28 10:31:12 - INFO - code: 113585.SS price 169.066
2022-09-28 10:31:12 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:13 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:13 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:14 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:14 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:15 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:15 - INFO - code: 128053.SZ price 144.692
2022-09-28 10:31:16 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:16 - INFO - code: 128053.SZ price 144.692
2022-09-28 10:31:17 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:17 - INFO - code: 128053.SZ price 144.692
2022-09-28 10:31:18 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:18 - INFO - code: 128053.SZ price 144.691
2022-09-28 10:31:19 - INFO - code: 113585.SS price 169.062
2022-09-28 10:31:19 - INFO - code: 128053.SZ price 144.691
2022-09-28 10:31:20 - INFO - code: 113585.SS price 169.062
为了更为直观，过滤掉另外一只可转债
只保留一只
2022-09-28 10:31:00 - INFO - code: 113585.SS price 169.147
2022-09-28 10:31:01 - INFO - code: 113585.SS price 169.147
2022-09-28 10:31:02 - INFO - code: 113585.SS price 169.156
2022-09-28 10:31:03 - INFO - code: 113585.SS price 169.156
2022-09-28 10:31:04 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:05 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:06 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:07 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:08 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:09 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:10 - INFO - code: 113585.SS price 169.066
2022-09-28 10:31:11 - INFO - code: 113585.SS price 169.066 可以看到价格也是基本没个3s更新一次。
更多ptrade实盘代码，请常见个人星球。
【可转债追涨杀跌日内T+0，双低 低价 低溢价 规模多因子轮动】
查看全部
如：
run_daily(context, get_price, '09:44')
定义的get_price 函数，
然后get_price函数里面有一个死循环，不断地获取价格。
因为ptrade的行情切片 是每3秒更新的一次的，如果行情没更新，那么当前的价格也是过去最近的一个3s的价格。
现在问题是，在一个固定的时间里面，不断地读取价格函数，能获取到最新的价格吗 ？
我们用代码实践一下：
import time
def initialize(context):
# 初始化策略
run_daily(context, get_price, '09:44')
def handle_data(context, data):
pass
def get_price(context):
for i in range(10):
target_list =['113585.SS','123057.SZ']
bond_gear_price_target = get_gear_price(target_list)
for code in target_list:
price = bond_gear_price_target[code]['offer_grp'][1][0]
log.info('code: {} price {} '.format(code,price))
time.sleep(1)
输出的结果：
2022-09-28 10:31:00 - INFO - code: 113585.SS price 169.147
2022-09-28 10:31:00 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:01 - INFO - code: 113585.SS price 169.147
2022-09-28 10:31:01 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:02 - INFO - code: 113585.SS price 169.156
2022-09-28 10:31:02 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:03 - INFO - code: 113585.SS price 169.156
2022-09-28 10:31:03 - INFO - code: 128053.SZ price 144.8
2022-09-28 10:31:04 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:04 - INFO - code: 128053.SZ price 144.8
2022-09-28 10:31:05 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:05 - INFO - code: 128053.SZ price 144.8
2022-09-28 10:31:06 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:06 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:07 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:07 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:08 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:08 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:09 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:09 - INFO - code: 128053.SZ price 144.746
2022-09-28 10:31:10 - INFO - code: 113585.SS price 169.066
2022-09-28 10:31:10 - INFO - code: 128053.SZ price 144.746
2022-09-28 10:31:11 - INFO - code: 113585.SS price 169.066
2022-09-28 10:31:11 - INFO - code: 128053.SZ price 144.746
2022-09-28 10:31:12 - INFO - code: 113585.SS price 169.066
2022-09-28 10:31:12 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:13 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:13 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:14 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:14 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:15 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:15 - INFO - code: 128053.SZ price 144.692
2022-09-28 10:31:16 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:16 - INFO - code: 128053.SZ price 144.692
2022-09-28 10:31:17 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:17 - INFO - code: 128053.SZ price 144.692
2022-09-28 10:31:18 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:18 - INFO - code: 128053.SZ price 144.691
2022-09-28 10:31:19 - INFO - code: 113585.SS price 169.062
2022-09-28 10:31:19 - INFO - code: 128053.SZ price 144.691
2022-09-28 10:31:20 - INFO - code: 113585.SS price 169.062
为了更为直观，过滤掉另外一只可转债
只保留一只
2022-09-28 10:31:00 - INFO - code: 113585.SS price 169.147
2022-09-28 10:31:01 - INFO - code: 113585.SS price 169.147
2022-09-28 10:31:02 - INFO - code: 113585.SS price 169.156
2022-09-28 10:31:03 - INFO - code: 113585.SS price 169.156
2022-09-28 10:31:04 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:05 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:06 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:07 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:08 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:09 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:10 - INFO - code: 113585.SS price 169.066
2022-09-28 10:31:11 - INFO - code: 113585.SS price 169.066 可以看到价格也是基本没个3s更新一次。
更多ptrade实盘代码，请常见个人星球。
【可转债追涨杀跌日内T+0，双低 低价 低溢价 规模多因子轮动】
查看全部
假设在一个事件循环里：
如：
run_daily(context, get_price, '09:44')
定义的get_price 函数，
然后get_price函数里面有一个死循环，不断地获取价格。
因为ptrade的行情切片 是每3秒更新的一次的，如果行情没更新，那么当前的价格也是过去最近的一个3s的价格。
现在问题是，在一个固定的时间里面，不断地读取价格函数，能获取到最新的价格吗 ？
我们用代码实践一下：
输出的结果：
为了更为直观，过滤掉另外一只可转债
只保留一只
更多ptrade实盘代码，请常见个人星球。
【可转债追涨杀跌日内T+0，双低 低价 低溢价 规模多因子轮动】
如：
run_daily(context, get_price, '09:44')
定义的get_price 函数，
然后get_price函数里面有一个死循环，不断地获取价格。
因为ptrade的行情切片 是每3秒更新的一次的，如果行情没更新，那么当前的价格也是过去最近的一个3s的价格。
现在问题是，在一个固定的时间里面，不断地读取价格函数，能获取到最新的价格吗 ？
我们用代码实践一下：
import time
def initialize(context):
# 初始化策略
run_daily(context, get_price, '09:44')
def handle_data(context, data):
pass
def get_price(context):
for i in range(10):
target_list =['113585.SS','123057.SZ']
bond_gear_price_target = get_gear_price(target_list)
for code in target_list:
price = bond_gear_price_target[code]['offer_grp'][1][0]
log.info('code: {} price {} '.format(code,price))
time.sleep(1)
输出的结果：
2022-09-28 10:31:00 - INFO - code: 113585.SS price 169.147
2022-09-28 10:31:00 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:01 - INFO - code: 113585.SS price 169.147
2022-09-28 10:31:01 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:02 - INFO - code: 113585.SS price 169.156
2022-09-28 10:31:02 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:03 - INFO - code: 113585.SS price 169.156
2022-09-28 10:31:03 - INFO - code: 128053.SZ price 144.8
2022-09-28 10:31:04 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:04 - INFO - code: 128053.SZ price 144.8
2022-09-28 10:31:05 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:05 - INFO - code: 128053.SZ price 144.8
2022-09-28 10:31:06 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:06 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:07 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:07 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:08 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:08 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:09 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:09 - INFO - code: 128053.SZ price 144.746
2022-09-28 10:31:10 - INFO - code: 113585.SS price 169.066
2022-09-28 10:31:10 - INFO - code: 128053.SZ price 144.746
2022-09-28 10:31:11 - INFO - code: 113585.SS price 169.066
2022-09-28 10:31:11 - INFO - code: 128053.SZ price 144.746
2022-09-28 10:31:12 - INFO - code: 113585.SS price 169.066
2022-09-28 10:31:12 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:13 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:13 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:14 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:14 - INFO - code: 128053.SZ price 144.785
2022-09-28 10:31:15 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:15 - INFO - code: 128053.SZ price 144.692
2022-09-28 10:31:16 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:16 - INFO - code: 128053.SZ price 144.692
2022-09-28 10:31:17 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:17 - INFO - code: 128053.SZ price 144.692
2022-09-28 10:31:18 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:18 - INFO - code: 128053.SZ price 144.691
2022-09-28 10:31:19 - INFO - code: 113585.SS price 169.062
2022-09-28 10:31:19 - INFO - code: 128053.SZ price 144.691
2022-09-28 10:31:20 - INFO - code: 113585.SS price 169.062
为了更为直观，过滤掉另外一只可转债
只保留一只
2022-09-28 10:31:00 - INFO - code: 113585.SS price 169.147可以看到价格也是基本没个3s更新一次。
2022-09-28 10:31:01 - INFO - code: 113585.SS price 169.147
2022-09-28 10:31:02 - INFO - code: 113585.SS price 169.156
2022-09-28 10:31:03 - INFO - code: 113585.SS price 169.156
2022-09-28 10:31:04 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:05 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:06 - INFO - code: 113585.SS price 169.199
2022-09-28 10:31:07 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:08 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:09 - INFO - code: 113585.SS price 169.068
2022-09-28 10:31:10 - INFO - code: 113585.SS price 169.066
2022-09-28 10:31:11 - INFO - code: 113585.SS price 169.066
更多ptrade实盘代码，请常见个人星球。
【可转债追涨杀跌日内T+0，双低 低价 低溢价 规模多因子轮动】
