Ta-Lib源码解析（三）：蜡烛图指标 (Candlestick Indicator) #（附Python重构代码和示意图）（补充中）

最新推荐文章于 2023-12-06 07:21:23 发布
最新推荐文章于 2023-12-06 07:21:23 发布
阅读量2k 收藏 9
点赞数 3
分类专栏： 技术分析 量化相关 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43420026/article/details/126743440
版权

TA_Lib指标目录

3.（蜡烛图指标）Candlestick Indicator

蜡烛图指标为识别K线形态的指标，笔者认为重点在于定义方式所提供的思路，背后的投资逻辑可以借鉴但不建议直接参考

文档的翻译内容和源码逻辑存在不一致的现象，笔者分别列出中文百科中的定义和源码实际逻辑，供大家参考

一. 前言

技术分析理论中的一些模糊词，ta-lib中给出了精确的定义

源码
见 ta_global.c

TA_RetCode TA_RestoreCandleDefaultSettings( TA_CandleSettingType settingType )
{
    const TA_CandleSetting TA_CandleDefaultSettings[] = {
        /* real body is long when it's longer than the average of the 10 previous candles' real body */
        { TA_BodyLong, TA_RangeType_RealBody, 10, 1.0 },
        /* real body is very long when it's longer than 3 times the average of the 10 previous candles' real body */
        { TA_BodyVeryLong, TA_RangeType_RealBody, 10, 3.0 },
        /* real body is short when it's shorter than the average of the 10 previous candles' real bodies */
        { TA_BodyShort, TA_RangeType_RealBody, 10, 1.0 },
        /* real body is like doji's body when it's shorter than 10% the average of the 10 previous candles' high-low range */
        { TA_BodyDoji, TA_RangeType_HighLow, 10, 0.1 },
        /* shadow is long when it's longer than the real body */
        { TA_ShadowLong, TA_RangeType_RealBody, 0, 1.0 },
        /* shadow is very long when it's longer than 2 times the real body */
        { TA_ShadowVeryLong, TA_RangeType_RealBody, 0, 2.0 },
        /* shadow is short when it's shorter than half the average of the 10 previous candles' sum of shadows */
        { TA_ShadowShort, TA_RangeType_Shadows, 10, 1.0 },
        /* shadow is very short when it's shorter than 10% the average of the 10 previous candles' high-low range */
        { TA_ShadowVeryShort, TA_RangeType_HighLow, 10, 0.1 },
        /* when measuring distance between parts of candles or width of gaps */
        /* "near" means "<= 20% of the average of the 5 previous candles' high-low range" */
        { TA_Near, TA_RangeType_HighLow, 5, 0.2 },
        /* when measuring distance between parts of candles or width of gaps */
        /* "far" means ">= 60% of the average of the 5 previous candles' high-low range" */
        { TA_Far, TA_RangeType_HighLow, 5, 0.6 },
        /* when measuring distance between parts of candles or width of gaps */
        /* "equal" means "<= 5% of the average of the 5 previous candles' high-low range" */
        { TA_Equal, TA_RangeType_HighLow, 5, 0.05 }
    };

    int i;
    if( settingType > TA_AllCandleSettings )
        return TA_BAD_PARAM;
    if( settingType == TA_AllCandleSettings )
        for( i = 0; i < TA_AllCandleSettings; ++i )
            TA_Globals->candleSettings[i] = TA_CandleDefaultSettings[i];
    else
        TA_Globals->candleSettings[settingType] = TA_CandleDefaultSettings[settingType];
    return TA_SUCCESS;
}

翻译

TA_BodyLong： 当期蜡烛体长度超过过去十日蜡烛体长度的平均值
TA_ShadowVeryLong： 当期蜡烛体长度超过过去十日蜡烛体长度的平均值的三倍
TA_BodyShort： 当期蜡烛体长度低于过去十日蜡烛体长度的平均值
TA_BodyDoji： 蜡烛体类似于十字线，短于过去十日蜡烛体长度的平均值的10%
TA_ShadowLong： 当期影线长度长于蜡烛体长度
TA_ShadowVeryLong： 当期影线长度长于蜡烛体长度两倍
TA_ShadowShort： 当期影线短于前十期影线长度平均值的一半
TA_ShadowVeryShort： 当期影线短于前十期high-low长度平均值的10%
TA_Near： 小于前五期20%的high-low长度平均值
TA_Far： 大于前五期60%的high-low长度平均值
TA_Equal： 小于前五期5%的high-low长度平均值

二. 单K线模型

CDLBELTHOLD（捉腰带线）

python函数原型：

cdlbelthold= CDL2BELTHOLD(open, high, low, close)

解释：

看涨为例，其开市价位于当日的最低点，然后市场一路上扬。

在这里插入图片描述
重构代码（来自ta_CDLBELTHOLD.c， 有修改， 只保留逻辑）：

def CDLBELTHOLD_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 11:
        high_low_range = high - low
        shadow_very_short = high_low_range.rolling(10).mean().shift(1) * 0.1
        real_body = abs(open - close)
        body_long = real_body.rolling(10).mean().shift(1)
        shadow_upper = high - np.maximum(close, open)
        shadow_lower = np.minimum(close, open) - low
        condition_1 = real_body > body_long
        condition_2_1 = (close > open) & (shadow_lower < shadow_very_short)
        condition_2_2 = (close < open) & (shadow_upper < shadow_very_short)
        cdlbelthold = np.where(condition_1 & condition_2_1, 100, 0)
        cdlbelthold = np.where(condition_1 & condition_2_2, -100, cdlbelthold)
    else:
        cdlbelthold = np.zeros(_len).astype(int)
    return cdlbelthold

CDLCLOSINGMARUBOZU （收盘缺影线）

python函数原型：

cdlclosingmarubozu= CDLCLOSINGMARUBOZU(open, high, low, close)

解释：

中文百科：一日K线模式，以阳线为例，最低价低于开盘价，收盘价等于最高价， 预示着趋势持续。
源码与抓腰带线几乎相同

在这里插入图片描述
重构代码（来自ta_CDLBELTHOLD.c， 与BELTHOLD极其相似应该直接复制粘贴该条件）：

def CDLCLOSINGMARUBOZU_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 11:
        high_low_range = high - low
        shadow_very_short = high_low_range.rolling(10).mean().shift(1) * 0.1
        real_body = abs(open - close)
        body_long = real_body.rolling(10).mean().shift(1)
        shadow_upper = high - np.maximum(close, open)
        shadow_lower = np.minimum(close, open) - low
        condition_1 = real_body > body_long
        condition_2_1 = (close > open) & (shadow_upper < shadow_very_short)
        condition_2_2 = (close < open) & (shadow_lower < shadow_very_short)
        cdlclosingmarubozu = np.where(condition_1 & condition_2_1, 100, 0)
        cdlclosingmarubozu = np.where(condition_1 & condition_2_2, -100, cdlclosingmarubozu)
    else:
        cdlclosingmarubozu = np.zeros(_len).astype(int)
    return cdlclosingmarubozu

CDLDOJI（doji十字）

python函数原型：

cdldoji = CDLDOJI(open, high, low, close)

解释：

单k线模型，十字线

在这里插入图片描述
重构代码（来自ta_CDLDOJI.c， 有修改， 只保留逻辑）：

def CDLDOJI_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 11:
        real_body = abs(open - close)
        high_low_range = abs(high - low)
        doji = high_low_range.rolling(10).mean().shift(1) * 0.1
        condition = real_body < doji
        cdldoji = np.where(condition, 100, 0)
    else:
        cdldoji = np.zeros(_len).astype(int)
    return cdldoji

CDLDRAGONFLYDOJI （蜻蜓十字）

python函数原型：

cdldragonflydoji= CDLDRAGONFLYDOJI (open, high, low, close)

解释：

单k线模型，T字线

在这里插入图片描述

重构代码（来自ta_CDLDRAGONFLYDOJI.c， 有修改， 只保留逻辑）：

def CDLDRAGONFLYDOJI_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 11:
        real_body = abs(open - close)
        high_low_range = abs(high - low)
        shadow_upper = high - np.maximum(close, open)
        shadow_lower = np.minimum(close, open) - low
        shadow_very_short = high_low_range.rolling(10).mean().shift(1) * 0.1
        doji = high_low_range.rolling(10).mean().shift(1) * 0.1
        condition = (real_body < doji) & (shadow_upper < shadow_very_short) & (shadow_lower > shadow_very_short)
        cdldragonflydoji = np.where(condition, 100, 0)
    else:
        cdldragonflydoji = np.zeros(_len).astype(int)
    return cdldragonflydoji

