PandasTA 原始碼解析（十九）

.\pandas-ta\tests\test_ext_indicator_overlap_ext.py

# 從當前包中匯入 sample_data 和 pandas_ta 模組
from .config import sample_data
from .context import pandas_ta
# 從 unittest 模組中匯入 skip 和 TestCase 類
from unittest import skip, TestCase
# 從 pandas 模組中匯入 DataFrame 類
from pandas import DataFrame

# 定義測試類 TestOverlapExtension，繼承自 TestCase 類
class TestOverlapExtension(TestCase):
    # 在測試類中所有測試方法執行之前執行，用於設定測試資料
    @classmethod
    def setUpClass(cls):
        cls.data = sample_data

    # 在測試類中所有測試方法執行之後執行，用於清理測試資料
    @classmethod
    def tearDownClass(cls):
        del cls.data

    # 在每個測試方法執行之前執行的方法，此處為空
    def setUp(self): pass
    
    # 在每個測試方法執行之後執行的方法，此處為空
    def tearDown(self): pass

    # 測試 alma 方法的擴充套件功能
    def test_alma_ext(self):
        # 呼叫 data 物件的 ta 屬性的 alma 方法，並將結果追加到 data 中
        self.data.ta.alma(append=True)
        # 斷言 data 物件是 DataFrame 類的例項
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 data 物件的最後一列的列名為 "ALMA_10_6.0_0.85"
        self.assertEqual(self.data.columns[-1], "ALMA_10_6.0_0.85")

    # 測試 dema 方法的擴充套件功能，以下測試方法同理
    def test_dema_ext(self):
        self.data.ta.dema(append=True)
        self.assertIsInstance(self.data, DataFrame)
        self.assertEqual(self.data.columns[-1], "DEMA_10")

    def test_ema_ext(self):
        self.data.ta.ema(append=True)
        self.assertIsInstance(self.data, DataFrame)
        self.assertEqual(self.data.columns[-1], "EMA_10")

    def test_fwma_ext(self):
        self.data.ta.fwma(append=True)
        self.assertIsInstance(self.data, DataFrame)
        self.assertEqual(self.data.columns[-1], "FWMA_10")

    def test_hilo_ext(self):
        self.data.ta.hilo(append=True)
        self.assertIsInstance(self.data, DataFrame)
        self.assertEqual(list(self.data.columns[-3:]), ["HILO_13_21", "HILOl_13_21", "HILOs_13_21"])

    def test_hl2_ext(self):
        self.data.ta.hl2(append=True)
        self.assertIsInstance(self.data, DataFrame)
        self.assertEqual(self.data.columns[-1], "HL2")

    def test_hlc3_ext(self):
        self.data.ta.hlc3(append=True)
        self.assertIsInstance(self.data, DataFrame)
        self.assertEqual(self.data.columns[-1], "HLC3")

    def test_hma_ext(self):
        self.data.ta.hma(append=True)
        self.assertIsInstance(self.data, DataFrame)
        self.assertEqual(self.data.columns[-1], "HMA_10")

    def test_hwma_ext(self):
        self.data.ta.hwma(append=True)
        self.assertIsInstance(self.data, DataFrame)
        self.assertEqual(self.data.columns[-1], "HWMA_0.2_0.1_0.1")

    def test_jma_ext(self):
        self.data.ta.jma(append=True)
        self.assertIsInstance(self.data, DataFrame)
        self.assertEqual(self.data.columns[-1], "JMA_7_0")

    def test_kama_ext(self):
        self.data.ta.kama(append=True)
        self.assertIsInstance(self.data, DataFrame)
        self.assertEqual(self.data.columns[-1], "KAMA_10_2_30")

    def test_ichimoku_ext(self):
        self.data.ta.ichimoku(append=True)
        self.assertIsInstance(self.data, DataFrame)
        self.assertEqual(list(self.data.columns[-5:]), ["ISA_9", "ISB_26", "ITS_9", "IKS_26", "ICS_26"])

    def test_linreg_ext(self):
        self.data.ta.linreg(append=True)
        self.assertIsInstance(self.data, DataFrame)
        self.assertEqual(self.data.columns[-1], "LR_14")

    def test_mcgd_ext(self):
        self.data.ta.mcgd(append=True)
        self.assertIsInstance(self.data, DataFrame)
        self.assertEqual(self.data.columns[-1], "MCGD_10")
    # 測試擴充套件方法：計算中間點指標
    def test_midpoint_ext(self):
        # 呼叫中間點指標計算方法，並將結果追加到資料幀中
        self.data.ta.midpoint(append=True)
        # 斷言資料型別為資料幀
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"MIDPOINT_2"
        self.assertEqual(self.data.columns[-1], "MIDPOINT_2")

    # 測試擴充套件方法：計算中間價指標
    def test_midprice_ext(self):
        # 呼叫中間價指標計算方法，並將結果追加到資料幀中
        self.data.ta.midprice(append=True)
        # 斷言資料型別為資料幀
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"MIDPRICE_2"
        self.assertEqual(self.data.columns[-1], "MIDPRICE_2")

    # 測試擴充套件方法：計算OHLC4指標
    def test_ohlc4_ext(self):
        # 呼叫OHLC4指標計算方法，並將結果追加到資料幀中
        self.data.ta.ohlc4(append=True)
        # 斷言資料型別為資料幀
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"OHLC4"
        self.assertEqual(self.data.columns[-1], "OHLC4")

    # 測試擴充套件方法：計算PWMA指標
    def test_pwma_ext(self):
        # 呼叫PWMA指標計算方法，並將結果追加到資料幀中
        self.data.ta.pwma(append=True)
        # 斷言資料型別為資料幀
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"PWMA_10"
        self.assertEqual(self.data.columns[-1], "PWMA_10")

    # 測試擴充套件方法：計算RMA指標
    def test_rma_ext(self):
        # 呼叫RMA指標計算方法，並將結果追加到資料幀中
        self.data.ta.rma(append=True)
        # 斷言資料型別為資料幀
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"RMA_10"
        self.assertEqual(self.data.columns[-1], "RMA_10")

    # 測試擴充套件方法：計算SINWMA指標
    def test_sinwma_ext(self):
        # 呼叫SINWMA指標計算方法，並將結果追加到資料幀中
        self.data.ta.sinwma(append=True)
        # 斷言資料型別為資料幀
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"SINWMA_14"
        self.assertEqual(self.data.columns[-1], "SINWMA_14")

    # 測試擴充套件方法：計算SMA指標
    def test_sma_ext(self):
        # 呼叫SMA指標計算方法，並將結果追加到資料幀中
        self.data.ta.sma(append=True)
        # 斷言資料型別為資料幀
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"SMA_10"
        self.assertEqual(self.data.columns[-1], "SMA_10")

    # 測試擴充套件方法：計算SSF指標
    def test_ssf_ext(self):
        # 呼叫SSF指標計算方法，並將結果追加到資料幀中，使用兩個極點
        self.data.ta.ssf(append=True, poles=2)
        # 斷言資料型別為資料幀
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"SSF_10_2"
        self.assertEqual(self.data.columns[-1], "SSF_10_2")

        # 再次呼叫SSF指標計算方法，並將結果追加到資料幀中，使用三個極點
        self.data.ta.ssf(append=True, poles=3)
        # 斷言資料型別為資料幀
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"SSF_10_3"
        self.assertEqual(self.data.columns[-1], "SSF_10_3")

    # 測試擴充套件方法：計算SWMA指標
    def test_swma_ext(self):
        # 呼叫SWMA指標計算方法，並將結果追加到資料幀中
        self.data.ta.swma(append=True)
        # 斷言資料型別為資料幀
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"SWMA_10"
        self.assertEqual(self.data.columns[-1], "SWMA_10")

    # 測試擴充套件方法：計算超級趨勢指標
    def test_supertrend_ext(self):
        # 呼叫超級趨勢指標計算方法，並將結果追加到資料幀中
        self.data.ta.supertrend(append=True)
        # 斷言資料型別為資料幀
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後四列的列名分別為"SUPERT_7_3.0", "SUPERTd_7_3.0", "SUPERTl_7_3.0", "SUPERTs_7_3.0"
        self.assertEqual(list(self.data.columns[-4:]), ["SUPERT_7_3.0", "SUPERTd_7_3.0", "SUPERTl_7_3.0", "SUPERTs_7_3.0"])

    # 測試擴充套件方法：計算T3指標
    def test_t3_ext(self):
        # 呼叫T3指標計算方法，並將結果追加到資料幀中
        self.data.ta.t3(append=True)
        # 斷言資料型別為資料幀
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"T3_10_0.7"
        self.assertEqual(self.data.columns[-1], "T3_10_0.7")

    # 測試擴充套件方法：計算TEMA指標
    def test_tema_ext(self):
        # 呼叫TEMA指標計算方法，並將結果追加到資料幀中
        self.data.ta.tema(append=True)
        #
    # 測試 VWMA 擴充套件函式
    def test_vwma_ext(self):
        # 呼叫 VWMA 函式，將結果追加到 DataFrame 中
        self.data.ta.vwma(append=True)
        # 斷言 DataFrame 例項化
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 DataFrame 最後一列的列名為 "VWMA_10"
        self.assertEqual(self.data.columns[-1], "VWMA_10")
    
    # 測試 WCP 擴充套件函式
    def test_wcp_ext(self):
        # 呼叫 WCP 函式，將結果追加到 DataFrame 中
        self.data.ta.wcp(append=True)
        # 斷言 DataFrame 例項化
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 DataFrame 最後一列的列名為 "WCP"
        self.assertEqual(self.data.columns[-1], "WCP")
    
    # 測試 WMA 擴充套件函式
    def test_wma_ext(self):
        # 呼叫 WMA 函式，將結果追加到 DataFrame 中
        self.data.ta.wma(append=True)
        # 斷言 DataFrame 例項化
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 DataFrame 最後一列的列名為 "WMA_10"
        self.assertEqual(self.data.columns[-1], "WMA_10")
    
    # 測試 ZLMA 擴充套件函式
    def test_zlma_ext(self):
        # 呼叫 ZLMA 函式，將結果追加到 DataFrame 中
        self.data.ta.zlma(append=True)
        # 斷言 DataFrame 例項化
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 DataFrame 最後一列的列名為 "ZL_EMA_10"
        self.assertEqual(self.data.columns[-1], "ZL_EMA_10")

