标签归档:回测

量化投资单因子回测神器 — Alphalens

还记得我们在前面采用的回测工具Backtrader吗?Backtrader是一款非常灵活的回测工具,基于它你能回测任何你想要测试的idea.

但是针对单因子回测,Backtrader 开发回测代码以及生成报告上并不算很方便,我们需要自己编写买卖逻辑,在生成的报告上也没有IC、IR、回撤等的数据分析,而实际上,从单因子回测的技术实现角度上来说,这些都是可以自动化生成的。

Alphalens就是一个专门实现单因子自动回测的神器,我们只要给它输入因子值的列,还有每支股票收盘价的数据,它就能自动生成数据分析及报告,并带有十几张可视化的报告数据统计图:

下面就带大家入门使用一下Alphalens,如果对你有帮助的话,记得点一下赞/在看哦。

1.准备

开始之前,你要确保Python和pip已经成功安装在电脑上,如果没有,请访问这篇文章:超详细Python安装指南 进行安装。

(可选1) 如果你用Python的目的是数据分析,可以直接安装Anaconda:Python数据分析与挖掘好帮手—Anaconda,它内置了Python和pip.

(可选2) 此外,推荐大家用VSCode编辑器来编写小型Python项目:Python 编程的最好搭档—VSCode 详细指南

Windows环境下打开Cmd(开始—运行—CMD),苹果系统环境下请打开Terminal(command+空格输入Terminal),输入命令安装依赖:

pip install alphalens
pip install tushare
pip install pandas

2.数据预处理

正如前面所说,我们只需要把因子值和收盘价放入Alphalens中,就能自动生成回测和报告结果。

所以,我们90%的工作都会在数据处理这一部分,回测和分析都是抽象封装好的,并不需要太多地去担心它。

为了测试,我们导入tushare的数据进行测试:

import pandas as pd
import tushare as ts
from alphalens.utils import get_clean_factor_and_forward_returns
from alphalens.tears import create_full_tear_sheet

pro = ts.pro_api()
# 此接口获取的数据为未复权数据,回测建议使用复权数据,这里为批量获取股票数据做了简化
df = pro.daily(ts_code='000001.SZ,600982.SH', start_date='20200101', end_date='20211122')
df.index = pd.to_datetime(df['trade_date'])
df.index.name = None
df.sort_index(inplace=True)

这里获取了000001.SZ,600982.SH两只股票在2020-01-01到2021-11-22的日线数据,将交易日期设为了索引并排序。效果如下:

然后需要设置多索引的因子列 assets,第一个索引为日期,第二个索引为股票代码:

# 多索引的因子列,第一个索引为日期,第二个索引为股票代码
assets = df.set_index([df.index, df['ts_code']], drop=True)

​效果如下,仔细观察的话能发现其与导入的数据只有索引的不同:

然后,设置收盘价的Dataframe,这个与因子数据的格式不同,索引是时间,每一列是每只股票对应的收盘价:

# column为股票代码,index为日期,值为收盘价
close = df.pivot_table(index='trade_date', columns='ts_code', values='close')
close.index = pd.to_datetime(close.index)

到这一步,我们的初始化工作就完成了,下面就放到 Alphalens 进行测试。

3.Alphalens回测及报告

使用Alphalens进行回测,是非常轻松而写意的,只需要导入包,给它传递因子数据和收盘价数据即可:

from alphalens.utils import get_clean_factor_and_forward_returns
from alphalens.tears import create_full_tear_sheet

ret = get_clean_factor_and_forward_returns(assets[['pct_chg']], close)
create_full_tear_sheet(ret, long_short=False)

get_clean_factor_and_forward_returns 接受的第一个参数就是因子的列,我们只需要从前面预处理好的 assets 中任取一列作为因子进行回测即可,第二列是收盘价。

值得注意的是,因子数据在回测的时候,注意不要使用到未来数据,因为我们是用前一天的数据预测下一天的收盘价,所以要对因子列进行移位处理,这点一定要注意。

