缠论再学习1-K线标准化

最新推荐文章于 2025-03-05 08:52:07 发布

永远的麦田

最新推荐文章于 2025-03-05 08:52:07 发布

阅读量1.9k

点赞数 4

分类专栏：缠论文章标签：学习

本文链接：https://blog.csdn.net/luhouxiang/article/details/141089704

版权

缠论专栏收录该内容

1 篇文章

订阅专栏

之前学过几轮缠论，由于总总原因，止步于缠论的线段。最近发现有一点时间了，再来学习一下。

缠论的基础是K线，笔和线段，其中K线这一块需要先进行标准化的工作，即把有包含关系的K线合并成一根新K线，然后拿这根新K线和右边邻近的K线进行比较，判断是否形成新的包含关系，依此类推。

包含关系分两种：左包含，右包含（完全相等的视为左包含）

K线的方向分两种：向上，向下

处理合并时，还需要知道K线的方向，即当前K线与前一根K线相比，是非包含关系，若当前K线高于前一根K线，则视为向上，若当前K线低于前一根K线，则视为向下。若当前K线没有前一根K线（即是第一根K线），则初始化为向下（默认向上也可以）。

1.K线包含关系及方向说明图：

2.K线包含关系推论1

3、K线包含关系推论2

4、K线包含关系的分类

5、K线包含关系处理示范

至此概念学完，后面需要研究怎样实现。

实现逻辑也不是太难，大体逻辑如下：首先判断当前K线与前一根相比是否为独立K线，若是，则进行独立K线处理，否则进行简单包含K线处理，之后设置下一根K线为当前K线，然后进入for循环模式，判断是否存在下一根K线，不存在直接就结束了，存在则再次判断是否为独立K线，是的话进行独立K线处理，否则进入复杂包含K线处理，然后将下一根K线设置为当前K线，直到for循环结束退出程序。流程图如下所示：

独立K线的处理很简单，如下图所示：

简单包含K线的处理和复杂包含K线的处理略为复杂，复杂的原因是需要区分向上K线和向下K线的处理

最后，所有的包含处理都是调用了最基础的包含K线的处理逻辑

至此，K线标准化的主要逻辑就完成了，实现的效果图如下所示：

贴出核心代码：

K线定义：

class KLine:
    """K线类
    """
    def __init__(self, time=0, open=0, high=0, low=0, close=0, volume=0, symbol=""):
        self.time = time    # 时间
        self.open = open    # 开
        self.high = high    # 高
        self.low = low      # 低
        self.close = close  # 收
        self.volume = volume    # 成交量
        self.symbol = symbol    # 合约号

    def __str__(self):
        return "t:{},o:{},h:{},l:{},c:{},v:{}".\
            format(str(datetime.fromtimestamp(self.time)),
                   self.open, self.high, self.low, self.close, self.volume)

    def __repr__(self):
        return self.__str__()

合并K线定义：

class stCombineK:
    """K线合并类
    """
    def __init__(self, data, begin, end, base, isup):
        self.data: KLine = data     # K线数据
        self.pos_begin: int = begin      # 起始
        self.pos_end: int = end          # 结束
        self.pos_extreme: int = base     # 最高或者最低位置,极值点位置
        self.isUp: KSide = KSide(isup)            # 是否向上
        # print(self.isUp)

    def __str__(self):
        up = "up" if self.isUp == KSide.UP else "down"
        return "[{}]:begin:{},end:{},base:{}".format(up, self.pos_begin, self.pos_end, self.pos_extreme)

    def __repr__(self):
        return self.__str__()

独立K线和包含K线的处理逻辑：

    def IndependentK(b_up: KSide):
        """用于处理独立K线的情况，更新标志和指针，并进行值的拷贝"""
        nonlocal pPrev
        nonlocal pLast
        pPrev = pCur
        pLast += 1  # 每处理一根独立K线，pLast增加1
        combs[pLast] = copy.deepcopy(combs[pCur])    # 值的拷贝，而不是指针, 总是拷贝第一个
        combs[pLast].isUp = b_up
        return

    def ContainsK(low, high, index, pos_end):
        """用于处理包含K线的情况，更新K线的数据和位置"""
        nonlocal pPrev
        combs[pLast].data.low = low
        combs[pLast].data.high = high
        combs[pLast].pos_end = pos_end
        combs[pLast].pos_extreme = index

        pPrev = pLast
        return

