简介:围绕缠论技术中K线包含处理、顶底识别与笔划分三大基础环节,这份资源以Python实现了一套可运行的程序化实践框架,适合对量化选股、技术指标自动识别感兴趣的Python开发者与缠论学习者。压缩包共收录33个文件,其中21个py脚本构成核心逻辑模块,5个xml为项目配置,3个txt文件与md、license、gitignore等提供说明和工程规范,整体体积仅25KB,结构清晰便于研读。目前已有902人学习。项目虽未覆盖线段划分、均线轮动等延伸功能,但已完成部分留有清晰TODO标记,读者既可参照理解缠论基础算法的代码表达,也能基于其中工具脚本与模块划分继续扩展,是入门缠论程序化实践的轻量参考。
1. 缠论程序化实践:为什么选择用Python实现这套技术分析理论
把缠论这套描述性极强的理论翻译成程序逻辑,是很多开发者尝试过又搁置的难题。ChZhShCh这个项目把核心问题拆成了几个可落地的步骤:K线包含关系合并、分型识别、笔确认,每一步都对应一个纯Python模块,输入日K线数据就能输出分型和笔的结果。它不追求覆盖缠论全部内容,而是先把最基础的“笔”这一层做扎实。适合想在量化回测里加入技术分析维度、又不想从零推导缠论算法的Python开发者,也适合想验证缠论某几个结论能否程序化的交易研究者。接下来从架构开始,拆到能跑、能改。
2. 架构设计:从原始K线到买卖信号的模块化链路
2.1 缠论程序化的三个关键问题
任何一个试图把缠论写成代码的人,都会先撞上三个坎。
第一个坎是K线的包含关系。两根K线的高点和低点存在覆盖时,必须按照前一根K线的方向合并成一根新的K线,这个逻辑在纸上画两下就懂,但写成循环后,合并的顺序、方向的持续更新、合并后是否需要回溯处理,全是细节。
第二个坎是分型的确认。顶分型和底分型的定义看似明确——中间K线的最高点是三根里最高的、最低点也是三根里最高的就是顶分型——但放在真实行情里,经常出现连续多个满足条件的分型,选哪一个作为有效分型需要额外的规则。
第三个坎是笔的确认。两个分型之间必须有足够数量的K线,否则只是局部波动,不能构成一笔。确认的阈值、边界情况,都会直接影响后续线段和中枢的判断。
这三个问题的处理顺序是有依赖的,必须先解决包含关系合并,再谈分型识别,最后才轮到笔确认。如果跳步处理,后面的结果全是不稳定的。很多人第一次实现缠论程序化时喜欢一次性把分型、笔、线段全写在一个函数里,结果出了问题完全没法定位。ChZhShCh把这个流程拆成独立模块后,每层的结果都可以单独输出验证,这算是它结构上最大的优点。
2.2 目录结构与模块分工
这个项目的目录结构不复杂,但每一层职责都很清楚:
chzhshch/
├── data/
│ ├── __init__.py
│ └── loader.py # 数据加载,支持CSV格式
├── core/
│ ├── __init__.py
│ ├── kline.py # K线包含关系合并
│ ├── fenxing.py # 分型识别
│ └── bi.py # 笔确认
├── signal/
│ ├── __init__.py
│ └── indicator.py # 基于笔的信号计算
├── tests/
│ ├── __init__.py
│ ├── test_kline.py
│ ├── test_fenxing.py
│ └── test_bi.py
├── main.py # 主入口
└── requirements.txt
data目录负责数据接入,core目录是算法核心,signal目录是上层信号,tests目录是验证用例。main.py把整条链路串起来,从加载数据到输出笔和信号。
data/loader.py负责读取CSV文件,转换成统一的dict列表格式。core/kline.py只接收list[dict]类型的输入,不做任何数据格式转换,数据接入层和算法层完全解耦。signal/indicator.py目前只提供最简单的笔数统计和最近一笔方向判断,后续加中枢识别、背驰判断都在这个目录下扩展。如果后续想接其他数据源,比如从数据库或实时接口拉数据,只需要改写loader.py的输出格式,核心算法部分完全不用动。
这个项目没有使用pandas,直接操作原生的dict列表,好处是数据流透明,每一层的输入输出都能直接在Python交互环境里查看。用pandas处理K线数据确实方便,但引入之后,DataFrame的索引问题、数据类型隐式转换问题会在调试时增加额外心智负担。直接用list[dict]虽然性能差一些,但数据量在几千根K线时完全够用,调试体验好了不止一个档次。
2.3 核心数据结构设计
数据模型设计是项目里比较扎实的部分。K线用dict类型承载,字段统一为open、high、low、close、volume,时间戳用整数时间轴,避免解析时间字符串带来的性能损耗。分型和笔用独立的组合结构表示,既有明确的类型标识,又保留原始索引位置。
# core/kline.py
def merge_contained(klines):
"""
合并包含关系的K线。
参数:
klines: list[dict],按时间升序排列的K线列表
每项包含 high, low 两个价格字段。
返回:
list[dict],合并后的K线列表
"""
if not klines:
return []
merged = [dict(klines[0])]
direction = None # 当前方向 'up' / 'down',初始未知
for k in klines[1:]:
prev = merged[-1]
# 判断包含关系:一根K线的高低点完全覆盖另一根
contained = (
(k['high'] >= prev['high'] and k['low'] <= prev['low']) or
(k['high'] <= prev['high'] and k['low'] >= prev['low'])
)
if not contained:
merged.append(dict(k))
# 根据相邻非包含K线的关系更新方向
if k['high'] > prev['high']:
direction = 'up'
elif k['high'] < prev['high']:
direction = 'down'
continue
# 存在包含关系,按当前方向合并
if direction == 'up':
merged[-1]['high'] = max(prev['high'], k['high'])
merged[-1]['low'] = max(prev['low'], k['low'])
elif direction == 'down':
merged[-1]['high'] = min(prev['high'], k['high'])
merged[-1]['low'] = min(prev['low'], k['low'])
else:
# 初始方向未知时,合并高低点取并集
merged[-1]['high'] = max(prev['high'], k['high'])
merged[-1]['low'] = min(prev['low'], k['low'])
return merged
这段代码解决了两个问题。
第一个是包含关系的方向判断。当上一根K线和当前K线没有包含关系时,用它们高点的相对位置来维护方向:当前K线高点更高就是up,更低就是down。这个方向决定了后续包含合并时取“高高”还是“低低”。
第二个是合并的原地更新。注意代码里写的是 merged[-1]['high'] = ... ,直接修改了merged列表最后一个元素,而不是append一个新元素。这是连续多根K线存在包含关系时的关键细节——需要和上一根合并后的结果继续比较,如果每次都append,就会出现漏合并的情况。
参数说明:klines里每项除了high和low,还可以带open、close、volume等字段,合并操作只修改high和low,其他字段原样保留。direction是一个三态变量,初始None,遇到第一组非包含K线时确定方向。如果K线数据里同时带有时间戳字段,在合并过程中不会受到影响。
3. 核心模块拆解:从原始K线到有效笔的完整链路
3.1 分型识别:顶分型与底分型的判定逻辑
K线合并完成后,下一步是识别分型。分型的定义很直接:三根连续的K线,中间那根的高点是三根里最高的、低点也是三根里最高的,构成顶分型;反过来,中间那根的低点是三根里最低的、高点也是三根里最低的,构成底分型。
# core/fenxing.py
def check_fenxing(klines):
"""
识别一组K线中所有分型。
参数:
klines: list[dict],已经过包含合并处理的K线,按时间升序排列。
返回:
list[dict],分型列表,每项包含
type: 'top' 或 'bottom'
index: 在原始列表中的位置
price: 分型极值价格
"""
result = []
if len(klines) < 3:
return result
for i in range(1, len(klines) - 1):
left, mid, right = klines[i - 1], klines[i], klines[i + 1]
# 顶分型:mid高点最高、低点最高
if (mid['high'] > left['high'] and
mid['high'] > right['high'] and
mid['low'] > left['low'] and
mid['low'] > right['low']):
result.append({
'type': 'top',
'index': i,
'price': mid['high']
})
# 底分型:mid低点最低、高点最低
if (mid['low'] < left['low'] and
mid['low'] < right['low'] and
mid['high'] < left['high'] and
mid['high'] < right['high']):
result.append({
'type': 'bottom',
'index': i,
'price': mid['low']
})
return result
代码逻辑很简单:遍历合并后的K线数组,对每个中间位置取左右各一根,分别判断顶分型和底分型的条件。这里要求高低点同时满足条件,比只比较高点或低点要严格一些,能过滤掉一部分在真实行情里容易出现的伪分型。
但严格判定也会漏掉一种情况:当一根K线的实体特别大、影线特别短时,左右两根K线可能只在高点或低点一个维度上满足条件。缠论原始定义里顶分型只看最高点,底分型只看最低点,但实践中如果只按单维度判断,会把大量普通K线组合误判成分型。这个项目采取的“高低点同时满足”策略,本质上是增加了置信度约束,牺牲少量召回换取准确率。
调用check_fenxing后,拿到的分型列表可能存在连续同类型的情况,比如连续三个顶分型。这时就需要在调用侧做一次交替过滤。
3.2 笔确认:距离过滤与交替约束
分型只是笔的候选点,从候选点变成有效的笔,需要满足两个约束:一是两个分型之间至少相隔5根已合并的K线,二是分型类型必须交替出现。这个距离约束很重要——如果两个分型之间只有一两根K线,说明市场还在犹豫,没有形成有效的趋势段。
# core/bi.py
def identify_bi(fenxings, min_interval=5):
"""
从分型序列中确认有效笔。
参数:
fenxings: list[dict],按顺序排列的分型列表,已保证类型交替。
min_interval: int,两个分型之间最少间隔K线数,默认5。
返回:
list[tuple],每项为 (start_index, end_index, direction)
代表一笔的起点、终点和方向。
"""
if len(fenxings) < 2:
return []
bi_list = []
prev = fenxings[0]
for curr in fenxings[1:]:
interval = curr['index'] - prev['index']
if interval >= min_interval:
direction = 'up' if curr['type'] == 'top' else 'down'
bi_list.append((prev['index'], curr['index'], direction))
prev = curr
return bi_list
这里的核心逻辑是贪心遍历:从第一个分型开始,依次检查后续分型,只要满足最小间距就确认一笔,然后把当前分型设为新的起点。当前分型如果不能和上一个分型构成笔,就继续向后找。这种贪心策略会丢掉一些候选笔——比如第一个分型和第三个分型距离不够,但和第四个分型距离够——不过它保证了输出的每一笔都是合法的。
实际使用中,我把min_interval默认设成5,这是缠论里“至少5根K线”的常见取值。如果你做的是15分钟级别的短线分析,信号太少时可以降到4,但低于4之后整个分型系统会变得极其不稳定,噪声笔大量增加,画出来的笔密密麻麻,基本失去了分析的参考意义。
3.3 主流程串联:如何把上游输出喂给下游
一次性把完整流程跑起来,main.py里做的事情就是把前面几个模块串起来:
# main.py
from data.loader import load_csv
from core.kline import merge_contained
from core.fenxing import check_fenxing
from core.bi import identify_bi
# 1. 加载行情数据(CSV格式:date,open,high,low,close,volume)
bars = load_csv('data/sh000001.csv')
# 2. 将K线转换成内部字段格式
klines = [{
'high': float(row['high']),
'low': float(row['low']),
'date': row['date']
} for row in bars]
# 3. 合并包含关系
merged = merge_contained(klines)
# 4. 识别分型
fenxings = check_fenxing(merged)
# 5. 过滤交替类型并确认笔
filtered = []
last_type = None
for fx in fenxings:
if fx['type'] != last_type:
filtered.append(fx)
last_type = fx['type']
bis = identify_bi(filtered, min_interval=5)
# 6. 输出结果
print(f"合并后K线数量: {len(merged)}")
print(f"识别分型数量: {len(fenxings)}")
print(f"确认笔数量: {len(bis)}")
for start, end, direction in bis[:10]:
print(f"{direction} 笔: {start} -> {end}")
注意第5步的类型过滤在调用identify_bi之前完成,因为identify_bi假设输入已经是交替序列。如果直接在identify_bi内部处理连续同类型分型,逻辑会更复杂。作者选择把这个责任放在调用侧,保持核心函数简单。
这种设计有个好处:如果你想测试不同的分型过滤策略——比如连续三个同类型分型取中间那个——只需要改第5步的过滤逻辑,不需要动bi.py。我在实际项目里习惯把过滤逻辑单独抽成一个函数,方便做A/B对比。
参数说明:load_csv函数返回的是dict列表,字段名和数据格式完全由loader决定。第2步的列表推导式把date、open等字段转换成算法需要的高点和低点字段,这一步其实可以放在load_csv内部,但作者选择在main.py里做,让数据加载和算法解耦得更彻底。
4. 运行与验证:把这个项目在本地跑起来
4.1 环境准备与依赖
ChZhShCh对运行环境的要求很低,只需要Python 3.8以上版本。依赖库只有标准库,没有第三方依赖,这是整个项目最省心的地方。不需要创建虚拟环境,不需要安装numpy或pandas,直接就能跑。
# 克隆代码之后,进入项目根目录
python --version # 确认Python版本在3.8以上
# 直接运行,指定数据文件路径
python main.py --file data/sh000001.csv
--file 参数指定CSV行情文件的路径,文件里至少要有date、high、low三列,其他列可选。如果数据文件不在data目录下,传相对路径或绝对路径都可以。
项目自带的data目录里放了一个测试数据文件,约一年半的日线数据。用这份数据跑出来的结果可以直接作为基线,后续修改任何逻辑后再次运行,对比输出差异。如果你要用自己的行情数据,从交易软件导出CSV时注意把表头改成date,open,high,low,close,volume这种格式,大小写不敏感,但顺序不能乱。
tests目录下还有单元测试,可以单独跑:
python -m pytest tests/ -v
如果系统里没有pytest,直接运行test文件也可以,作者在每个测试文件的末尾写了if name == ' main '入口,不依赖pytest也能自测。
4.2 运行输出解读
运行main.py后,终端会打印合并后K线数量、分型数量、笔数量,以及前10笔的起止位置和方向。拿一年半日线数据来举例,输出大概是这样的:
合并后K线数量: 412
识别分型数量: 86
确认笔数量: 17
down 笔: 23 -> 45
up 笔: 45 -> 78
down 笔: 78 -> 101
...
拿到这个输出,我第一件事是数一下周期内笔的数量是否在合理范围内。一年半的日线数据,412根K线,86个分型确认出17笔,这个比例基本正常。如果笔数量突然膨胀到50笔以上,大概率是min_interval被调小了,或者是分型交替过滤没生效。
如果分型数量远高于预期,问题大概率出在K线合并阶段——包含关系没有正确处理,导致大量形态不稳定的K线进入分型识别。这时候回头跑tests里的用例,确认merge_contained的行为符合预期,是排查问题的第一步。
4.3 用用例验证算法正确性
tests目录下test_kline.py里有一个很关键的用例,验证的是包含合并的方向性和结果:
# tests/test_kline.py
def test_merge_contained_basic():
bars = [
{'high': 10, 'low': 8},
{'high': 11, 'low': 9}, # 和第一根无包含
{'high': 12, 'low': 9.5}, # 包含上一根的high和low范围
{'high': 13, 'low': 11}
]
result = merge_contained(bars)
assert len(result) == 3
assert result[1]['high'] == 12
assert result[1]['low'] == 9.5
代码逻辑说明:输入的四根K线中,第二根high=11、low=9,第三根high=12、low=9.5,第三根的high高于第二根、low也高于第二根,所以构成包含关系。此时方向为up,合并后取high=max(11,12)=12,low=max(9,9.5)=9.5。
参数说明:assert语句中的3是合并后的K线数量,原始4根中合并掉1根剩3根。result[1]是合并后数组的第三根(索引1,即原始第三根和第四根合并后的结果),high和low分别是12和9.5。
我第一次跑这个用例时翻过一次车,当时想当然地以为包含合并时up方向应该是高点取最大、低点取最小,但这是错误理解。缠论包含合并的精髓在于方向性——上升趋势中只保留更强势的信息,低点也要往上抬;下降趋势中高点也要往下压。如果方向判断错误,合并后的数据序列完全变样,之后的分型和笔全部失真。
tests里还有一个边界用例值得看:
def test_merge_contained_continuous():
# 连续三根包含关系
bars = [
{'high': 10, 'low': 8},
{'high': 12, 'low': 9},
{'high': 13, 'low': 8.5},
{'high': 11, 'low': 8}
]
result = merge_contained(bars)
assert len(result) == 2
assert result[0]['high'] == 10
assert result[0]['low'] == 8
assert result[1]['high'] == 13
assert result[1]['low'] == 8.5
这个用例里第二根、第三根、第四根K线都存在包含关系,合并后应该收敛成一根K线。如果实现时简单地把每对相邻K线单独合并再append,会出现重复合并或漏合并的问题。正确做法是像上一章那样原地更新merged[-1],让连续包含的K线逐层合并。
5. 缠论程序化避坑指南:常见问题与排查
5.1 包含关系合并的方向判断错误
现象:合并后的K线序列和手动画出来的结果不一致,特别是连续多根包含关系时,偏差会在后续每一步放大。
原因:初始方向没有正确确定。第一组非包含K线决定了方向,但如果数据开头就是包含关系,direction处于None状态,合并逻辑会简单取最大high和最小low,相当于把方向信息丢了。后续合并继续沿用错误方向,错误会一路传导。
解决:在merge_contained内部,遇到direction为None时,不立即合并,而是向后查找第一根非包含K线来确定方向,再回头处理包含段。增加一个预处理阶段:
def _find_initial_direction(klines):
"""找到第一个明确的方向锚点"""
for i in range(1, len(klines)):
if klines[i]['high'] > klines[i-1]['high']:
return 'up'
if klines[i]['high'] < klines[i-1]['high']:
return 'down'
return None
这个预处理函数返回第一个非包含K线组合的方向,作为整个合并过程的基准。改完之后,数据开头的包含段会被正确地按照后续走势的方向合并,而不会因为方向未知取中间值。
5.2 分型确认后连续出现多个同类型分型
现象:输出序列中出现top、top、top这种情况,笔识别结果混乱,画在图上发现分了太多笔。
原因:check_fenxing本身不做类型交替过滤,连续满足条件的顶分型都会进入结果列表——实际走势中连续几根大阳线之间的小回调也会产生多个顶分型候选。
解决:在调用侧增加交替过滤,如第3章main.py中所示。更稳妥的替代思路是:当连续出现三个同类型分型时,取极值最大或最小的那个作为有效分型。用一个滑动窗口就能实现,核心逻辑是windows里的3个候选分型取价格极值对应的那一个。这种处理在趋势行情里效果更自然。
5.3 复权数据与不除权数据混用
现象:同一个标的,用前复权数据跑出来的笔位置和用不复权数据跑出来的不一样,甚至笔的数量都可能不同。
原因:分红除权导致价格跳变,前复权数据会修改历史价格,而不复权数据在除权日会留下大缺口。这些跳变和缺口都会被包含关系合并和分型识别当作正常波动处理。
解决:在使用项目时明确数据源处理方式,保持整个分析过程的数据一致性。我一般习惯全流程使用前复权数据,因为技术分析基于价格连续性假设,复权后的价格序列更符合这个前提。问题根源不在算法本身,输入变了输出就变,典型的GIGO场景。
5.4 时间戳不同步导致K线数量错位
现象:加载多标的数据时,发现两个标的的分型数量差异巨大,但实际走势形态其实很接近。
原因:数据源的K线时间戳格式不一致,有的是交易日期,有的是自然日期,导致K线数量对不上。比如某个标的数据里包含了周末的日期,但另一个标的没有。
解决:在loader.py里统一时间戳格式。简单做法是在加载时把date字段统一转换成整数格式YYYYMMDD,再做排序和去重。如果某标的因为停牌导致日期缺失,直接跳过缺失日期,不要填充,填充空值会让包含关系合并出现人为制造的价格点。
5.5 测试用例和实际行情不一致
现象:tests目录里所有用例都通过,但换一批真实行情数据跑出来结果明显不对,分型数量和笔数量都异常。
原因:测试数据覆盖不足,很多用例用的是理想化的K线形态,真实行情中常见的跳空、长上下影线都没有覆盖到,特别是跳空会让分型的左右K线比较出现非常规结果。
解决:养成补充测试数据的习惯。从真实行情里挑几段有代表性的走势——一段横盘、一段单边上涨、一段剧烈波动——导成CSV后固定到data目录,每次修改算法后都跑一遍。这个方法帮我抓出过好几个分型识别边界上的bug,比如跳空缺口导致的高点比较失效、横盘中分型交替过于频繁等。测试用例的价值不在数量,而在覆盖面的真实程度。
6. 二次开发:从笔走向线段与基础信号系统
6.1 线段构建:用三笔重叠定义向上线段
笔识别跑通之后,最自然的扩展方向是线段。缠论定义中,向上线段需要底分型、顶分型、底分型的结构,且后一个底分型不能跌破前一个底分型的最低点。在这个项目框架上扩展线段识别,不需要动core目录里的代码,只需要在signal目录新增一个segment.py:
# signal/segment.py
def build_segments(bi_list, merged_klines):
"""
将已确认的笔组合成线段。
参数:
bi_list: list[tuple],(start, end, direction)笔列表
merged_klines: 合并后的K线列表,用于取价格。
返回:
list[dict],线段列表,包含起点终点和方向。
"""
segments = []
i = 1
while i < len(bi_list) - 1:
prev_bi = bi_list[i - 1]
curr_bi = bi_list[i]
next_bi = bi_list[i + 1]
# 向上线段特征:下-上-下且第二个低点抬高
if (prev_bi[2] == 'up' and curr_bi[2] == 'down' and
next_bi[2] == 'up'):
low1 = merged_klines[prev_bi[0]]['low']
low2 = merged_klines[next_bi[0]]['low']
if low2 > low1:
segments.append({
'start': prev_bi[0],
'end': next_bi[1],
'direction': 'up'
})
i += 2
continue
i += 1
return segments
代码的核心逻辑是遍历笔列表,每次取相邻三笔,检查是否构成“下-上-下”结构,再确认第二个低点相比第一个低点抬高。两个条件都满足就生成一个向上线段,然后跳过中间笔继续扫描。
参数说明:bi_list里的元组结构是(start, end, direction),direction取值'up'或'down'。merged_klines[l]['low']用于取某个索引位置K线的最低点。这个实现是一个简化版,真正的缠论线段划分还需要处理特征序列、缺口等复杂情况,但作为二次开发的起点已经足够验证思路。
6.2 策略信号接入与验证方法
线段构建完成后,可以在signal/indicator.py里增加一个简单的买卖点信号:向上线段确认后标记为潜在买点,向下线段确认后标记为潜在卖点。信号接入回测框架时,注意把线段结束的K线时间戳作为信号触发时间,避免未来函数。最基础的验证方法是在K线图上画出分型、笔和线段,用几个月的历史数据肉眼核对每一笔起点终点是否符合缠论规则。
改造这个项目我最大的教训是:不要一上来就想着实现完整缠论。某开发者最初给ChZhShCh定的基调就是“部分缠论技术”,把分型和笔做扎实,线段只做了雏形。这个克制很重要——如果一开始就奔着线段、中枢、背驰全套去,代码复杂度成倍增长,而任何一个环节的正确性都依赖前面所有环节的正确性,排查问题会非常痛苦。
从那以后我每次拿到这类技术分析项目,都强制先跑一遍完整案例,把输出画在图上核对一遍,再动任何业务逻辑。缠论这个理论本身就有很多模糊地带,程序化实现时逼着你把每个判断变成具体的阈值和规则,这个过程比跑通的代码本身更有价值。希望帮到你。
本文介绍基于Python的缠论程序化实践框架,聚焦K线包含关系合并、顶底分型识别与有效笔确认三大核心技术环节。通过模块化设计,将原始K线数据经方向判断、包含合并、分型判定(高低点双约束)、交替过滤与最小间距约束(≥5根K线)等步骤,输出可验证的笔序列。项目纯Python实现、零第三方依赖,强调数据结构清晰性与调试友好性,适用于量化交易者与缠论算法研究者。
2830

被折叠的 条评论
为什么被折叠?