运行程序,就能生成如下的报告:

还有一点需要提醒大家的是,开源Alphalens的Quantopian公司已经倒闭,所以项目暂时没人维护了,部分代码没有适配最新的依赖,所以可能会有问题,比如下面的:

原本是通过 .get_values() 获得 input_periods, 但是 get_values 在 pandas 0.25.0 中已经被弃用,最新的pandas版本这里需要改成 .to_numpy() 才能生效。

除了这个小缺点,Alphalens整体上是非常符合大家单因子测试的需求的。它的分析报告可能没有那么齐全,我们也可以考虑在Alphalens的基础上增加其他的分析内容,如果能开源出来则更好了。

考虑到后续Alphalens没人维护,我fork了Alphalens,并增加了自己的改动,希望有余力的同学也能来一起贡献代码:
https://github.com/Ckend/alphalens

我们的文章到此就结束啦,如果你喜欢今天的 Python 教程,请持续关注Python实用宝典。

有任何问题,可以在公众号后台回复:加群,回答相应验证信息,进入互助群询问。

原创不易,希望你能在下面点个赞和在看支持我继续创作,谢谢!


​Python实用宝典 ( pythondict.com )
不只是一个宝典
欢迎关注公众号:Python实用宝典

可转债交易策略 — Python 量化投资实战教程(10)

以下内容仅供参考学习,不构成投资意见。

可转债,是一种具有中国特色的、受到国家管理和保护的债券,之所以说它很有特色,是因为它身上具备了两种闪闪发光的特性:

1.债性 — 安全保本

可转债本质上是一种公司的债券,也就是我们生活中所说的“欠条”,每张“欠条”的价值是100块钱。

如果你持有一张可转债,它就代表着上市公司欠你100块钱,而且未来必须偿还这笔钱并附带利息。截止到目前,所有上市的可转债,都完成了保本的使命。

也就是说,如果你在转债价格低于100元的时候买入,此时就是保本的。而且公司在赎回时,会付你一定的利息,所以当你在可转债价格低于100元的时候买入,就是保本保利的。

2.股性(可转换) — 存在套利空间

可转债是一张可转换为股票的公司债券。比如目前 晨光转债 转股价为 12.25 元,100/12.25=8.16,那么一张晨光转债会被取证转为8股晨光生物,其余的尾数会被转换为证券账户资金。

目前晨光生物正股16.10元,转换后,你相当于获得了8*16.10=128.8元的股票,加上刚刚尾数补充的账户资金,转股后你相当于获得了131.43元,131.43元被称为转股价值。

也就是说,如果你在前一天收盘前买入了1张晨光转债,并在当前转换为股票,第二天你会获得价值为131.43元的股票+证券账户资金。目前晨光转债的价格为 130.2 元,净利0.93%,但这个套利逻辑有个大前提:第二天开盘股价不会跌,如果跌了,你就拿不到这么多的价值,甚至有可能亏本。

下面本文要研究和利用的,不是可转债的股性,而是可转债的债性。

就如前面所说的,如果你买入100元以下的可转债,除非公司老板带着小姨子跑路,否则都是保本的。于是就有了下面这个自动交易的逻辑:

对于100元以下的可转债,触发某种上涨信号时,买入。上涨0.5%则卖出。如果下跌则一直持有。

上涨就赚了,下跌的话长期持有也不亏,利用可转债的债性及T+0交易的特性实行日内高频率交易就是这个策略的主要逻辑。

1.准备

开始之前,你要确保Python和pip已经成功安装在电脑上,如果没有,请访问这篇文章:超详细Python安装指南 进行安装。

(可选1) 如果你用Python的目的是数据分析,可以直接安装Anaconda:Python数据分析与挖掘好帮手—Anaconda,它内置了Python和pip.

(可选2) 此外,推荐大家用VSCode编辑器来编写小型Python项目:Python 编程的最好搭档—VSCode 详细指南

