首页 > 编程语言 >PandasTA 源码解析（十九）

PandasTA 源码解析（十九）

时间：2024-04-15 13:55:56浏览次数：21  
标签：断言 PandasTA 十九 self DataFrame 源码 data def ta

.\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")

标签：断言,PandasTA,十九,self,DataFrame,源码,data,def,ta
From： https://www.cnblogs.com/apachecn/p/18135800

相关文章

  • PandasTA 源码解析（二十一）
    .\pandas-ta\tests\test_indicator_performance.py#导入所需的模块和函数from.configimportsample_datafrom.contextimportpandas_ta#从unittest模块中导入TestCase类fromunittestimportTestCase#从pandas模块中导入Series类frompandasimportSeries......
  • PandasTA 源码解析（一）
    .\pandas-ta\docs\conf.py#-*-coding:utf-8-*-##ConfigurationfilefortheSphinxdocumentationbuilder.##Thisfiledoesonlycontainaselectionofthemostcommonoptions.Fora#fulllistseethedocumentation:#http://www.sphinx-doc.org/e......
  • PandasTA 源码解析（二）
    .\pandas-ta\pandas_ta\candles\cdl_inside.py#-*-coding:utf-8-*-#从pandas_ta.utils中导入candle_color和get_offset函数frompandas_ta.utilsimportcandle_color,get_offset#从pandas_ta.utils中导入verify_series函数frompandas_ta.utilsimportve......
  • PandasTA 源码解析（四）
    .\pandas-ta\pandas_ta\momentum\cg.py#-*-coding:utf-8-*-#从pandas_ta.utils中导入get_offset,verify_series,weights函数frompandas_ta.utilsimportget_offset,verify_series,weights#定义CenterofGravity(CG)指标函数defcg(close,length=None,......
  • PandasTA 源码解析（三）
    .\pandas-ta\pandas_ta\custom.py#设置文件编码为UTF-8#-*-coding:utf-8-*-#导入必要的模块importimportlib#动态导入模块的工具importos#提供与操作系统交互的功能importsys#提供与Python解释器交互的功能importtypes#提供对Python类型和类的......
  • PandasTA 源码解析（六）
    .\pandas-ta\pandas_ta\momentum\rsi.py#-*-coding:utf-8-*-#导入所需模块和函数frompandasimportDataFrame,concatfrompandas_taimportImportsfrompandas_ta.overlapimportrmafrompandas_ta.utilsimportget_drift,get_offset,verify_series,signals......
  • PandasTA 源码解析（五）
    .\pandas-ta\pandas_ta\momentum\kst.py#-*-coding:utf-8-*-#导入DataFrame类frompandasimportDataFrame#导入roc函数from.rocimportroc#导入验证序列函数、获取漂移和偏移的函数frompandas_ta.utilsimportget_drift,get_offset,verify_series#定义......
  • PandasTA 源码解析（八）
    .\pandas-ta\pandas_ta\momentum\__init__.py#设置文件编码为UTF-8#导入ao指标from.aoimportao#导入apo指标from.apoimportapo#导入bias指标from.biasimportbias#导入bop指标from.bopimportbop#导入brar指标from.brarimportbrar#导......
  • PandasTA 源码解析（七）
    .\pandas-ta\pandas_ta\momentum\stc.py#-*-coding:utf-8-*-从pandas库中导入DataFrame和Series类从pandas_ta.overlap模块中导入ema函数从pandas_ta.utils模块中导入get_offset、non_zero_range和verify_series函数#定义函数：SchaffTrendCycle(STC......
  • BackTrader 中文文档（二十九）
    原文：www.backtrader.com/开发一个指标原文：www.backtrader.com/blog/posts/2015-07-18-developing-an-indicator/developing-an-indicator/在对backtrader进行了大量的微调之后（因为它已经运行了一段时间），我决定不仅通过GitHub分享它，还要告诉世界它的存在，并在"Reddit"上发......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99