Các Chỉ Báo Kỹ Thuật Phổ Biến

Trong bài viết này, chúng ta sẽ tìm hiểu về các chỉ báo kỹ thuật phổ biến được sử dụng trong phân tích kỹ thuật.

Chỉ Báo Xu Hướng

1. Moving Average

import pandas as pd
import numpy as np

class MovingAverage:
    def __init__(self, period=20, ma_type='SMA'):
        self.period = period
        self.ma_type = ma_type

    def calculate(self, df):
        if self.ma_type == 'SMA':
            return df['close'].rolling(window=self.period).mean()
        elif self.ma_type == 'EMA':
            return df['close'].ewm(span=self.period, adjust=False).mean()
        elif self.ma_type == 'WMA':
            weights = np.arange(1, self.period + 1)
            return df['close'].rolling(window=self.period).apply(
                lambda x: np.sum(weights * x) / weights.sum(), raw=True
            )

2. MACD

class MACD:
    def __init__(self, fast_period=12, slow_period=26, signal_period=9):
        self.fast_period = fast_period
        self.slow_period = slow_period
        self.signal_period = signal_period

    def calculate(self, df):
        # Tính toán MACD
        exp1 = df['close'].ewm(span=self.fast_period, adjust=False).mean()
        exp2 = df['close'].ewm(span=self.slow_period, adjust=False).mean()
        macd = exp1 - exp2
        signal = macd.ewm(span=self.signal_period, adjust=False).mean()
        histogram = macd - signal

        return pd.DataFrame({
            'MACD': macd,
            'Signal': signal,
            'Histogram': histogram
        })

Chỉ Báo Động Lực

1. RSI

class RSI:
    def __init__(self, period=14):
        self.period = period

    def calculate(self, df):
        # Tính toán RSI
        delta = df['close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=self.period).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=self.period).mean()
        rs = gain / loss
        rsi = 100 - (100 / (1 + rs))

        return rsi

2. Stochastic Oscillator

class StochasticOscillator:
    def __init__(self, k_period=14, d_period=3):
        self.k_period = k_period
        self.d_period = d_period

    def calculate(self, df):
        # Tính toán Stochastic
        low_min = df['low'].rolling(window=self.k_period).min()
        high_max = df['high'].rolling(window=self.k_period).max()

        k = 100 * ((df['close'] - low_min) / (high_max - low_min))
        d = k.rolling(window=self.d_period).mean()

        return pd.DataFrame({
            'K': k,
            'D': d
        })

Chỉ Báo Biến Động

1. Bollinger Bands

class BollingerBands:
    def __init__(self, period=20, std_dev=2):
        self.period = period
        self.std_dev = std_dev

    def calculate(self, df):
        # Tính toán Bollinger Bands
        middle_band = df['close'].rolling(window=self.period).mean()
        std = df['close'].rolling(window=self.period).std()

        upper_band = middle_band + (std * self.std_dev)
        lower_band = middle_band - (std * self.std_dev)

        return pd.DataFrame({
            'Middle': middle_band,
            'Upper': upper_band,
            'Lower': lower_band
        })

2. ATR

class ATR:
    def __init__(self, period=14):
        self.period = period

    def calculate(self, df):
        # Tính toán ATR
        high_low = df['high'] - df['low']
        high_close = np.abs(df['high'] - df['close'].shift())
        low_close = np.abs(df['low'] - df['close'].shift())

        ranges = pd.concat([high_low, high_close, low_close], axis=1)
        true_range = np.max(ranges, axis=1)

        atr = true_range.rolling(window=self.period).mean()

        return atr

Chỉ Báo Khối Lượng

1. OBV

class OBV:
    def calculate(self, df):
        # Tính toán OBV
        obv = pd.Series(0.0, index=df.index)

        for i in range(1, len(df)):
            if df['close'].iloc[i] > df['close'].iloc[i-1]:
                obv.iloc[i] = obv.iloc[i-1] + df['volume'].iloc[i]
            elif df['close'].iloc[i] < df['close'].iloc[i-1]:
                obv.iloc[i] = obv.iloc[i-1] - df['volume'].iloc[i]
            else:
                obv.iloc[i] = obv.iloc[i-1]

        return obv

2. Money Flow Index

class MoneyFlowIndex:
    def __init__(self, period=14):
        self.period = period

    def calculate(self, df):
        # Tính toán Money Flow Index
        typical_price = (df['high'] + df['low'] + df['close']) / 3
        money_flow = typical_price * df['volume']

        positive_flow = pd.Series(0.0, index=df.index)
        negative_flow = pd.Series(0.0, index=df.index)

        for i in range(1, len(df)):
            if typical_price.iloc[i] > typical_price.iloc[i-1]:
                positive_flow.iloc[i] = money_flow.iloc[i]
            else:
                negative_flow.iloc[i] = money_flow.iloc[i]

        positive_mf = positive_flow.rolling(window=self.period).sum()
        negative_mf = negative_flow.rolling(window=self.period).sum()

        mfi = 100 - (100 / (1 + positive_mf / negative_mf))

        return mfi

Best Practices

1. Kết hợp nhiều chỉ báo
2. Xác định thời gian phù hợp
3. Tránh tín hiệu nhiễu
4. Theo dõi xu hướng chính
5. Quản lý rủi ro

Kết luận

Các chỉ báo kỹ thuật là công cụ quan trọng trong phân tích thị trường. Tuy nhiên, cần sử dụng chúng một cách hợp lý và kết hợp với các phương pháp phân tích khác để đạt hiệu quả tốt nhất.

admin

Biên tập viên, Hướng Nghiệp Dữ Liệu

737 Bài viết

15.4k Người theo dõi

120k+ Lượt đọc

Biên tập viên nội dung tại Hướng Nghiệp Dữ Liệu, phụ trách tổng hợp và biên soạn các bài viết về lập trình Python, dữ liệu và công nghệ.

Theo dõi Liên hệ Zalo