Windows环境下打开Cmd(开始—运行—CMD),苹果系统环境下请打开Terminal(command+空格输入Terminal),输入命令安装依赖:

在终端输入以下命令安装我们所需要的依赖模块:

pip install backtrader
pip install easytrader

看到 Successfully installed xxx 则说明安装成功。

某些券商在登录的时候可能需要识别验证码,这时候需要下载tesseract

1.下载并安装tesseract

前往 tesseract-ocr 官网下载二进制包,此外你也可以在Python实用宝典公众号后台回复: 量化投资10,直接获得本文源代码和tesseract的安装包。

双击下载下来的安装包,然后傻瓜式安装就可以,这里只需要注意一点:安装过程中有一个让你选择 Additional language data(download) 表示选择的话帮你下载语言包,这里最好不要选择勾选,因为勾选的话,安装过程非常慢,本教程只需要用到数字和英文识别而已。

2.配置环境变量

右击我的电脑/计算机,选择属性,然后选择高级属性设置,选择环境变量,在系统变量的path变量中添加你的 tesseract 目录就可以了

3.判断是否安装成功

在命令行中输入:

tesseract --version

出现下面的提示说明安装成功:

2.回测

按照这个策略的逻辑,回测的目的不在于探讨是否会亏损,而在于最高能赚多少。

为什么不需要探讨亏损?因为实际上即便我们买入80元的广汇转债,一直持有,3年后它以100元的价格赎回,我们的3年收益都达到了20%,平均年化率达6.67%。

当然,风险是有的,广汇老板如果带着小姨子跑路了,那你的转债可能一文不值,但是目前还没有出现过这种情况,因为如果出现了这种情况,将出现严重的信用危机,监管部门不可能允许这种情况发生。

回测的主要目的在于:怎样进行自动化交易,能最大化我们的收益。

关于编写策略的方法我们前面九篇系列文章都讲的很清楚了,这里就不再赘述,这里只重点研究买入的逻辑。

2.1 基于分钟K线的Sma金叉策略

这是最简单的策略,如果sma5和sma10实现金叉,则买入债券。涨0.5%则卖出,否则不动。

部分代码如下:

    def golden(self, a, b):
        if a[-1] - b[-1] < 0 and a[0] - b[0] > 0:
            return True
        else:
            return False

    def next(self):
        if self.order:
            return

        if not self.position:
            if self.golden(self.sma5, self.sma10):
                self.order = self.buy()
                self.params.buydays.append(self.datas[0].datetime.date(0))

        else:
            condition = (self.dataclose[0] - self.bar_executed_close) / self.bar_executed_close
            if condition > 0.005:
                self.order = self.sell()
                self.dead = False
                self.params.selldays.append(self.datas[0].datetime.date(0))
                self.params.hold_days.append((self.params.selldays[-1] - self.params.buydays[-1]).days)
                if self.params.buydays[-1] != self.params.selldays[-1]:
                    days = get_every_day(self.params.buydays[-1], self.params.selldays[-1])
                    for day in days:
                        self.params.hold_count[day] += 1

随机抽取了15只低价债券,回测了 2020-9-15 至 2020-11-8 之间的走势,一共交易了59次,每次买入50股。

可以看到每次交易的平均持有日期为4天,这是平均值,如果你看中位数会更大,有些交易可能连续持有了30天,有些可能当天买入当天卖出,两极分化比较大。

不过即便这样,按平均每次收益0.5%、平均每支债券价格为80元的情况来看, 59次交易*0.005*80*50股 = 1180元,如果可转债每次交易的平均手续费是1元,那么除去手续费 1180-2*59=1062元。看起来是一笔可观的羊毛,但是你必须忍受有部分资金被套牢在一些低价转债的情况。

2.2 基于分钟K线的EMA金叉的策略

