砖型图策略是一种技术分析工具，它可以帮助交易者识别趋势和价格变动方向，并为交易决策提供支持。在这篇文章中，我们将探讨砖型图策略的基本原理和如何使用它来制定交易策略。
砖型图策略的基本原理
砖型图策略是由日本股票交易家斋藤康嘉于1990年代初发明的。该策略使用的是一种称为“砖块”的图形来显示价格的变化。砖块由一系列的价格区间组成，这些价格区间可以是股票、期货、外汇或其他资产的价格。
砖型图策略的核心思想是识别价格趋势。如果价格上涨，砖块的颜色为红色；如果价格下跌，砖块的颜色为绿色。当价格趋势改变时，砖块的颜色也会随之改变。
如何使用砖型图策略来制定交易策略
使用砖型图策略来制定交易策略通常需要以下步骤：
- 确定砖块大小
在砖型图策略中，砖块的大小可以影响趋势的识别。通常，交易者可以根据交易资产的波动性和自己的交易风险偏好来确定砖块大小。例如，如果交易者希望捕捉短期波动，可以选择较小的砖块大小。而如果交易者希望捕捉长期趋势，可以选择较大的砖块大小。
- 识别价格趋势
使用砖型图策略的一个主要目的是识别价格趋势。交易者可以通过观察砖块的颜色和大小来识别价格趋势。例如，如果看到一系列的红色砖块，就表明价格处于上涨趋势中。反之，如果看到一系列的绿色砖块，就表明价格处于下跌趋势中。
- 制定交易策略
一旦交易者识别了价格趋势，就可以制定相应的交易策略。例如，如果价格处于上涨趋势中，交易者可以考虑买入或持有头寸。而如果价格处于下跌趋势中，交易者可以考虑卖空或者持有空头头寸。
砖型图策略是一种简单而有效的技术分析工具，可以帮助交易者识别价格趋势，并为交易决策提供支持。使用砖型图策略制定交易策略需要根据交易资产的波动性和自己的交易风险偏好来确定砖块大小，并通过观察砖块的颜色和大小来识别价格趋势。最终，交易者可以根据价格趋势制定相应的交易策略。
使用Python可以方便地实现砖型图策略，下面将介绍如何使用Python编写一个简单的砖型图策略。
from simctp import * # 导入simctp库中的所有内容
from simctp import Tick_Data # 导入simctp库中的Tick_Data类
再写一个策略类，在策略代码里写了注释，这里不做过多介绍
class 砖型策略(obj): # 定义一个名为砖型策略的类，继承自obj类
def __init__(self): # 初始化方法
super().__init__() # 调用父类的初始化方法
self.codelist = ["ni2405","rb2405","i2405","l2405","j2405","p2405"] # 订阅合约列表
self.objtype = objtype.renko # 策略类型设置为renko，默认为tick
self.renko_tick = 1 # 设定砖型幅度，默认合约10，最小变动价
def on_bar(self, bar, tick: Tick_Data): # on_bar方法，在每根K线更新时被调用
print(tick.LastPrice) # 打印最新tick的价格
if len(bar) < 2: # 如果bar的长度小于2，则返回
return
kline = bar[-1] # 获取最新的砖型数据
position = self.get_pos(tick.code) # 获取指定合约的持仓信息
if position.pos_long <= 0 and position.pos_short <= 0 and kline["Renko"] == "上涨": # 如果是空仓，且连续两个上涨砖，则开多单
print("砖型图策略开多单")
self.insert_order(tick.code, 1, tick.AskPrice1, DirectionType.Buy, OffsetType.Open) # 开多单
if position.pos_long <= 0 and position.pos_short <= 0 and kline["Renko"] == "下跌": # 如果是空仓，且连续两个下跌砖，则开空单
print("砖型图策略开空单")
self.insert_order(tick.code, 1, tick.BidPrice1, DirectionType.Sell, OffsetType.Open) # 开空单
if position.pos_long > 0 and position.long_pos_frozen == 0 and kline["Renko"] == "下跌": # 如果有多单，最新砖下跌，上一砖是上涨，则平多单开空单
print("砖型图策略平多单并开空")
if position.pos_long_today > 0 and position.exchange_id in ["SHFE", "INE"]: # 判断是否为上期所和能源所今仓
self.insert_order(tick.code, position.pos_long, tick.BidPrice1, DirectionType.Sell, OffsetType.CloseToday) # 多头平今
else:
self.insert_order(tick.code, position.pos_long, tick.BidPrice1, DirectionType.Sell, OffsetType.Close) # 多头平仓
if position.pos_short > 0 and position.short_pos_frozen == 0 and kline["Renko"] == "上涨": # 如果有空单，最新砖上涨，上一砖是下跌，则平空单开多单
print("砖型图策略平空单并开多")
if position.pos_short_today > 0 and position.exchange_id in ["SHFE", "INE"]: # 判断是否为上期所和能源所今仓
self.insert_order(tick.code, position.pos_short, tick.BidPrice1, DirectionType.Buy, OffsetType.Open) # 空头平今
else:
self.insert_order(tick.code, position.pos_short, tick.BidPrice1, DirectionType.Buy, OffsetType.Open) # 空头平仓
Account = self.get_account()
print(Account.close_profit) #获取账号状态并打印平仓盈亏
print(Account.commission) #获取账号状态并打印手续费
最后启动策略
t = TMS()
t.add_obj(砖型策略())
t.run()
执行后的效果
策略完整源码
from simctp import * # 导入simctp库中的所有内容
from simctp import Tick_Data # 导入simctp库中的Tick_Data类
class macd(obj):
def __init__(self):
super().__init__()
self.codelist = ["ni2405","rb2405","i2405","l2405","j2405","p2405"] # 订阅合约
self.objtype = objtype.bar
self.dete = dete.time3
self.orders = {} # 保存每个合约的订单信息
self.pyramid_ratio = 0.5 # 金字塔加仓比例为50%
self.max_pyramid_count = 3 # 最大加仓次数为3次
def get_volume(self,code):
quote = self.get_quote(code)
available = self.get_account().balance #静态权益
multiplier = quote.VolumeMultiple*quote.LastPrice
max_open = available * 0.1
# 计算最大开仓手数
max_volume = int(max_open / multiplier)
if max_volume <= 0:
max_volume = 1
else:
max_volume = max_volume
return max_volume
def get_volume2(self, code, last_price, stop_loss_price, take_profit_ratio=3, is_long=True):
quote = self.get_quote(code)
account = self.get_account()
available_funds = account.balance
risk_percent = 1 / 100
max_acceptable_loss = available_funds * risk_percent
if is_long:
loss_per_trade = (last_price - stop_loss_price) * quote.VolumeMultiple
else:
loss_per_trade = (stop_loss_price - last_price) * quote.VolumeMultiple
max_position = int(max_acceptable_loss / loss_per_trade)
stop_profit_price = last_price + (last_price - stop_loss_price) * take_profit_ratio if is_long else last_price - (stop_loss_price - last_price) * take_profit_ratio
if max_position <= 0:
max_position = 1
else:
max_position = max_position
return [max_position, stop_profit_price]
def calculate_max_position(self, code, last_price, stop_loss_price, take_profit_ratio=3, is_long=True):
quote = self.get_quote(code)
account = self.get_account()
# 计算可用资金
# available_funds = account.static_balance - account.margin - account.commission
available_funds = account.available
# 计算总资金的1%
risk_percent = 1 / 100
# 计算最大亏损金额
max_acceptable_loss = available_funds * risk_percent
# 计算最大开仓量
if is_long:
loss_per_trade = (last_price - stop_loss_price) * quote.VolumeMultiple
max_position = int(max_acceptable_loss / loss_per_trade)
stop_profit_price = last_price + (last_price - stop_loss_price) * take_profit_ratio
else:
loss_per_trade = (stop_loss_price - last_price) * quote.VolumeMultiple
max_position = int(max_acceptable_loss / loss_per_trade)
stop_profit_price = last_price - (stop_loss_price-last_price) * take_profit_ratio
if max_position <= 0:
max_position = 1
else:
max_position = max_position
return [max_position,stop_profit_price]
def pyramid_open(self, symbol, direction, price, volume, stop_loss_price, stop_profit_price, Stop_loss_range, count):
"""
金字塔加仓开仓函数
"""
if count >= self.max_pyramid_count:
return
new_volume = int(volume * self.pyramid_ratio)
if new_volume <= 0:
new_volume = 1
else:
new_volume = new_volume
new_price = price
# if direction == "BUY":
# print(Stop_loss_range)
# new_price += Stop_loss_range * 0.5
# else:
# new_price -= Stop_loss_range * 0.5
new_order = self.send(symbol=symbol, volume=new_volume, price=new_price, direction=direction, offset="OPEN")
self.orders[symbol]["volume"] += new_volume
self.orders[symbol]["count"] += 1
self.orders[symbol]["open_price"] = new_price
self.orders[symbol]["stop_loss_price"] = stop_loss_price
self.orders[symbol]["stop_profit_price"] = stop_profit_price
self.orders[symbol]["Stop_loss_range"] = Stop_loss_range
# self.pyramid_open(symbol, direction, new_price, new_volume, stop_loss_price, stop_profit_price, Stop_loss_range, count + 1)
def on_bar(self, bar, tick: Tick_Data):
symbol = tick.InstrumentID
macd = self.MACD(bar)
# print(macd)
xh = self.XH(macd.dif,macd.dea)
MACD_cross = self.MACDZT(macd)
HHLL = self.HHLL(bar,10)
position = self.get_pos(symbol)
last_price = bar[-1]["close"]
# print(max(HHLL.H.iloc[-10:]))
if symbol in self.orders:
open_price = self.orders[symbol]["open_price"]
stop_loss_price = self.orders[symbol]["stop_loss_price"]
stop_profit_price = self.orders[symbol]["stop_profit_price"]
Stop_loss_range = self.orders[symbol]["Stop_loss_range"]
volume = self.orders[symbol]["volume"]
count = self.orders[symbol]["count"]
else:
open_price = None
stop_loss_price = None
stop_profit_price = None
Stop_loss_range = None
volume = 0
count = 0
# 如果是空仓
if position.pos_long <= 0 and position.pos_short <= 0 and MACD_cross.get("shangjin")==1 and MACD_cross.get("zhuangtai")=='金叉':
volume = self.get_volume(symbol)
stop_loss_price = min(HHLL.L.iloc[-10:]) # 设置止损位为前10日最低价
order = self.send(symbol=symbol, volume=volume, price=0, direction="BUY", offset="OPEN")
stop_profit_price = last_price + (last_price - stop_loss_price) * 3 # 设置止盈位为开仓价与止损幅度的3倍
Stop_loss_range = last_price - stop_loss_price
self.orders[symbol] = {"open_price": last_price, "stop_loss_price": stop_loss_price, "stop_profit_price": stop_profit_price, "Stop_loss_range": Stop_loss_range, "volume": volume, "count": 1}
# 如果是空仓
if position.pos_long <= 0 and position.pos_short <= 0 and MACD_cross.get("xiasi")==1 and MACD_cross.get("zhuangtai")=='死叉':
volume = self.get_volume(symbol)
stop_loss_price = max(HHLL.H.iloc[-10:]) # 设置止损位为前10日最高价
order = self.send(symbol=symbol, volume=volume, price=0, direction="SELL", offset="OPEN")
stop_profit_price = last_price - (stop_loss_price - last_price) * 3 # 设置止盈位为开仓价与止损幅度的3倍
Stop_loss_range = stop_loss_price - last_price
self.orders[symbol] = {"open_price": last_price, "stop_loss_price": stop_loss_price, "stop_profit_price": stop_profit_price, "Stop_loss_range": Stop_loss_range, "volume": volume, "count": 1}
# 如果有多单
if position.pos_long > 0 and stop_loss_price is not None:
profit = position.float_profit_long / position.pos_long # 计算当前持仓盈亏
stop_distance = 0 # 默认值为0，避免Stop_loss_range为None时出现TypeError异常
if Stop_loss_range is not None:
stop_distance = Stop_loss_range # 计算止损幅度
# 止损、止盈和平仓
if MACD_cross.get("deazhuangtai")=="下穿" or (stop_loss_price is not None and last_price <= stop_loss_price) or (stop_profit_price is not None and last_price >= stop_profit_price):
if position.pos_long_today > 0 and position.exchange_id in ["SHFE", "INE"]:
order = self.send(symbol=symbol, volume=position.pos_long, price=0, direction="SELL", offset="CLOSETODAY")
else:
order = self.send(symbol=symbol, volume=position.pos_long, price=0, direction="SELL", offset="CLOSE")
self.orders.pop(symbol, None)
return
# 金字塔加仓
if profit > stop_distance * 1 and count < self.max_pyramid_count and MACD_cross.get("zhuangtai")=="金叉":
self.pyramid_open(symbol, "BUY", tick.LastPrice, volume, stop_loss_price, stop_profit_price, stop_distance, count)
# 动态跟踪止损
if stop_loss_price is not None and profit > stop_distance * 3:
stop_loss_price = max(stop_loss_price, last_price - stop_distance)
if stop_loss_price != self.orders[symbol]["stop_loss_price"]:
self.orders[symbol]["stop_loss_price"] = stop_loss_price
elif position.pos_short > 0 and stop_loss_price is not None:
profit = position.float_profit_short / position.pos_short # 计算当前持仓盈亏
stop_distance = Stop_loss_range # 计算止损幅度
if Stop_loss_range is not None:
stop_distance = Stop_loss_range # 计算止损幅度
# 止损、止盈和平仓
if MACD_cross.get("deazhuangtai")=="上穿" or (stop_loss_price is not None and last_price >= stop_loss_price) or (stop_profit_price is not None and last_price <= stop_profit_price):
if position.pos_short_today > 0 and position.exchange_id in ["SHFE", "INE"]:
order = self.send(symbol=symbol, volume=position.pos_short, price=0, direction="BUY", offset="CLOSETODAY")
else:
order = self.send(symbol=symbol, volume=position.pos_short, price=0, direction="BUY", offset="CLOSE")
self.orders.pop(symbol, None)
return
# 金字塔加仓
if profit > Stop_loss_range * 1 and count < self.max_pyramid_count and MACD_cross.get("zhuangtai")=="死叉":
self.pyramid_open(symbol, "SELL", tick.LastPrice, volume, stop_loss_price, stop_profit_price, Stop_loss_range, count)
# 动态跟踪止损
if stop_loss_price is not None and profit > stop_distance * 3:
stop_loss_price = min(stop_loss_price, last_price + Stop_loss_range)
if stop_loss_price != self.orders[symbol]["stop_loss_price"]:
self.orders[symbol]["stop_loss_price"] = stop_loss_price
print(position.json)
class kdj(obj):
def __init__(self):
super().__init__()
self.codelist = ["ni2405","rb2405","i2405","l2405","j2405","p2405"] # 订阅合约
# self.codelist = ["IF2403"]
self.objtype = objtype.bar
self.dete = dete.time3
def get_volume(self,code):
quote = self.get_quote(code)
available = self.get_account().balance #静态权益
multiplier = quote.VolumeMultiple*quote.LastPrice
max_open = available * 0.1
# 计算最大开仓手数
max_volume = int(max_open / multiplier)
if max_volume <= 0:
max_volume = 1
else:
max_volume = max_volume
return max_volume
def on_bar(self, bar, tick: Tick_Data):
if len(bar)<10:
return
kdj = self.KDJ(bar)
xh = self.XH(kdj.K,kdj.D)
position = self.get_pos(tick.code)
print(xh,tick.LastPrice)
# 止损止盈逻辑
if position.pos_long > 0:
stop_loss = position.open_price_long - tick.PriceTick*9 # 设置止损价为成本价-3最小变动价
if tick.LastPrice <= stop_loss:
self.send(symbol=tick.code, volume=position.pos_long, price=tick.BidPrice1, direction="SELL", offset="CLOSE")
else:
take_profit = position.open_price_long + tick.PriceTick*3 # 设置止盈价为成本价+9最小变动价
if tick.LastPrice >= take_profit:
self.send(symbol=tick.code, volume=position.pos_long, price=tick.AskPrice1, direction="SELL", offset="CLOSE")
elif position.pos_short > 0:
stop_loss = position.open_price_short + tick.PriceTick*9 # 设置止损价为成本价+3最小变动价
if tick.LastPrice >= stop_loss:
self.send(symbol=tick.code, volume=position.pos_short, price=tick.AskPrice1, direction="BUY", offset="CLOSE")
else:
take_profit = position.open_price_short - tick.PriceTick*3 # 设置止盈价为成本价-9最小变动价
if tick.LastPrice <= take_profit:
self.send(symbol=tick.code, volume=position.pos_short, price=tick.BidPrice1, direction="BUY", offset="CLOSE")
# 金叉死叉逻辑
if position.pos_long <= 0 and position.pos_short <= 0 and xh == '金叉':
self.send(symbol=tick.code, volume=1, price=tick.AskPrice1, direction="BUY", offset="OPEN")
if position.pos_long <= 0 and position.pos_short <= 0 and xh == "死叉":
self.send(symbol=tick.code, volume=1, price=tick.BidPrice1, direction="SELL", offset="OPEN")
# if position.pos_long > 0 and xh == '死叉':
# self.send(symbol=tick.code, volume=1, price=tick.BidPrice1, direction="SELL", offset="CLOSE")
# self.send(symbol=tick.code, volume=1, price=tick.BidPrice1, direction="SELL", offset="OPEN")
# if position.pos_short > 0 and xh == '金叉':
# self.send(symbol=tick.code, volume=1, price=tick.AskPrice1, direction="BUY", offset="CLOSE")
# self.send(symbol=tick.code, volume=1, price=tick.AskPrice1, direction="BUY", offset="OPEN")
position = self.get_pos(tick.code)
print("合约持仓数据： ",position.json)
print("账户平仓盈亏： ",self.get_account().close_profit)
class 砖型策略(obj): # 定义一个名为砖型策略的类，继承自obj类
def __init__(self): # 初始化方法
super().__init__() # 调用父类的初始化方法
self.codelist = ["ni2405","rb2405","i2405","l2405","j2405","p2405"] # 订阅合约列表
self.objtype = objtype.renko # 策略类型设置为renko，默认为tick
self.renko_tick = 1 # 设定砖型幅度，默认合约10，最小变动价
def on_bar(self, bar, tick: Tick_Data): # on_bar方法，在每根K线更新时被调用
print(tick.LastPrice) # 打印最新tick的价格
if len(bar) < 2: # 如果bar的长度小于2，则返回
return
kline = bar[-1] # 获取最新的砖型数据
position = self.get_pos(tick.code) # 获取指定合约的持仓信息
if position.pos_long <= 0 and position.pos_short <= 0 and kline["Renko"] == "上涨": # 如果是空仓，且连续两个上涨砖，则开多单
print("砖型图策略开多单")
self.insert_order(tick.code, 1, tick.AskPrice1, DirectionType.Buy, OffsetType.Open) # 开多单
if position.pos_long <= 0 and position.pos_short <= 0 and kline["Renko"] == "下跌": # 如果是空仓，且连续两个下跌砖，则开空单
print("砖型图策略开空单")
self.insert_order(tick.code, 1, tick.BidPrice1, DirectionType.Sell, OffsetType.Open) # 开空单
if position.pos_long > 0 and position.long_pos_frozen == 0 and kline["Renko"] == "下跌": # 如果有多单，最新砖下跌，上一砖是上涨，则平多单开空单
print("砖型图策略平多单并开空")
if position.pos_long_today > 0 and position.exchange_id in ["SHFE", "INE"]: # 判断是否为上期所和能源所今仓
self.insert_order(tick.code, position.pos_long, tick.BidPrice1, DirectionType.Sell, OffsetType.CloseToday) # 多头平今
else:
self.insert_order(tick.code, position.pos_long, tick.BidPrice1, DirectionType.Sell, OffsetType.Close) # 多头平仓
if position.pos_short > 0 and position.short_pos_frozen == 0 and kline["Renko"] == "上涨": # 如果有空单，最新砖上涨，上一砖是下跌，则平空单开多单
print("砖型图策略平空单并开多")
if position.pos_short_today > 0 and position.exchange_id in ["SHFE", "INE"]: # 判断是否为上期所和能源所今仓
self.insert_order(tick.code, position.pos_short, tick.BidPrice1, DirectionType.Buy, OffsetType.Open) # 空头平今
else:
self.insert_order(tick.code, position.pos_short, tick.BidPrice1, DirectionType.Buy, OffsetType.Open) # 空头平仓
Account = self.get_account()
print(Account.close_profit) #获取账号状态并打印平仓盈亏
print(Account.commission) #获取账号状态并打印手续费
class zszy(obj): # 定义一个名为zszy的类，继承自obj类
def __init__(self): # 初始化方法
super().__init__() # 调用父类的初始化方法
self.codelist = ["IC2403"] # 存储合约代码列表
self.objtype = objtype.tick # 设置对象类型为tick
self.zs = -500 # 止损条件，浮动盈亏小于该值时进行平仓
self.zy = 1500 # 止盈条件，浮动盈亏大于该值时进行平仓
def on_tick(self, tick: Tick_Data, code): # on_tick方法，在每根K线更新时被调用
all_pos = self.get_pos() # 获取所有持仓信息
for pos in all_pos.values(): # 遍历所有持仓
if pos.pos_long == 0 and pos.pos_short == 0: # 如果该合约没有持仓，则跳过本次循环
continue
if pos.pos_long > 0 and (pos.float_profit_long < self.zs or pos.float_profit_long > self.zy): # 如果多单达到了止损或者止盈条件
self.send(pos.symbol, abs(pos.pos_long), pos.last_price, DirectionType.Sell, OffsetType.Close) # 发送平仓指令
elif pos.pos_short > 0 and (pos.float_profit_short < self.zs or pos.float_profit_short > self.zy): # 如果空单达到了止损或者止盈条件
self.send(pos.symbol, abs(pos.pos_short), pos.last_price, DirectionType.Buy, OffsetType.Close) # 发送平仓指令
print(f"{pos.symbol} close_profit: {pos.close_profit}") # 输出该合约的平仓盈亏信息
t = TMS()
# t.add_obj(macd())
# t.add_obj(kdj())
t.add_obj(砖型策略())
# t.add_obj(zszy())
t.run()
1870
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
