Price 反向交易者买入和卖出价格输出差异

请看附件中的图片。买入和卖出订单价格是第二天的开盘价，由“f”价格确认：{order.executed.price:6.2f}“'out put是第二天的开盘价，在运行“cerebro.addwriter（bt.WriterFile，csv=True，out='outputfiles{}.csv.”后，文件中记录的价格与执行价格不同。

我把代码附在这里了

import math
import datetime
import backtrader as bt

def run_test_single():
    ticker="OXY"
    print("ticker")
    print(ticker)
    macd_stock_test2(ticker)


def macd_stock_test2(ticker):
    cerebro = bt.Cerebro()
    cerebro.addstrategy(GoldCross)
    cerebro.broker.set_cash(1000000)

    feed = bt.feeds.YahooFinanceData(

        dataname=ticker,

        timeframe=bt.TimeFrame.Days,
        fromdate=datetime.datetime(1996, 1, 1),
        todate=datetime.datetime(2020, 12, 31),
        reverse=False,
    )
    cerebro.adddata(feed)

    cerebro.addwriter(bt.WriterFile, csv=True, out='outputfiles\{}.csv'.format(ticker))

    print("starting portfolio value: %.2f" % cerebro.broker.getvalue())
    cerebro.run()

    print("final portfolio value: %.2f" % cerebro.broker.getvalue())
    cerebro.plot(style='candle')

class GoldCross(bt.Strategy):  #unknow gold cross

    # set parameters to define fast and slow
    params = (
        ("fast", 12),
        ("slow", 26),
        ("order_percentage", 0.95),
        ("ticker", "stock"),
    )

    # define constractors
    def __init__(self):
        print("position size:", self.position.size)

        self.fast_moving_average = bt.indicators.EMA(
            self.data.close, period=self.params.fast, plotname="12 day moving average"
        )

        self.slow_moving_average = bt.indicators.EMA(
            self.data.close, period=self.params.slow, plotname="26 day moving average"
        )

        self.crossover = bt.indicators.CrossOver(
            self.fast_moving_average, self.slow_moving_average
        )

    def log(self, txt, dt=None):
        """ Logging function fot this strategy"""
        dt = dt or self.data.datetime[0]
        if isinstance(dt, float):
            dt = bt.num2date(dt)
        print("%s, %s" % (dt.date(), txt))

    def notify_order(self, order):
        """ Triggered upon changes to orders. """

        # Suppress notification if it is just a submitted order.
        if order.status == order.Submitted:
            return

        # Print out the date, security name, order number and status.
        dt, dn = self.datetime.date(), order.data._name
        type = "Buy" if order.isbuy() else "Sell"
        self.log(
            # print(dn)
            f"{order.data._name:<6} Order: {order.ref:3d}\tType: {type:<5}\tStatus"
            f" {order.getstatusname():<8} \t"
            f"Size: {order.created.size:9.1f} Price: {order.created.price:9.4f} "
            f"Position: {self.getposition(order.data).size}"
        )
        if order.status == order.Margin:
            return

        # Check if an order has been completed
        if order.status in [order.Completed]:
            self.log(
                f"{order.data._name:<6} {('BUY' if order.isbuy() else 'SELL'):<5} "
                f"EXECUTED for: {dn} "
                f"Price: {order.executed.price:6.2f} "
                f"Cost: {order.executed.value:6.2f} "
                f"Comm: {order.executed.comm:4.2f} "
                f"Size: {order.created.size:9.4f} "
            )

    def notify_trade(self, trade):
        """Provides notification of closed trades."""
        if trade.isclosed:
            self.log(
                "{} Closed: PnL Gross {}, Net {},".format(
                    trade.data._name,
                    round(trade.pnl, 2),
                    round(trade.pnlcomm, 1),
                )
            )

    def next(self):
        if self.position.size == 0:
            if self.crossover > 0:
                amount_to_invest = self.params.order_percentage * self.broker.cash
                self.size = math.floor(amount_to_invest / self.data.close)

                self.log(
                    "Buy {} shares of {} at {}".format(
                        self.size,
                        self.params.ticker,
                        self.data.close[0],
                    )
                )
                self.buy(size=self.size,price=self.data.close[0])

        if self.position.size > 0:
            if self.crossover < 0:
                self.log(
                    "Sell {} shares of {} at {}".format(
                        self.size, self.params.ticker, self.data.close[0],
                    )
                )
                self.sell(size=self.size,price=self.data.close[0])

    def end(self):
        self.sell(size=self.size, price=self.data.close[0])
        return


if __name__ == "__main__":
    print("File one executed when ran directly")
    run_test_single()

else:
    print("File one executed when imported")

导入数学
导入日期时间
作为bt的进口反向交易者
def运行测试单次（）
ticker=“OXY”
打印（“股票代码”）
打印（股票代码）
macd_股票测试2（股票代码）
def macd_股票测试2（股票代码）：
脑波
脑力劳动者战略（金十字）
脑波经纪商套现（1000000）
feed=bt.feeds.yahoo财务数据(
dataname=股票代码，
timeframe=bt.timeframe.Days，
fromdate=datetime.datetime（1996,1,1），
todate=datetime.datetime（2020,12,31），
反向=假，
)
大脑添加数据（提要）
addwriter（bt.WriterFile，csv=True，out='outputfiles\{}.csv'.格式（ticker））
打印（“起始投资组合值：%.2f”%cerebro.broker.getvalue（））
脑波跑
打印（“最终投资组合价值：%.2f”%cerebro.broker.getvalue（）
脑波图（style='candle'）
金十字勋章（bt.Strategy）：#未知金十字勋章
#设置参数以定义快速和慢速
参数=(
（“快速”，12），
（“慢”，26），
（“订单百分比”，0.95），
（“股票代码”、“股票”），
)
#定义承包商
定义初始化（自）：
打印（“位置大小：”，self.position.size）
self.fast\u moving\u average=bt.indicators.EMA(
self.data.close，period=self.params.fast，plotname=“12天移动平均线”
)
self.slow\u moving\u average=bt.indicators.EMA(
self.data.close，period=self.params.slow，plotname=“26天移动平均线”
)
self.crossion=bt.indicators.crossion(
self.fast\u moving\u average，self.slow\u moving\u average
)
def日志（self，txt，dt=None）：
“”“此策略的日志记录功能”“”
dt=dt或self.data.datetime[0]
如果是持续（dt，浮动）：
dt=bt.num2日期（dt）
打印（“%s，%s”%（dt.date（），txt））
def通知单（自身、订单）：
“”“在更改订单时触发。”“”
#如果只是提交的订单，则禁止通知。
如果order.status==order.Submitted：
返回
#打印日期、安全名称、订单号和状态。
dt，dn=self.datetime.date（），order.data.\u name
type=“Buy”如果订单为。isbuy（）否则为“销售”
self.log(
#打印（dn）
f{顺序数据。\名称：