接下来我们测试一下使用EMA均线的效果,这里选择的是ema(12)和ema(50):

    def golden(self, a, b):
        if a[-1] - b[-1] < 0 and a[0] - b[0] > 0:
            return True
        else:
            return False

    def next(self):
        if self.order:
            return

        if not self.position:
            if self.golden(self.exp1, self.exp2):
                self.order = self.buy()
                self.params.buydays.append(self.datas[0].datetime.date(0))

        else:
            condition = (self.dataclose[0] - self.bar_executed_close) / self.bar_executed_close
            if condition > 0.005:
                self.order = self.sell()
                self.dead = False
                self.params.selldays.append(self.datas[0].datetime.date(0))
                self.params.hold_days.append((self.params.selldays[-1] - self.params.buydays[-1]).days)
                if self.params.buydays[-1] != self.params.selldays[-1]:
                    days = get_every_day(self.params.buydays[-1], self.params.selldays[-1])
                    for day in days:
                        self.params.hold_count[day] += 1

效果如下:

交易次数相对于sma策略少了14次,所以收益肯定也会下降。平均持有日期达到了5.4天,相比于sma策略也有所提高。因此ema在我们的整个策略逻辑里表现地比sma策略稍差一些。

上面展示了两种策略在我们的低价转债投资逻辑里的应用和分析,由于篇幅关系这里就不再展示一些其他策略的回测结果,大家有兴趣可以自己试一下。

3.自动交易

使用easytrader模块,可以简单实现一个单进程的自动交易程序。

对于本策略而言单进程的自动交易程序也够了,因为这个策略要求的实时性并不是很高。

由于这部分代码无法脱敏,因此不能进行深入地讲解。逻辑并不难,每分钟对指定的股票进行监控,当其符合相关策略时进行买入或卖出,下面进行简单的讲解。

1.读取今日需检测的股票

在一天开始交易之前,需要获取今日所符合条件的低价可转债:

def start():
    account = Account()
    codes = read_today_codes()
    logger.info(f"总股票数 {len(codes)}")
    last_ping_time = datetime.datetime.now().timestamp()

2.巡检

在交易时间里,循环检测可转债是否符合买入策略

    while True:
        # 是否在交易时间
        if not check_time():
            continue
        for code in codes:
            now = int(datetime.datetime.now().timestamp())
            logger.info(f"{now} - {code}")
            try:
                # TODO: 异步执行算法
                buy_dict = algorithm(code)
                if not buy_dict:
                    continue
                logger.info(buy_dict)
                buy_time = list(buy_dict.keys())[0]
                buy_value = list(buy_dict.values())[0]

                if abs(int(buy_time.timestamp()) - now) < 300:
                    logic(account, code, buy_time, buy_value)

            except Exception as e:
                traceback.print_exc()
                logger.info(e)
                # send_mail(f"算法解析失败: {traceback.print_exc()}", "WRONG", code)

如果符合买入规则,在logic函数内,便会对可转债发布买单,同时挂一个0.5%利润的卖单。

3.卖单兜底

理想化情况下,在你挂了买单后立马成交,此时顺利挂出卖单。

不理想情况下,在你挂了买单后,几分钟后才成交,出现这种异步的情况后,卖单无法顺利挂出。

所以我们需要有一个兜底的措施:

        now = datetime.datetime.now()
        new_ping_time = now.timestamp()
        if new_ping_time - last_ping_time > 15:
            # 大于15秒,检测持仓,把未委托卖出的单子委托卖出
            account.every_day_sell()
        last_ping_time = new_ping_time
        logger.info(f"{datetime.datetime.strftime(now, '%Y-%m-%d %H:%M:%S')} ping")

每次巡检任务都检查持仓,如果存在未挂出卖单的可转债,则按成本价+0.5%的利润挂出卖单。这样保证没有漏掉的可转债。

上述只是简单的几个步骤,实现上你会还有许多细节需要考虑,大家可以自己尝试实现一个这样的自动交易流程。

