# 快速开始

欢迎使用 TechKit！本指南将帮助您在 5 分钟内掌握 TechKit 的基本用法。即使您没有编程经验，也可以跟随本指南快速上手。

## 基本概念

TechKit 的使用遵循一个简单的三步模式：

1. **创建** - 使用参数创建指标实例
2. **更新/计算** - 用数据更新指标（增量）或批量计算
3. **检查有效性** - 在使用结果前检查是否有效

### 什么是技术指标？

技术指标是基于历史价格数据计算出的数值，用于分析市场趋势、判断买卖时机。例如：
- **SMA (简单移动平均)**: 计算一段时间内的平均价格，用于识别趋势
- **RSI (相对强弱指标)**: 范围 0-100，用于判断超买/超卖
- **MACD**: 用于识别趋势变化和动量

### 为什么需要检查有效性？

每个指标都需要一定数量的历史数据才能开始计算。例如，20 周期的 SMA 需要至少 20 个价格数据点。在数据不足时，结果标记为"无效"（`valid=False`），此时不应使用计算结果。

## 增量更新（实时数据流）

**适用场景**: 实时接收价格数据，需要立即计算指标

增量更新适合处理实时数据流，每次只处理一个新数据点，计算效率高（O(1)）。

::::{tab-set}
:::{tab-item} Python
```python
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: 计算中... (需要更多数据)")
```
:::

:::{tab-item} JavaScript/Node.js
```javascript
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();
```
:::

:::{tab-item} C++
```cpp
#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;  // 指标自动释放
}
```
:::
::::


## 批量计算（历史数据分析）

**适用场景**: 已有完整的历史数据，需要一次性计算所有指标值

批量计算适合分析历史数据，一次性处理所有数据点，性能高效。

::::{tab-set}
:::{tab-item} Python
```python
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}")
```
:::

:::{tab-item} JavaScript/Node.js
```javascript
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();
```
:::

:::{tab-item} C++
```cpp
#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）

::::{tab-set}
:::{tab-item} Python
```python
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)
```
:::

:::{tab-item} JavaScript/Node.js
```javascript
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）、下轨。

```python
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 线数据。

::::{tab-set}
:::{tab-item} Python
```python
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}")
```
:::

:::{tab-item} JavaScript/Node.js
```javascript
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 两条线。

```python
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 平滑

```python
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 线平滑

```python
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% 兼容

### 使用示例

::::{tab-set}
:::{tab-item} 替换前（TA-Lib）
```python
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)
```
:::

:::{tab-item} 替换后（TechKit）
```python
# 只需修改这一行！
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 个）

### 完整示例

```python
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 的基本用法！建议继续学习：

1. **[Python API 参考](../api/python-api.md)** - 查看所有可用的指标和详细参数
2. **[示例代码](examples.md)** - 查看实际应用场景的完整示例
3. **[指标参考](../indicators/index.md)** - 了解每个指标的含义和用法

## 常见问题

**Q: 增量更新和批量计算哪个更快？**

A: 
- **批量计算**：对于历史数据分析，批量计算通常更快（向量化优化）
- **增量更新**：对于实时数据流，增量更新是唯一选择，且性能优秀（O(1)）

**Q: 如何知道指标需要多少数据才能开始计算？**

A: 使用 `lookback` 属性：
```python
rsi = tk.RSI(14)
print(f"RSI(14) 需要 {rsi.lookback} 个数据点")
# 输出：RSI(14) 需要 14 个数据点
```

**Q: 可以同时使用多个指标吗？**

A: 可以！每个指标实例都是独立的：
```python
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()` 方法：
```python
rsi = tk.RSI(14)
# ... 处理一些数据 ...
rsi.reset()  # 重置到初始状态，可以重新使用
```