.\pandas-ta\tests\test_ext_indicator_performance.py

# 從當前目錄下的 config 模組匯入 sample_data 物件
from .config import sample_data
# 從當前目錄下的 context 模組匯入 pandas_ta 擴充套件
from .context import pandas_ta
# 匯入 TestCase 類
from unittest import TestCase
# 匯入 DataFrame 類
from pandas import DataFrame

# 定義 TestPerformaceExtension 類，繼承自 TestCase 類
class TestPerformaceExtension(TestCase):
    # 在測試類中所有測試方法執行前執行的類方法
    @classmethod
    def setUpClass(cls):
        # 初始化測試資料為 sample_data
        cls.data = sample_data
        # 檢查是否收盤價大於其50日簡單移動平均線
        cls.islong = cls.data["close"] > pandas_ta.sma(cls.data["close"], length=50)

    # 在測試類中所有測試方法執行後執行的類方法
    @classmethod
    def tearDownClass(cls):
        # 刪除測試資料物件
        del cls.data
        # 刪除 islong 物件

    # 在每個測試方法執行前執行的方法
    def setUp(self): pass
    # 在每個測試方法執行後執行的方法
    def tearDown(self): pass

    # 測試對數收益率擴充套件方法
    def test_log_return_ext(self):
        # 計算對數收益率，並將結果附加到資料框中
        self.data.ta.log_return(append=True)
        # 斷言資料物件為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言資料框的最後一列為 "LOGRET_1"
        self.assertEqual(self.data.columns[-1], "LOGRET_1")

    # 測試累積對數收益率擴充套件方法
    def test_cum_log_return_ext(self):
        # 計算累積對數收益率，並將結果附加到資料框中
        self.data.ta.log_return(append=True, cumulative=True)
        # 斷言資料物件為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言資料框的最後一列為 "CUMLOGRET_1"

    # 測試百分比收益率擴充套件方法
    def test_percent_return_ext(self):
        # 計算百分比收益率，並將結果附加到資料框中
        self.data.ta.percent_return(append=True)
        # 斷言資料物件為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言資料框的最後一列為 "PCTRET_1"

    # 測試累積百分比收益率擴充套件方法
    def test_cum_percent_return_ext(self):
        # 計算累積百分比收益率，並將結果附加到資料框中
        self.data.ta.percent_return(append=True, cumulative=True)
        # 斷言資料物件為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言資料框的最後一列為 "CUMPCTRET_1"