欢迎在公众号后台回复:加群,回答相应红字验证信息,进入互助群交流。

我们的文章到此就结束啦,如果你喜欢今天的Python 实战教程,请持续关注Python实用宝典。

原创不易,希望你能在下面点个赞和在看支持我继续创作,谢谢!


​Python实用宝典 (pythondict.com)
不只是一个宝典
欢迎关注公众号:Python实用宝典

自定义MySQL数据流 — Python 量化投资实战教程(9)

前面八篇量化投资实战教程,我们所使用到的数据仅仅只有收盘价、成交量等普通指标,如果我们有其他的指标需要进行回测怎么办?

此外,前面使用的数据源都是基于csv文件的,我们能否从数据库(比如MySQL)中直接提取数据作为回测的数据源呢?

​事实上,backtrader虽然没有直接提供接口给我们做这样的优化,但是我们可以通过继承DataBase基类重写DataFeed实现目的。下面就给大家演示一下如何从MySQL中提取数据并增加换手率指标进行回测。

本文完整源代码和数据均在开源代码仓库中:
https://github.com/Ckend/pythondict-quant

1.准备

开始之前,你要确保Python和pip已经成功安装在电脑上,如果没有,请访问这篇文章:超详细Python安装指南 进行安装。

(可选1) 如果你用Python的目的是数据分析,可以直接安装Anaconda:Python数据分析与挖掘好帮手—Anaconda,它内置了Python和pip.

(可选2) 此外,推荐大家用VSCode编辑器来编写小型Python项目:Python 编程的最好搭档—VSCode 详细指南

Windows环境下打开Cmd(开始—运行—CMD),苹果系统环境下请打开Terminal(command+空格输入Terminal),输入命令安装依赖:

在终端输入以下命令安装我们所需要的依赖模块:

pip install backtrader
pip install numpy
pip install matplotlib

看到 Successfully installed xxx 则说明安装成功。

2.自定义DataFeed

何为DataFeed?DataFeed 即 backtrader 中的“数据源”,任何数据进入策略回测前都要通过DataFeed,而DataFeed中会对数据进行处理,使得策略可以高效地进行计算。

而我们今天要做的,就是增加一个基于MySQL的DataFeed,使得整个流程变得更加自动化。

首先,需要定义一个类,使其继承与backtrader的数据基类 DataBase:

from backtrader.feed import DataBase
from backtrader import date2num


class MySQLData(DataBase):
    pass

如果需要从外部传入所需股票数据的代码和其一定范围内的K线数据,需要提前定义params. 此外,如果你有除了datetime(时间)open(开盘价)close(收盘价)high(最高价)low(最低价)volume(成交量) 之外的指标。需要提前定义lines,如下所示:

class MySQLData(DataBase):
    params = (
        ('fromdate', datetime.datetime.min),
        ('todate', datetime.datetime.max),
        ('ts_code', ''),
    )
    lines = (
        "turnover",
        "turnover_rate"
    )

可见在lines中,我增加了两个指标:turnover(成交额)turnover_rate(换手率)

接下来,编写一个函数根据params参数从MySQL中获取数据:

    def load_data_from_db(self, table, ts_code, start_time, end_time):
        """
        从MySQL加载指定数据
        Args:
            table (str): 表名
            ts_code (str): 股票代码
            start_time (str): 起始时间
            end_time (str): 终止时间
        return:
            data (List): 数据集
        """
        db = pymysql.connect(
            host="localhost",
            user="root",
            password="12345678",
            db="golden_stone",
            port=3306
        )

        cur = db.cursor()
        sql = cur.execute(
            f"SELECT * FROM {table} WHERE trade_time >= '{start_time}' and trade_time < '{end_time}'"
            f"and ts_code = '{ts_code}' order by trade_time asc"
        )
        data = cur.fetchall()
        db.close()
        return iter(list(data))

代码本身没有什么可说的,记得替换你本地的mysql配置,值得注意的是最后一行,拿到mysql数据后需要转化为迭代器。

