0%

金融市场基本技术指标

发表于 更新于 分类于
本文字数： 3.1k

做了一点常用的技术指标，方便以后查阅。

SMA (简单滑动平均）

1
2
3
4
5
6
7
def SMA(price, n):
    length = len(price)
    sma = []
    for e in range(n, length + 1):
        avg = np.mean(price[e-n:e])
        sma.append(avg)
    return sma

RSI

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
def RSI(close_price, n):
    length = len(close_price)
    rsi = []
    avg_gain = []
    avg_loss = []

    for e in range(n, length):
        if e == n:
            cut = close_price[:e+1]
            up = 0
            down = 0

            for i in range(1, n + 1):
                delta = cut[i] - cut[i-1]
                if delta > 0:
                    up += delta
                else:
                    down += -delta
            avg_gain.append(up / n)
            avg_loss.append(down / n)
            rs = up / down
            rsi.append(100 - 100 / (1 + rs))

        else:
            delta = close_price[e] - close_price[e - 1]
            gain = (avg_gain[e-n-1] * (n - 1) + max(delta, 0)) / n
            loss = (avg_loss[e-n-1] * (n - 1) + max(-delta, 0)) / n
            avg_gain.append(gain)
            avg_loss.append(loss)
            rs = gain / loss
            rsi.append(100 - 100 / (1 + rs))

    return rsi

KDJ

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
def KDJ(series, n, a1, a2):
    length = len(series)
    K = [0.5]
    D = [0.5]
    J = [0]
    a1 = 1 / a1
    a2 = 1 / a2

    for e in range(n, length+1):
        L = series.iloc[e-n:e, 4].min()
        H = series.iloc[e-n:e, 3].max()
        C = series.iat[e-1, 2]
        rsv = (C - L) / (H - L)
        K.append(a1 * rsv + (1 - a1) * K[e-n])
        D.append(a2 * K[e-n+1] + (1 - a2) * D[e-n])
        J.append(3 * K[e-n+1] - 2 * D[e-n+1])

    return [K[1:], D[1:], J[1:]]

W%R（威廉指数）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def WR(series, n1, n2):
    length = len(series)
    wr1 = []
    wr2 = []
    for e in range(n1, length+1):
        C = series.iat[e - 1, 2]
        L1 = series.iloc[e-n1:e, 4].min()
        H1 = series.iloc[e-n1:e, 3].max()
        wr1.append((H1 - C) / (H1 - L1))

        L2 = series.iloc[e-n2:e, 4].min()
        H2 = series.iloc[e-n2:e, 3].max()
        wr2.append((H2 - C) / (H2 - L2))

    return wr1, wr2

EMA（指数滑动平均）

1
2
3
4
5
6
7
8
9
10
11
def EMA(price, n):
    ema = []
    length = len(price)
    a = 2 / (n + 1)
    first = np.mean(price[0:n])
    for i in range(n-1, length):
        if i == n-1:
            ema.append(first)
        else:
            ema.append(a * price[i] + (1 - a) * ema[-1])
    return np.array(ema)

MACD

1
2
3
4
5
6
7
8
def MACD(close_price, period1, period2, period3):
    ema_long = EMA(close_price, period1)
    ema_short = EMA(close_price, period2)
    dif = ema_short[period1-period2:] - ema_long
    dea = EMA(dif, period3)
    dif = dif[period3-1:]
    bar = 2 * (dif - dea)
    return [dif, dea, bar]

Bollinger Band（布林带）

1
2
3
4
5
6
7
8
9
10
11
12
def BBand(close_price, n, k):
    length = len(close_price)
    midBand = SMA(close_price, n)
    length = length - n + 1
    upperBand = []
    lowerBand = []
    for i in range(length):
        std = np.std(np.array(close_price[i:i+n]))
        kn = k * std
        upperBand.append(midBand[i] + kn)
        lowerBand.append(midBand[i] - kn)
    return [upperBand, midBand, lowerBand]