.\pandas-ta\tests\test_ext_indicator_statistics.py

# 從config模組中匯入sample_data變數
from .config import sample_data
# 從context模組中匯入pandas_ta模組
from .context import pandas_ta
# 從unittest模組中匯入skip和TestCase類
from unittest import skip, TestCase
# 從pandas模組中匯入DataFrame類
from pandas import DataFrame

# 定義測試統計擴充套件功能的測試類
class TestStatisticsExtension(TestCase):
    # 在所有測試方法執行前執行，設定測試資料
    @classmethod
    def setUpClass(cls):
        cls.data = sample_data

    # 在所有測試方法執行後執行，刪除測試資料
    @classmethod
    def tearDownClass(cls):
        del cls.data

    # 測試方法執行前執行的方法
    def setUp(self): pass
    # 測試方法執行後執行的方法
    def tearDown(self): pass

    # 測試計算熵擴充套件功能
    def test_entropy_ext(self):
        # 呼叫entropy方法計算熵，並將結果追加到資料中
        self.data.ta.entropy(append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"ENTP_10"

    # 測試計算峰度擴充套件功能
    def test_kurtosis_ext(self):
        # 呼叫kurtosis方法計算峰度，並將結果追加到資料中
        self.data.ta.kurtosis(append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"KURT_30"

    # 測試計算絕對平均偏差擴充套件功能
    def test_mad_ext(self):
        # 呼叫mad方法計算絕對平均偏差，並將結果追加到資料中
        self.data.ta.mad(append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"MAD_30"

    # 測試計算中位數擴充套件功能
    def test_median_ext(self):
        # 呼叫median方法計算中位數，並將結果追加到資料中
        self.data.ta.median(append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"MEDIAN_30"

    # 測試計算分位數擴充套件功能
    def test_quantile_ext(self):
        # 呼叫quantile方法計算分位數，並將結果追加到資料中
        self.data.ta.quantile(append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"QTL_30_0.5"

    # 測試計算偏度擴充套件功能
    def test_skew_ext(self):
        # 呼叫skew方法計算偏度，並將結果追加到資料中
        self.data.ta.skew(append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"SKEW_30"

    # 測試計算標準差擴充套件功能
    def test_stdev_ext(self):
        # 呼叫stdev方法計算標準差，並將結果追加到資料中
        self.data.ta.stdev(append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"STDEV_30"

    # 測試計算所有時間序列標準差擴充套件功能
    def test_tos_stdevall_ext(self):
        # 呼叫tos_stdevall方法計算所有時間序列標準差，並將結果追加到資料中
        self.data.ta.tos_stdevall(append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後7列的列名為指定列表

    # 測試計算方差擴充套件功能
    def test_variance_ext(self):
        # 呼叫variance方法計算方差，並將結果追加到資料中
        self.data.ta.variance(append=True)
        # 斷言資料類���為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為"VAR_30"

.\pandas-ta\tests\test_ext_indicator_trend.py

# 從config模組中匯入sample_data變數
from .config import sample_data
# 從context模組中匯入pandas_ta模組
from .context import pandas_ta
# 從unittest模組中匯入skip和TestCase類
from unittest import skip, TestCase
# 從pandas模組中匯入DataFrame類
from pandas import DataFrame

# 定義測試TrendExtension類，繼承自TestCase類
class TestTrendExtension(TestCase):
    # 設定測試類的類方法setUpClass，用於設定測試資料
    @classmethod
    def setUpClass(cls):
        cls.data = sample_data

    # 設定測試類的類方法tearDownClass，用於清理測試資料
    @classmethod
    def tearDownClass(cls):
        del cls.data

    # 設定測試方法的setUp，無操作
    def setUp(self): pass
    # 設定測試方法的tearDown，無操作
    def tearDown(self): pass

    # 測試ADX擴充套件功能
    def test_adx_ext(self):
        # 呼叫ADX擴充套件方法，將結果附加到資料框中
        self.data.ta.adx(append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後三列的列名
        self.assertEqual(list(self.data.columns[-3:]), ["ADX_14", "DMP_14", "DMN_14"])

    # 測試AMAT擴充套件功能
    def test_amat_ext(self):
        # 呼叫AMAT擴充套件方法，將結果附加到資料框中
        self.data.ta.amat(append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後兩列的列名
        self.assertEqual(list(self.data.columns[-2:]), ["AMATe_LR_8_21_2", "AMATe_SR_8_21_2"])

    # 測試Aroon擴充套件功能
    def test_aroon_ext(self):
        # 呼叫Aroon擴充套件方法，將結果附加到資料框中
        self.data.ta.aroon(append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後三列的列名
        self.assertEqual(list(self.data.columns[-3:]), ["AROOND_14", "AROONU_14", "AROONOSC_14"])

    # 測試Chop擴充套件功能
    def test_chop_ext(self):
        # 呼叫Chop擴充套件方法，將結果附加到資料框中，設定ln引數為False
        self.data.ta.chop(append=True, ln=False)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名
        self.assertEqual(self.data.columns[-1], "CHOP_14_1_100")

        # 再次呼叫Chop擴充套件方法，將結果附加到資料框中，設定ln引數為True
        self.data.ta.chop(append=True, ln=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名
        self.assertEqual(self.data.columns[-1], "CHOPln_14_1_100")

    # 測試CKSP擴充套件功能
    def test_cksp_ext(self):
        # 呼叫CKSP擴充套件方法，將結果附加到資料框中，設定tvmode引數為False
        self.data.ta.cksp(tvmode=False, append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後兩列的列名
        self.assertEqual(list(self.data.columns[-2:]), ["CKSPl_10_3_20", "CKSPs_10_3_20"])

    # 測試CKSP_TV擴充套件功能
    def test_cksp_tv_ext(self):
        # 呼叫CKSP擴充套件方法，將結果附加到資料框中，設定tvmode引數為True
        self.data.ta.cksp(tvmode=True, append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後兩列的列名
        self.assertEqual(list(self.data.columns[-2:]), ["CKSPl_10_1_9", "CKSPs_10_1_9"])

    # 測試Decay擴充套件功能
    def test_decay_ext(self):
        # 呼叫Decay擴充套件方法，將結果附加到資料框中
        self.data.ta.decay(append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名
        self.assertEqual(self.data.columns[-1], "LDECAY_5")

        # 再次呼叫Decay擴充套件方法，設定mode引數為"exp"，將結果附加到資料框中
        self.data.ta.decay(mode="exp", append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名
        self.assertEqual(self.data.columns[-1], "EXPDECAY_5")

    # 測試Decreasing擴充套件功能
    def test_decreasing_ext(self):
        # 呼叫Decreasing擴充套件方法，將結果附加到資料框中
        self.data.ta.decreasing(append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名
        self.assertEqual(self.data.columns[-1], "DEC_1")

        # 再次呼叫Decreasing擴充套件方法，設定length引數為3，strict引數為True，將結果附加到資料框中
        self.data.ta.decreasing(length=3, strict=True, append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名
        self.assertEqual(self.data.columns[-1], "SDEC_3")

    # 測試DPO擴充套件功能
    def test_dpo_ext(self):
        # 呼叫DPO擴充套件方法，將結果附加到資料框中
        self.data.ta.dpo(append=True)
        # 斷言資料型別為DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名
        self.assertEqual(self.data.columns[-1], "DPO_20")
    # 測試增長指標計算函式的擴充套件功能
    def test_increasing_ext(self):
        # 呼叫增長指標計算函式，將結果追加到原始資料後面
        self.data.ta.increasing(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為 "INC_1"
        self.assertEqual(self.data.columns[-1], "INC_1")

        # 呼叫增長指標計算函式，計算視窗長度為3的嚴格增長指標，並將結果追加到原始資料後面
        self.data.ta.increasing(length=3, strict=True, append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為 "SINC_3"
        self.assertEqual(self.data.columns[-1], "SINC_3")

    # 測試長期趨勢計算函式的擴充套件功能
    def test_long_run_ext(self):
        # 未傳遞引數，返回原始資料
        self.assertEqual(self.data.ta.long_run(append=True).shape, self.data.shape)

        # 計算快速和慢速指數移動平均線
        fast = self.data.ta.ema(8)
        slow = self.data.ta.ema(21)
        # 計算長期趨勢指標，並將結果追加到原始資料後面
        self.data.ta.long_run(fast, slow, append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為 "LR_2"
        self.assertEqual(self.data.columns[-1], "LR_2")

    # 測試拋物線停止和反轉指標計算函式的擴充套件功能
    def test_psar_ext(self):
        # 計算拋物線停止和反轉指標，並將結果追加到原始資料後面
        self.data.ta.psar(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後四列的列名為指定的拋物線引數
        self.assertEqual(
            list(self.data.columns[-4:]), ["PSARl_0.02_0.2", "PSARs_0.02_0.2", "PSARaf_0.02_0.2", "PSARr_0.02_0.2"])

    # 測試 QStick 指標計算函式的擴充套件功能
    def test_qstick_ext(self):
        # 計算 QStick 指標，並將結果追加到原始資料後面
        self.data.ta.qstick(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為 "QS_10"
        self.assertEqual(self.data.columns[-1], "QS_10")

    # 測試短期趨勢計算函式的擴充套件功能
    def test_short_run_ext(self):
        # 未傳遞引數，返回原始資料
        self.assertEqual(
            self.data.ta.short_run(append=True).shape, self.data.shape)

        # 計算快速和慢速指數移動平均線
        fast = self.data.ta.ema(8)
        slow = self.data.ta.ema(21)
        # 計算短期趨勢指標，並將結果追加到原始資料後面
        self.data.ta.short_run(fast, slow, append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為 "SR_2"
        self.assertEqual(self.data.columns[-1], "SR_2")

    # 測試 TTM 趨勢指標計算函式的擴充套件功能
    def test_ttm_trend_ext(self):
        # 計算 TTM 趨勢指標，並將結果追加到原始資料後面
        self.data.ta.ttm_trend(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為 "TTM_TRND_6"
        self.assertEqual(list(self.data.columns[-1:]), ["TTM_TRND_6"])

    # 測試渦輪指標計算函式的擴充套件功能
    def test_vortext_ext(self):
        # 計算渦輪指標，並將結果追加到原始資料後面
        self.data.ta.vortex(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後兩列的列名為 "VTXP_14" 和 "VTXM_14"
        self.assertEqual(list(self.data.columns[-2:]), ["VTXP_14", "VTXM_14"])

.\pandas-ta\tests\test_ext_indicator_volatility.py

# 匯入所需模組
from .config import sample_data
from .context import pandas_ta
# 匯入 TestCase 類
from unittest import TestCase
# 匯入 DataFrame 類
from pandas import DataFrame

# 建立測試類 TestVolatilityExtension，繼承自 TestCase 類
class TestVolatilityExtension(TestCase):
    # 在所有測試方法執行之前執行的方法
    @classmethod
    def setUpClass(cls):
        # 設定測試資料
        cls.data = sample_data

    # 在所有測試方法執行之後執行的方法
    @classmethod
    def tearDownClass(cls):
        # 刪除測試資料
        del cls.data

    # 在每個測試方法執行之前執行的方法
    def setUp(self): pass
    
    # 在每個測試方法執行之後執行的方法
    def tearDown(self): pass

    # 測試 aberration 方法是否正常工作
    def test_aberration_ext(self):
        # 呼叫 aberration 方法
        self.data.ta.aberration(append=True)
        # 斷言 data 是否為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 data 的最後四列是否等於給定列表
        self.assertEqual(list(self.data.columns[-4:]), ["ABER_ZG_5_15", "ABER_SG_5_15", "ABER_XG_5_15", "ABER_ATR_5_15"])

    # 測試 accbands 方法是否正常工作
    def test_accbands_ext(self):
        # 呼叫 accbands 方法
        self.data.ta.accbands(append=True)
        # 斷言 data 是否為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 data 的最後三列是否等於給定列表
        self.assertEqual(list(self.data.columns[-3:]), ["ACCBL_20", "ACCBM_20", "ACCBU_20"])

    # 測試 atr 方法是否正常工作
    def test_atr_ext(self):
        # 呼叫 atr 方法
        self.data.ta.atr(append=True)
        # 斷言 data 是否為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 data 的最後一列是否等於給定字串
        self.assertEqual(self.data.columns[-1], "ATRr_14")

    # 測試 bbands 方法是否正常工作
    def test_bbands_ext(self):
        # 呼叫 bbands 方法
        self.data.ta.bbands(append=True)
        # 斷言 data 是否為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 data 的最後五列是否等於給定列表
        self.assertEqual(list(self.data.columns[-5:]), ["BBL_5_2.0", "BBM_5_2.0", "BBU_5_2.0", "BBB_5_2.0", "BBP_5_2.0"])

    # 測試 donchian 方法是否正常工作
    def test_donchian_ext(self):
        # 呼叫 donchian 方法
        self.data.ta.donchian(append=True)
        # 斷言 data 是否為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 data 的最後三列是否等於給定列表
        self.assertEqual(list(self.data.columns[-3:]), ["DCL_20_20", "DCM_20_20", "DCU_20_20"])

    # 測試 kc 方法是否正常工作
    def test_kc_ext(self):
        # 呼叫 kc 方法
        self.data.ta.kc(append=True)
        # 斷言 data 是否為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 data 的最後三列是否等於給定列表
        self.assertEqual(list(self.data.columns[-3:]), ["KCLe_20_2", "KCBe_20_2", "KCUe_20_2"])

    # 測試 massi 方法是否正常工作
    def test_massi_ext(self):
        # 呼叫 massi 方法
        self.data.ta.massi(append=True)
        # 斷言 data 是否為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 data 的最後一列是否等於給定字串
        self.assertEqual(self.data.columns[-1], "MASSI_9_25")

    # 測試 natr 方法是否正常工作
    def test_natr_ext(self):
        # 呼叫 natr 方法
        self.data.ta.natr(append=True)
        # 斷言 data 是否為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 data 的最後一列是否等於給定字串
        self.assertEqual(self.data.columns[-1], "NATR_14")

    # 測試 pdist 方法是否正常工作
    def test_pdist_ext(self):
        # 呼叫 pdist 方法
        self.data.ta.pdist(append=True)
        # 斷言 data 是否為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 data 的最後一列是否等於給定字串
        self.assertEqual(self.data.columns[-1], "PDIST")

    # 測試 rvi 方法是否正常工作
    def test_rvi_ext(self):
        # 呼叫 rvi 方法
        self.data.ta.rvi(append=True)
        # 斷言 data 是否為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 data 的最後一列是否等於給定字串
        self.assertEqual(self.data.columns[-1], "RVI_14")

    # 測試 rvi 方法是否正常工作，且使用 refined 引數
    def test_rvi_refined_ext(self):
        # 呼叫 rvi 方法，傳入 refined 引數為 True
        self.data.ta.rvi(refined=True, append=True)
        # 斷言 data 是否為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 data 的最後一列是否等於給定字串
        self.assertEqual(self.data.columns[-1], "RVIr_14")

    # 測試 rvi 方法是否正常工作，且使用 thirds 引數
    def test_rvi_thirds_ext(self):
        # 呼叫 rvi 方法，傳入 thirds 引數為 True
        self.data.ta.rvi(thirds=True, append=True)
        # 斷言 data 是否為 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 斷言 data 的最後一列是否等於給定字串
        self.assertEqual(self.data.columns[-1], "RVIt_14")
    # 測試擴充套件函式：計算熱力指標
    def test_thermo_ext(self):
        # 呼叫熱力指標計算函式，並將結果附加到原始資料上
        self.data.ta.thermo(append=True)
        # 確保結果是 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 檢查結果中最後四列的列名是否符合預期
        self.assertEqual(list(self.data.columns[-4:]), ["THERMO_20_2_0.5", "THERMOma_20_2_0.5", "THERMOl_20_2_0.5", "THERMOs_20_2_0.5"])

    # 測試擴充套件函式：計算真實範圍
    def test_true_range_ext(self):
        # 呼叫真實範圍計算函式，並將結果附加到原始資料上
        self.data.ta.true_range(append=True)
        # 確保結果是 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 檢查結果中最後一列的列名是否符合預期
        self.assertEqual(self.data.columns[-1], "TRUERANGE_1")

    # 測試擴充套件函式：計算 UI 指標
    def test_ui_ext(self):
        # 呼叫 UI 指標計算函式，並將結果附加到原始資料上
        self.data.ta.ui(append=True)
        # 確保結果是 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 檢查結果中最後一列的列名是否符合預期
        self.assertEqual(self.data.columns[-1], "UI_14")

        # 呼叫 UI 指標計算函式，使用 everget 引數，並將結果附加到原始資料上
        self.data.ta.ui(append=True, everget=True)
        # 確保結果是 DataFrame 型別
        self.assertIsInstance(self.data, DataFrame)
        # 檢查結果中最後一列的列名是否符合預期
        self.assertEqual(self.data.columns[-1], "UIe_14")

.\pandas-ta\tests\test_ext_indicator_volume.py

# 匯入所需的模組
from .config import sample_data
from .context import pandas_ta
# 匯入測試用例相關的模組
from unittest import TestCase
# 從 pandas 模組中匯入 DataFrame 類
from pandas import DataFrame

# 定義測試類 TestVolumeExtension，繼承自 TestCase 類
class TestVolumeExtension(TestCase):
    # 在整個測試類執行之前呼叫，設定測試所需的資料
    @classmethod
    def setUpClass(cls):
        # 獲取示例資料
        cls.data = sample_data
        # 獲取示例資料中的 "open" 列
        cls.open = cls.data["open"]

    # 在整個測試類執行之後呼叫，清理測試所用到的資料
    @classmethod
    def tearDownClass(cls):
        # 刪除示例資料
        del cls.data
        # 刪除示例資料中的 "open" 列
        del cls.open

    # 在每個測試方法執行之前呼叫，可用於設定測試前的準備工作
    def setUp(self): pass
    
    # 在每個測試方法執行之後呼叫，可用於清理測試後的工作
    def tearDown(self): pass

    # 測試 AD 指標擴充套件功能
    def test_ad_ext(self):
        # 呼叫 ad 方法計算 AD 指標並將其追加到資料幀中
        self.data.ta.ad(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言資料幀的最後一列為 "AD"
        self.assertEqual(self.data.columns[-1], "AD")

    # 測試 AD 指標中 open 引數擴充套件功能
    def test_ad_open_ext(self):
        # 呼叫 ad 方法計算 AD 指標，傳入 open_ 引數，並將其追加到資料幀中
        self.data.ta.ad(open_=self.open, append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言資料幀的最後一列為 "ADo"
        self.assertEqual(self.data.columns[-1], "ADo")

    # 測試 ADOSC 指標擴充套件功能
    def test_adosc_ext(self):
        # 呼叫 adosc 方法計算 ADOSC 指標並將其追加到資料幀中
        self.data.ta.adosc(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言資料幀的最後一列為 "ADOSC_3_10"
        self.assertEqual(self.data.columns[-1], "ADOSC_3_10")

    # 測試 AOBV 指標擴充套件功能
    def test_aobv_ext(self):
        # 呼叫 aobv 方法計算 AOBV 指標並將其追加到資料幀中
        self.data.ta.aobv(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言資料幀的最後七列為給定列表中的列名
        self.assertEqual(
            list(self.data.columns[-7:]),
            ["OBV", "OBV_min_2", "OBV_max_2", "OBVe_4", "OBVe_12", "AOBV_LR_2", "AOBV_SR_2"],
        )
        # 移除 "OBV" 列，以免干擾 test_obv_ext() 測試方法
        self.data.drop("OBV", axis=1, inplace=True)

    # 測試 CMF 指標擴充套件功能
    def test_cmf_ext(self):
        # 呼叫 cmf 方法計算 CMF 指標並將其追加到資料幀中
        self.data.ta.cmf(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言資料幀的最後一列為 "CMF_20"
        self.assertEqual(self.data.columns[-1], "CMF_20")

    # 測試 EFI 指標擴充套件功能
    def test_efi_ext(self):
        # 呼叫 efi 方法計算 EFI 指標並將其追加到資料幀中
        self.data.ta.efi(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言資料幀的最後一列為 "EFI_13"
        self.assertEqual(self.data.columns[-1], "EFI_13")

    # 測試 EOM 指標擴充套件功能
    def test_eom_ext(self):
        # 呼叫 eom 方法計算 EOM 指標並將其追加到資料幀中
        self.data.ta.eom(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言資料幀的最後一列為 "EOM_14_100000000"
        self.assertEqual(self.data.columns[-1], "EOM_14_100000000")

    # 測試 KVO 指標擴充套件功能
    def test_kvo_ext(self):
        # 呼叫 kvo 方法計算 KVO 指標並將其追加到資料幀中
        self.data.ta.kvo(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言資料幀的倒數第二和最後一列為給定列表中的列名
        self.assertEqual(list(self.data.columns[-2:]), ["KVO_34_55_13", "KVOs_34_55_13"])

    # 測試 MFI 指標擴充套件功能
    def test_mfi_ext(self):
        # 呼叫 mfi 方法計算 MFI 指標並將其追加到資料幀中
        self.data.ta.mfi(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言資料幀的最後一列為 "MFI_14"
        self.assertEqual(self.data.columns[-1], "MFI_14")

    # 測試 NVI 指標擴充套件功能
    def test_nvi_ext(self):
        # 呼叫 nvi 方法計算 NVI 指標並將其追加到資料幀中
        self.data.ta.nvi(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言資料幀的最後一
    # 測試 pvol 方法是否正常執行並將結果附加到資料框中
    def test_pvol_ext(self):
        self.data.ta.pvol(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為 "PVOL"
    
    # 測試 pvr 方法是否正常執行並將結果附加到資料框中
    def test_pvr_ext(self):
        self.data.ta.pvr(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為 "PVR"
    
    # 測試 pvt 方法是否正常執行並將結果附加到資料框中
    def test_pvt_ext(self):
        self.data.ta.pvt(append=True)
        # 斷言資料型別為 DataFrame
        self.assertIsInstance(self.data, DataFrame)
        # 斷言最後一列的列名為 "PVT"
    
    # 測試 vp 方法是否正常執行並返回 DataFrame
    def test_vp_ext(self):
        result = self.data.ta.vp()
        # 斷言返回結果的資料型別為 DataFrame
        self.assertIsInstance(result, DataFrame)
        # 斷言返回結果的名稱為 "VP_10"

.\pandas-ta\tests\test_indicator_candle.py

# 從專案的config模組中匯入錯誤分析、樣本資料、相關性、相關性閾值和詳細程度
from .config import error_analysis, sample_data, CORRELATION, CORRELATION_THRESHOLD, VERBOSE
# 從專案的context模組中匯入pandas_ta
from .context import pandas_ta

# 匯入TestCase類和skip裝飾器從unittest模組
from unittest import TestCase, skip
# 匯入pandas測試模組作為pdt別名
import pandas.testing as pdt
# 從pandas模組匯入DataFrame和Series類
from pandas import DataFrame, Series

# 匯入talib庫作為tal別名
import talib as tal

# 定義測試類TestCandle，繼承自TestCase類
class TestCandle(TestCase):
    # 設定測試類的類方法setUpClass，在所有測試方法之前執行
    @classmethod
    def setUpClass(cls):
        # 初始化測試資料
        cls.data = sample_data
        # 將列名轉換為小寫
        cls.data.columns = cls.data.columns.str.lower()
        # 初始化開盤價、最高價、最低價和收盤價
        cls.open = cls.data["open"]
        cls.high = cls.data["high"]
        cls.low = cls.data["low"]
        cls.close = cls.data["close"]
        # 如果資料中包含成交量列，則初始化成交量
        if "volume" in cls.data.columns:
            cls.volume = cls.data["volume"]

    # 設定測試類的類方法tearDownClass，在所有測試方法之後執行
    @classmethod
    def tearDownClass(cls):
        # 刪除開盤價、最高價、最低價和收盤價
        del cls.open
        del cls.high
        del cls.low
        del cls.close
        # 如果測試資料中存在成交量列，則刪除成交量
        if hasattr(cls, "volume"):
            del cls.volume
        # 刪除測試資料
        del cls.data

    # 設定測試方法的setUp，在每個測試方法之前執行
    def setUp(self): pass
    
    # 設定測試方法的tearDown，在每個測試方法之後執行
    def tearDown(self): pass

    # 測試Heikin-Ashi指標的方法
    def test_ha(self):
        # 計算Heikin-Ashi指標
        result = pandas_ta.ha(self.open, self.high, self.low, self.close)
        # 斷言結果型別為DataFrame
        self.assertIsInstance(result, DataFrame)
        # 斷言結果名稱為"Heikin-Ashi"
        self.assertEqual(result.name, "Heikin-Ashi")

    # 測試蠟燭圖形態指標的方法
    def test_cdl_pattern(self):
        # 計算所有蠟燭圖形態指標
        result = pandas_ta.cdl_pattern(self.open, self.high, self.low, self.close, name="all")
        # 斷言結果型別為DataFrame
        self.assertIsInstance(result, DataFrame)
        # 斷言結果列數與蠟燭圖形態指標名稱列表長度相等
        self.assertEqual(len(result.columns), len(pandas_ta.CDL_PATTERN_NAMES))

        # 計算特定蠟燭圖形態指標（doji）的方法
        result = pandas_ta.cdl_pattern(self.open, self.high, self.low, self.close, name="doji")
        # 斷言結果型別為DataFrame
        self.assertIsInstance(result, DataFrame)

        # 計算多個蠟燭圖形態指標（doji、inside）的方法
        result = pandas_ta.cdl_pattern(self.open, self.high, self.low, self.close, name=["doji", "inside"])
        # 斷言結果型別為DataFrame
        self.assertIsInstance(result, DataFrame)

    # 測試Doji蠟燭圖形態指標的方法
    def test_cdl_doji(self):
        # 計算Doji蠟燭圖形態指標
        result = pandas_ta.cdl_doji(self.open, self.high, self.low, self.close)
        # 斷言結果型別為Series
        self.assertIsInstance(result, Series)
        # 斷言結果名稱為"CDL_DOJI_10_0.1"
        self.assertEqual(result.name, "CDL_DOJI_10_0.1")

        try:
            # 使用talib計算Doji蠟燭圖形態指標
            expected = tal.CDLDOJI(self.open, self.high, self.low, self.close)
            # 斷言結果與talib計算結果相等
            pdt.assert_series_equal(result, expected, check_names=False)
        except AssertionError:
            try:
                # 如果斷言失敗，計算結果與talib計算結果的相關性
                corr = pandas_ta.utils.df_error_analysis(result, expected, col=CORRELATION)
                # 斷言相關性大於相關性閾值
                self.assertGreater(corr, CORRELATION_THRESHOLD)
            except Exception as ex:
                # 如果出現異常，呼叫錯誤分析函式
                error_analysis(result, CORRELATION, ex)

    # 測試Inside蠟燭圖形態指標的方法
    def test_cdl_inside(self):
        # 計算Inside蠟燭圖形態指標
        result = pandas_ta.cdl_inside(self.open, self.high, self.low, self.close)
        # 斷言結果型別為Series
        self.assertIsInstance(result, Series)
        # 斷言結果名稱為"CDL_INSIDE"
        self.assertEqual(result.name, "CDL_INSIDE")

        # 計算Inside蠟燭圖形態指標，並轉換為布林值
        result = pandas_ta.cdl_inside(self.open, self.high, self.low, self.close, asbool=True)
        # 斷言結果型別為Series
        self.assertIsInstance(result, Series)
        # 斷言結果名稱為"CDL_INSIDE"
        self.assertEqual(result.name, "CDL_INSIDE")

    # 測試Z蠟燭圖形態指標的方法
    def test_cdl_z(self):
        # 計算Z蠟燭圖形態指標
        result = pandas_ta.cdl_z(self.open, self.high, self.low, self.close)
        # 斷言結果型別為DataFrame
        self.assertIsInstance(result, DataFrame)
        # 斷言結果名稱為"CDL_Z_30_1"
        self.assertEqual(result.name, "CDL_Z_30_1")