在类初始化的时候,需要定义相关的数据存放变量并调用上述函数获取数据:

    def __init__(self, *args, **kwargs):
        self.result = []
        self.empty = False

    def start(self):
        self.result = self.load_data_from_db("stock_normalk", self.p.ts_code, self.p.fromdate, self.p.todate)

接下来到了关键的步骤,在 `cerebro.adddata(data)` 的时候,cerebro会遍历Datafeed的所有数据,此时会调用_load函数, 因此我们需要在这里,将数据库中提取的每列数据对应到lines上:

    def _load(self):
        if self.empty:
            return False
        try:
            one_row = next(self.result)
        except StopIteration:
            return False
        self.lines.datetime[0] = date2num(one_row[3])
        self.lines.open[0] = float(one_row[4])
        self.lines.high[0] = float(one_row[5])
        self.lines.low[0] = float(one_row[6])
        self.lines.close[0] = float(one_row[7])
        self.lines.volume[0] = float(one_row[8])
        self.lines.turnover[0] = float(one_row[9])
        self.lines.turnover_rate[0] = float(one_row[12])
        return True

如果你完整地看完了我的上述分析,那么理解下面整个DataFeed,甚至自己写一个DataFeed,是非常容易的。

# Python 实用宝典
# 自定义数据流 — Python 量化投资实战教程(9)
import datetime
import traceback
import pymysql

from backtrader.feed import DataBase
from backtrader import date2num


class MySQLData(DataBase):
    params = (
        ('fromdate', datetime.datetime.min),
        ('todate', datetime.datetime.max),
        ('ts_code', ''),
    )
    lines = (
        "turnover",
        "turnover_rate"
    )

    def load_data_from_db(self, table, ts_code, start_time, end_time):
        """
        从MySQL加载指定数据
        Args:
            table (str): 表名
            ts_code (str): 股票代码
            start_time (str): 起始时间
            end_time (str): 终止时间
        return:
            data (List): 数据集
        """
        db = pymysql.connect(
            host="localhost",
            user="root",
            password="12345678",
            db="golden_stone",
            port=3306
        )

        cur = db.cursor()
        sql = cur.execute(
            f"SELECT * FROM {table} WHERE trade_time >= '{start_time}' and trade_time < '{end_time}'"
            f"and ts_code = '{ts_code}' order by trade_time asc"
        )
        data = cur.fetchall()
        db.close()
        return iter(list(data))

    def __init__(self, *args, **kwargs):
        self.result = []
        self.empty = False

    def start(self):
        self.result = self.load_data_from_db("stock_normalk", self.p.ts_code, self.p.fromdate, self.p.todate)

    def _load(self):
        if self.empty:
            return False
        try:
            one_row = next(self.result)
        except StopIteration:
            return False
        self.lines.datetime[0] = date2num(one_row[3])
        self.lines.open[0] = float(one_row[4])
        self.lines.high[0] = float(one_row[5])
        self.lines.low[0] = float(one_row[6])
        self.lines.close[0] = float(one_row[7])
        self.lines.volume[0] = float(one_row[8])
        self.lines.turnover[0] = float(one_row[9])
        self.lines.turnover_rate[0] = float(one_row[12])
        return True

3.使用自定义数据流进行回测

接下来,让我们尝试使用这个自定义数据流输入数据,采用第二章的macd策略辅助增加换手率指标进行回测。

这里当然需要你先读懂第二章的内容,如果有点忘记了,可以回头阅读一下,非常简单:

Python 量化投资实战教程(2) —MACD策略

首先,在回测模块及next函数中,引入换手率指标:

class TestStrategy(bt.Strategy):
    def log(self, txt, dt=None):
        ''' Logging function fot this strategy'''
        dt = dt or self.datas[0].datetime.date(0)
        print('%s, %s' % (dt.isoformat(), txt))

    @staticmethod
    def percent(today, yesterday):
        return float(today - yesterday) / today

    def __init__(self):
        self.dataclose = self.datas[0].close
        self.volume = self.datas[0].volume
        # 新的变更:引入换手率指标
        self.turnover_rate = self.datas[0].turnover_rate