CDLGRAVESTONEDOJI （墓碑十字）

python函数原型：

cdlgravestonedoji = CDLGRAVESTONEDOJI(open, high, low, close)

解释：

单k线模型，倒T字线

在这里插入图片描述
重构代码（来自ta_CDLGRAVESTONEDOJI.c， 有修改， 只保留逻辑）：

def CDLGRAVESTONEDOJI_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 11:
        real_body = abs(open - close)
        high_low_range = abs(high - low)
        shadow_upper = high - np.maximum(close, open)
        shadow_lower = np.minimum(close, open) - low
        shadow_very_short = high_low_range.rolling(10).mean().shift(1) * 0.1
        doji = high_low_range.rolling(10).mean().shift(1) * 0.1
        condition = (real_body < doji) & (shadow_upper > shadow_very_short) & (shadow_lower < shadow_very_short)
        cdlgravestonedoji = np.where(condition, 100, 0)
    else:
        cdlgravestonedoji = np.zeros(_len).astype(int)
    return cdlgravestonedoji

三. 双K线模型

CDLCOUNTERATTACK （反击线）

python函数原型：

cdlcounterattack = CDLCOUNTERATTACK(open, high, low, close)

解释：

双k线模型，一大阴一大阳，且收盘价接近，
延续第二根K线地行情

在这里插入图片描述
重构代码（来自ta_CDLCOUNTERATTACK.c， 有修改， 只保留逻辑）：

def CDLCOUNTERATTACK_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 12:
        real_body = abs(open - close)
        high_low_range = abs(high - low)
        equal = high_low_range.rolling(5).mean().shift(1) * 0.05
        body_long = real_body.rolling(10).mean().shift(1)
        condition_1_1 = (close.shift(1) > open.shift(1)) & \
                        (close < open)
        condition_1_2 = (close.shift(1) < open.shift(1)) & \
                        (close > open)
        condition_2 = (real_body.shift(1) > body_long.shift(1)) & \
                      (real_body > body_long) & \
                      (close <= close.shift(1) + equal.shift(1)) & \
                      (close >= close.shift(1) - equal.shift(1))

        cdlcounterattack = np.where(condition_1_1 & condition_2, -100, 0)
        cdlcounterattack = np.where(condition_1_2 & condition_2, 100, cdlcounterattack)
    else:
        cdlcounterattack = np.zeros(_len).astype(int)
    return cdlcounterattack

CDLDARKCLOUDCOVER（乌云压顶）

python函数原型：

cdldarkcloudcover = CDLDARKCLOUDCOVER(open, high, low, close, penetration=0.5)

解释：

双k线模型，第一根大阳
第二根阴线开盘高于前一日最高
收盘再前一日实体下半部分
见顶信号

在这里插入图片描述

重构代码（来自ta_CDLDARKCLOUDCOVER.c， 有修改， 只保留逻辑）：

def CDLDARKCLOUDCOVER_(open, high, low, close, penetration=0.5):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 12:
        real_body = abs(open - close)
        high_low_range = abs(high - low)
        equal = high_low_range.rolling(5).mean().shift(1) * 0.05
        body_long = real_body.rolling(10).mean().shift(1)
        condition_1 = (close.shift(1) > open.shift(1)) & \
                      (real_body.shift(1) > body_long.shift(1))
        condition_2 = (close < open) & \
                      (open > high.shift(1)) & \
                      (close > open.shift(1)) & \
                      (close < close.shift(1) - real_body.shift(1) * penetration)
        cdldarkcloudcover = np.where(condition_1 & condition_2, -100, 0)
    else:
        cdldarkcloudcover = np.zeros(_len).astype(int)
    return cdldarkcloudcover

CDLDOJISTAR（十字星）

python函数原型：

cdldojistar = CDLDOJISTAR(open, high, low, close)

解释：

双k线模型，第一根大阴或者大阳
第二根高开or低开，十字星
反转信号

在这里插入图片描述

重构代码（来自ta_CDLDOJISTAR.c， 有修改， 只保留逻辑）：

def CDLDOJISTAR_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 12:
        real_body = abs(open - close)
        high_low_range = abs(high - low)
        doji = high_low_range.rolling(10).mean().shift(1) * 0.1
        body_long = real_body.rolling(10).mean().shift(1)
        condition_1_1 = (close.shift(1) > open.shift(1)) & \
                        (np.maximum(close, open) > close.shift(1))
        condition_1_2 = (close.shift(1) < open.shift(1)) & \
                        (np.minimum(close, open) < close.shift(1))
        condition_2 = (real_body.shift(1) > body_long.shift(1)) & \
                      (real_body <= doji)
        cdldojistar = np.where(condition_1_1 & condition_2, -100, 0)
        cdldojistar = np.where(condition_1_2 & condition_2, 100, cdldojistar)
    else:
        cdldojistar = np.zeros(_len).astype(int)
    return cdldojistar

CDLENGULFING （吞噬模式）

python函数原型：

cdlengulfing= CDLENGULFING(open, high, low, close)

解释：

两日K线模式，分多头吞噬和空头吞噬，以多头吞噬为例，第一日为阴线， 第二日阳线，第一日的开盘价和收盘价在第二日开盘价收盘价之内，但不能完全相同。

在这里插入图片描述

重构代码（来自ta_CDLENGULFING.c， 有修改， 只保留逻辑）：

def CDLENGULFING_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 12:
        condition_1 = (close.shift(1) < open.shift(1)) & (close > open) & \
                      (close > open.shift(1)) & (open < close.shift(1))
        condition_2 = (close.shift(1) > open.shift(1)) & (close < open) & \
                      (close < open.shift(1)) & (open > close.shift(1))
        cdlengulfing = np.where(condition_1, 100, 0)
        cdlengulfing = np.where(condition_2, -100, cdlengulfing)
    else:
        cdlengulfing = np.zeros(_len).astype(int)
    return cdlengulfing

CDLHAMMER（锤头）

python函数原型：

cdlhammer = CDLHAMMER(open, high, low, close)

解释：

两日K线模式，第二日为长下影短上影的短实体，且实体下沿低于前一日最低价（Near）

重构代码（来自ta_CDLHAMMER.c， 有修改， 只保留逻辑）：

def CDLHAMMER_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 12:
        condition_1 = (close.shift(1) < open.shift(1)) & (close > open) & \
                      (close > open.shift(1)) & (open < close.shift(1))
        condition_2 = (close.shift(1) > open.shift(1)) & (close < open) & \
                      (close < open.shift(1)) & (open > close.shift(1))
        cdlengulfing = np.where(condition_1, 100, 0)
        cdlengulfing = np.where(condition_2, -100, cdlengulfing)
    else:
        cdlengulfing = np.zeros(_len).astype(int)
    return cdlengulfing

四. 三K线模型

CDL2CROW（双乌鸦）

python函数原型：

cdl2crows= CDL2CROWS(open, high, low, close)

解释：

对于双乌鸦形状的定义，中文百科和ta-lib中定义的方式不一样，

中文百科中第一天长阳线后，第二天高开收阴, 形成缺口，第三天的大阴线包裹住第二天的阴线

ta-lib中第一根和第二跟定义相同，第三跟阴线开盘价再第二根阴线开收之间，收盘价再第一根阳线开收之间

在这里插入图片描述

投资逻辑（仅供参考，不宜借鉴）：按照主散博弈模型，主力推高出大阳线吸引散户关注，高开吸引散户进场，主力出货一部分，再次高开吸引散户进场，主力在次出货

第一根长阳线：
O P E N − 2 − C L O S E − 2 > A V G ( ∣ O P E N − C L O S E ∣ ) OPEN_{-2}-CLOSE_{-2} > AVG(|OPEN-CLOSE|) OPEN−2​−CLOSE−2​>AVG(∣OPEN−CLOSE∣)
第二根阴线：
O P E N − 1 > C L O S E − 1 > C L O S E − 2 OPEN_{-1} > CLOSE_{-1} > CLOSE_{-2} OPEN−1​>CLOSE−1​>CLOSE−2​
第三根阴线：
O P E N − 1 < O P E N 0 < C L O S E − 2 OPEN_{-1} < OPEN_{0} < CLOSE_{-2} OPEN−1​<OPEN0​<CLOSE−2​

重构代码（来自ta_CDL2CROW.c， 有修改， 只保留逻辑）：

