Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· openaiHugging Face Suzhen/CodeChat

用backtrader 如何构建自个的策略

  1. User

    用backtrader 如何构建自个的策略

  2. Assistant

    如果你想使用backtrader构建自己的策略,可以按照以下步骤进行操作:

    1. 导入backtrader模块
    import backtrader as bt
    
    1. 创建自己的策略类,并继承bt.Strategy类
    class MyStrategy(bt.Strategy):
        pass
    
    1. 在自己的策略类中定义需要用到的参数
    class MyStrategy(bt.Strategy):
        params = (
            ('maperiod', 15),
            ('printlog', False),
        )
    

    上面的代码定义了两个参数,一个是maperiod,表示移动平均线的周期,另一个是printlog,表示是否打印日志。

    1. 在自己的策略类中定义init方法,并在其中初始化需要用到的指标/数据
    class MyStrategy(bt.Strategy):
        params = (
            ('maperiod', 15),
            ('printlog', False),
        )
    
        def __init__(self):
            # 初始化移动平均线指标
            self.moving_average = bt.indicators.SimpleMovingAverage(
                self.data.close, period=self.params.maperiod
            )
    
            if self.params.printlog:
                # 打印日志
                print('Moving Average Period:', self.params.maperiod)
    

    上面的代码初始化了一个移动平均线指标,并在参数printlog为True时打印日志。

    1. 在自己的策略类中定义next方法,并在其中进行买入/卖出操作
    class MyStrategy(bt.Strategy):
        params = (
            ('maperiod', 15),
            ('printlog', False),
        )
    
        def __init__(self):
            # 初始化移动平均线指标
            self.moving_average = bt.indicators.SimpleMovingAverage(
                self.data.close, period=self.params.maperiod
            )
    
            if self.params.printlog:
                # 打印日志
                print('Moving Average Period:', self.params.maperiod)
    
        def next(self):
            # 当前价格大于移动平均线时买入
            if self.data.close[0] > self.moving_average[0]:
                self.buy()
    
            # 当前价格小于移动平均线时卖出
            if self.data.close[0] < self.moving_average[0]:
                self.sell()
    

    上面的代码在每个时刻(tick)进行买入/卖出操作,当当前价格大于移动平均线时买入,当前价格小于移动平均线时卖出。

    1. 在主函数中加载数据和策略,并运行回测
    if __name__ == '__main__':
        # 创建回测引擎
        cerebro = bt.Cerebro()
    
        # 加载数据
        data = bt.feeds.YahooFinanceData(
            dataname='AAPL',
            fromdate=datetime.datetime(2010, 1, 1),
            todate=datetime.datetime(2019, 12, 31),
        )
        cerebro.adddata(data)
    
        # 加载策略
        cerebro.addstrategy(MyStrategy)
    
        # 设置初始资金
        cerebro.broker.setcash(100000.0)
    
        # 运行回测
        cerebro.run()
    
        # 输出最终资产值
        print('Final Portfolio Value:', cerebro.broker.getvalue())
    

    上面的代码加载了AAPL从2010年1月1日到2019年12月31日的数据,并使用MyStrategy策略进行回测。初始资金为100000.0美元,最终输出回测结果。

    以上就是使用backtrader构建自己的策略的基本步骤。实际上,backtrader支持非常多的指标和操作,可以根据自己的需求进行灵活的组合和配置。

  3. User

    举个红三兵的例子

  4. Assistant

    红三兵是一种常见的股票交易策略,通常应用于股票市场。下面举一个红三兵的例子,使用backtrader构建策略。

    红三兵是一种多头策略,通常在下跌市场中使用。其基本原理是在股价下跌时,当连续三根阳线出现时,说明多头力量开始增强,此时可以考虑买入。其具体判断条件为:

    1. 当前价格高于20天均线
    2. 三个连续的阳线,其中每个阳线的实体部分都大于前一个阳线的实体部分
    3. 成交量逐步增加

    下面的代码展示如何使用backtrader构建一个红三兵策略,并在AAPL历史数据上运行回测。

    import backtrader as bt
    import datetime
    
    class RedThreeSoldiers(bt.Strategy):
        params = (
            ('maperiod', 20),
            ('printlog', False),
        )
    
        def __init__(self):
            self.data_close = self.datas[0].close
            self.data_open = self.datas[0].open
            self.data_volume = self.datas[0].volume
            self.data_high = self.datas[0].high
            self.data_low = self.datas[0].low
    
            self.order = None
            self.highest = self.data.high(-1)
            self.second_high = self.data.high(-2)
            self.lowest = self.data.low(-1)
            self.second_low = self.data.low(-2)
            self.moving_average = bt.indicators.SimpleMovingAverage(
                self.data_close, period=self.params.maperiod
            )
    
        def next(self):
            if not self.position:
                # 价格高于20天均线
                if self.data_close[0] > self.moving_average[0]:
                    # 三个连续的阳线
                    if self.data_close[0] > self.data_open[-1] \
                            and self.data_close[-1] > self.data_open[-2] \
                            and self.data_close[-2] > self.data_open[-3]:
                        # 每个阳线的实体部分都大于前一个阳线的实体部分
                        if self.data_close[-1] > self.data_close[-2] \
                                and self.data_close[-2] > self.data_close[-3]:
                            # 成交量逐步增加
                            if self.data_volume[-1] > self.data_volume[-2] > self.data_volume[-3]:
                                self.buy()
    
            if self.position:
                if self.data_close[0] < self.highest:
                    self.sell()
                else:
                    self.highest = self.data_close[0]
                    if self.data_close[0] < self.second_high:
                        self.sell()
                    else:
                        self.second_high = self.data_close[0]
    
            if len(self) > 5 and self.position:
                if self.data_close[0] < self.lowest:
                    self.sell()
                else:
                    self.lowest = self.data_close[0]
                    if self.data_close[0] < self.second_low:
                        self.sell()
                    else:
                        self.second_low = self.data_close[0]
    
    if __name__ == '__main__':
        cerebro = bt.Cerebro()
        data = bt.feeds.YahooFinanceData(
            dataname='AAPL',
            fromdate=datetime.datetime(2010, 1, 1),
            todate=datetime.datetime(2019, 12, 31),
        )
    
        cerebro.addsizer(bt.sizers.PercentSizer, percents=95)
        cerebro.addstrategy(RedThreeSoldiers)
        cerebro.adddata(data)
        cerebro.broker.setcash(1000000.0)
        print('Starting Portfolio Value: %.2f' % cerebro.broker.getvalue())
        cerebro.run()
        print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())
    

    上面的代码中,使用了backtrader中的各种内置指标和方法来实现红三兵策略的逻辑。同时,也可以看到backtrader提供了很好的扩展性和灵活性,可以根据自己的需求进行自定义的操作。运行这段代码可以得到回测结果,并根据回测结果进行可行性的判断。

  5. User

    只要绿三兵与红三兵,不要均线与成交量

  6. Assistant

    好的,下面举一个不使用均线和成交量,仅使用绿三兵和红三兵的例子。

    首先,我们先来了解一下绿三兵和红三兵:

    • 绿三兵:在一段上升趋势中,出现三个连续相似的阴线,且每日收盘价都在上日的收盘价之下。这种形态表明多头力量正在下降,价格可能会进一步下跌。

    • 红三兵:在一段下跌趋势中,出现三个连续相似的阳线,且每日收盘价都在上日的收盘价之上。这种形态表明多头力量正在增强,价格可能会进一步上涨。

    下面的代码展示如何使用backtrader构建一个不使用均线和成交量,仅使用绿三兵和红三兵的策略。

    import backtrader as bt
    import datetime
    
    class ThreeSoldiers(bt.Strategy):
        def __init__(self):
            self.highest_price = -1
    
        def next(self):
            # 记录前两根K线的收盘价格
            c1 = self.data.close[-3]
            c2 = self.data.close[-2]
            c3 = self.data.close[-1]
            # 记录前两根K线的开盘价格
            o1 = self.data.open[-3]
            o2 = self.data.open[-2]
            o3 = self.data.open[-1]
    
            # 红三兵:每天的收盘价都在上日的收盘价之上,o3>c3>o2>c2>o1>c1
            if c3 > c2 > c1 and o3 > c2 and o2 > c1 and o3 > o2 and o2 > o1:
                if self.highest_price < c3:
                    self.highest_price = c3
                else:
                    self.buy()
    
            # 绿三兵:每天的收盘价都在上日的收盘价之下,o3<c3<o2<c2<o1<c1
            elif c1 > c2 > c3 and o1 < c2 and o2 < c1 and o2 < o1 and o3 < o2:
                if c3 > self.highest_price and self.position:
                    self.sell()
                elif not self.position:
                    self.sell()
    

    在上述代码中,我们通过判断前三天的K线收盘价和开盘价的大小关系,来判断该日是否出现了红三兵或绿三兵形态。

    当我们遇到了绿三兵形态时,如果当前持仓,我们就会按照当前最高价格进行卖出操作。如果没有持仓,我们会进行卖出操作。

    当我们遇到了红三兵形态,当当前价格高于之前的最高价格时,我们会进行买入操作。

    最后,我们只需要通过backtrader加载历史行情数据,并将策略添加到回测引擎中即可。

    data = bt.feeds.YahooFinanceData(
        dataname='AAPL',
        fromdate=datetime.datetime(2010, 1, 1),
        todate=datetime.datetime(2019, 12, 31),
    )
    
    cerebro = bt.Cerebro()
    cerebro.addstrategy(ThreeSoldiers)
    cerebro.adddata(data)
    cerebro.broker.setcash(1000000.0)
    print('Starting Portfolio Value: %.2f' % cerebro.broker.getvalue())
    cerebro.run()
    print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())
    
  7. User

    c1 = self.data.close[-3]

  8. Assistant

    这一行代码是获取当前K线的前三个收盘价中的第一个收盘价,也就是倒数第三个K线的收盘价。

    c1 = self.data.close[-3]
    

    其中 self.data 表示当前数据,self.data.close 表示当前数据中的收盘价,[-3] 表示取收盘价序列中的倒数第三个元素(也就是前三个K线的最早一个收盘价)。

  9. User

    c1 = self.data.close[0]

  10. Assistant

    c1 = self.data.close[0] 这一行代码是获取当前K线的收盘价,也就是收盘价序列中的最后一个元素,即当前时刻的收盘价。

    其中 self.data 表示当前数据,self.data.close 表示当前数据中的收盘价,[0] 表示取收盘价序列中的最后一个元素(也就是当前时刻的收盘价)。

  11. User

    red_three_soldiers = all([ closes[-3] < opens[-3], # Day 1 bullish closes[-2] < opens[-2], # Day 2 bullish closes[-1] < opens[-1], # Day 3 bullish lows[-3] < lows[-2] < lows[-1], # Prices ascending highs[-3] < highs[-2] < highs[-1] # High prices ascending ])

  12. Assistant

    这是一个判断是否出现红三兵形态的代码段,它使用Python中的all()函数来判断列表中的所有元素是否都是True。具体地,这段代码使用了收盘价、开盘价、最高价、最低价等数据展开如下:

    closes = self.data.close.get(size=3)           # 最近3个交易日的收盘价
    opens = self.data.open.get(size=3)             # 最近3个交易日的开盘价
    highs = self.data.high.get(size=3)             # 最近3个交易日的最高价
    lows = self.data.low.get(size=3)               # 最近3个交易日的最低价
    
    red_three_soldiers = all([
        closes[-3] < opens[-3],                     # Day 1 bullish
        closes[-2] < opens[-2],                     # Day 2 bullish
        closes[-1] < opens[-1],                     # Day 3 bullish
        lows[-3] < lows[-2] < lows[-1],              # Prices ascending
        highs[-3] < highs[-2] < highs[-1]            # High prices ascending
    ])
    

    具体地,上面的代码会获取最近三个交易日的收盘价、开盘价、最高价和最低价,然后判断当前时刻是否出现了红三兵形态,即:

    1. 前三个交易日的收盘价都低于开盘价(表示三个阴线),即 closes[-3] < opens[-3] and closes[-2] < opens[-2] and closes[-1] < opens[-1]
    2. 前三个交易日的最低价组成一个递增的序列(表示逐步上升),即 lows[-3] < lows[-2] < lows[-1]
    3. 前三个交易日的最高价组成一个递增的序列(表示高价逐步上升),即 highs[-3] < highs[-2] < highs[-1]

    如果以上三个条件都满足,则说明当前时刻出现红三兵形态。最后,通过使用all()函数将以上条件的布尔值结果组合起来,得到了最终的判断结果。

  13. User

    self.current_order = self.buy()

  14. Assistant

    self.current_order = self.buy() 这行代码表示在当前价格下单买入,并将该买入订单对象存储在了self.current_order变量中,以便后续需要使用时进行查询或关闭该订单。

    在backtrader中,使用self.buy()来下单买入,self.sell()来下单卖出,这两个函数都会返回一个订单对象,具体的订单信息(如开单价格、成交价格、成交量等)可以通过查询该订单对象来获取。同时,backtrader也提供了self.cancel()函数来取消一个订单,self.close()函数来关闭当前仓位。

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