next函数买入时增加判断换手率必须小于3%的条件:

    # Python 实用宝典
    def next(self):
        self.log('Close, %.2f' % self.dataclose[0])
        if self.order:
            return

        if not self.position:
            condition1 = self.macd[-1] - self.signal[-1]
            condition2 = self.macd[0] - self.signal[0]
            # 增加判断换手率小于3%的条件
            if condition1 < 0 and condition2 > 0 and self.turnover_rate[0] < 3:
                self.log('BUY CREATE, %.2f' % self.dataclose[0])
                self.order = self.buy()

        else:
            condition = (self.dataclose[0] - self.bar_executed_close) / self.dataclose[0]
            if condition > 0.1 or condition < -0.1:
                self.log('SELL CREATE, %.2f' % self.dataclose[0])
                self.order = self.sell()

最后,引入我们刚刚编写完成的MySQLData Feed,传入相关参数读取股票为603520.SH的数据流,取2017年1月1日至2020年4月12日的数据,并调用回测函数:

if __name__ == '__main__':
    cerebro = bt.Cerebro()

    cerebro.addstrategy(TestStrategy)

    # 加载数据到模型中
    data = MySQLData(
        ts_code="sh603520",
        fromdate=datetime.datetime(2017, 1, 1),
        todate=datetime.datetime(2020, 4, 12),
    )
    cerebro.adddata(data)

    cerebro.broker.setcash(10000)

    cerebro.addsizer(bt.sizers.FixedSize, stake=100)

    cerebro.broker.setcommission(commission=0.005)

    print('Starting Portfolio Value: %.2f' % cerebro.broker.getvalue())

    cerebro.run()

    print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())

    cerebro.plot()

效果如下:

与原来相比,加入换手率指标后,利润率有一定的提高,不过就如我们之前所说的,单一股票维度的回测是不准确的,如果大家有兴趣,可以将第三章:

Python 量化投资实战教程(3) —A股回测MACD策略

改造一下并加入换手率指标进行回测,看看这个指标是否真的有正效益。

本文完整源代码和数据均在开源代码仓库中:
https://github.com/Ckend/pythondict-quant

如果你访问不了github,也可以在公众号后台回复 量化投资9 下载相关代码。

欢迎在公众号后台回复:加群,回答相应红字验证信息,进入互助群交流。

我们的文章到此就结束啦,如果你喜欢今天的Python 实战教程,请持续关注Python实用宝典。

原创不易,希望你能在下面点个赞和在看支持我继续创作,谢谢!


​Python实用宝典 (pythondict.com)
不只是一个宝典
欢迎关注公众号:Python实用宝典

A股回测“孕线”策略 — Python 量化投资实战教程(8)

上一篇文章《Python 量化投资实战教程(7)—孕线真的有用吗?》中我们讲到了孕线的形态和其基本的量化规则。

不过,当时只是基于一支股票对这个策略进行回测,数据量过少,其结果并不具有参考性。

今天,我们将在A股中抽取1000只股票,计算这些股票在2010年1月1日至2020年5月10日采用孕线策略的收益率。

本文完整源代码和数据均在开源代码仓库中:
https://github.com/Ckend/pythondict-quant

1.准备

开始之前,你要确保Python和pip已经成功安装在电脑上噢,如果没有,请访问这篇文章:超详细Python安装指南 进行安装。如果你用Python的目的是数据分析,可以直接安装Anaconda:Python数据分析与挖掘好帮手—Anaconda

Windows环境下打开Cmd(开始—运行—CMD),苹果系统环境下请打开Terminal(command+空格输入Terminal),准备开始输入命令安装依赖。