def CDL2CROWS_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 13:
        real_body = abs(open - close)
        body_long = real_body.rolling(10).mean().shift(1)
        # 第一根大阳线
        condition1 = (close.shift(2) - open.shift(2)) > body_long.shift(2)
        # 第二根阴线
        condition2 = (open.shift(1) > close.shift(1)) & (close.shift(1) > close.shift(2))
        # 第三根阴线
        condition3 = (open.shift(1) > open) & (open > close.shift(1)) & \
                     (close.shift(2) > close) & (close > open.shift(2))
        cdl2crow = np.where(condition1 & condition2 & condition3, -100, 0)
        cdl2crow[:12] = 0
    else:
        cdl2crow = np.zeros(_len).astype(int)
    return cdl2crow

CDL3BLACKCROW（三乌鸦）

python函数原型：

cdl3blackcrows= CDL3BLACKCROWS(open, high, low, close)

解释：

（1）连续三天长阴线。（ta-lib无此要求）
（2）每天的收盘出现新低。
（3）每天的开盘在前一天的实体内。
（4）每天的收盘等于或接近当天的最低。
（5）第一根阴线跌破前阳线最高点（ta-lib特有要求）

在这里插入图片描述

第一根阳线：
O P E N − 3 − C L O S E − 3 > 0 OPEN_{-3}-CLOSE_{-3} > 0 OPEN−3​−CLOSE−3​>0
第一根阴线：
O P E N − 2 > C L O S E − 2 C L O S E − 2 < H I G H − 3 C L O S E − 2 − L O W − 2 < A V G ( C L O S E − L O W ) − 2 OPEN_{-2} > CLOSE_{-2} \\ CLOSE_{-2} < HIGH_{-3} \\ CLOSE_{-2} - LOW_{-2} < AVG(CLOSE-LOW)_{-2} OPEN−2​>CLOSE−2​CLOSE−2​<HIGH−3​CLOSE−2​−LOW−2​<AVG(CLOSE−LOW)−2​
第二根阴线：
O P E N − 1 > C L O S E − 1 C L O S E − 1 < C L O S E − 2 C L O S E − 1 − L O W − 1 < A V G ( C L O S E − L O W ) − 1 OPEN_{-1} > CLOSE_{-1} \\ CLOSE_{-1} < CLOSE_{-2} \\ CLOSE_{-1} - LOW_{-1} < AVG(CLOSE-LOW)_{-1} OPEN−1​>CLOSE−1​CLOSE−1​<CLOSE−2​CLOSE−1​−LOW−1​<AVG(CLOSE−LOW)−1​
第三根阴线：
O P E N 0 > C L O S E 0 C L O S E 0 < C L O S E − 1 C L O S E 0 − L O W 0 < A V G ( C L O S E − L O W ) 0 OPEN_{0} > CLOSE_{0} \\ CLOSE_{0} < CLOSE_{-1} \\ CLOSE_{0} - LOW_{0} < AVG(CLOSE-LOW)_{0} OPEN0​>CLOSE0​CLOSE0​<CLOSE−1​CLOSE0​−LOW0​<AVG(CLOSE−LOW)0​

重构代码（来自ta_CDL3BLACKCROWS.c， 有修改， 只保留逻辑）：

def CDL3BLACKCROWS_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 14:
        shadow_lower = np.minimum(close, open) - low
        high_low_range = abs(high - low)
        shadow_very_short = high_low_range.rolling(10).mean().shift(1) * 0.1
        # 第一根阳线
        condition1 = (close.shift(3) - open.shift(3)) > 0
        # 第一根阴线
        condition2 = (open.shift(2) > close.shift(2)) & \
                     (close.shift(2) < high.shift(3)) & \
                     (shadow_lower.shift(2) < shadow_very_short.shift(2))
        # 第二根阴线
        condition3 = (open.shift(1) > close.shift(1)) & \
                     (close.shift(1) < close.shift(2)) & \
                     (shadow_lower.shift(1) < shadow_very_short.shift(1))
        # 第三根阴线
        condition4 = (open > close) & \
                     (close < close.shift(1)) & \
                     (shadow_lower < shadow_very_short)
        cdl3blackcrows = np.where(condition1 & condition2 & condition3 & condition4, -100, 0)
        cdl3blackcrows[:13] = 0
    else:
        cdl3blackcrows = int(np.zeros(_len))
    return cdl3blackcrows

CDL3INSIDE（三内部上涨和下跌）

python函数原型：

cdl2inside = CDL3INSIDE(open, high, low, close)

解释：

  1. 母子信号是该信号的主要组成部分。第一天包裹第二天
  2. 母蜡烛的颜色应当与长蜡烛日的颜色相反。
  3. 如果趋势表明为上涨，则第三天的收盘价高于第一天的开盘价；否则，第三天的收盘价会低于第一天的开盘价。

以下四种情况皆会产生信号（四种情况，一二涨，三四跌）
三内部下跌

三内部下跌
在这里插入图片描述
在这里插入图片描述

三内部上涨

第一根阴线：
O P E N − 2 − C L O S E − 2 > A V G ( ∣ O P E N − C L O S E ∣ ) OPEN_{-2}-CLOSE_{-2} > AVG(|OPEN-CLOSE|) OPEN−2​−CLOSE−2​>AVG(∣OPEN−CLOSE∣)
第二根线：
∣ O P E N − 1 − C L O S E − 1 ∣ < A V G ( ∣ O P E N − C L O S E ∣ ) m a x ( O P E N − 1 , C L O S E − 1 ) < O P E N − 2 m i n ( O P E N − 1 , C L O S E − 1 ) > C L O S E − 2 |OPEN_{-1} - CLOSE_{-1}| < AVG(|OPEN-CLOSE|) \\ max(OPEN_{-1}, CLOSE_{-1}) < OPEN_{-2} \\ min(OPEN_{-1}, CLOSE_{-1}) > CLOSE_{-2} \\ ∣OPEN−1​−CLOSE−1​∣<AVG(∣OPEN−CLOSE∣)max(OPEN−1​,CLOSE−1​)<OPEN−2​min(OPEN−1​,CLOSE−1​)>CLOSE−2​
第三根阳线：
O P E N < C L O S E C L O S E > O P E N − 2 OPEN < CLOSE \\ CLOSE > OPEN_{-2} \\ OPEN<CLOSECLOSE>OPEN−2​

三内部下跌

第一根阳线：
C L O S E − 2 − O P E N − 2 > A V G ( ∣ O P E N − C L O S E ∣ ) CLOSE_{-2}-OPEN_{-2} > AVG(|OPEN-CLOSE|) CLOSE−2​−OPEN−2​>AVG(∣OPEN−CLOSE∣)
第二根线：
∣ O P E N − 1 − C L O S E − 1 ∣ < A V G ( ∣ O P E N − C L O S E ∣ ) m a x ( O P E N − 1 , C L O S E − 1 ) < C L O S E − 2 m i n ( O P E N − 1 , C L O S E − 1 ) > O P E N − 2 |OPEN_{-1} - CLOSE_{-1}| < AVG(|OPEN-CLOSE|) \\ max(OPEN_{-1}, CLOSE_{-1}) < CLOSE_{-2} \\ min(OPEN_{-1}, CLOSE_{-1}) > OPEN_{-2} \\ ∣OPEN−1​−CLOSE−1​∣<AVG(∣OPEN−CLOSE∣)max(OPEN−1​,CLOSE−1​)<CLOSE−2​min(OPEN−1​,CLOSE−1​)>OPEN−2​
第三根阳线：
O P E N > C L O S E C L O S E < O P E N − 2 OPEN > CLOSE \\ CLOSE < OPEN_{-2} \\ OPEN>CLOSECLOSE<OPEN−2​

重构代码（来自ta_CDL3INSIDE.c， 有修改， 只保留逻辑）：

def CDL3INSIDE_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 13:
        body_long = abs(open - close)
        avg_body_long = body_long.rolling(10).mean().shift(1)
        # 第一根母线
        condition1 = abs(close.shift(2) - open.shift(2)) > avg_body_long.shift(2)
        # 第二根子线
        condition2 = (abs(close.shift(1) - open.shift(1)) <= avg_body_long.shift(1)) & \
                     (np.maximum(close.shift(1), open.shift(1)) < np.maximum(close.shift(2), open.shift(2))) & \
                     (np.minimum(close.shift(1), open.shift(1)) > np.minimum(close.shift(2), open.shift(2)))
        # 第三根长阴线
        condition3_1 = (close.shift(2) > open.shift(2)) & (close < open) & (close < open.shift(2))
        # 第三根长阳线
        condition3_2 = (close.shift(2) < open.shift(2)) & (close > open) & (close > open.shift(2))

        cdl3inside = np.where(condition1 & condition2 & condition3_1, -100, 0)
        cdl3inside = np.where(condition1 & condition2 & condition3_2, 100, cdl3inside)
        cdl3inside[:12] = 0
    else:
        cdl3inside = np.zeros(_len).astype(int)
    return cdl3inside

