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