合并所有K线一开始的初始化部分

    size = len(combs)
    if len(combs) < 2:    # <=2时，返回本身的长度
        return size

    pBegin = 0      # 起始位置
    pLast = pBegin  # 最后一个独立K线的位置
    pPrev = pBegin  # 前一个独立K线的位置
    pCur = pBegin + 1           # 当前K线的位置
    pEnd = pBegin + size - 1    # 最后一个K线位置

前两根K线的处理流程：

 # 初始合并逻辑
    if greater_than_0(combs[pCur].data.high - combs[pPrev].data.high) and \
        greater_than_0(combs[pCur].data.low - combs[pPrev].data.low):
        # 高点升，低点也升, 向上
        IndependentK(KSide.UP)
    elif less_than_0(combs[pCur].data.high - combs[pPrev].data.high) and \
        less_than_0(combs[pCur].data.low - combs[pPrev].data.low):
        # 高点降，低点也降，向下
        IndependentK(KSide.DOWN)
    else:
        if greater_than_0(combs[pCur].data.high - combs[pPrev].data.high) or \
            less_than_0(combs[pCur].data.low - combs[pPrev].data.low):
            # 高点高于前 或是 低点低于前， 右包含，向上合并
            ContainsK(combs[pPrev].data.low, combs[pCur].data.high, combs[pCur].pos_begin, combs[pCur].pos_begin)
        else:   # 左包函，即低点高于前，高点低于前，也向上合并
            ContainsK(combs[pCur].data.low, combs[pPrev].data.high, combs[pPrev].pos_begin, combs[pCur].pos_begin)
    pCur += 1   # 当前pCur向后走一步

两根K线之后循环处理的流程：

 while pCur <= pEnd:
        if greater_than_0(combs[pCur].data.high - combs[pPrev].data.high) and \
                greater_than_0(combs[pCur].data.low - combs[pPrev].data.low):
            IndependentK(KSide.UP)  # 独立K 向上
        elif less_than_0(combs[pCur].data.high - combs[pPrev].data.high) and \
                less_than_0(combs[pCur].data.low - combs[pPrev].data.low):
            IndependentK(KSide.DOWN)    # 独立K 向下
        else:
            # 包含
            if greater_than_0(combs[pCur].data.high - combs[pPrev].data.high) or \
                    less_than_0(combs[pCur].data.low - combs[pPrev].data.low):
                    # 右包含
                if combs[pLast].isUp == KSide.UP:    # 向上，一样高取左极值，不一样高肯定是右高，取右值
                    pos_index = combs[pPrev].pos_extreme if equ_than_0(combs[pCur].data.high - combs[pPrev].data.high) \
                        else combs[pCur].pos_begin
                    ContainsK(combs[pPrev].data.low, combs[pCur].data.high, pos_index, combs[pCur].pos_begin)
                else:         # 向下，一样低取左极值，不一样低肯定是右低，取右值
                    pos_index = combs[pPrev].pos_extreme if equ_than_0(combs[pCur].data.low - combs[pPrev].data.low) \
                        else combs[pCur].pos_begin
                    ContainsK(combs[pCur].data.low, combs[pPrev].data.high, pos_index, combs[pCur].pos_begin)
            else:   # 左包含
                if combs[pLast].isUp == KSide.UP:  # 向上，一样高取左极值，否则高肯定是右高，取右值
                    pos_index = combs[pPrev].pos_begin if combs[pPrev].pos_begin == combs[pPrev].pos_end \
                        else combs[pPrev].pos_extreme
                    ContainsK(combs[pCur].data.low, combs[pPrev].data.high, pos_index, combs[pCur].pos_begin)
                else:       # 向下，一样低取左极值，否则低肯定是右低，取右值
                    pos_index = combs[pPrev].pos_begin if combs[pPrev].pos_begin == combs[pPrev].pos_end \
                        else combs[pPrev].pos_extreme
                    ContainsK(combs[pPrev].data.low, combs[pCur].data.high, pos_index, combs[pCur].pos_begin)
        pCur += 1

至此K线的合并解决