CDL3OUTSIDE（三外部上涨和下跌）

python函数原型：

cdl2outside = CDL3OUTSIDE(open, high, low, close)

解释：

  1. 母子信号是该信号的主要组成部分，第一天包裹第二天
  2. 第一日和第二日的颜色相反
  3. 如果趋势表明为上涨，则第三天的收盘价高于第一天的开盘价；否则，第三天的收盘价会低于第一天的开盘价。

在这里插入图片描述

三外部上涨（下跌同理）

第一根阴线：
O P E N − 2 > C L O S E − 2 OPEN_{-2}>CLOSE_{-2} OPEN−2​>CLOSE−2​
第二根阳线：
O P E N − 1 < C L O S E − 1 C L O S E − 1 > O P E N − 2 O P E N − 1 < C L O S E − 2 OPEN_{-1}<CLOSE_{-1} \\ CLOSE_{-1}>OPEN_{-2} \\ OPEN_{-1}<CLOSE_{-2} \\ OPEN−1​<CLOSE−1​CLOSE−1​>OPEN−2​OPEN−1​<CLOSE−2​
第三根阳线：
C L O S E < C L O S E − 1 CLOSE < CLOSE_{-1} CLOSE<CLOSE−1​
重构代码（来自ta_CDL3OUTSIDE.c， 有修改， 只保留逻辑）：

def CDL3OUTSIDE_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 4:
        # 第一根子线阳
        condition_1_1 = close.shift(2) > open.shift(2)
        # 第二根母线阴
        condition_1_2 = (open.shift(1) > close.shift(1)) & \
                        (close.shift(1) < open.shift(2)) & \
                        (open.shift(1) > close.shift(2))
        # 第三根阴线
        condition_1_3 = (close < close.shift(1))
        cdl3outside = np.where(condition_1_1 & condition_1_2
                               & condition_1_3, -100, 0)

        # 第一根子线阳
        condition_2_1 = close.shift(2) < open.shift(2)
        # 第二根母线阴
        condition_2_2 = (open.shift(1) < close.shift(1)) & \
                       (close.shift(1) > open.shift(2)) & \
                       (open.shift(1) < close.shift(2))
        # 第三根阴线
        condition_2_3 = (close > close.shift(1))
        cdl3outside = np.where(condition_2_1 & condition_2_2
                               & condition_2_3, 100, cdl3outside)
        cdl3outside[:3] = 0
    else:
        cdl3outside = np.zeros(_len).astype(int)
    return cdl3outside

CDL3STARSINSOUTH (南方三星)

python函数原型：

cdl3starsinsouth = CDL3STARSINSOUTH(open, high, low, close)

解释：

（1）三天连续阴线
（2）第一天大阴线且有较长的大影线
（3）第二天开盘位于前一天实体内，收盘位于前一天下影线内，且实体短于前一天
（4）第三天上下影线特别短（veryshort），实体短（bodyshort）且位于前一天的high，low之间
（5）见底信号

在这里插入图片描述
第一根阴线：
C L O S E − 2 < O P E N − 2 O P E N − 2 − C L O S E − 2 > A V G ( ∣ C L O S E − O P E N ∣ ) C L O S E − 2 − L O W − 2 > B O D Y _ L O N G − 2 CLOSE_{-2} < OPEN_{-2} \\ OPEN_{-2}-CLOSE{-2} > AVG(|CLOSE-OPEN|) \\ CLOSE_{-2}-LOW_{-2} > BODY\_LONG_{-2} CLOSE−2​<OPEN−2​OPEN−2​−CLOSE−2>AVG(∣CLOSE−OPEN∣)CLOSE−2​−LOW−2​>BODY_LONG−2​

第二根阴线：
C L O S E − 1 < O P E N − 1 O P E N − 1 − C L O S E − 1 < C L O S E − 1 − O P E N − 1 C L O S E − 2 < O P E N − 1 < = H I G H − 2 L O W − 2 < = L O W − 1 < C L O S E − 2 C L O S E − 1 − L O W − 1 > S H A D O W _ V E R Y _ S H O R T − 1 CLOSE_{-1} < OPEN_{-1} \\ OPEN_{-1}-CLOSE{-1} < CLOSE_{-1} - OPEN_{-1} \\ CLOSE_{-2} < OPEN_{-1} <= HIGH_{-2} \\ LOW_{-2} <= LOW_{-1} < CLOSE_{-2} \\ CLOSE_{-1}-LOW_{-1} >SHADOW\_VERY\_SHORT_{-1} CLOSE−1​<OPEN−1​OPEN−1​−CLOSE−1<CLOSE−1​−OPEN−1​CLOSE−2​<OPEN−1​<=HIGH−2​LOW−2​<=LOW−1​<CLOSE−2​CLOSE−1​−LOW−1​>SHADOW_VERY_SHORT−1​

第三根阴线：
C L O S E < O P E N O P E N − C L O S E > B O D Y _ S H O R T H I G H − O P E N < S H A D O W _ V E R Y _ S H O R T C L O S E − L O W < S H A D O W _ V E R Y _ S H O R T L O W > L O W − 1 H I G H < H I G H − 1 CLOSE<OPEN \\ OPEN-CLOSE > BODY\_SHORT \\ HIGH-OPEN < SHADOW\_VERY\_SHORT \\ CLOSE-LOW < SHADOW\_VERY\_SHORT \\ LOW > LOW_{-1} \\ HIGH < HIGH_{-1} CLOSE<OPENOPEN−CLOSE>BODY_SHORTHIGH−OPEN<SHADOW_VERY_SHORTCLOSE−LOW<SHADOW_VERY_SHORTLOW>LOW−1​HIGH<HIGH−1​

重构代码（来自ta_CDL3STARSINSOUTH.c， 有修改， 只保留逻辑）：

def CDL3STARSINSOUTH_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 13:
        real_body = abs(open - close)
        avg_body_long = real_body.rolling(10).mean().shift(1)
        body_short = real_body.rolling(10).mean().shift(1) * 0.5
        shadow_lower = np.minimum(close, open) - low
        high_low_range_10per = (high - low) * 0.1
        shadow_very_short = high_low_range_10per.rolling(10).mean().shift(1)
        shadow_upper = high - np.maximum(close, open)
        # 第一根阴线
        condition_1 = (close.shift(2) < open.shift(2)) & (real_body.shift(2) > avg_body_long.shift(2)) & \
                      (shadow_lower.shift(2) > 2 * real_body.shift(2))
        # 第二根阴线
        condition_2 = (close.shift(1) < open.shift(1)) & (real_body.shift(1) < real_body.shift(2)) & \
                      (open.shift(1) > close.shift(2)) & (open.shift(1) <= high.shift(2)) & \
                      (low.shift(1) < close.shift(2)) & (low.shift(1) >= low.shift(2)) & \
                      (shadow_lower.shift(1) > shadow_very_short.shift(1))
        # 第三根阴线
        condition_3 = (close < open) & (real_body < body_short) & \
                      (shadow_lower < shadow_very_short) & (shadow_upper < shadow_very_short) & \
                      (low > low.shift(1)) & (high < high.shift(1))

        cdl3starsinsouth = np.where(condition_1 & condition_2 & condition_3, 100, 0)
    else:
        cdl3starsinsouth = np.zeros(_len).astype(int)
    return cdl3starsinsouth

CDL3WHITESOLDIERS (三白兵)

python函数原型：

cdl3whitesoldiers = CDL3WHITESOLDIERS(open, high, low, close)

解释：

（1）三天连续阳线
（2）三天上影线非常短
（3）开盘价接近（near）前一日实体之内
（4）后一日实体不比前一日小很多（far）
（5）最后一日实体不短（bodyshort）

示意图：
在这里插入图片描述
第一日阳线：
C L O S E − 2 > O P E N − 2 S H A D O W _ U P P E R − 2 > S H A D O W _ V E R Y _ S H O R T − 2 CLOSE_{-2} > OPEN_{-2} \\ SHADOW\_UPPER_{-2} > SHADOW\_VERY\_SHORT_{-2} CLOSE−2​>OPEN−2​SHADOW_UPPER−2​>SHADOW_VERY_SHORT−2​

