Skip to content
TheChatArchiveThe Chat Archive
Qwenqwen3-235b-a22b-instruct-2507-invalid· Alibaba (Qwen)Hugging Face Arena Expert 5K

加入佣金、滑点、止盈

  1. User

    加入佣金、滑点、止盈

  2. Qwen Assistant

    以下是 加入佣金、滑点、止盈逻辑 的完整升级代码。新增功能已用 🆕 标记,确保与原有逻辑无缝集成。


    ✅ 新增功能说明

    功能实现方式说明
    佣金按成交金额比例扣除(如 0.1%)在下单时,买入成本增加佣金,卖出收入减少佣金
    滑点模拟实际成交价偏差(如 0.05%)买入时价格上浮,卖出时价格下浮
    止盈盈利超过阈值(如 10%)时强制平仓类似止损逻辑,但判断盈利而非亏损

    📦 升级后的完整代码(main.py)

    import time
    import pandas as pd
    import pandas_ta as ta
    from xtquant.xtdata import get_price
    from xtquant.xtconstant import MARKET_XSHG, MARKET_XSHE
    from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback
    import datetime
    
    # ======================
    # 📌 配置参数(新增佣金、滑点、止盈)
    # ======================
    
    ETF_CODE = '510300.SH'       # 沪深300ETF,可替换为你想交易的ETF
    MARKET = MARKET_XSHG         # 上海市场
    
    GRID_COUNT = 5               # 网格数量(上下各几格)
    ATR_MULTIPLIER = 1.0         # ATR 乘数,用于动态网格大小(GRID_SIZE = ATR * ATR_MULTIPLIER)
    
    RSI_PERIOD = 14              # RSI周期
    RSI_OVERBOUGHT = 70          # RSI超买阈值,高于此不买
    RSI_OVERSOLD = 30            # RSI超卖阈值,低于此不卖
    
    ATR_PERIOD = 14              # ATR周期
    BB_PERIOD = 20               # 布林带周期
    BB_STD = 2.0                 # 布林带标准差倍数
    
    STOP_LOSS_PCT = -0.05        # 止损阈值(如 -5% 亏损时强制平仓)
    STOP_PROFIT_PCT = 0.10       # 止盈阈值(如 +10% 盈利时强制平仓)
    
    COMMISSION_RATE = 0.001      # 佣金比例(如 0.1%)
    SLIPPAGE_RATE = 0.0005       # 滑点比例(如 0.05%)
    
    QMT_TRADER_PATH = r'D:\QMT\trader'  # QMT trader目录,请修改为你的实际路径
    QMT_TRADER_PORT = 12345             # QMT端口,请根据实际情况填写
    
    # ======================
    # 🧠 网格交易类(最终版)
    # ======================
    
    class ETFGridTrader:
        def __init__(self):
            self.base_price = None
            self.grid_prices = []     # 网格价格列表(从低到高)
            self.position = 0         # 当前持仓数量(股)
            self.average_cost = 0.0   # 平均买入成本(用于止损/止盈)
            self.total_bought = 0     # 总买入股数(用于计算平均成本)
            self.trader = None
            self.callback = None
            self.is_logged_in = False
    
        def update_grid(self, current_price, atr):
            """基于当前价格和 ATR 动态更新网格价格"""
            grid_size = atr * ATR_MULTIPLIER
            self.base_price = current_price
            self.grid_prices = []
            for i in range(-GRID_COUNT, GRID_COUNT + 1):
                price = self.base_price * (1 + i * grid_size)
                self.grid_prices.append(round(price, 3))  # 保留3位小数
            print("[动态网格更新] 基准价格:%.3f, ATR: %.3f, 网格大小: %.3f, 网格价格:%s" % (self.base_price, atr, grid_size, self.grid_prices))
    
        def calculate_indicators(self, df):
            """使用 pandas_ta 计算 RSI、ATR、布林带"""
            df.ta.rsi(length=RSI_PERIOD, append=True)
            df.ta.atr(length=ATR_PERIOD, append=True)
            df.ta.bbands(length=BB_PERIOD, std=BB_STD, append=True)
            
            latest = df.iloc[-1]
            rsi = latest['RSI_{}'.format(RSI_PERIOD)]
            atr = latest['ATRr_{}'.format(ATR_PERIOD)]
            bb_upper = latest['BBU_{}_{}'.format(BB_PERIOD, BB_STD)]
            bb_lower = latest['BBL_{}_{}'.format(BB_PERIOD, BB_STD)]
            
            return rsi, atr, bb_upper, bb_lower
    
        def should_buy(self, rsi, current_price, bb_upper):
            """根据 RSI 和布林带判断是否允许买入"""
            return rsi < RSI_OVERBOUGHT and current_price < bb_upper  # RSI不过买,且未突破上轨
    
        def should_sell(self, rsi, current_price, bb_lower):
            """根据 RSI 和布林带判断是否允许卖出"""
            return rsi > RSI_OVERSOLD and current_price > bb_lower  # RSI不过卖,且未突破下轨
    
        def check_stop_loss(self, current_price):
            """检查止损:如果亏损超过阈值,强制平仓"""
            if self.position <= 0:
                return False
            
            pnl_pct = (current_price - self.average_cost) / self.average_cost
            if pnl_pct <= STOP_LOSS_PCT:
                print("[止损触发] 当前盈亏: %.2f%%, 超过阈值 %.2f%%, 强制平仓" % (pnl_pct * 100, STOP_LOSS_PCT * 100))
                return True
            return False
    
        def check_take_profit(self, current_price):
            """检查止盈:如果盈利超过阈值,强制平仓"""
            if self.position <= 0:
                return False
            
            pnl_pct = (current_price - self.average_cost) / self.average_cost
            if pnl_pct >= STOP_PROFIT_PCT:
                print("[止盈触发] 当前盈亏: %.2f%%, 超过阈值 %.2f%%, 强制平仓" % (pnl_pct * 100, STOP_PROFIT_PCT * 100))
                return True
            return False
    
        def get_current_price(self):
            """获取最新行情价格"""
            df = get_price(ETF_CODE, period='1d', count=1, dividend_type='front')
            if df.empty:
                print("[错误] 无法获取 %s 的行情数据" % ETF_CODE)
                return None
            latest_close = df['close'].iloc[-1]
            return latest_close
    
        def login_qmt_trader(self):
            """登录 QMT 实盘交易接口"""
            class MyCallback(XtQuantTraderCallback):
                def on_disconnected(self):
                    print("[QMT] 交易连接断开")
    
                def on_order_status(self, order):
                    print("[QMT订单] 状态更新:", order)
    
                def on_trade(self, trade):
                    print("[QMT成交] 成交信息:", trade)
    
            self.callback = MyCallback()
            self.trader = XtQuantTrader(QMT_TRADER_PATH, QMT_TRADER_PORT)
            ret = self.trader.start()
            if not ret:
                print("[QMT] 交易接口启动失败")
                return False
    
            # 登录(请填写你的账号、密码、券商等信息)
            ret_code, ret_data = self.trader.login('你的账号', '你的密码', '你的券商', '1')  # 1 代表实盘,0 代表仿真
            if ret_code != 0:
                print("[QMT] 登录失败,错误码:", ret_code, ret_data)
                return False
            else:
                print("[QMT] 登录成功")
                self.is_logged_in = True
                return True
    
        def place_order(self, action, price, qty):
            """下单(买入/卖出),加入滑点和佣金处理"""
            if not self.is_logged_in or not self.trader:
                print("[QMT] 未登录或交易接口未启动,无法下单")
                return
    
            stock_code = ETF_CODE
            order_type = 1 if action == 'buy' else 2  # 1:买入 2:卖出
            price_type = 1  # 1:限价单
    
            # 🆕 处理滑点:买入时价格上浮,卖出时价格下浮
            if action == 'buy':
                adjusted_price = price * (1 + SLIPPAGE_RATE)
            else:
                adjusted_price = price * (1 - SLIPPAGE_RATE)
    
            # 🆕 处理佣金:买入时成本增加,卖出时收入减少
            if action == 'buy':
                cost_price = adjusted_price * (1 + COMMISSION_RATE)
            else:
                sell_price = adjusted_price * (1 - COMMISSION_RATE)
    
            print(f"[QMT] 下单: {action.upper()} {qty}股 {stock_code} @ 调整后价格 {adjusted_price:.3f}(含滑点),实际成本 {cost_price:.3f}(含佣金)")
    
            ret_code, ret_data = self.trader.order_stock(stock_code, order_type, adjusted_price, qty, price_type)
            if ret_code != 0:
                print("[QMT] 下单失败:", ret_code, ret_data)
            else:
                print("[QMT] 下单成功")
    
            # 🆕 更新平均成本(仅在买入时)
            if action == 'buy':
                self.average_cost = (self.average_cost * self.total_bought + cost_price * qty) / (self.total_bought + qty)
                self.total_bought += qty
                self.position += qty
            elif action == 'sell':
                self.position -= qty
                if self.position <= 0:
                    self.average_cost = 0.0  # 清仓后重置成本
                    self.total_bought = 0
    
        def run(self):
            """主循环:定时运行网格策略"""
            print("[策略] 启动 ETF 网格交易策略(含 RSI/布林带过滤 + ATR动态网格 + 止损/止盈 + 佣金/滑点)")
            while True:
                try:
                    # 1. 获取最新价格
                    current_price = self.get_current_price()
                    if current_price is None:
                        time.sleep(60)
                        continue
    
                    # 2. 获取足够数据计算指标
                    data_count = max(RSI_PERIOD, ATR_PERIOD, BB_PERIOD) + 1
                    df = get_price(ETF_CODE, period='1d', count=data_count, dividend_type='front')
                    if df is None or len(df) < data_count:
                        print("[指标] 数据不足,跳过")
                        time.sleep(60)
                        continue
    
                    # 3. 计算 RSI、ATR、布林带
                    rsi, atr, bb_upper, bb_lower = self.calculate_indicators(df)
                    print(f"[行情] 当前价格: {current_price:.3f}, RSI: {rsi:.2f}, ATR: {atr:.3f}, BB上轨: {bb_upper:.3f}, BB下轨: {bb_lower:.3f}")
    
                    # 4. 动态更新网格
                    self.update_grid(current_price, atr)
    
                    # 5. 检查止损/止盈(优先级:止损 > 止盈)
                    if self.check_stop_loss(current_price):
                        qty = self.position  # 卖出所有持仓
                        self.place_order('sell', current_price, qty)
                        continue  # 平仓后跳过本次循环
                    elif self.check_take_profit(current_price):
                        qty = self.position  # 卖出所有持仓
                        self.place_order('sell', current_price, qty)
                        continue  # 平仓后跳过本次循环
    
                    # 6. 网格交易逻辑
                    for grid_price in self.grid_prices:
                        if current_price <= grid_price and self.position < GRID_COUNT * 100:  # 假设每格100股
                            if self.should_buy(rsi, current_price, bb_upper):
                                qty = 100  # 每次买100股
                                self.place_order('buy', grid_price, qty)
                                print(f"[买入] {qty}股 @ {grid_price:.3f},持仓:{self.position}")
                            break
    
                        elif current_price >= grid_price and self.position > 0:
                            if self.should_sell(rsi, current_price, bb_lower):
                                qty = 100  # 每次卖100股
                                self.place_order('sell', grid_price, qty)
                                print(f"[卖出] {qty}股 @ {grid_price:.3f},持仓:{self.position}")
                            break
    
                    # 7. 暂停一段时间(如 60 秒)
                    time.sleep(60)
    
                except Exception as e:
                    print("[异常]", e)
                    time.sleep(60)
    
    # ======================
    # 🚀 启动策略
    # ======================
    
    if __name__ == '__main__':
        trader = ETFGridTrader()
        # 先登录 QMT(实盘交易需配置正确)
        if trader.login_qmt_trader():
            trader.run()
        else:
            print("[错误] QMT 登录失败,仅模拟运行(无真实下单)")
            # 你也可以在这里实现模拟交易逻辑(只打印不交易)
    

    🛠 使用说明(最终版)

    1. 修改配置参数(新增部分)

    STOP_LOSS_PCT = -0.05        # 止损阈值(如 -5% 亏损时强制平仓)
    STOP_PROFIT_PCT = 0.10       # 止盈阈值(如 +10% 盈利时强制平仓)
    
    COMMISSION_RATE = 0.001      # 佣金比例(如 0.1%)
    SLIPPAGE_RATE = 0.0005       # 滑点比例(如 0.05%)
    

    2. 登录 QMT 时替换真实信息

    ret_code, ret_data = self.trader.login('你的账号', '你的密码', '你的券商', '1')  # '1' 是实盘,'0' 是仿真
    

    3. 运行方式

    确保 QMT 已启动,运行:

    python main.py
    

    4. 示例输出

    [动态网格更新] 基准价格:3.500, ATR: 0.050, 网格大小: 0.050, 网格价格:[3.325, 3.375, ..., 3.675]
    [止损触发] 当前盈亏: -5.50%, 超过阈值 -5.00%, 强制平仓
    [止盈触发] 当前盈亏: 12.00%, 超过阈值 10.00%, 强制平仓
    [买入] 100股 @ 3.450,持仓:100
    [卖出] 100股 @ 3.550,持仓:0
    

    ✅ 功能验证

    功能验证方式
    佣金检查下单时 实际成本 是否包含佣金(如 3.450 → 3.453)
    滑点检查下单时 调整后价格 是否包含滑点(如 3.450 → 3.452)
    止盈当盈利超过 STOP_PROFIT_PCT 时,自动平仓
    止损当亏损超过 STOP_LOSS_PCT 时,自动平仓
    优先级止损优先于止盈触发(例如,同时满足时只执行止损)

    📩 下一步建议

    如你想要:

    • ✅ 加入 多ETF轮动
    • ✅ 支持 日志记录(文件)
    • ✅ 支持 仓位控制(最大持仓限制)
    • ✅ 支持 回测功能(Backtrader)

    👉 欢迎继续提问,我可以继续帮你扩展!

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.