当然,我更推荐大家用VSCode编辑器,把本文代码Copy下来,在编辑器下方的终端运行命令安装依赖模块,多舒服的一件事啊:Python 编程的最好搭档—VSCode 详细指南。

在终端输入以下命令安装我们所需要的依赖模块:

pip install backtrader
pip install numpy
pip install matplotlib

看到 Successfully installed xxx 则说明安装成功。

2.策略

买入卖出策略与上篇文章一致:

买入:符合孕线形态时,买入。

卖出:涨10%或跌10%。

策略核心代码如下:

    # Python 实用宝典
    def next(self):
        self.log("Close, %.2f" % self.dataclose[0])
        if self.order:
            return
        if not self.position:
            # condition1 = self.sma20[0] > self.dataclose[0]
            if self.dataclose[-1] < self.dataopen[-1]:
                harami = (
                    self.datahigh[0] < self.dataopen[-1]
                    and self.datalow[0] > self.dataclose[-1]
                )
            else:
                harami = (
                    self.datahigh[0] < self.dataclose[-1]
                    and self.datalow[0] > self.dataopen[-1]
                )

            if harami:
                self.log("BUY CREATE, %.2f" % self.dataclose[0])
                self.order = self.buy()

        else:
            condition = (self.dataclose[0] - self.bar_executed_close) / self.dataclose[0]
            if condition > 0.1 or condition < -0.1:
                self.log("SELL CREATE, %.2f" % self.dataclose[0])
                self.order = self.sell()

除此之外,在交易完成时要记录利润率:

    def notify_order(self, order):
        if order.status in [order.Submitted, order.Accepted]:
            return
        if order.status in [order.Completed]:
            if order.isbuy():
                self.log(
                    "BUY EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f"
                    % (order.executed.price, order.executed.value, order.executed.comm)
                )

                self.buyprice = order.executed.price
                self.buycomm = order.executed.comm
                self.bar_executed_close = self.dataclose[0]
            else:
                self.log(
                    "SELL EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f"
                    % (order.executed.price, order.executed.value, order.executed.comm)
                )
                temp = float(order.executed.price - self.buyprice)/float(self.buyprice)
                self.params.profits.append(temp)

            self.bar_executed = len(self)

        elif order.status in [order.Canceled, order.Margin, order.Rejected]:
            self.log("Order Canceled/Margin/Rejected")

        self.order = None

最后,分析每支股票的利润率,求得平均值并绘图:

# 计算
pos = []
neg = []
for data in result:
    res = np.mean(result[data])
    if res > 0:
        pos.append(res)
    else:
        neg.append(res)
print(f"正收益数量: {len(pos)}, 负收益数量:{len(neg)}")

plt.hist(pos, facecolor="red", edgecolor="black", alpha=0.7)
plt.hist(neg, facecolor="green", edgecolor="black", alpha=0.7)
plt.show()

最终算得正收益数量:493,负收益数量:507,利润分布图如下:

3.总结

针对A股1000支股票10年运行轨迹的回测结果显示,孕线策略收益可能性略低于50%,并不是一个靠谱的通用策略。

也许该策略特别符合某些股票,但是大家请注意,这样的“符合”是基于小样本概率的,这样想你就明白了:【抛五次硬币,五次都朝上的概率是不小的】,因此三千只股票中出现几只这样的股票也非常正常。

不过,许多策略都不能单独使用,我们这个例子中也只是做了一种最简单的回测,如果你有兴趣,可以改造我们的代码,将你自己的想法加入到该策略中,并尝试回测,看看效果如何。

欢迎在公众号后台回复:加群,回答相应红字验证信息,进入互助群交流。

我们的文章到此就结束啦,如果你喜欢今天的Python 实战教程,请持续关注Python实用宝典。

原创不易,希望你能在下面点个赞和在看支持我继续创作,谢谢!


​Python实用宝典 (pythondict.com)
不只是一个宝典
欢迎关注公众号:Python实用宝典