第二日阳线：
C L O S E − 1 > O P E N − 1 S H A D O W _ U P P E R − 1 > S H A D O W _ V E R Y _ S H O R T − 1 C L O S E − 1 > C L O S E − 2 O P E N − 1 > O P E N − 2 O P E N − 1 < = C L O S E − 2 + N E A R R E A L _ B O D Y − 1 > R E A L _ B O D Y − 2 − F A R CLOSE_{-1} > OPEN_{-1} \\ SHADOW\_UPPER_{-1} > SHADOW\_VERY\_SHORT_{-1} \\ CLOSE_{-1} > CLOSE_{-2} \\ OPEN_{-1} > OPEN_{-2} \\ OPEN_{-1} <= CLOSE_{-2} + NEAR \\ REAL\_BODY_{-1} > REAL\_BODY_{-2} - FAR CLOSE−1​>OPEN−1​SHADOW_UPPER−1​>SHADOW_VERY_SHORT−1​CLOSE−1​>CLOSE−2​OPEN−1​>OPEN−2​OPEN−1​<=CLOSE−2​+NEARREAL_BODY−1​>REAL_BODY−2​−FAR

第三日阳线：
C L O S E > O P E N S H A D O W _ U P P E R > S H A D O W _ V E R Y _ S H O R T C L O S E > C L O S E − 1 O P E N > O P E N − 1 O P E N < = C L O S E − 1 + N E A R R E A L _ B O D Y > R E A L _ B O D Y − 1 − F A R R E A L _ B O D Y > B O D Y _ S H O R T CLOSE > OPEN \\ SHADOW\_UPPER > SHADOW\_VERY\_SHORT \\ CLOSE > CLOSE_{-1} \\ OPEN > OPEN_{-1} \\ OPEN <= CLOSE_{-1} + NEAR \\ REAL\_BODY > REAL\_BODY_{-1} - FAR \\ REAL\_BODY > BODY\_SHORT CLOSE>OPENSHADOW_UPPER>SHADOW_VERY_SHORTCLOSE>CLOSE−1​OPEN>OPEN−1​OPEN<=CLOSE−1​+NEARREAL_BODY>REAL_BODY−1​−FARREAL_BODY>BODY_SHORT

重构代码（来自ta_CDL3LINESTRKE.c， 有修改， 只保留逻辑）：

def CDL3WHITESOLDIERS_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 13:
        real_body = abs(open - close)
        body_short = real_body.rolling(10).mean().shift(1) * 0.5
        high_low_range_10per = (high - low) * 0.1
        shadow_very_short = high_low_range_10per.rolling(10).mean().shift(1)
        shadow_upper = high - np.maximum(close, open)
        high_low_range_20per = (high - low) * 0.2
        high_low_range_60per = (high - low) * 0.6
        near = high_low_range_20per.rolling(5).mean().shift(1)
        far = high_low_range_60per.rolling(5).mean().shift(1)

        # 第一根阳线
        condition_1 = (close.shift(2) > open.shift(2)) & (shadow_upper.shift(2) < shadow_very_short.shift(2))

        # 第二根阳线
        condition_2 = (close.shift(1) > open.shift(1)) & (shadow_upper.shift(1) < shadow_very_short.shift(1)) & \
                      (close.shift(1) > close.shift(2)) & (open.shift(1) > open.shift(2)) & \
                      (open.shift(1) <= close.shift(2) + near.shift(2)) & \
                      (real_body.shift(1) > real_body.shift(2) - far.shift(2))

        # 第三根阳线
        condition_3 = (close > open) & (shadow_upper < shadow_very_short) & (close > close.shift(1)) & \
                      (open > open.shift(1)) & (open <= close.shift(1) + near.shift(1)) & \
                      (real_body > real_body.shift(1) - far.shift(1)) & \
                      (real_body > body_short)

        cdl3whitesoldiers = np.where(condition_1 & condition_2 & condition_3, 100, 0)
    else:
        cdl3whitesoldiers = np.zeros(_len).astype(int)
    return cdl3whitesoldiers

CDLABANDONEDBABY（弃婴）

python函数原型：

cdlabandonedbaby = CDLABANDONEDBABY(open, high, low, close, penetration=0.3)

解释：

（1）三天K线，若第一日涨
（2）第二日跳空高开且收十字星
（3）第三日低开收阴
（4）预示反转

在这里插入图片描述
顶部为例：
第一根阳线：
C L O S E − 2 > O P E N − 2 R E A L _ B O D Y − 2 > B O D Y _ L O N G − 2 CLOSE_{-2} > OPEN_{-2} \\ REAL\_BODY_{-2} > BODY\_LONG_{-2} CLOSE−2​>OPEN−2​REAL_BODY−2​>BODY_LONG−2​

第二根上缺口：
R E A L _ B O D Y − 1 < = B O D Y _ D O J I − 1 L O W − 1 > H I G H − 2 REAL\_BODY_{-1} <= BODY\_DOJI_{-1} \\ LOW_{-1} > HIGH_{-2} REAL_BODY−1​<=BODY_DOJI−1​LOW−1​>HIGH−2​

第三跟阴线：
C L O S E > O P E N R E A L _ B O D Y > B O D Y _ L O N G C L O S E < C L O S E − 2 − R E A L _ B O D Y − 2 × P E N E T R A T I O N L O W − 1 > H I G H CLOSE > OPEN \\ REAL\_BODY > BODY\_LONG \\ CLOSE < CLOSE_{-2} - REAL\_BODY_{-2} \times PENETRATION \\ LOW_{-1} > HIGH CLOSE>OPENREAL_BODY>BODY_LONGCLOSE<CLOSE−2​−REAL_BODY−2​×PENETRATIONLOW−1​>HIGH

重构代码（来自ta_CDLABANDONEDBABY.c， 有修改， 只保留逻辑）：

def CDLABANDONEDBABY_(open, high, low, close, penetration=0.3):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 13:
        real_body = abs(open - close)
        body_short = real_body.rolling(10).mean().shift(1) * 0.5
        body_long = real_body.rolling(10).mean().shift(1)
        body_doji = real_body.rolling(10).mean().shift(1) * 0.1
        # 第一根阳线
        condition_1_1 = (close.shift(2) > open.shift(2)) & (real_body.shift(2) > body_long.shift(2))
        # 第二根上缺口
        condition_1_2 = (real_body.shift(1) <= body_doji.shift(1)) & \
                        (low.shift(1) > high.shift(2))

        # 第三根阴线
        condition_1_3 = (close < open) & (real_body > body_short) & \
                        (close < close.shift(2) - real_body.shift(2) * penetration) & \
                        (low.shift(1) > high)
        cdl3abandonbaby = np.where(condition_1_1 & condition_1_2 & condition_1_3, -100, 0)

        # 第一根阳线
        condition_2_1 = (close.shift(2) < open.shift(2)) & (real_body.shift(2) > body_long.shift(2))
        # 第二根上缺口
        condition_2_2 = (real_body.shift(1) <= body_doji.shift(1)) & \
                        (high.shift(1) < low.shift(2))

        # 第三根阴线
        condition_2_3 = (close > open) & (real_body > body_short) & \
                        (close > close.shift(2) + real_body.shift(2) * penetration) & \
                        (high.shift(1) < low)
        cdl3abandonbaby = np.where(condition_2_1 & condition_2_2 & condition_2_3, 100, cdl3abandonbaby)
    else:
        cdl3abandonbaby = np.zeros(_len).astype(int)
    return cdl3abandonbaby

CDLADVANCEBLOCK（大敌当前）

python函数原型：

cdladvanceblock = = CDLADVANCEBLOCK(open, high, low, close)

百科解释：三日K线模式，三日都收阳，每日收盘价都比前一日高， 开盘价都在前一日实体以内，实体变短，上影线变长。

talib中定义了四种满足advanceblock的条件
公共条件：

  1. 三练阳，收盘价逐日往上
  2. 三日开盘价高于前一日开盘价，不超过（near）前一日收盘价
  3. 首日长实体（body_long）,短上影线（shadow_short）
情况1：上升阻碍由于第二根bar的短实体
  1. 第二日实体远短于（far）第一日实体
  2. 第三日实体不长于（near）第二日实体

在这里插入图片描述

R E A L _ B O D Y − 1 < R E A L _ B O D Y − 2 − F a r − 2 R E A L _ B O D Y 0 < R E A L _ B O D Y − 1 + N e a r − 1 REAL\_BODY_{-1} < REAL\_BODY_{-2} - Far_{-2} \\ REAL\_BODY_{0} < REAL\_BODY_{-1} + Near_{-1} REAL_BODY−1​<REAL_BODY−2​−Far−2​REAL_BODY0​<REAL_BODY−1​+Near−1​

情况2：上升阻碍由于第三根bar的短实体
  1. 第三日实体远短于（far）第二日实体

在这里插入图片描述

