def handle_data(self, data):
from zipline.api import (
order_percent,
order_target,
order_target_percent,
order_target_value,
order_value,
)
for style in [
MarketOrder(),
LimitOrder(10),
StopOrder(10),
StopLimitOrder(10, 10)
]:
with assert_raises(UnsupportedOrderParameters):
order(self.asset, 10, limit_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order(self.asset, 10, stop_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_value(self.asset, 300, limit_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_value(self.asset, 300, stop_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_percent(self.asset, .1, limit_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_percent(self.asset, .1, stop_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_target(self.asset, 100, limit_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_target(self.asset, 100, stop_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_target_value(self.asset,
100,
limit_price=10,
style=style)
with assert_raises(UnsupportedOrderParameters):
order_target_value(self.asset, 100, stop_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_target_percent(self.asset,
.2,
limit_price=10,
style=style)
with assert_raises(UnsupportedOrderParameters):
order_target_percent(self.asset,
.2,
stop_price=10,
style=style)
def rebalance(context, data):
"""
Execute orders according to our schedule_function() timing.
"""
# calculate intraday returns for our winners
current_prices = data.current(context.winners, "price")
prior_closes = data.history(context.winners, "close", 2, "1d").iloc[0]
intraday_returns = (current_prices - prior_closes) / prior_closes
positions = context.portfolio.positions
# Exit positions we no longer want to hold
for asset, position in positions.items():
if asset not in context.winners:
algo.order_target_value(asset, 0, style=MarketOrder())
# Enter long positions
for asset in context.winners:
# if already long, nothing to do
if asset in positions:
continue
# if the stock is up for the day, don't enter
if intraday_returns[asset] > 0:
continue
# otherwise, buy a fixed $100K position per asset
algo.order_target_value(asset, 100e3, style=MarketOrder())
def rebalance(context, data):
history = data.history(assets=context.asset,
fields=['close'],
bar_count=10,
frequency='1d')
date = history.index.values[-1]
close = history['close'].values
print("===============================================================")
print("持仓数 amount=", context.portfolio.positions[symbol('IBM')].amount)
print("每股成本 cost_basis=",
context.portfolio.positions[symbol('IBM')].cost_basis)
print("最新价格 last_sale_price=",
context.portfolio.positions[symbol('IBM')].last_sale_price)
print("能否交易 can_trade=", data.can_trade(context.asset))
print("current price=", data.current(context.asset, 'close'))
print("使用现金 capital_used=", context.portfolio.capital_used)
print("剩余现金 cash=", context.portfolio.cash)
print("今日收益 pnl=", context.portfolio.pnl)
print("收益率 returns=", context.portfolio.returns)
print("起始现金 starting_cash=", context.portfolio.starting_cash)
print("总市值 portfolio_value=", context.portfolio.portfolio_value)
print("持仓市值 positions_value=", context.portfolio.positions_value)
amount = context.portfolio.positions[symbol('IBM')].amount
if amount == 0:
order_id = order_target_value(context.asset, 200)
else:
order_id = order_target_value(context.asset, 400)
print("order_id==>", order_id)
def handle_data(self, data):
from zipline.api import (
order_percent,
order_target,
order_target_percent,
order_target_value,
order_value,
)
for style in [MarketOrder(), LimitOrder(10),
StopOrder(10), StopLimitOrder(10, 10)]:
with assert_raises(UnsupportedOrderParameters):
order(self.asset, 10, limit_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order(self.asset, 10, stop_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_value(self.asset, 300, limit_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_value(self.asset, 300, stop_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_percent(self.asset, .1, limit_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_percent(self.asset, .1, stop_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_target(self.asset, 100, limit_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_target(self.asset, 100, stop_price=10, style=style)
with assert_raises(UnsupportedOrderParameters):
order_target_value(self.asset, 100,
limit_price=10,
style=style)
with assert_raises(UnsupportedOrderParameters):
order_target_value(self.asset, 100,
stop_price=10,
style=style)
with assert_raises(UnsupportedOrderParameters):
order_target_percent(self.asset, .2,
limit_price=10,
style=style)
with assert_raises(UnsupportedOrderParameters):
order_target_percent(self.asset, .2,
stop_price=10,
style=style)
def handle_data(context, data):
c = context
for position in c.portfolio.positions.itervalues():
if position.amount == 0:
if position.asset.symbol in c.stops:
del c.stops[position.asset.symbol]
continue
elif position.asset.symbol not in c.stops:
stoploss = c.stoploss if position.amount > 0 else -c.stoploss
c.stops[position.asset.symbol] = position.last_sale_price * (
1 - stoploss)
# log.info(' ! I have added '+str(position.asset.symbol)+' to Stops @ '+str((position.last_sale_price)*(1-stoploss)))
elif c.stops[
position.asset.
symbol] > position.last_sale_price and position.amount > 0:
# sell
log.info(' ! ' + str(position.asset.symbol) +
'- (Long) has hit stoploss @ ' +
str(position.last_sale_price))
if not get_open_orders(position.sid):
order_target_value(position.sid, 0.0)
c.stoppedout.append(position.asset.symbol)
del c.stops[position.asset.symbol]
elif c.stops[
position.asset.
symbol] < position.last_sale_price and position.amount < 0:
# sell
log.info(' ! ' + str(position.asset.symbol) +
'- (Short) has hit stoploss @ ' +
str(position.last_sale_price))
if not get_open_orders(position.sid):
order_target_value(position.sid, 0.0)
c.stoppedout.append(position.asset.symbol)
del c.stops[position.asset.symbol]
elif c.stops[position.asset.symbol] < position.last_sale_price * (
1 - c.stoploss) and position.amount > 0:
c.stops[position.asset.symbol] = position.last_sale_price * (
1 - c.stoploss)
# log.info(' ! I have updated '+str(position.asset.symbol)+'- (Long) to stop @ '+str((position.last_sale_price)*(1- c.stoploss)))
elif c.stops[position.asset.symbol] > position.last_sale_price * (
1 + c.stoploss) and position.amount < 0:
c.stops[position.asset.symbol] = position.last_sale_price * (
1 + c.stoploss)
def bonds(context, data):
logger.debug('buying bonds on: %s', algo.get_datetime())
logger.debug('num open orders: %s', len(algo.get_open_orders()))
logger.debug('len existing portfolio (afer ejection): %s',
len(context.portfolio.positions))
logger.debug('cash: %s', context.portfolio.cash)
logger.debug('portfolio_value: %s', context.portfolio.portfolio_value)
logger.debug('num_positions: %s', len(context.portfolio.positions))
logger.debug('positions: %s', context.portfolio.positions)
if logger.level is logging.DEBUG:
for equity, values in context.portfolio.positions.items():
logger.debug(
'context.portfolio.positions - equity: %s, amount: %s, cost_basis: %s, sold_on: %s, sold_at_price: %s',
equity, values.amount, values.cost_basis,
values.last_sale_date, values.last_sale_price)
if context.portfolio.cash > 0 and context.trend_filter is False:
logger.debug('converting all cash to bonds')
order_target_value(algo.sid('FIBBG000NTFYM5'), context.portfolio.cash)
def rebalance(context, data):
history = data.history(context.asset, ['close', 'high', 'low', 'open'],
context.T + 1, '1d')
# 获取当前持仓数
current_position = context.portfolio.positions[context.asset].amount
print("当前持仓数==>%d" % current_position)
# 获取当前行情数据
price = data.current(context.asset, 'close')
record(price=price)
# 1 计算ATR
atr = calc_atr(history.iloc[:len(history) - 1])
# 2 判断加仓或止损
if context.hold_flag is True and current_position > 0: # 先判断是否持仓
temp = add_or_stop(price, context.last_buy_price, atr, context)
if temp == 1: # 判断加仓
if context.add_time < context.limit_unit: # 判断加仓次数是否超过上限
print("产生加仓信号")
cash_amount = min(context.portfolio.cash,
context.unit * price) # 不够1unit时买入剩下全部
context.last_buy_price = price
if cash_amount >= price:
context.add_time += 1
print("正在买入 %s" % context.asset)
print("下单金额为 %s 元" % cash_amount)
order_target_value(
context.asset,
context.portfolio.positions_value + cash_amount)
else:
print("订单无效，下单金额小于交易所最小交易金额")
else:
print("加仓次数已经达到上限，不会加仓")
elif temp == -1: # 判断止损
# 重新初始化参数！重新初始化参数！重新初始化参数！非常重要！
init_local_context(context)
# 卖出止损
print("产生止损信号")
print("正在卖出 %s" % context.asset)
print("卖出数量为 %s" % current_position)
order_target_percent(context.asset, 0.0)
# 3 判断入场离场
else:
out = in_or_out(context, history.iloc[:len(history) - 1], price,
context.T)
if out == 1: # 入场
if context.hold_flag is False:
value = context.portfolio.cash * 0.01
context.unit = calc_unit(value, atr)
print('unit===>%d, atr===>%d' % (context.unit, atr))
context.add_time = 1
context.hold_flag = True
context.last_buy_price = price
cash_amount = min(context.portfolio.cash, context.unit * price)
# 有买入信号，执行买入
print("产生入场信号")
print("正在买入 %s" % context.asset)
print("下单金额为 %s 元" % cash_amount)
order_target_value(context.asset, cash_amount)
else:
print("已经入场，不产生入场信号")
elif out == -1: # 离场
if context.hold_flag is True:
if current_position >= 1:
print("产生止盈离场信号")
# 重新初始化参数
init_local_context(context)
# 有卖出信号，且持有仓位，则市价单全仓卖出
print("正在卖出 %s" % context.asset)
print("卖出数量为 %s" % current_position)
order_target_percent(context.asset, 0.0)
else:
print("尚未入场或已经离场，不产生离场信号")
def rebalance(context, data):
current_position = context.portfolio.positions[context.asset].amount
if context.stop_loss_triggered:
print("已触发止损线, 此bar不会有任何指令 ... ")
return
if context.stop_win_triggered:
print("已触发止盈线, 此bar不会有任何指令 ... ")
return
# 检查是否到达止损线或者止盈线，如果是，强制平仓，并结束所有操作
if context.portfolio.portfolio_value < context.portfolio_stop_loss * context.portfolio.starting_cash or context.portfolio.portfolio_value > context.portfolio_stop_win * context.portfolio.starting_cash:
should_stopped = True
else:
should_stopped = False
# 如果有止盈/止损信号，则强制平仓，并结束所有操作
if should_stopped:
# 低于止损线，需要止损
if context.portfolio.portfolio_value < context.portfolio_stop_loss * context.portfolio.starting_cash:
print(
"当前净资产:%.2f 位于止损线下方 (%f), 初始资产:%.2f, 触发止损动作" %
(context.portfolio.portfolio_value, context.portfolio_stop_loss,
context.portfolio.starting_cash))
context.stop_loss_triggered = True
# 高于止盈线，需要止盈
else:
print(
"当前净资产:%.2f 位于止盈线上方 (%f), 初始资产:%.2f, 触发止盈动作" %
(context.portfolio.portfolio_value, context.portfolio_stop_win,
context.portfolio.starting_cash))
context.stop_win_triggered = True
if context.stop_loss_triggered:
print("设置 stop_loss_triggered（已触发止损信号）为真")
else:
print("设置 stop_win_triggered （已触发止损信号）为真")
# 有止盈/止损，且当前有仓位，则强平所有仓位
if current_position > 0:
print("正在卖出 %s" % context.asset)
order_target_percent(context.asset, 0.0)
return
# 获取当前价格
price = data[context.asset].price
record(price=price)
# 设置网格策略基础价格（base_price)
if context.base_price is None:
# 获取历史数据, 取后sma_window_size根bar
history = data.history(context.asset, ['close'], context.sma_window_size, '1d')
if len(history.index) < context.sma_window_size:
print("bar的数量不足, 等待下一根bar...")
return
# 计算sma均线值
sma = ta.SMA(history['close'].values, timeperiod=context.sma_window_size)[-1]
# 若当前价格满足条件，则设置当前价格为基础价
if price < context.price_to_sma_threshold * sma and context.base_price is None:
context.base_price = price
# 在基础价格位置建仓，仓位为50%
print("建仓中...")
cash_to_spent = cash_to_spent_fn(context.portfolio.portfolio_value, 0.5, context.portfolio.cash)
print("正在买入 %s" % context.asset)
print("下单金额为 %s 元" % cash_to_spent)
order_target_value(context.asset, cash_to_spent)
return
# 还没有找到base_price，则继续找，不着急建仓
if context.base_price is None:
print("尚未找到合适的基准价格，进入下一根bar")
return
cash_to_spent = 0
# 计算为达到目标仓位需要买入/卖出的金额
# 价格低于buy4所对应的价格时，仓位调至100%
if price / context.base_price < context.buy4:
cash_to_spent = cash_to_spent_fn(context.portfolio.portfolio_value, 1, context.portfolio.cash)
# 价格大于等于buy4对应的价格，低于buy3所对应的价格时，仓位调至90%
elif price / context.base_price < context.buy3:
cash_to_spent = cash_to_spent_fn(context.portfolio.portfolio_value, 0.9, context.portfolio.cash)
# 价格大于等于buy3对应的价格，低于buy2所对应的价格时，仓位调至70%
elif price / context.base_price < context.buy2:
cash_to_spent = cash_to_spent_fn(context.portfolio.portfolio_value, 0.7, context.portfolio.cash)
# 价格大于等于buy2对应的价格，低于buy1所对应的价格时，仓位调至60%
elif price / context.base_price < context.buy1:
cash_to_spent = cash_to_spent_fn(context.portfolio.portfolio_value, 0.6, context.portfolio.cash)
# 价格大于sell4对应的价格，仓位调至0%
elif price / context.base_price > context.sell4:
cash_to_spent = cash_to_spent_fn(context.portfolio.portfolio_value, 0, context.portfolio.cash)
# 价格小于等于sell4对应的价格，大于sell3所对应的价格时，仓位调至10%
elif price / context.base_price > context.sell3:
cash_to_spent = cash_to_spent_fn(context.portfolio.portfolio_value, 0.1, context.portfolio.cash)
# 价格小于等于sell3对应的价格，大于sell2所对应的价格时，仓位调至30%
elif price / context.base_price > context.sell2:
cash_to_spent = cash_to_spent_fn(context.portfolio.portfolio_value, 0.3, context.portfolio.cash)
# 价格小于等于sell2对应的价格，大于sell1所对应的价格时，仓位调至40%
elif price / context.base_price > context.sell1:
cash_to_spent = cash_to_spent_fn(context.portfolio.portfolio_value, 0.4, context.portfolio.cash)
# 根据策略调整仓位
if cash_to_spent > price:
# 市价单买入一定金额
print("正在买入 %s" % context.asset)
print("下单金额为 %s 元" % str(cash_to_spent))
order_target_value(context.asset, context.portfolio.positions_value + cash_to_spent)
elif cash_to_spent < 0:
# 计算需要卖出的数量，并已市价单卖出
quantity = min(current_position, -1 * cash_to_spent / price)
if quantity > 1:
print("正在卖出 %d 股" % int(quantity))
order_target(context.asset, current_position - int(quantity))
