快速开始
欢迎使用 TechKit！本指南将帮助您在 5 分钟内掌握 TechKit 的基本用法。即使您没有编程经验，也可以跟随本指南快速上手。
基本概念
TechKit 的使用遵循一个简单的三步模式：
创建 - 使用参数创建指标实例
更新/计算 - 用数据更新指标（增量）或批量计算
检查有效性 - 在使用结果前检查是否有效
什么是技术指标？
技术指标是基于历史价格数据计算出的数值，用于分析市场趋势、判断买卖时机。例如：
SMA (简单移动平均): 计算一段时间内的平均价格，用于识别趋势
RSI (相对强弱指标): 范围 0-100，用于判断超买/超卖
MACD: 用于识别趋势变化和动量
为什么需要检查有效性？
每个指标都需要一定数量的历史数据才能开始计算。例如，20 周期的 SMA 需要至少 20 个价格数据点。在数据不足时，结果标记为"无效"（valid=False），此时不应使用计算结果。
增量更新（实时数据流）
适用场景: 实时接收价格数据，需要立即计算指标
增量更新适合处理实时数据流，每次只处理一个新数据点，计算效率高（O(1)）。
import techkit as tk
# 步骤 1: 创建指标实例
# RSI(14) 表示使用 14 个周期计算相对强弱指标
rsi = tk.RSI(period=14)
# 步骤 2: 模拟实时价格流（实际应用中，这可能是从交易所 API 获取）
price_stream = [100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0, 106.2, 105.8]
# 步骤 3: 逐个处理价格数据
for price in price_stream:
# 更新指标，传入新的价格
result = rsi.update(price)
# 步骤 4: 检查结果是否有效
if result.valid: # 如果有效，说明已经有足够的数据计算指标
print(f"价格: {price:.2f}, RSI: {result.value:.2f}")
# 可以根据 RSI 值做交易决策
if result.value > 70:
print(" ⚠️ 超买信号（RSI > 70）")
elif result.value < 30:
print(" ⚠️ 超卖信号（RSI < 30）")
else:
# 数据不足，还不能计算指标
print(f"价格: {price:.2f}, RSI: 计算中... (需要更多数据)")
import { init, RSI } from 'techkit';
// 步骤 0: 初始化（必须在使用前调用一次）
await init();
// 步骤 1: 创建指标实例
const rsi = new RSI(14); // 14 周期 RSI
// 步骤 2: 模拟实时价格流
const priceStream = [100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0, 106.2, 105.8];
// 步骤 3: 逐个处理价格数据
for (const price of priceStream) {
// 更新指标
const result = rsi.update(price);
// 步骤 4: 检查结果是否有效
if (result.valid) {
console.log(`价格: ${price.toFixed(2)}, RSI: ${result.value.toFixed(2)}`);
// 交易决策
if (result.value > 70) {
console.log(' ⚠️ 超买信号（RSI > 70）');
} else if (result.value < 30) {
console.log(' ⚠️ 超卖信号（RSI < 30）');
}
} else {
console.log(`价格: ${price.toFixed(2)}, RSI: 计算中... (需要更多数据)`);
}
}
// 清理资源（重要！）
rsi.dispose();
#include <techkit/techkit.hpp>
#include <iostream>
#include <vector>
int main() {
// 步骤 1: 创建指标实例
auto rsi = techkit::Indicator::RSI(14);
// 步骤 2: 模拟实时价格流
std::vector<double> price_stream = {100.0, 101.5, 102.3, 101.8, 103.2,
104.1, 103.5, 105.0, 106.2, 105.8};
// 步骤 3: 逐个处理价格数据
for (double price : price_stream) {
// 更新指标
auto result = rsi.update(price);
// 步骤 4: 检查结果是否有效
if (result.valid) {
std::cout << "价格: " << price << ", RSI: " << result.value << std::endl;
// 交易决策
if (result.value > 70) {
std::cout << " ⚠️ 超买信号（RSI > 70）" << std::endl;
} else if (result.value < 30) {
std::cout << " ⚠️ 超卖信号（RSI < 30）" << std::endl;
}
} else {
std::cout << "价格: " << price << ", RSI: 计算中... (需要更多数据)" << std::endl;
}
}
return 0; // 指标自动释放
}
批量计算（历史数据分析）
适用场景: 已有完整的历史数据，需要一次性计算所有指标值
批量计算适合分析历史数据，一次性处理所有数据点，性能高效。
import techkit as tk
import numpy as np
# 步骤 1: 准备历史价格数据
# 这里使用 NumPy 数组（推荐），也可以使用 Python 列表
prices = np.array([100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0,
106.2, 105.8, 107.0, 106.5, 108.0, 107.5, 109.0, 108.5,
110.0, 109.5, 111.0, 110.5, 112.0, 111.5, 113.0, 112.5])
# 步骤 2: 批量计算指标
# calculate() 方法返回一个 NumPy 数组，包含每个位置对应的指标值
rsi_values = tk.RSI(14).calculate(prices) # 计算 RSI
sma_values = tk.SMA(20).calculate(prices) # 计算 SMA
# 步骤 3: 理解结果
# 结果数组中，NaN (Not a Number) 表示该位置数据不足，无法计算指标
# 例如，RSI(14) 需要 14 个数据点，所以前 13 个位置是 NaN
print("RSI 值:", rsi_values)
print("SMA 值:", sma_values)
# 步骤 4: 过滤有效值（可选）
# 只保留有效的指标值（非 NaN）
valid_rsi = rsi_values[~np.isnan(rsi_values)]
valid_sma = sma_values[~np.isnan(sma_values)]
print(f"\n有效 RSI 值数量: {len(valid_rsi)}")
print(f"有效 SMA 值数量: {len(valid_sma)}")
# 步骤 5: 使用结果进行分析
# 例如，找出所有超买的位置（RSI > 70）
overbought_positions = np.where(rsi_values > 70)[0]
print(f"\n超买位置（索引）: {overbought_positions}")
import { init, RSI, SMA } from 'techkit';
await init();
// 步骤 1: 准备历史价格数据
const prices = [100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0,
106.2, 105.8, 107.0, 106.5, 108.0, 107.5, 109.0, 108.5,
110.0, 109.5, 111.0, 110.5, 112.0, 111.5, 113.0, 112.5];
// 步骤 2: 批量计算指标
const rsi = new RSI(14);
const sma = new SMA(20);
const rsiValues = rsi.calculate(prices);
const smaValues = sma.calculate(prices);
// 步骤 3: 理解结果
// 结果数组中，NaN 表示该位置数据不足
console.log('RSI 值:', rsiValues);
console.log('SMA 值:', smaValues);
// 步骤 4: 过滤有效值
const validRsi = rsiValues.filter(v => !isNaN(v));
const validSma = smaValues.filter(v => !isNaN(v));
console.log(`\n有效 RSI 值数量: ${validRsi.length}`);
console.log(`有效 SMA 值数量: ${validSma.length}`);
// 步骤 5: 使用结果进行分析
const overboughtPositions = [];
rsiValues.forEach((value, index) => {
if (!isNaN(value) && value > 70) {
overboughtPositions.push(index);
}
});
console.log(`\n超买位置（索引）: ${overboughtPositions}`);
// 清理资源
rsi.dispose();
sma.dispose();
#include <techkit/techkit.hpp>
#include <iostream>
#include <vector>
#include <algorithm>
int main() {
// 步骤 1: 准备历史价格数据
std::vector<double> prices = {100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0,
106.2, 105.8, 107.0, 106.5, 108.0, 107.5, 109.0, 108.5,
110.0, 109.5, 111.0, 110.5, 112.0, 111.5, 113.0, 112.5};
// 步骤 2: 批量计算指标
auto rsi = techkit::Indicator::RSI(14);
auto sma = techkit::Indicator::SMA(20);
auto rsi_values = rsi.calculate(prices.data(), prices.size());
auto sma_values = sma.calculate(prices.data(), prices.size());
// 步骤 3: 输出结果
std::cout << "RSI 值: ";
for (size_t i = 0; i < rsi_values.size(); ++i) {
if (rsi_values[i].valid) {
std::cout << rsi_values[i].value << " ";
} else {
std::cout << "NaN ";
}
}
std::cout << std::endl;
// 步骤 4: 找出超买位置
std::vector<size_t> overbought_positions;
for (size_t i = 0; i < rsi_values.size(); ++i) {
if (rsi_values[i].valid && rsi_values[i].value > 70) {
overbought_positions.push_back(i);
}
}
std::cout << "\n超买位置（索引）: ";
for (size_t pos : overbought_positions) {
std::cout << pos << " ";
}
std::cout << std::endl;
return 0;
}
多输出指标
有些指标会返回多个值，例如 MACD 返回三条线：MACD 线、信号线、柱状图。
MACD 示例
MACD (Moving Average Convergence Divergence) 是最常用的多输出指标之一，它返回三个值：
macd: MACD 线（快线 - 慢线）
signal: 信号线（MACD 的移动平均）
histogram: 柱状图（MACD - Signal）
import techkit as tk
import numpy as np
# 步骤 1: 创建 MACD 指标
# 参数说明：
# fast=12: 快线周期（12 周期 EMA）
# slow=26: 慢线周期（26 周期 EMA）
# signal=9: 信号线周期（9 周期 EMA）
macd = tk.MACD(fast=12, slow=26, signal=9)
# 方式 1: 增量更新
prices = [100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0]
for price in prices:
result = macd.update(price)
if result.valid:
print(f"价格: {price:.2f}")
print(f" MACD 线: {result.macd:.4f}")
print(f" 信号线: {result.signal:.4f}")
print(f" 柱状图: {result.histogram:.4f}")
# 交易信号：柱状图从负转正，可能是买入信号
if result.histogram > 0 and result.macd > result.signal:
print(" ✅ 可能的买入信号")
# 方式 2: 批量计算
# calculate() 返回一个命名元组，可以直接解包
prices_array = np.array([100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0,
106.2, 105.8, 107.0, 106.5, 108.0, 107.5, 109.0, 108.5,
110.0, 109.5, 111.0, 110.5, 112.0, 111.5, 113.0, 112.5])
macd_line, signal_line, histogram = macd.calculate(prices_array)
# 使用结果
print("\nMACD 线:", macd_line)
print("信号线:", signal_line)
print("柱状图:", histogram)
import { init, MACD } from 'techkit';
await init();
// 步骤 1: 创建 MACD 指标
const macd = new MACD({
fastPeriod: 12, // 快线周期
slowPeriod: 26, // 慢线周期
signalPeriod: 9 // 信号线周期
});
// 方式 1: 增量更新
const prices = [100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0];
for (const price of prices) {
const result = macd.update(price);
if (result.valid) {
console.log(`价格: ${price.toFixed(2)}`);
console.log(` MACD 线: ${result.macd.toFixed(4)}`);
console.log(` 信号线: ${result.signal.toFixed(4)}`);
console.log(` 柱状图: ${result.histogram.toFixed(4)}`);
// 交易信号
if (result.histogram > 0 && result.macd > result.signal) {
console.log(' ✅ 可能的买入信号');
}
}
}
// 方式 2: 批量计算
const pricesArray = [100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0,
106.2, 105.8, 107.0, 106.5, 108.0, 107.5, 109.0, 108.5,
110.0, 109.5, 111.0, 110.5, 112.0, 111.5, 113.0, 112.5];
const { macd: macdLine, signal: signalLine, histogram } = macd.calculate(pricesArray);
console.log('\nMACD 线:', macdLine);
console.log('信号线:', signalLine);
console.log('柱状图:', histogram);
macd.dispose();
布林带 (Bollinger Bands) 示例
布林带返回三条线：上轨、中轨（SMA）、下轨。
import techkit as tk
import numpy as np
# 创建布林带指标
# period=20: 使用 20 周期 SMA 作为中轨
# std_up=2.0: 上轨距离中轨 2 个标准差
# std_dn=2.0: 下轨距离中轨 2 个标准差
bb = tk.BBANDS(period=20, std_up=2.0, std_dn=2.0)
prices = np.array([100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0,
106.2, 105.8, 107.0, 106.5, 108.0, 107.5, 109.0, 108.5,
110.0, 109.5, 111.0, 110.5, 112.0, 111.5, 113.0, 112.5])
# 批量计算
upper, middle, lower = bb.calculate(prices)
# 使用结果
# 价格接近上轨可能表示超买，接近下轨可能表示超卖
for i in range(len(prices)):
if not np.isnan(upper[i]):
price = prices[i]
if price >= upper[i] * 0.99: # 价格接近上轨
print(f"位置 {i}: 价格 {price:.2f} 接近上轨 {upper[i]:.2f}，可能超买")
elif price <= lower[i] * 1.01: # 价格接近下轨
print(f"位置 {i}: 价格 {price:.2f} 接近下轨 {lower[i]:.2f}，可能超卖")
OHLCV 指标（需要完整 K 线数据）
有些指标需要完整的 K 线数据（开盘价、最高价、最低价、收盘价、成交量），例如 ATR (Average True Range)、Stochastic 等。
什么是 OHLCV？
O (Open): 开盘价
H (High): 最高价
L (Low): 最低价
C (Close): 收盘价
V (Volume): 成交量
ATR 示例
ATR (Average True Range) 用于衡量价格波动性，需要完整的 K 线数据。
import techkit as tk
import numpy as np
# 步骤 1: 创建 ATR 指标
# period=14: 使用 14 个周期计算平均真实波幅
atr = tk.ATR(period=14)
# 方式 1: 增量更新（单个 K 线）
# 模拟一个 K 线数据
result = atr.update_ohlcv(
open=100.0, # 开盘价
high=102.0, # 最高价
low=99.0, # 最低价
close=101.5, # 收盘价
volume=1000 # 成交量（ATR 不使用成交量，但需要提供）
)
if result.valid:
print(f"ATR: {result.value:.4f}")
# ATR 值越大，表示价格波动越大
# 方式 2: 批量计算（多个 K 线）
# 准备多根 K 线的数据
open_prices = np.array([100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0,
106.2, 105.8, 107.0, 106.5, 108.0, 107.5, 109.0, 108.5,
110.0, 109.5, 111.0, 110.5, 112.0, 111.5, 113.0, 112.5])
high_prices = open_prices + 2.0 # 简化：最高价 = 开盘价 + 2
low_prices = open_prices - 1.5 # 简化：最低价 = 开盘价 - 1.5
close_prices = open_prices + 0.5 # 简化：收盘价 = 开盘价 + 0.5
volumes = np.array([1000] * len(open_prices)) # 成交量
# 批量计算 ATR
atr_values = atr.calculate_ohlcv(
open=open_prices,
high=high_prices,
low=low_prices,
close=close_prices,
volume=volumes
)
print("ATR 值:", atr_values)
# 使用 ATR 进行风险管理
# 例如：止损距离可以设置为 2 * ATR
for i in range(len(atr_values)):
if not np.isnan(atr_values[i]):
stop_loss_distance = 2 * atr_values[i]
print(f"位置 {i}: 建议止损距离 = {stop_loss_distance:.4f}")
import { init, ATR } from 'techkit';
await init();
// 步骤 1: 创建 ATR 指标
const atr = new ATR(14);
// 方式 1: 增量更新
const result = atr.updateOHLCV({
open: 100.0,
high: 102.0,
low: 99.0,
close: 101.5,
volume: 1000
});
if (result.valid) {
console.log(`ATR: ${result.value.toFixed(4)}`);
}
// 方式 2: 批量计算
const openPrices = [100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0,
106.2, 105.8, 107.0, 106.5, 108.0, 107.5, 109.0, 108.5,
110.0, 109.5, 111.0, 110.5, 112.0, 111.5, 113.0, 112.5];
const highPrices = openPrices.map(p => p + 2.0);
const lowPrices = openPrices.map(p => p - 1.5);
const closePrices = openPrices.map(p => p + 0.5);
const volumes = new Array(openPrices.length).fill(1000);
const atrValues = atr.calculateOHLCV(openPrices, highPrices, lowPrices, closePrices, volumes);
console.log('ATR 值:', atrValues);
// 风险管理
atrValues.forEach((value, i) => {
if (!isNaN(value)) {
const stopLossDistance = 2 * value;
console.log(`位置 ${i}: 建议止损距离 = ${stopLossDistance.toFixed(4)}`);
}
});
atr.dispose();
Stochastic 示例
随机指标（Stochastic）也需要完整的 K 线数据，返回 %K 和 %D 两条线。
import techkit as tk
import numpy as np
# 创建随机指标
# k_period=14: %K 的计算周期
# k_slow=3: %K 的平滑周期
# d_period=3: %D 的计算周期（%K 的移动平均）
stoch = tk.STOCH(k_period=14, k_slow=3, d_period=3)
# 准备 K 线数据
open_prices = np.array([100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0,
106.2, 105.8, 107.0, 106.5, 108.0, 107.5, 109.0, 108.5,
110.0, 109.5, 111.0, 110.5, 112.0, 111.5, 113.0, 112.5])
high_prices = open_prices + 2.0
low_prices = open_prices - 1.5
close_prices = open_prices + 0.5
volumes = np.array([1000] * len(open_prices))
# 批量计算
slowk, slowd = stoch.calculate_ohlcv(open_prices, high_prices, low_prices, close_prices, volumes)
# 使用结果
# %K 和 %D 都在 0-100 之间
# > 80: 超买，< 20: 超卖
for i in range(len(slowk)):
if not np.isnan(slowk[i]) and not np.isnan(slowd[i]):
if slowk[i] > 80 and slowd[i] > 80:
print(f"位置 {i}: 超买信号 (%K={slowk[i]:.2f}, %D={slowd[i]:.2f})")
elif slowk[i] < 20 and slowd[i] < 20:
print(f"位置 {i}: 超卖信号 (%K={slowk[i]:.2f}, %D={slowd[i]:.2f})")
指标链（组合多个指标）
指标链允许您将多个指标串联起来，实现复杂的分析。例如：先计算 RSI，再对 RSI 进行平滑处理。
示例：RSI 平滑
import techkit as tk
import numpy as np
# 创建指标链
# 步骤：先计算 RSI(14)，然后对结果应用 EMA(9) 进行平滑
chain = tk.Chain([
tk.RSI(14), # 第一步：计算 14 周期 RSI
tk.EMA(9) # 第二步：对 RSI 值进行 9 周期 EMA 平滑
])
# 准备价格数据
prices = np.array([100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0,
106.2, 105.8, 107.0, 106.5, 108.0, 107.5, 109.0, 108.5,
110.0, 109.5, 111.0, 110.5, 112.0, 111.5, 113.0, 112.5])
# 计算平滑后的 RSI
smoothed_rsi = chain.calculate(prices)
print("原始 RSI:", tk.RSI(14).calculate(prices))
print("平滑 RSI:", smoothed_rsi)
# 平滑后的 RSI 波动更小，信号更稳定
示例：MACD 的 MACD 线平滑
import techkit as tk
import numpy as np
# 更复杂的链：MACD -> 对 MACD 线进行平滑
# 注意：MACD 返回多个值，链会自动处理第一个值（MACD 线）
chain = tk.Chain([
tk.MACD(12, 26, 9), # 计算 MACD
tk.EMA(5) # 对 MACD 线进行 5 周期平滑
])
prices = np.array([100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0,
106.2, 105.8, 107.0, 106.5, 108.0, 107.5, 109.0, 108.5,
110.0, 109.5, 111.0, 110.5, 112.0, 111.5, 113.0, 112.5])
smoothed_macd_line = chain.calculate(prices)
print("平滑后的 MACD 线:", smoothed_macd_line)
TA-Lib 兼容性
如果您之前使用 TA-Lib，TechKit 提供了完全兼容的 API，可以无缝替换。
为什么需要兼容模式？
迁移方便: 现有代码只需修改导入语句
API 一致: 函数签名和参数名称与 TA-Lib 完全相同
结果一致: 算法实现与 TA-Lib 100% 兼容
使用示例
import talib
import numpy as np
# 准备数据
prices = np.array([100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0])
# 计算指标
rsi = talib.RSI(prices, timeperiod=14)
sma = talib.SMA(prices, timeperiod=20)
macd, signal, hist = talib.MACD(prices, fastperiod=12, slowperiod=26, signalperiod=9)
print("RSI:", rsi)
print("SMA:", sma)
# 只需修改这一行！
import techkit.talib_compat as ta # 原来：import talib
import numpy as np
# 准备数据（完全相同）
prices = np.array([100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0])
# 计算指标（API 完全相同）
rsi = ta.RSI(prices, timeperiod=14)
sma = ta.SMA(prices, timeperiod=20)
macd, signal, hist = ta.MACD(prices, fastperiod=12, slowperiod=26, signalperiod=9)
print("RSI:", rsi)
print("SMA:", sma)
# 结果与 TA-Lib 完全一致！
支持的函数
TechKit 兼容模式支持所有 TA-Lib 函数，包括：
重叠研究: SMA, EMA, WMA, DEMA, TEMA, KAMA, TRIMA, T3, BBANDS, MIDPOINT, MIDPRICE, SAR 等
动量指标: RSI, MACD, STOCH, ADX, CCI, MOM, ROC, WILLR, MFI 等
波动率指标: ATR, NATR, TRANGE
成交量指标: OBV, AD, ADOSC
统计函数: STDDEV, VAR, LINEARREG, LINEARREG_SLOPE 等
K 线形态: CDL_DOJI, CDL_HAMMER, CDL_ENGULFING 等（61 个）
完整示例
import techkit.talib_compat as ta
import numpy as np
# 准备 OHLCV 数据
close = np.array([100.0, 101.5, 102.3, 101.8, 103.2, 104.1, 103.5, 105.0,
106.2, 105.8, 107.0, 106.5, 108.0, 107.5, 109.0, 108.5,
110.0, 109.5, 111.0, 110.5, 112.0, 111.5, 113.0, 112.5])
high = close + 2.0
low = close - 1.5
open_price = close - 0.5
volume = np.array([1000] * len(close))
# 计算各种指标（与 TA-Lib 完全相同）
rsi = ta.RSI(close, timeperiod=14)
sma = ta.SMA(close, timeperiod=20)
macd, signal, hist = ta.MACD(close, fastperiod=12, slowperiod=26, signalperiod=9)
upper, middle, lower = ta.BBANDS(close, timeperiod=20, nbdevup=2.0, nbdevdn=2.0)
atr = ta.ATR(high, low, close, timeperiod=14)
stoch_k, stoch_d = ta.STOCH(high, low, close, fastk_period=14, slowk_period=3, slowd_period=3)
print("所有指标计算完成！")
print(f"RSI 最后值: {rsi[-1]:.2f}")
print(f"SMA 最后值: {sma[-1]:.2f}")
下一步
现在您已经掌握了 TechKit 的基本用法！建议继续学习：
Python API 参考 - 查看所有可用的指标和详细参数
示例代码 - 查看实际应用场景的完整示例
指标参考 - 了解每个指标的含义和用法
常见问题
Q: 增量更新和批量计算哪个更快？
A:
批量计算：对于历史数据分析，批量计算通常更快（向量化优化）
增量更新：对于实时数据流，增量更新是唯一选择，且性能优秀（O(1)）
Q: 如何知道指标需要多少数据才能开始计算？
A: 使用 lookback 属性：
rsi = tk.RSI(14)
print(f"RSI(14) 需要 {rsi.lookback} 个数据点")
# 输出：RSI(14) 需要 14 个数据点
Q: 可以同时使用多个指标吗？
A: 可以！每个指标实例都是独立的：
sma = tk.SMA(20)
rsi = tk.RSI(14)
macd = tk.MACD(12, 26, 9)
# 可以同时更新
for price in prices:
sma_result = sma.update(price)
rsi_result = rsi.update(price)
macd_result = macd.update(price)
Q: 如何重置指标状态？
A: 使用 reset() 方法：
rsi = tk.RSI(14)
# ... 处理一些数据 ...
rsi.reset() # 重置到初始状态，可以重新使用