R E A L _ B O D Y 0 < R E A L _ B O D Y − 1 − F a r − 1 REAL\_BODY_{0} < REAL\_BODY_{-1} - Far_{-1} REAL_BODY0​<REAL_BODY−1​−Far−1​

情况3：上升阻碍由于逐渐变短的实体和不短的上影线
  1. 第三根实体小于第二根，第二根实体小于第一根
  2. 第三根或第二根上影线不短（shadow_short）

在这里插入图片描述

R E A L _ B O D Y − 1 < R E A L _ B O D Y − 2 R E A L _ B O D Y 0 < R E A L _ B O D Y − 1 ( S H A D O W _ U P P E R 0 > S H A D O W _ S H O R T 0 )   o r ( S H A D O W _ U P P E R − 1 > S H A D O W _ S H O R T − 1 ) REAL\_BODY_{-1} < REAL\_BODY_{-2} \\ REAL\_BODY_{0} < REAL\_BODY_{-1} \\ (SHADOW\_UPPER_{0} > SHADOW\_SHORT_{0})\ or \\ (SHADOW\_UPPER_{-1} > SHADOW\_SHORT_{-1}) REAL_BODY−1​<REAL_BODY−2​REAL_BODY0​<REAL_BODY−1​(SHADOW_UPPER0​>SHADOW_SHORT0​) or(SHADOW_UPPER−1​>SHADOW_SHORT−1​)

情况4：上升阻碍由于第三根较短的实体和长上影线
  1. 第三根实体小于第二根
  2. 第三根上影线长（shadow_long）

在这里插入图片描述

R E A L _ B O D Y 0 < R E A L _ B O D Y − 1 S H A D O W _ U P P E R 0 > S H A D O W _ L O N G 0 REAL\_BODY_{0} < REAL\_BODY_{-1} \\ SHADOW\_UPPER_{0} > SHADOW\_LONG_{0} REAL_BODY0​<REAL_BODY−1​SHADOW_UPPER0​>SHADOW_LONG0​

重构代码（来自ta_CDL3LINESTRKE.c， 有修改， 只保留逻辑）：

def CDLADVANCEBLOCK_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 13:
        real_body = abs(open - close)
        body_long = real_body.rolling(10).mean().shift(1)
        high_low_range = high - low
        near = high_low_range.rolling(5).mean().shift(1) * 0.2
        far = high_low_range.rolling(5).mean().shift(1) * 0.6
        shadow_upper = high - np.maximum(close, open)
        shadow_lower = np.minimum(close, open) - low
        shadow_short = (shadow_upper + shadow_lower).rolling(10).mean().shift(1) * 0.5
        common_condition = (close.shift(2) > open.shift(2)) & (close.shift(1) > open.shift(1)) & \
                           (close > open) & (close > close.shift(1)) & (close.shift(1) > close.shift(2)) & \
                           (open.shift(1) > open.shift(2)) & (open.shift(1) <= close.shift(2) + near.shift(2)) & \
                           (open > open.shift(1)) & (open < close.shift(1) + near.shift(1)) & \
                           (real_body.shift(2) > body_long.shift(2)) & (shadow_upper.shift(2) < shadow_short.shift(2))

        # 第二根远小于第一根， 第三根不长于第二根
        # 上升阻碍在第二根bar，第三根不得阻碍
        condition_1 = (real_body.shift(1) < real_body.shift(2) - far.shift(2)) & \
                      (real_body < real_body.shift(1) + near.shift(1))

        # 第三更远小于第二根
        # 上升阻碍在第三根bar
        condition_2 = (real_body < real_body.shift(1) - far.shift(1))

        # 第三根小于第二根，第二根小于第一根， 第三和第二根不具有长上影线
        # 上升阻碍在逐渐变小地上影线和实体
        condition_3 = (real_body.shift(1) < real_body.shift(2)) & (real_body < real_body.shift(1)) & \
                      (shadow_upper > shadow_short) & (shadow_upper.shift(1) > shadow_short.shift(1))

        # 第三根小于第二根， 第三根有很长地上影线
        # 上升阻碍在第三根长上影线和短实体
        condition_4 = (real_body < real_body.shift(1)) & (shadow_upper > real_body)

        cdladvanceblock = np.where(common_condition & (condition_1 | condition_2 | condition_3 | condition_4), -100, 0)
    else:
        cdladvanceblock = np.zeros(_len).astype(int)
    return cdladvanceblock

CDLEVENINGDOJISTAR （十字暮星）

python函数原型：

cdleveningdojistar = CDLEVENINGDOJISTAR (open, high, low, close, penetration=0.3)

解释：

与CDLABANDONEDBABY（弃婴）非常相似，缺口放宽至实体缺口

  1. 第一日大阳线
  2. 第二日高开十字线
  3. 第三日大阴线，收盘小于第一根实体的30%分位数

在这里插入图片描述
重构代码（来自ta_CDLEVENINGDOJISTAR.c， 有修改， 只保留逻辑）：

def CDLEVENINGDOJISTAR_(open, high, low, close, penetration=0.3):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 13:
        real_body = abs(open - close)
        body_long = real_body.rolling(10).mean().shift(1)
        high_low_range = high - low
        doji = high_low_range.rolling(10).mean().shift(1) * 0.1
        condition_1 = (real_body.shift(2) > body_long.shift(2)) & \
                      (close.shift(2) > open.shift(2))
        condition_2 = (real_body.shift(1) < doji.shift(1)) & \
                      (np.minimum(close.shift(1), open.shift(1)) > close.shift(2))
        condition_3 = (real_body > body_long) & \
                      (close < open) & \
                      (close < close.shift(2) - real_body.shift(2) * penetration)
        cdleveningdojistar = np.where(condition_1 & condition_2 & condition_3, -100, 0)
    else:
        cdleveningdojistar = np.zeros(_len).astype(int)
    return cdleveningdojistar

CDLEVENINGSTAR （暮星）

python函数原型：

cdleveningstar= CDLEVENINGSTAR (open, high, low, close, penetration=0.3)

与CDLEVENINGDOJISTAR （十字暮星）非常相似，十字线放宽至短线

  1. 第一日大阳线
  2. 第二日高开短线
  3. 第三日大阴线，收盘小于第一根实体的30%分位数

在这里插入图片描述

重构代码（来自ta_CDLEVENINGSTAR.c， 有修改， 只保留逻辑）：

def CDLEVENINGSTAR_(open, high, low, close, penetration=0.3):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 13:
        real_body = abs(open - close)
        body_long = real_body.rolling(10).mean().shift(1)
        condition_1 = (real_body.shift(2) > body_long.shift(2)) & \
                      (close.shift(2) > open.shift(2))
        condition_2 = (real_body.shift(1) <= body_long.shift(1)) & \
                      (np.minimum(close.shift(1), open.shift(1)) > close.shift(2))
        condition_3 = (real_body > body_long) & \
                      (close < open) & \
                      (close < close.shift(2) - real_body.shift(2) * penetration)
        cdleveningstar = np.where(condition_1 & condition_2 & condition_3, -100, 0)
    else:
        cdleveningstar = np.zeros(_len).astype(int)
    return cdleveningstar

CDLGAPSIDESIDEWHITE （向上/下跳空并列阳线）

python函数原型：

cdlgapsidesidewhite = CDLGAPSIDESIDEWHITE(open, high, low, close)

解释：

向上或向下跳空后，两根并列（equal）几乎等长（Near）的阳线
趋势方向为跳空方向
在这里插入图片描述
三连阴情况类似

重构代码（来自ta_CDLGAPSIDESIDEWHITE.c， 有修改， 只保留逻辑）：

def CDLGAPSIDESIDEWHITE_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 13:
        real_body = abs(open - close)
        high_low_range = high - low
        near = high_low_range.rolling(5).mean().shift(1) * 0.2
        equal = high_low_range.rolling(5).mean().shift(1) * 0.05
        # 向上跳空
        condition_1_1 = np.maximum(close.shift(2), open.shift(2)) < np.minimum(open.shift(1), open)
        # 向下跳空
        condition_1_2 = np.minimum(close.shift(2), open.shift(2)) > np.minimum(close.shift(1), close)

        condition_2 = (close.shift(1) > open.shift(1)) & \
                      (close > open)

        condition_3 = (real_body <= real_body.shift(1) + near.shift(1)) & \
                      (real_body >= real_body.shift(1) - near.shift(1)) & \
                      (open <= open.shift(1) + equal.shift(1)) & \
                      (open >= open.shift(1) - equal.shift(1))
        cdlgapsidesidewhite = np.where(condition_1_1 & condition_2 & condition_3, 100, 0)
        cdlgapsidesidewhite = np.where(condition_1_2 & condition_2 & condition_3, -100, cdlgapsidesidewhite)
    else:
        cdlgapsidesidewhite = np.zeros(_len).astype(int)
    return cdlgapsidesidewhite

