cfdaily突破策略买卖规则目录
📋 规则体系设计
1. 规则层级结构
纯突破策略规则体系
├── 突破检测规则
│ ├── 价格突破规则
│ ├── 成交量确认规则
│ └── 过滤条件规则
├── 买入执行规则
│ ├── 买入时机规则
│ ├── 买入金额规则
│ └── 买入确认规则
├── 卖出执行规则
│ ├── 止盈规则
│ ├── 止损规则
│ ├── 移动止损规则
│ └── 强制卖出规则
└── 仓位管理规则
├── 初始仓位规则
├── 加仓规则
└── 减仓规则
2. 核心规则定义
2.1 突破检测规则 (breakout_rules.py)
# rules/breakout_rules.py
from typing import Dict, List
import pandas as pd
class BreakoutRules:
"""突破检测规则集合"""
def __init__(self, config: Dict):
self.config = config
def is_new_high_breakout(self, stock_data: pd.DataFrame) -> bool:
"""检测新高突破"""
current_price = stock_data['close'].iloc[-1]
prev_high = stock_data['high'].rolling(window=self.config['period']).max().iloc[-2]
# 价格突破条件
price_condition = current_price > prev_high * (1 + self.config['min_breakout_pct'])
# 成交量确认
volume_condition = self._check_volume_confirmation(stock_data)
# 突破前震荡确认
consolidation_condition = self._check_prior_consolidation(stock_data)
return price_condition and volume_condition and consolidation_condition
def is_range_breakout(self, stock_data: pd.DataFrame) -> bool:
"""检测区间突破"""
# 确定区间范围
recent_data = stock_data.tail(self.config['range_period'])
resistance = recent_data['high'].max()
support = recent_data['low'].min()
current_price = stock_data['close'].iloc[-1]
range_amplitude = (resistance - support) / support
# 区间突破条件
if self.config['breakout_direction'] == 'up':
breakout_condition = (
current_price > resistance and
range_amplitude >= self.config['min_range_amplitude']
)
else:
breakout_condition = (
current_price < support and
range_amplitude >= self.config['min_range_amplitude']
)
# 成交量确认
volume_condition = self._check_volume_confirmation(stock_data)
return breakout_condition and volume_condition
def _check_volume_confirmation(self, stock_data: pd.DataFrame) -> bool:
"""成交量确认规则"""
current_volume = stock_data['volume'].iloc[-1]
avg_volume = stock_data['volume'].rolling(window=20).mean().iloc[-1]
# 成交量要求
return current_volume >= avg_volume * self.config['min_volume_ratio']
def _check_prior_consolidation(self, stock_data: pd.DataFrame) -> bool:
"""突破前震荡确认规则"""
# 检查突破前价格是否在一定范围内震荡
lookback = self.config['consolidation_lookback']
recent_data = stock_data.tail(lookback)
price_range = recent_data['high'].max() - recent_data['low'].min()
avg_price = recent_data['close'].mean()
consolidation_ratio = price_range / avg_price
return consolidation_ratio <= self.config['max_consolidation_ratio']
2.2 买入执行规则 (buy_rules.py)
# rules/buy_rules.py
from typing import Dict, Optional
import pandas as pd
from dataclasses import dataclass
@dataclass
class BuySignal:
"""买入信号"""
stock_code: str
signal_date: str
signal_price: float
signal_type: str # 'new_high', 'range_breakout', 'pattern_breakout'
confidence_score: float
volume_ratio: float
class BuyRules:
"""买入执行规则集合"""
def __init__(self, config: Dict):
self.config = config
def should_buy(self, signal: BuySignal, current_price: float) -> bool:
"""判断是否应该买入"""
# 基本买入条件
if not self._check_basic_buy_conditions(signal):
return False
# 价格确认
if not self._check_price_confirmation(signal, current_price):
return False
# 风险控制
if not self._check_risk_conditions(signal):
return False
return True
def get_buy_price(self, signal: BuySignal, market_data: pd.DataFrame) -> float:
"""获取买入价格"""
if self.config['buy_timing'] == 'close':
# 突破日收盘价买入
return signal.signal_price
elif self.config['buy_timing'] == 'next_open':
# 突破次日开盘价买入
next_date = pd.to_datetime(signal.signal_date) + pd.Timedelta(days=1)
next_data = market_data.loc[market_data['date'] >= next_date].iloc[0]
return next_data['open']
elif self.config['buy_timing'] == 'limit':
# 限价买入
return signal.signal_price * (1 + self.config['buy_limit_offset'])
return signal.signal_price
def get_buy_amount(self, signal: BuySignal, total_capital: float) -> float:
"""获取买入金额"""
if self.config['buy_amount_type'] == 'percentage':
# 按总资金比例买入
base_amount = total_capital * self.config['buy_percentage']
# 根据信号强度调整
adjusted_amount = base_amount * signal.confidence_score
# 单只股票最大仓位限制
max_position = total_capital * self.config['max_position_per_stock']
return min(adjusted_amount, max_position)
elif self.config['buy_amount_type'] == 'fixed':
# 固定金额买入
return self.config['fixed_buy_amount']
return 0
def _check_basic_buy_conditions(self, signal: BuySignal) -> bool:
"""检查基本买入条件"""
# 信号强度要求
if signal.confidence_score < self.config['min_confidence_score']:
return False
# 成交量要求
if signal.volume_ratio < self.config['min_volume_ratio']:
return False
# 突破类型启用检查
breakout_type_enabled = self.config['breakout_types'].get(signal.signal_type, False)
if not breakout_type_enabled:
return False
return True
def _check_price_confirmation(self, signal: BuySignal, current_price: float) -> bool:
"""价格确认规则"""
if not self.config['confirmation']['required']:
return True
# 价格确认条件
price_change = (current_price - signal.signal_price) / signal.signal_price
if self.config['confirmation']['direction'] == 'up':
return price_change >= self.config['confirmation']['percentage']
elif self.config['confirmation']['direction'] == 'down':
return price_change <= -self.config['confirmation']['percentage']
return True
def _check_risk_conditions(self, signal: BuySignal) -> bool:
"""风险控制规则"""
# 市场状态检查
if self.config['market_state']['check_required']:
# 检查市场是否处于可买入状态
pass
# 突破频率限制
if self.config['frequency_limit']['enabled']:
# 限制同一股票的买入频率
pass
return True
2.3 卖出执行规则 (sell_rules.py)
# rules/sell_rules.py
from typing import Dict, Optional
import pandas as pd
from dataclasses import dataclass
@dataclass
class SellSignal:
"""卖出信号"""
stock_code: str
signal_date: str
signal_price: float
signal_type: str # 'take_profit', 'stop_loss', 'force_sell'
profit_loss_pct: float
holding_days: int
class SellRules:
"""卖出执行规则集合"""
def __init__(self, config: Dict):
self.config = config
def should_sell(self, position: Dict, current_price: float, market_data: pd.DataFrame) -> Optional[SellSignal]:
"""判断是否应该卖出"""
# 检查止盈条件
take_profit_signal = self._check_take_profit(position, current_price)
if take_profit_signal:
return take_profit_signal
# 检查止损条件
stop_loss_signal = self._check_stop_loss(position, current_price)
if stop_loss_signal:
return stop_loss_signal
# 检查强制卖出条件
force_sell_signal = self._check_force_sell(position, current_price, market_data)
if force_sell_signal:
return force_sell_signal
return None
def _check_take_profit(self, position: Dict, current_price: float) -> Optional[SellSignal]:
"""检查止盈条件"""
if not self.config['take_profit']['enabled']:
return None
buy_price = position['buy_price']
holding_days = position['holding_days']
current_profit_pct = (current_price - buy_price) / buy_price
# 固定止盈
if self.config['take_profit']['fixed']['enabled']:
if current_profit_pct >= self.config['take_profit']['fixed']['percentage']:
return SellSignal(
stock_code=position['stock_code'],
signal_date=pd.Timestamp.now().strftime('%Y-%m-%d'),
signal_price=current_price,
signal_type='take_profit',
profit_loss_pct=current_profit_pct,
holding_days=holding_days
)
# 动态止盈
if self.config['take_profit']['dynamic']['enabled'] and 'highest_price' in position:
highest_price = position['highest_price']
trailing_stop_price = highest_price * (1 - self.config['take_profit']['dynamic']['trailing_stop_percentage'])
if current_price <= trailing_stop_price:
return SellSignal(
stock_code=position['stock_code'],
signal_date=pd.Timestamp.now().strftime('%Y-%m-%d'),
signal_price=current_price,
signal_type='take_profit',
profit_loss_pct=current_profit_pct,
holding_days=holding_days
)
# 时间止盈
if self.config['take_profit']['time_based']['enabled']:
if holding_days >= self.config['take_profit']['time_based']['max_holding_days']:
return SellSignal(
stock_code=position['stock_code'],
signal_date=pd.Timestamp.now().strftime('%Y-%m-%d'),
signal_price=current_price,
signal_type='take_profit',
profit_loss_pct=current_profit_pct,
holding_days=holding_days
)
return None
def _check_stop_loss(self, position: Dict, current_price: float) -> Optional[SellSignal]:
"""检查止损条件"""
if not self.config['stop_loss']['enabled']:
return None
buy_price = position['buy_price']
holding_days = position['holding_days']
current_loss_pct = (current_price - buy_price) / buy_price
# 固定止损
if self.config['stop_loss']['fixed']['enabled']:
if current_loss_pct <= -self.config['stop_loss']['fixed']['percentage']:
return SellSignal(
stock_code=position['stock_code'],
signal_date=pd.Timestamp.now().strftime('%Y-%m-%d'),
signal_price=current_price,
signal_type='stop_loss',
profit_loss_pct=current_loss_pct,
holding_days=holding_days
)
# 移动止损
if self.config['stop_loss']['moving']['enabled'] and 'highest_price' in position:
highest_price = position['highest_price']
moving_stop_price = highest_price * (1 - self.config['stop_loss']['moving']['percentage'])
if current_price <= moving_stop_price:
return SellSignal(
stock_code=position['stock_code'],
signal_date=pd.Timestamp.now().strftime('%Y-%m-%d'),
signal_price=current_price,
signal_type='stop_loss',
profit_loss_pct=current_loss_pct,
holding_days=holding_days
)
# 技术止损
if self.config['stop_loss']['technical']['enabled']:
# 检查是否跌破重要技术位
pass
return None
def _check_force_sell(self, position: Dict, current_price: float, market_data: pd.DataFrame) -> Optional[SellSignal]:
"""检查强制卖出条件"""
if not self.config['force_sell']['enabled']:
return None
buy_price = position['buy_price']
holding_days = position['holding_days']
current_pct = (current_price - buy_price) / buy_price
# 成交量异常条件
if self.config['force_sell']['volume_anomaly']['enabled']:
volume_condition = self._check_volume_anomaly(position, market_data)
if volume_condition:
return SellSignal(
stock_code=position['stock_code'],
signal_date=pd.Timestamp.now().strftime('%Y-%m-%d'),
signal_price=current_price,
signal_type='force_sell',
profit_loss_pct=current_pct,
holding_days=holding_days
)
# 价格异常条件
if self.config['force_sell']['price_anomaly']['enabled']:
price_condition = self._check_price_anomaly(position, current_price)
if price_condition:
return SellSignal(
stock_code=position['stock_code'],
signal_date=pd.Timestamp.now().strftime('%Y-%m-%d'),
signal_price=current_price,
signal_type='force_sell',
profit_loss_pct=current_pct,
holding_days=holding_days
)
return None
def _check_volume_anomaly(self, position: Dict, market_data: pd.DataFrame) -> bool:
"""检查成交量异常"""
# 获取最近成交量数据
recent_volume = market_data.tail(10)['volume']
# 计算成交量比率
avg_volume = recent_volume.mean()
current_volume = market_data['volume'].iloc[-1]
volume_ratio = current_volume / avg_volume
return volume_ratio < self.config['force_sell']['volume_anomaly']['drop_ratio']
def _check_price_anomaly(self, position: Dict, current_price: float) -> bool:
"""检查价格异常"""
buy_price = position['buy_price']
price_drop_pct = (current_price - buy_price) / buy_price
return price_drop_pct <= -self.config['force_sell']['price_anomaly']['drop_percentage']
2.4 仓位管理规则 (position_rules.py)
# rules/position_rules.py
from typing import Dict, List
import pandas as pd
class PositionRules:
"""仓位管理规则集合"""
def __init__(self, config: Dict):
self.config = config
def can_open_position(self, portfolio: Dict, stock_data: pd.DataFrame) -> bool:
"""判断是否可以开仓"""
# 持仓数量限制
if len(portfolio['positions']) >= self.config['max_positions']:
return False
# 资金使用率限制
capital_usage = portfolio['total_value'] / portfolio['capital']
if capital_usage >= self.config['max_capital_usage']:
return False
# 个股仓位限制
stock_code = stock_data['code'].iloc[-1]
existing_position = self._get_existing_position(portfolio, stock_code)
if existing_position:
current_weight = existing_position['value'] / portfolio['total_value']
if current_weight >= self.config['max_position_per_stock']:
return False
# 行业暴露限制
industry = stock_data['industry'].iloc[-1]
industry_exposure = self._calculate_industry_exposure(portfolio, industry)
if industry_exposure >= self.config['max_industry_exposure']:
return False
return True
def should_add_position(self, position: Dict, current_price: float) -> bool:
"""判断是否应该加仓"""
if not self.config['add_position']['enabled']:
return False
buy_price = position['buy_price']
price_increase_pct = (current_price - buy_price) / buy_price
# 价格涨幅条件
if price_increase_pct >= self.config['add_position']['conditions']['price_increase']['percentage']:
# 检查加仓次数限制
add_count = position.get('add_count', 0)
if add_count < self.config['add_position']['max_add_times']:
return True
return False
def should_reduce_position(self, position: Dict, current_price: float) -> bool:
"""判断是否应该减仓"""
if not self.config['reduce_position']['enabled']:
return False
buy_price = position['buy_price']
current_profit_pct = (current_price - buy_price) / buy_price
# 部分止盈条件
if self.config['reduce_position']['partial_take_profit']['enabled']:
if current_profit_pct >= self.config['reduce_position']['partial_take_profit']['percentage']:
return True
# 风险控制减仓
if self.config['reduce_position']['risk_control']['enabled']:
# 基于市场风险或个股风险判断
pass
return False
def _get_existing_position(self, portfolio: Dict, stock_code: str) -> Optional[Dict]:
"""获取现有持仓"""
for position in portfolio['positions']:
if position['stock_code'] == stock_code:
return position
return None
def _calculate_industry_exposure(self, portfolio: Dict, industry: str) -> float:
"""计算行业暴露"""
industry_value = 0
total_value = portfolio['total_value']
for position in portfolio['positions']:
if position.get('industry') == industry:
industry_value += position['value']
return industry_value / total_value if total_value > 0 else 0
3. 目录结构
rules/
├── README.md # 本说明文件
├── __init__.py # 规则包初始化
├── breakout_rules.py # 突破检测规则
├── buy_rules.py # 买入执行规则
├── sell_rules.py # 卖出执行规则
├── position_rules.py # 仓位管理规则
├── validation_rules.py # 规则验证工具（待创建）
├── optimization_rules.py # 规则优化工具（待创建）
└── test_rules.py # 规则测试模块（待创建）
4. 规则使用指南
4.1 规则初始化
from rules.breakout_rules import BreakoutRules
from rules.buy_rules import BuyRules
from rules.sell_rules import SellRules
from rules.position_rules import PositionRules
# 加载配置
import yaml
with open('configs/trading_config.yaml', 'r') as f:
trading_config = yaml.safe_load(f)
# 创建规则实例
breakout_rules = BreakoutRules(trading_config['breakout'])
buy_rules = BuyRules(trading_config['buy'])
sell_rules = SellRules(trading_config['sell'])
position_rules = PositionRules(trading_config['position'])
4.2 规则执行流程
# 1. 检测突破信号
if breakout_rules.is_new_high_breakout(stock_data):
# 2. 生成买入信号
buy_signal = BuySignal(...)
# 3. 检查买入条件
if buy_rules.should_buy(buy_signal, current_price):
# 4. 检查仓位限制
if position_rules.can_open_position(portfolio, stock_data):
# 执行买入
pass
# 5. 监控卖出条件
sell_signal = sell_rules.should_sell(position, current_price, market_data)
if sell_signal:
# 执行卖出
pass
5. 规则优化
5.1 参数优化建议
- 回测验证: 在不同市场环境下测试规则
- 敏感性分析: 分析参数变化对绩效的影响
- 组合优化: 优化规则组合和权重
5.2 规则迭代流程
- 数据收集: 收集历史交易数据
- 规则测试: 测试新规则或参数
- 绩效评估: 评估规则改进效果
- 规则更新: 更新规则库和配置文件
6. 当前状态
✅ 已完成
- 规则体系设计
- 核心规则类实现
- 规则框架建立
🔄 进行中
- 规则优化算法开发
- 规则验证工具实现
- 规则性能测试
⏳ 待开始
- 机器学习规则发现
- 实时规则监控系统
- 规则版本管理系统
7. 联系人
规则设计: 待定（量化研究团队）
规则实现: 赵云（数据工程将军）
规则验证: 待定（风险管理团队）
开发状态: 规则体系设计完成，开始规则优化
预计完成: 核心规则模块本周内完成