第四章 规则策略--双底策略

一、概述

双底交易系统是一种基于技术分析的交易策略，它主要依赖于股票价格在特定时期内形成两个底部形态的现象。以下是对双底交易系统的详细讲解：

基本原理

双底形态，也称为“W底”，是股票价格走势中的一种常见形态。它表示在一段时间内，股票价格两次下跌到相近的低位，然后开始反弹。这种形态通常发生在股票价格经势转向的时候，即从一个下跌趋势转向上升趋势。

策略

在双底交易系统中，投资者会在第二个底部形成后买入股票。这是因为在双底形态中，第二个底部通常比第一个底部高，这表明市场的买盘力量正在增强，股票价格有可能反弹。

优点

1. 明确性：双底形态一旦形成，通常是一个强烈的买入信号，这为投资者提供了明确的交易方向。

2. 可靠性：双底形态是市场价格行为的一部分，它反映了市场供需关系的变化，因此具有较高的可靠性。

风险

虽然双底交易系统有其优点，但也存在一定的风险。例如，如果市场趋势并未如预期那样转变，投资者可能会面临损失。因此，在使用双底交易系统时，投资者应该结合其他技术指标和市场信息，以更准确地判断市场走势。

总的来说，双底交易系统是一种基于股票价格形态的交易策略，它可以帮助投资者在市场趋势转变时把握机会。然而，像所有的交易策略一样，它并不能保证每次交易都能盈利，投资者在使用时应充分理解其原理，并结合实际情况灵活运用。

二、代码

利用状态机规则可以实现股票众多形态，确定交易点位，是非常好的实现思路。

• 构建双底形态数据

def double_bottom_strategy(self, stock_list, convert_num, break_num, result_dict):
    # 确定首行位置信息
    bef_status, bef_record = self.getFirstRecord(stock_list, convert_num, break_num, result_dict)
    # 确定剩余行位置
    for i in range(len(stock_list)):
        index = i
        row = stock_list[i] # dt,close,open,hight,low
        if index <= bef_record.index:  # 首行位置，不需要记录
            continue
        self.create_empty_record(index, row, result_dict)  # 创建空记录
        if bef_status == Constants.upward:  # 判断 前一个状态为上升情况
            bef_status, bef_record = self.upward(bef_status, bef_record, index, row,
                                                 convert_num, break_num, result_dict)
        elif bef_status == Constants.downward:  # 判断 前一个状态为下降情况
            bef_status, bef_record = self.downward(bef_status, bef_record, index, row,
                                                   convert_num, break_num, result_dict)
        elif bef_status == Constants.double_bottom_upward: # 判断 当前一个状态为双底回升情况
            bef_status, bef_record = self.double_bottom_upward(bef_status, bef_record, index, row,
                                                               convert_num, break_num, result_dict)

• 上升逻辑判断

def upward(self, bef_status, bef_record, index, row, convert_num, break_num, result_dict):
    cur_close = row[1]
    if bef_record.upward is None:
        raise RuntimeError('cal upward is None.')
    # 继续上升的情况
    if cur_close > bef_record.upward:
        bef_status = Constants.upward
        bef_record = self.create_upward(bef_status, index, row, result_dict) # 状态不转移，为上升
        return bef_status, bef_record
    # 回撤-6个点的情况
    gap = ((cur_close - bef_record.upward) / bef_record.upward) * 100
    if gap <= convert_num * -1:
        bef_record.color = Constants.black
        result_dict[bef_record.dt] = bef_record
        bef_status = Constants.downward
        bef_record = self.create_downward(bef_status, index, row, result_dict)
    return bef_status, bef_record

• 下降逻辑判断

def download(self, bef_status, bef_record, index, row, convert_num, break_num, result_dict):
    cur_close = round(row[1], 2)
    if bef_record.downward is None:
        raise RuntimeError('calDownward downward is None.')
    # 继续下降的情况
    if cur_close < bef_record.downward:
        bef_status = Constants.downward  # 状态不转移，为下降
        bef_record = self.create_downward(bef_status, index, row, result_dict)
        return bef_status, bef_record
    # 回升6个点的情况
    gap = ((cur_close - bef_record.downward) / bef_record.downward) * 100
    if gap >= convert_num:
        bef_record.color = Constants.black  # 建立黑色关键点，且状态转移到自然回升
        result_dict[bef_record.dt] = bef_record
        bef_status = Constants.upward
        bef_record = self.create_upward(bef_status, index, row, result_dict) # 状态转移，为上升
        node_list = self.get_near_node(index, result_dict, 3) # 获得临近3个节点
        if len(node_list) == 3:
            db_gap = (node_list[0].close - node_list[2].close) / node_list[2].close * 100 # 双底价格差
            if db_gap > 0 and db_gap < 1: #双底价格>0，<1
                bef_status = Constants.double_bottom_upward
                bef_record = self.create_db_upward(bef_status, index, row, result_dict) # 状态转移，为双底回升
    # 回升小于6个点的情况
    elif gap >= break_num and gap < convert_num:
        node_list = self.get_near_node(index, result_dict, 2) # 获得临近2个节点
        if len(node_list) == 2:
            db_gap = (bef_record.close - node_list[1].close)/node_list[1].close * 100
            if db_gap > 0 and db_gap < break_num:
                bef_status = Constants.double_bottom_upward
                bef_record = self.create_db_upward(bef_status, index, row, result_dict) # 状态转移，为双底回升
    return bef_status, bef_record

1. 双底回升逻辑实现

def double_bottom_upward(self, bef_status, bef_record, index, row, convert_num, break_num, result_dict):
    cur_close = round(row[1], 2)
    if bef_record.double_bottom_upward is None:
        raise RuntimeError('cal double_bottom_upward is None.')
    # 判断 继续回升的情况
    if cur_close > bef_record.double_bottom_upward:
        node_list = self.get_near_node(index, result_dict, 2)  # 获得临近节点
        if len(node_list) == 2:
            if cur_close > node_list[1].upward:  # 判断当前价格高于前1个node
                bef_status = Constants.upward
                bef_record = self.create_upward(bef_status, index, row, result_dict)
            else:
                bef_status = Constants.double_bottom_upward
                bef_record = self.create_db_upward(bef_status, index, row, result_dict)
        else:  # 临近没有节点，状态延续
            bef_status = Constants.double_bottom_upward
            bef_record = self.double_bottom_upward(bef_status, index, row, result_dict)
        return bef_status, bef_record
    # 判断 回撤-6个点的情况
    gap = ((cur_close - bef_record.double_bottom_upward) / bef_record.double_bottom_upward) * 100
    if gap <= convert_num * -1:
        bef_status = Constants.downward
        bef_record = self.create_downward(bef_status, index, row, result_dict)
    return bef_status, bef_record

• 当首次处于双底状态时的点，即是买入点，如图：