五. 四K线模型

CDL3LINESTRIKE（三线打击）

python函数原型：

cdl3linestrike = CDL3LINESTRIKE(open, high, low, close)

解释：

（1）三天连续阳线
（2）每天阳线收盘价大于前一日收盘价
（3）开盘价接近（near）前一日实体之内
（4）第四日高开，跌破第一日开盘价，被认为是上涨信号
（5）阴线情况相反

在这里插入图片描述

三连阳情况

第一根阳线：
O P E N − 3 < C L O S E − 3 OPEN_{-3} < CLOSE_{-3} OPEN−3​<CLOSE−3​
第二根阳线：
O P E N − 2 < C L O S E − 2 O P E N − 3 − N e a r < = O P E N − 2 < = C L O S E − 3 + N e a r C L O S E − 2 > C L O S E − 3 OPEN_{-2} < CLOSE_{-2} \\ OPEN_{-3}-Near<= OPEN_{-2} <= CLOSE_{-3}+Near \\ CLOSE_{-2} > CLOSE_{-3} OPEN−2​<CLOSE−2​OPEN−3​−Near<=OPEN−2​<=CLOSE−3​+NearCLOSE−2​>CLOSE−3​
第三根阳线：
O P E N − 1 < C L O S E − 1 O P E N − 2 − N e a r < = O P E N − 1 < = C L O S E − 2 + N e a r C L O S E − 1 > C L O S E − 2 OPEN_{-1} < CLOSE_{-1} \\ OPEN_{-2}-Near<= OPEN_{-1} <= CLOSE_{-2}+Near \\ CLOSE_{-1} > CLOSE_{-2} OPEN−1​<CLOSE−1​OPEN−2​−Near<=OPEN−1​<=CLOSE−2​+NearCLOSE−1​>CLOSE−2​
第四根阴线：
O P E N 0 > C L O S E − 1 C L O S E 0 < O P E N − 3 OPEN_{0} > CLOSE_{-1} \\ CLOSE_{0} < OPEN_{-3} OPEN0​>CLOSE−1​CLOSE0​<OPEN−3​

三连阴情况类似

重构代码（来自ta_CDL3LINESTRKE.c， 有修改， 只保留逻辑）：

def CDL3LINESTRIKE_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 9:
        high_low_range_20per = (high - low) * 0.2
        near = high_low_range_20per.rolling(5).mean().shift(1)
        # 三阳线
        # 第一根阳线
        condition_1_1 = (close.shift(3) > open.shift(3))
        # 第二根阳线
        condition_1_2 = (close.shift(2) > open.shift(2)) & \
                        (close.shift(2) > close.shift(3)) & \
                        (open.shift(2) >= open.shift(3) - near.shift(3)) & \
                        (open.shift(2) <= close.shift(3) + near.shift(3))
        # 第三根阳线
        condition_1_3 = (close.shift(1) > open.shift(1)) & \
                        (close.shift(1) > close.shift(2)) & \
                        (open.shift(1) >= open.shift(2) - near.shift(2)) & \
                        (open.shift(1) <= close.shift(2) + near.shift(2))
        # 第四根阴线
        condition_1_4 = (close < open) & \
                        (open > close.shift(1)) & \
                        (close < open.shift(3))

        cdl3linestrike = np.where(condition_1_1 & condition_1_2
                                  & condition_1_3 & condition_1_4, 100, 0)
        # 三阴线
        # 第一根阴线
        condition_2_1 = (close.shift(3) < open.shift(3))
        # 第二根阴线
        condition_2_2 = (close.shift(2) < open.shift(2)) & \
                        (close.shift(2) < close.shift(3)) & \
                        (open.shift(2) >= close.shift(3) - near.shift(3)) & \
                        (open.shift(2) <= open.shift(3) + near.shift(3))
        # 第三根阴线
        condition_2_3 = (close.shift(1) < open.shift(1)) & \
                        (close.shift(1) < close.shift(2)) & \
                        (open.shift(1) >= close.shift(2) - near.shift(2)) & \
                        (open.shift(1) <= open.shift(2) + near.shift(2))
        # 第四根阳线
        condition_2_4 = (close > open) & \
                        (open < close.shift(1)) & \
                        (close > open.shift(3))

        cdl3linestrike = np.where(condition_2_1 & condition_2_2
                                  & condition_2_3 & condition_2_4, -100, cdl3linestrike)
        cdl3linestrike[:8] = 0
    else:
        cdl3linestrike = np.zeros(_len).astype(int)
    return cdl3linestrike

CDLCONCEALBABYSWALL（藏婴吞没）

python函数原型：

cdlconcealbabyswall = CDLCONCEALBABYSWALL(open, high, low, close)

四日连续阴线，前两日无影线
第三日跌出实体缺口，但有不短的上影线，且最高价超过第二日收盘
第四日最高和最低价包裹第三日
底部信号
在这里插入图片描述

重构代码（来自ta_CDLCONCEALBABYSWALL.c， 有修改， 只保留逻辑）：


def CDLCONCEALBABYSWALL_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 14:
        high_low_range = high - low
        shadow_very_short = high_low_range.rolling(10).mean().shift(1) * 0.1
        shadow_upper = high - np.maximum(close, open)
        shadow_lower = np.minimum(close, open) - low
        condition_1 = (close.shift(3) < open.shift(3)) & \
                      (shadow_upper.shift(3) < shadow_very_short.shift(3)) & \
                      (shadow_lower.shift(3) < shadow_very_short.shift(3))

        condition_2 = (close.shift(2) < open.shift(2)) & \
                      (shadow_upper.shift(2) < shadow_very_short.shift(2)) & \
                      (shadow_lower.shift(2) < shadow_very_short.shift(2))

        condition_3 = (close.shift(1) < open.shift(1)) & \
                      (shadow_upper.shift(1) > shadow_very_short.shift(1)) & \
                      (open.shift(1) < close.shift(2)) & \
                      (high.shift(1) > close.shift(2))

        condition_4 = (close < open) & \
                      (high > high.shift(1)) & \
                      (low < low.shift(1))

        cdlconcealbabyswall = np.where(condition_1 & condition_2 & condition_3 & condition_4, 100, 0)
    else:
        cdlconcealbabyswall = np.zeros(_len).astype(int)
    return cdlconcealbabyswall

六. 五K线模型

CDLBREAKAWAY（脱离）

python函数原型：

cdlbreakaway = CDLBREAKAWAY(open, high, low, close)

以看涨脱离为例，大阴线后低开形成实体缺口，继续走低
第三日和第四日阴线的high和low持续走低
第五日反弹收盘在一二日缺口内（中文百科中无此要求）

在这里插入图片描述

重构代码（来自ta_CDLBREAKAWAY.c， 有修改， 只保留逻辑）：

def CDLBREAKAWAY_(open, high, low, close):
    _len = len(open)
    open, high, low, close = pd.Series(open), pd.Series(high), pd.Series(low), pd.Series(close)
    if _len >= 15:
        real_body = abs(open - close)
        body_long = real_body.rolling(10).mean().shift(1)
        # 看涨脱离
        condition_1_1 = (close.shift(4) < open.shift(4)) & (real_body.shift(4) > body_long.shift(4))
        condition_1_2 = (close.shift(3) < open.shift(3)) & (open.shift(3) < close.shift(4))
        condition_1_3 = (close.shift(2) < open.shift(2)) & \
                        (low.shift(2) < low.shift(3)) & \
                        (high.shift(2) < high.shift(3))
        condition_1_4 = (close.shift(1) < open.shift(1)) & \
                        (low.shift(1) < low.shift(2)) & \
                        (high.shift(1) < high.shift(2))
        condition_1_5 = (close > open) & (close > open.shift(3)) & (close < close.shift(4))

        # 看跌脱离
        condition_2_1 = (close.shift(4) > open.shift(4)) & (real_body.shift(4) > body_long.shift(4))
        condition_2_2 = (close.shift(3) > open.shift(3)) & (open.shift(3) > close.shift(4))
        condition_2_3 = (close.shift(2) > open.shift(2)) & \
                        (low.shift(2) > low.shift(3)) & \
                        (high.shift(2) > high.shift(3))
        condition_2_4 = (close.shift(1) > open.shift(1)) & \
                        (low.shift(1) > low.shift(2)) & \
                        (high.shift(1) > high.shift(2))
        condition_2_5 = (close < open) & (close < open.shift(3)) & (close > close.shift(4))

        cdlbreakaway = np.where(condition_1_1 & condition_1_2 & condition_1_3 & condition_1_4 & condition_1_5, 100, 0)
        cdlbreakaway = np.where(condition_2_1 & condition_2_2 & condition_2_3 & condition_2_4 & condition_2_5,
                               -100, cdlbreakaway)
    else:
        cdlbreakaway = np.zeros(_len).astype(int)
    return cdlbreakaway

