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

之前学过几轮缠论，由于总总缘故原由，止步于缠论的线段。最近发现有一点时间了，再来学习一下。
缠论的基础是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线定义：

1. class KLine:
2.     """K线类
3.     """
4.     def __init__(self, time=0, open=0, high=0, low=0, close=0, volume=0, symbol=""):
5.         self.time = time    # 时间
6.         self.open = open    # 开
7.         self.high = high    # 高
8.         self.low = low      # 低
9.         self.close = close  # 收
10.         self.volume = volume    # 成交量
11.         self.symbol = symbol    # 合约号
13.     def __str__(self):
14.         return "t:{},o:{},h:{},l:{},c:{},v:{}".\
15.             format(str(datetime.fromtimestamp(self.time)),
16.                    self.open, self.high, self.low, self.close, self.volume)
18.     def __repr__(self):
19.         return self.__str__()

复制代码

合并K线定义：

1. class stCombineK:
2.     """K线合并类
3.     """
4.     def __init__(self, data, begin, end, base, isup):
5.         self.data: KLine = data     # K线数据
6.         self.pos_begin: int = begin      # 起始
7.         self.pos_end: int = end          # 结束
8.         self.pos_extreme: int = base     # 最高或者最低位置,极值点位置
9.         self.isUp: KSide = KSide(isup)            # 是否向上
10.         # print(self.isUp)
12.     def __str__(self):
13.         up = "up" if self.isUp == KSide.UP else "down"
14.         return "[{}]:begin:{},end:{},base:{}".format(up, self.pos_begin, self.pos_end, self.pos_extreme)
16.     def __repr__(self):
17.         return self.__str__()

复制代码

独立K线和包含K线的处置惩罚逻辑：

1.     def IndependentK(b_up: KSide):
2.         """用于处理独立K线的情况，更新标志和指针，并进行值的拷贝"""
3.         nonlocal pPrev
4.         nonlocal pLast
5.         pPrev = pCur
6.         pLast += 1  # 每处理一根独立K线，pLast增加1
7.         combs[pLast] = copy.deepcopy(combs[pCur])    # 值的拷贝，而不是指针, 总是拷贝第一个
8.         combs[pLast].isUp = b_up
9.         return
11.     def ContainsK(low, high, index, pos_end):
12.         """用于处理包含K线的情况，更新K线的数据和位置"""
13.         nonlocal pPrev
14.         combs[pLast].data.low = low
15.         combs[pLast].data.high = high
16.         combs[pLast].pos_end = pos_end
17.         combs[pLast].pos_extreme = index
19.         pPrev = pLast
20.         return

复制代码

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

1.     size = len(combs)
2.     if len(combs) < 2:    # <=2时，返回本身的长度
3.         return size
5.     pBegin = 0      # 起始位置
6.     pLast = pBegin  # 最后一个独立K线的位置
7.     pPrev = pBegin  # 前一个独立K线的位置
8.     pCur = pBegin + 1           # 当前K线的位置
9.     pEnd = pBegin + size - 1    # 最后一个K线位置

复制代码

前两根K线的处置惩罚流程：

1. # 初始合并逻辑
2.     if greater_than_0(combs[pCur].data.high - combs[pPrev].data.high) and \
3.         greater_than_0(combs[pCur].data.low - combs[pPrev].data.low):
4.         # 高点升，低点也升, 向上
5.         IndependentK(KSide.UP)
6.     elif less_than_0(combs[pCur].data.high - combs[pPrev].data.high) and \
7.         less_than_0(combs[pCur].data.low - combs[pPrev].data.low):
8.         # 高点降，低点也降，向下
9.         IndependentK(KSide.DOWN)
10.     else:
11.         if greater_than_0(combs[pCur].data.high - combs[pPrev].data.high) or \
12.             less_than_0(combs[pCur].data.low - combs[pPrev].data.low):
13.             # 高点高于前 或是 低点低于前， 右包含，向上合并
14.             ContainsK(combs[pPrev].data.low, combs[pCur].data.high, combs[pCur].pos_begin, combs[pCur].pos_begin)
15.         else:   # 左包函，即低点高于前，高点低于前，也向上合并
16.             ContainsK(combs[pCur].data.low, combs[pPrev].data.high, combs[pPrev].pos_begin, combs[pCur].pos_begin)
17.     pCur += 1   # 当前pCur向后走一步

复制代码

两根K线之后循环处置惩罚的流程：

1. while pCur <= pEnd:
2.         if greater_than_0(combs[pCur].data.high - combs[pPrev].data.high) and \
3.                 greater_than_0(combs[pCur].data.low - combs[pPrev].data.low):
4.             IndependentK(KSide.UP)  # 独立K 向上
5.         elif less_than_0(combs[pCur].data.high - combs[pPrev].data.high) and \
6.                 less_than_0(combs[pCur].data.low - combs[pPrev].data.low):
7.             IndependentK(KSide.DOWN)    # 独立K 向下
8.         else:
9.             # 包含
10.             if greater_than_0(combs[pCur].data.high - combs[pPrev].data.high) or \
11.                     less_than_0(combs[pCur].data.low - combs[pPrev].data.low):
12.                     # 右包含
13.                 if combs[pLast].isUp == KSide.UP:    # 向上，一样高取左极值，不一样高肯定是右高，取右值
14.                     pos_index = combs[pPrev].pos_extreme if equ_than_0(combs[pCur].data.high - combs[pPrev].data.high) \
15.                         else combs[pCur].pos_begin
16.                     ContainsK(combs[pPrev].data.low, combs[pCur].data.high, pos_index, combs[pCur].pos_begin)
17.                 else:         # 向下，一样低取左极值，不一样低肯定是右低，取右值
18.                     pos_index = combs[pPrev].pos_extreme if equ_than_0(combs[pCur].data.low - combs[pPrev].data.low) \
19.                         else combs[pCur].pos_begin
20.                     ContainsK(combs[pCur].data.low, combs[pPrev].data.high, pos_index, combs[pCur].pos_begin)
21.             else:   # 左包含
22.                 if combs[pLast].isUp == KSide.UP:  # 向上，一样高取左极值，否则高肯定是右高，取右值
23.                     pos_index = combs[pPrev].pos_begin if combs[pPrev].pos_begin == combs[pPrev].pos_end \
24.                         else combs[pPrev].pos_extreme
25.                     ContainsK(combs[pCur].data.low, combs[pPrev].data.high, pos_index, combs[pCur].pos_begin)
26.                 else:       # 向下，一样低取左极值，否则低肯定是右低，取右值
27.                     pos_index = combs[pPrev].pos_begin if combs[pPrev].pos_begin == combs[pPrev].pos_end \
28.                         else combs[pPrev].pos_extreme
29.                     ContainsK(combs[pPrev].data.low, combs[pCur].data.high, pos_index, combs[pCur].pos_begin)
30.         pCur += 1

复制代码

至此K线的合并解决

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。