免责声明

本文仅为技术解析文档，内容全部开放，不对任何个人或机构提供任何投资建议

量化就是探索生活
关注
专栏目录
VC++2015编译TA-Lib-Core.dll C#调用带macd调试程序
02-02
VC++2015编译TA-Lib-Core.dll 包括 C#调用带macd调试程序
python探究talib.py
08-05
可视化探究talib的具体效果
Ta-Lib源码解析（一）：交叉指标(Overlap Studies) #（附Python重构代码）
量化就是探索生活
07-04 4962
TA_Lib源码解析1.（均线指标）Overlap Studies1.1 简单移动平均SMA（简单移动平均）MAVP （可变周期移动平均）TRIMA（三角移动平均）1.2 指数移动平均EMA（指数移动平均）DEMA（双指数移动平均）TEMA（三指数移动平均）T3（三重双指数移动平均（复杂））1.3 加权移动平均WMA（加权移动平均）HT_TRENDLINE（希尔伯特顺时变换）1.4自适应移动平均MAMA（梅萨自适应移动平均）KAMA（库夫曼自适应移动均线）1.5 中间价格MIDPRICE （）MIDPOIN
Talib技术因子详解（八）
叶子的博客
07-14 4086
talib安装方式：pip install Ta-lib Tushare数据获取请参考：金融量化分析基础环境搭建 数据获取代码请参考：Talib技术因子详解（一） 26、MACD 异同移动平均线，调用方式如下： macd, macdsignal, macdhist = talib.MACD(close, fastperiod, slowperiod, signalperiod) 当MACD升穿Signal Line，入市讯息；当MACD跌穿Signal Line，出市讯息。当MACD上升时，股票价
TALIB 中文文档 Statistic Functions 统计学指标
weixin_43493359的博客
06-03 1446
TALIB 中文文档 Statistic Functions 统计学指标
Ta-Lib源码解析（二）：动量指标 (Momentum Indicator) #（附Python重构代码）
量化就是探索生活
07-19 6544
TA_Lib指标目录2.（动量指标）Momentum Indicator2.1 趋势强弱，对方向不敏感MACD（异同移动平均线）MACDEXT（异同移动平均线拓展）MACDFIX（异同移动平均线（固定窗口大小））CCI（顺势指标）TRIX（三重指数平滑平均线）2.2 多空力量强弱对比BOP（力量均衡指标）RSI 2.（动量指标）Momentum Indicator 2.1 趋势强弱，对方向不敏感 MACD（异同移动平均线） python函数原型： macd, macdsignal, macdhist = M
CandleStick-Charts-in-Python:用于创建烛台图的Python代码
03-31
蜡烛烛图 用于创建烛台图的Python代码
ta-lib-0.4.0-borl.zip
06-02
TA-Lib 是用来对金融市场的数据进行技术分析。 Includes 200 indicators such as ADX, MACD, RSI, Stochastic, Bollinger Bands etc... Candlestick pattern recognition Open-source API for C/C++, Java, Perl, ...
python-highcharts:使用highchart.js在Python和IPython笔记本中进行绘图
03-07
Python高图 在Python或什至在IPython笔记本中，使用出色的库作为maplotlib的交互式替代。 安装 pip install charts 快速开始 首先导入库： import charts 其次，从data模块中加载一些示例数据，并从options模块中...
candlestick-screener:基于网络的技术筛选器，用于使用Python和Flask的烛台图案
05-03
烛台筛选器基于Web的技术筛选器，使用TA-Lib，Python和Flask进行烛台图案该存储库的视频教程： 烛台图案识别-https: QGkf2- 建立基于网络的技术筛选器-https: 寻找突破-https:
node-js-crypto-technical-analysis-candlestick-webserver:基于node.js的Candlestick技术分析Http Server
05-17
技术指标库 开始 npm install node index.js 或更改端口监听 node index.js 8080 开始 从实时市场下载一些蜡烛，然后将其发布到网络服务器 一些Urls： ...
ta-lib 源码简单分析
陆多多的专栏
06-02 3908
ta-lib的源码比较简单，重要的类就那么几个，如下: 类功能介绍 Core 指标分析实现的地方，类行数很多，ta-lib的核心 包含一些特性设置和功能实现，以macd为例，包含macdLookback,macd,macdExtLookback,macdExt,macdFixLookback,macdFix等实现。 可以发现，这些方法和参数都是有规律的。 macd指标实现方法为macd...
【backtrader源码分析36】talib.py源码注释(枯燥，仅供参考)
云金杞
05-08 758
talib的源代码注释，由于对talib内部结构了解并不是特别多，这个注释比较简略。 from __future__ import (absolute_import, division, print_function, unicode_literals) # The modules below should/must define __all__ with the objects wishes # or prepend an "_" (underscore)
python股票量化交易（6）---使用TA-Lib计算技术指标
热门推荐
李元静
01-29 1万+
务要日日知非，日日改过；一日不知非，即一日安于自是；一日无过可改，即一日无步可进；天下聪明俊秀不少，所以德不加修、业不加广者，只为因循二字，耽搁一生。 目录什么是TA-LibSMA指标的计算MACD指标的计算KDJ指标的计算 什么是TA-Lib TA-Lib（Technical Analysis Library）是python提供的开源技术分析库，自发布以来，已经有20多年的历史，它包含了大约200个技术指标的计算函数和K线形态识别函数，例如MACD、RSI、KDJ、动量指标等。 我们从前面的几篇博文分.
TA-Lib学习研究笔记（九）——Pattern Recognition （1）
最新发布
六月闻君
12-06 1723
形态识别的函数的应用，通过使用A股实际的数据，验证形态识别函数，用K线显示出现标志的形态走势，由于入口参数基本上是open, high, low, close ，统一设置程序代码，只更换函数即可。 发现有的形态在一个股票上从未出现，选择多个股票参与计算测试。 函数返回值integer (values are -100, 0 or 100) ，0 是无形态信号。100 和 -100 是有正向或负向的形态信号。
量化交易14-backtrader回测南方三星、三个白兵、脱离、藏婴吞没、弃婴、捉腰带线、反击线等形态
q15399129775的博客
04-12 1310
笔者此时会把我们常见的8种形态放在一起进行回测，然后得出结论，从而大家演示这几种函数的使用方法。 #cdl3starsinsouth - 南方三星(筑底上涨) #cdl3whitesoldiers - 三个白兵(上涨) #cdlbreakaway - 脱离(反转上涨) #cdlconcealbabyswall - 藏婴吞没(反转上涨) #cdlabandonedbaby - 弃婴(上涨或者下跌) #cdlbelthold - 捉腰带线(上涨或者下跌) #cdlcounterattack - 反击线(上涨或
windows python TA-Lib 库 源码安装 Python安装talib库
qq_41582302的博客
05-05 4948
Python安装talib库
Ta-lib学习笔记01--成交量指标
shuigge的博客
05-31 4976
TA-Lib 用中文可以称作技术分析库，是一种广泛用在程序化交易中进行金融市场数据的技术分析的函数库。它提供了多种技术分析的函数，可以大大方便我们量化投资中编程工作，内容主要包括：多种指标，如ADX, MACD, RSI, 布林轨道等等K线形态识别，如黄昏之星，锤形线等等 Talib的180个函数，其中六十多个“CDL”开头的函数，全都是关于K线图（英文蜡烛图，candle）。需注意的是，Ta-l
python股票量化交易（7）---K线图：乌鸦、乌云压顶、十字星
李元静
01-30 1万+
随缘济众，其类至繁，约言其纲，大约有十：第一，与人为善;第二，爱敬存心;第三，成人之美;第四，劝人为善;第五，救人危急;第六，兴建大利;第七，舍财作福;第八，护持正法;第九，敬重尊长;第十，爱惜物命。 目录前言两只乌鸦三只乌鸦乌云压顶十字星 前言 在股票的交易中，我们最长使用的图其实是K线图，比如什么十字星，什么乌鸦等都是比较常用的参考指标，这些形态在我们判断市场运行趋势时，起到了非常重要的作用。所以，本篇将详细讲解TA-Lib库识别K线的各种形态。 两只乌鸦 首先，我们将介绍最简单的K线形态：两只乌鸦.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

量化就是探索生活

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值