标签归档:量化投资

Python 凯利公式 — 最优投资本金计算

1955年,美国盛行答题积累奖金的电视节目,答题者通过连续答对题目来累计奖金池。而在电视外,庄家针对这个节目开设了答题者能否答对题目的赌盘,吸引了许多赌徒参与下注。

但是,节目在东海岸直播,西海岸则有直播延时,有赌徒便抓住了这个机会,利用延时提前通过电话得到了答题者答题情况,赶在西海岸直播前参与下注,从中套利。

受此启发,贝尔实验室的科学家约翰·拉里·凯利于1956年在《贝尔系统技术期刊》中提出了凯利公式:

“如果通信渠道的输入符号代表偶然事件的结果,在该偶然事件中,可以按照与其概率一致的赔率进行投注,那么一个赌徒就可以利用输入符号给他的信息,使他的钱以指数形式增长。”

论文中他以一个赛马模型提出了凯利公式的雏形:

其中:

f* = 应该放入投注的资本比值
p = 获胜的概率
q = 失败的概率
b = 赔率

举个例子,如果一个赌博你有60%的获胜率(p=0.6, q=0.4),并且赔率是1赔2(b=2),则赌客每次下注的资金是 40% (计算方式:(b*p-q)/b)

当然,当初提出这个公式的凯利其实是为了通信学研究的,并不是很贴近实际投资场景。不过,它有一个变形:

其中:

f* = 应该放入投注的资本比值
p = 获胜的概率
q = 失败的概率
rW = 净利润率
rL = 净损失率

这个公式很关键,因为它使得计算投资利润最大化的本金数额成为可能。比如说,使用我们之前的MACD量化投资策略:

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

有1万元购买股票,10%的止盈点,10%的止损点,假设针对某只股票每次盈利的概率是7/8,此时rW=0.1, rL=0.1,那么每次交易我们应该投入 f=((7/8)*0.1 – (1/8)*0.1) / 0.1*0.1=7.5%。

也就是说,按照这个策略买股票,每次你只能投入本金的7.5%才能使利润获得最大化。

这个公式用Python来计算也非常简单:

def kelly(p, q, rW, rL):
    """
    计算凯利公式

    Args:
        p (float): 获胜概率
        q (float): 失败概率
        rW (float): 净利润率
        rL (float): 净亏损率

    Returns:
        float: 最大化利润的投资本金占比(%)
    """
    return (p*rW - q*rL)/(rW * rL)

基本就是把公式照搬下来计算。

凯利公式看起来真的很不错,不过,请大家注意了,量化投资中的获胜概率,比如我们上述计算中的盈利概率: 7/8,是基于某只股票的历史数据推测出来的,历史并不代表未来,因为未来是不可知的,我们只能说这只股票,在过去,表现的不错。

所以,模型永远只是一个近似的替代,并不能说明一切,凯利公式也是一样,如果凯利公式告诉你,要放大仓位,你可要三思,万一发生黑天鹅事件,分分钟教你做人,如果你还上了杠杆,那就要上人生最重要的一堂课了。

我们经常会认为凯利公式所针对投注比例是全资产,事实上,我更喜欢将凯利公式所针对的投注比例当做是你可承受损失的资产。

比如你有100万,你能承受10万的损失,那么这10万就能拿来根据凯利公式进行投资,因为这是最保险,能让你心情不那么痛苦的做法。

不要贪,很重要。

我们的文章到此就结束啦,如果你喜欢今天的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实用宝典

Python 量化投资实战教程(7)—孕线真的有用吗?

如上图就是所谓的孕线(harami)形态,也叫作子线跟随母线。两线长度差异越大,信号越强烈。

从技术指标层面来讲,在综合了其他指标(如20日均线、macd等)的情况下,孕线是比较可靠的反转信号。

从上图可以知道,孕线看涨信号主要由以下指标组成:

1.前一根K线的实体完全覆盖第二根K线
2.价格处于底部位置

今天我们就来试试用上述指标回测603186这只股票,看看效果如何。

​为了简化问题,卖出信号由买入股票后涨10%或跌10%决定。

本文全部代码,请在Python实用宝典后台回复:量化投资7 进行下载。或到Github获取:
https://github.com/Ckend/pythondict-quant

1.基础版

该策略最大的难点在于如何判断价格处于底部位置。

我们第一版策略可以根据前三天的股价来判断是否处于底部位置。

如果股价连续三天下跌,第四天出现孕线上涨信号,则视为可买入信号。

对此股票使用该策略进行回测,时间是2010年1月1日至2020年8月15日,效果如下:

部分代码如下:

盈利9次,亏损10次,平均收益率1.3%,效果比较一般。

从中的买入点可以看到,该策略并没有准确地找到价格底部位置,许多买入点都在高点买入了。

2.优化版

为了解决高点买入的问题,我们需要合理的判断价格是否处于底部。

【连续多日下跌】这样的指标是无法判断价格所处的位置的。

相比之下,X日价格平均线却有一定的参考意义,如果价格低于20日平均线,可以认为该股票正处于近期的价格低谷中,此时出现的孕线才有价值。

因此,我们将【连续三日下跌】的指标更换为【价格低于20日均线】,重新进行回测

效果如下:

上述部分代码修改为:

平均收益率4.7%,盈利8次,亏损6次。不错,相比于基础版已经有非常大的改进。

但是,从图像上看还是有可以改进的地方。

3.加强版

事实上,第二版中有些孕线的当日最高价或当日最低价已经超过了前一日的K线实体,最标准的孕线应该是整根K线都在前一日的K线的实体内。

因此harami的计算方法依然需要改进,但是,这种孕线一整根都在前一日的K线实体内的情况,在这只股票10年的发展里只出现过4次,当然,这4次里3次都盈利了:

部分代码如下:

平均收益率6.5%,但这种最标准的孕线出现次数实在太少了,其实并不具备参考价值。

因此整体来看,孕线是一个不可强求的指标。

如果你是一个传统的投资者,可能很久很久才能在你的股票池里遇到一次标准的孕线。

如果你是一个量化投资者,即便你通过回测的方法找到了今天A股中所有符合孕线标准的股票,由于历史数据较少,并不足以构成投资参考价值,毕竟抛五次硬币,四次朝上的可能性也是挺大的。

总的而言,不推荐将孕线作为投资参考指标。不过,本文的研究仅仅局限于一只股票,下篇量化投资实战文章,我们将围绕整个A股,对孕线的可用性进行探讨。

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

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

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


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

Python celery异步快速下载股票数据

上一篇股票文章中,我们讲了如何通过tushare下载股票数据,并存入mongodb:

Python 获取股票数据并存入MongoDB实战教程

其中有非常大的优化空间,比如,单线程的下载速度太慢了,能不能用多线程的方式?有时候网络连接会失败,能不能增加重试机制?

这些问题,我们将在这篇文章里进行优化。

1.准备

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

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

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

此外,本文章是 Python 获取股票数据并存入MongoDB实战教程 的优化版,请根据该文章提前装好tushare和mongodb.

除此之外,你还需要安装celery和eventlet:

pip install celery
pip install eventlet

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

2.使用Celery异步下载股票数据

Celery是一个强大的异步任务队列,它可以让任务的执行完全脱离主程序,甚至可以被分配到其他主机上运行。

我们通常使用它来实现异步任务(async task)和定时任务(crontab)。

为了能异步下载股票,我们需要将上篇文章的内容拆分为两个部分:

1.Celery任务:获得某股票的日线数据
2.分发任务:分发获取指定股票的日线数据

这样,在我们的场景中,使用Celery实现异步任务主要包含三个步骤:

1.创建Celery任务实例(获得某股票的日线数据)
2.启动Celery Worker,用于运行任务
3.应用程序分发任务(分发获取指定股票的日线数据)

思路已经理清楚了,下面动手实践一下:

2.1 创建Celery任务实例:

此处大部分代码和上篇文章相似,因此下面仅显示和celery相关的核心代码:

# Python实用宝典
# https://pythondict.com
from celery import Celery

# 设置BROKER
BROKER_URL = 'mongodb://127.0.0.1:27017/celery'
# 新建celery任务
app = Celery('my_task', broker=BROKER_URL)

@app.task
def get_stock_daily(start_date, end_date, code):
    """
    Celery任务:获得某股票的日数据

    Args:
        start_date (str): 起始日
        end_date (str): 结束日
        code (str): 指定股票
    """


    # 请求tushare数据,并转化为json格式
    df = pro.daily(ts_code=code, start_date=start_date, end_date=end_date)
    data = json.loads(df.T.to_json()).values()

    # 这里为了保证数据的绝对稳定性,选择一条条创建
    for row in data:
        daily.update({"_id": f"{row['ts_code']}-{row['trade_date']}"}, row, upsert=True)

    print(f"{code}: 插入\更新 完毕 - {start_date} to {end_date}")

2.2 启动worker

在cmd执行以下命令启动celery worker:

python -m celery worker -A tasks --loglevel=info --pool=eventlet

注意,这里使用了–pool=eventlet,是为了让windows机器具有并行运行的能力。

2.3 分发获取指定股票的日数据

遍历一遍股票列表,通过delay调用Celery任务实例,将任务分发给worker:

# Python实用宝典
# https://pythondict.com
from tasks import get_stock_daily

def delay_stock_data(start_date, end_date):
    """
    获得A股所有股票日数据

    Args:
        start_date (str): 起始日
        end_date (str): 结束日
    """

    codes = open('./codes.csv', 'r', encoding='utf-8').readlines()

    # 遍历所有股票ID
    for code in codes:
        get_stock_daily.delay(start_date, end_date, code)

delay_stock_data("20180101", "20200725")

这样,worker就会在后台异步执行这些任务,切换到worker的命令行中,你会看到输出如丝般润滑:

好景不长,不久后你肯定会受到tushare发送回来的CPS限制错误:

Exception: 抱歉,您每分钟最多访问该接口800次,权限的具体详情访问:https://tushare.pro/document/1?doc_id=108。

3.限制访问次数与重试机制

为了解决这个CPS问题,我确实花了不少时间,尝试控制worker频率,无果,最终选择了一个不是办法的办法:

在Tushare报错的时候,捕捉起来,控制其60秒后重试

    # 请求tushare数据,并转化为json格式
    try:
        df = pro.daily(ts_code=code, start_date=start_date, end_date=end_date)
    except Exception as e:
        # 触发普通用户CPS限制,60秒后重试
        print(e)
        get_stock_daily.retry(countdown=60)

简单,但有效。

此外,为了防止网络请求出现问题,导致某个任务丢失,我们还可以在下发任务的时候使用apply_async配置失败重试。默认重试三次:

def delay_stock_data(start_date, end_date):
    """
    获得A股所有股票日数据

    Args:
        start_date (str): 起始日
        end_date (str): 结束日
    """

    codes = open('./codes.csv', 'r', encoding='utf-8').readlines()

    # 遍历所有股票ID
    for code in codes:
        get_stock_daily.apply_async(
            (start_date, end_date, code), retry=True
        )

这样,一个相对健壮的股票数据异步下载器就完成了。

用该方法把A股所有股票下载一遍,应该不会超过5分钟。

如果你给tushare氪了金,没有cps限制,下载时间不会超过1分钟。

目前github上好像缺少这样的项目,因此我将该项目开源到了GitHub上:

https://github.com/Ckend/stock_download_celery

目前仅支持日线数据,欢迎补充。

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

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

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


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

Python 获取股票数据并存入MongoDB实战教程

量化投资系列文章:

Backtrader 教程 — Python 量化投资实战教程(1)

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

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

Python 量化投资实战教程(4) —KDJ 策略

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

Python 量化投资实战教程(6) — 交易平均收益率

在前几篇量化投资文章中,使用的是保存为csv的本地股票数据。

但考虑到长远的未来,如果我们想要加快回测运行速度,就要分布式地在不同的机器上进行策略回测。

那么将股票数据保存到数据库上则是必然的选择,因为这样每台服务器都能够直接连接到同一个数据库拉到数据,管理起来方便许多。

今天我们就先讲讲如何使用MongoDB保存股票数据。

1.准备

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

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

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

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

pip install tushare
pip install pymongo

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

安装MongoDB

MongoDB 请前往以下链接下载:

https://www.mongodb.com/try/download/community

第一步选择On-Premises, 第二部选择自己的操作系统,第三部点击Download下载安装包。

下载完成安装包后一路默认即可,不过推荐修改data_path, 毕竟数据库有可能变得比较大,装在C盘不合适。

安装完成后,打开CMD输入以下命令启动MongoDB服务:

C:\Program Files\MongoDB\Server\4.2\bin\mongod.exe --dbpath F:\mongodb\data

前者是你的mongod.exe所在文件夹,后者是你的数据库文件路径。请注意根据自己的安装配置更改。

Tushare 股票数据接口

为了下载股票数据,我用到了tushare,一个大佬做的相对稳定的股票数据服务。

tushare采用积分制,你的积分越高,能调的接口约高级。不过其实我们的策略所需要的接口用普通账号的积分就够了。

你需要到https://tushare.pro/上注册一个tushare账户,然后进入账号页面拿到token:

这是我们需要用到的接口:

2.编写代码

首先,学会连接MongoDB数据库并创建集合(表),也就4行代码的事情:

import pymongo

# 建立连接
client = pymongo.MongoClient(host='localhost', port=27017)

# 连接stock数据库,注意只有往数据库中插入了数据,数据库才会自动创建
stock_db = client.stock

# 创建一个daily集合,类似于MySQL中"表"的概念
daily = stock_db["daily"]

这样就能连接本地MongoDB的stock数据库,如果该库不存在,当你往集合中插入数据的时候,就会自动新建数据库。

有一点需要非常注意:MongoDB默认不设密码,因此你如果要上线MongoDB,请注意手动设置密码。

其次,拿到股票数据:

def get_stock_daily(start_date, end_date):
    """
    获得A股所有股票日数据

    Args:
        start_date (str): 起始日
        end_date (str): 结束日
    """

    pro = ts.pro_api(token="你的账号token")
    codes = open('./codes.csv', 'r', encoding='utf-8').readlines()

    # 遍历所有股票ID
    for code in codes:
        code = code.strip('\n')

        # 请求tushare数据,并转化为json格式
        df = pro.daily(ts_code=code, start_date=start_date, end_date=end_date)

因为并不一定需要用到所有股票数据,所以我维护了一个股票列表:codes.csv.

当然,这个股票列表最好也写到MongoDB里以方便维护(我这里省麻烦就没写入了)。

如果你需要用到所有股票,请调tushare的stock_basic接口:

data = pro.stock_basic(exchange='', list_status='L', fields='ts_code,symbol,name,area,industry,list_date')

这个接口能返回当前所有正常上市的股票列表。

最后,将这些股票数据写入到MongoDB中:

def get_stock_daily(start_date, end_date):
    """
    获得A股所有股票日数据

    Args:
        start_date (str): 起始日
        end_date (str): 结束日
    """

    pro = ts.pro_api(token="你的账号token")
    codes = open('./codes.csv', 'r', encoding='utf-8').readlines()

    # 遍历所有股票ID
    for code in codes:
        code = code.strip('\n')

        # 请求tushare数据,并转化为json格式
        df = pro.daily(ts_code=code, start_date=start_date, end_date=end_date)
        data = json.loads(df.T.to_json()).values()

        # 对股票每一天数据进行保存,注意唯一性
        # 这里也可以批量创建,速度更快,但批量创建容易丢失数据
        # 这里为了保证数据的绝对稳定性,选择一条条创建
        for row in data:
            daily.update({"_id": f"{row['ts_code']}-{row['trade_date']}"}, row, upsert=True)

        time.sleep(0.1)

获得请求数据后,将其转置一下,以变成【字段-值】的形式,并转成json.

转成json后就可以保存到数据库中,这里我们选择了一条条数据地插入,而不是批量插入。

因为批量插入在遇到重复值的时候,可能会导致那一批数据全部丢失,对于股票回测而言,丢失数据是致命的。

最后,为了防止请求接口频率过高,设置了一个time.sleep延时。

全部核心代码如上所示,可运行的完整代码可以在【Python实用宝典】后台回复:MongoDB 下载。

3.可视化查看数据

MongoDB可视化查看数据,我推荐NoSQLBooster. 一个免费的MongoDB查看器。

https://nosqlbooster.com/downloads

选择对应系统下载,一路默认安装就能开始使用。

基本上你需要的功能它都有了(这界面其实很像Mysql Workbench)

啊对了,最后别忘记加我们新的交流群,加我好友,备注上面红字语句答案即可进群(防范营销号,大家见谅):

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

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


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

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

量化投资系列文章:

Backtrader 教程 — Python 量化投资原来这么简单(1)

Python 量化投资原来这么简单(2) —MACD策略(+26.9%)

Python 量化投资原来这么简单(3) —A股回测MACD策略

Github仓库:https://github.com/Ckend/pythondict-quant


上次,我们简单地用Python 和 backtrader 使用最简单的买入卖出策略进行了一次量化投资分析:

backtrader教程—量化投资原来这么简单(1)

这一次,让我们把策略变得复杂一点,使用MACD策略的信号线交叉交易法

本系列教程源代码Github仓库: https://github.com/Ckend/pythondict-quant

1.原理

为了解释MACD的原理,我们需要先了解指数移动平均线(下称EMA), 指数移动平均线是移动平均线的一种,能够根据数据点的新旧程度分配不同的权重,其更重视近期价格,减轻对往期价格的权重 ,而普通的移动平均线在所有价格上权重都一致,这是二者最大的不同。

EMA线还有周期上的不同,长期投资者通常选择50、100、200周期来追踪数月、甚至是年的价格趋势。而12天和26天的时间周期短,则广受短期投资者欢迎。而大部分股票软件的MACD线也是按照12天EMA和26天EMA进行计算的。

好了,接下来开始从上图讲起,上图可以看出两个基本规律:

蓝线上穿信号线(橙色)的时候看涨。

蓝线下穿信号线(橙色)的时候看跌

蓝线是什么呢?是MACD线,它通过将一个价格短期EMA和价格长期EMA相减得到,在大部分股票软件中是EMA(12) – EMA(26).

信号线是什么呢?它其实是MACD线的EMA,周期一般为9.

总结公式如下:

  • MACD=价格EMA(12) – 价格EMA(26).
  • 信号线=MACD的EMA(9)

而图中那些一个个的方块,则是由MACD线 – 信号线得到的差值,正值在上,负值在下。

明白了这些,我们就能够开始构建回测脚本了:

买入:
MACD线在前一天的值 < 信号线前一天的值
当天MACD线的值 > 当天信号线的值 时
说明发生了金叉,此时看涨,第二天买入。

卖出:若已盈利10%,则卖出;若已亏损10%,则卖出。

这个策略在股票 603186 上,每次交易100股的情况下,年回报率为26.9%.

2.准备

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

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

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

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

pip install backtrader

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

Backtrader基本使用请看我们前一篇文章:
backtrader教程—量化投资原来这么简单(1)

本文全部代码,请在Python实用宝典后台回复:量化投资2 进行下载。

3.构建策略

如果你没看第一篇文章,可能不知道如何构建这个策略,一脸懵逼也正常,所以推荐先阅读 backtrader教程—量化投资原来这么简单(1) ,当然,如果你只希望跑起来,修改一些参数,可以 Python实用宝典后台回复:量化投资2 下载全部源代码。

从MACD的原理中我们知道,MACD由EMA线计算而来,因此我们需要构建一个短期EMA和一个长期EMA,常规的选择是周期分别为12和26的EMA线:

from backtrader.indicators import EMA
me1 = EMA(self.data, period=12)
me2 = EMA(self.data, period=26)
self.macd = me1 - me2

根据前面的分析我们知道,信号线是MACD线周期为9的EMA:

self.signal = EMA(self.macd, period=9)

这样我们就构建完这两条重要的线了,是不是特别简单?接下来和第一篇文章一样,在策略的next函数中,编写买入卖出逻辑:

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

        if not self.position:
            # 如果没有持仓,若前一天MACD < Signal, 当天 Signal < MACD,则第二天买入
            condition1 = self.macd[-1] - self.signal[-1]
            condition2 = self.macd[0] - self.signal[0]
            if condition1 < 0 and condition2 > 0:
                self.log('BUY CREATE, %.2f' % self.dataclose[0])
                self.order = self.buy()

        else:
            # 若已盈利10%,则卖出;若已亏损10%,则卖出。 
            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()

买入逻辑就是我们在原理中提到的,若前一天MACD < Signal, 当天 Signal < MACD,则第二天买入。

卖出逻辑则简单许多, 若已盈利10%,则卖出;若已亏损10%,则卖出。

设置佣金为千分之五,每次交易为100股,初始资金为10000元:

    cerebro.broker.setcash(10000)
    cerebro.addsizer(bt.sizers.FixedSize, stake=100)
    cerebro.broker.setcommission(commission=0.005)

在命令行中运行脚本:

python macd.py

得到回测结果如下:

其实结果好得出乎意料,因为这是一个不算复杂的策略,在代码最后加上一句

cerebro.plot()

能看到整个策略的回测情况如图:

用红色的框标记策略交易成功上涨部分,绿色的框标记下跌部分。

可以看到,8次操作中盈利了7次。为什么能有这么好的结果呢?首先, 603186 是一个业绩不错的股票,其本身基本面不差,回测的前期也处于上涨状态,因此其回测效果极佳也就在意料之中。

此外,我们的卖出策略虽然无脑,但是在这种情况下发挥了非常好的作用,有几个地方成功在高点卖出。

从这个例子大家可以看到,虽然量化策略是有效果的,但是最重要的还是选股,如何选到最佳的股票,就需要大家多看财报、多动脑了,世界上没有不劳而获的财富,如果本文对你走向财富自由的道路有帮助的话,请记得点个在看或分享一下哦。

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

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

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

给作者打赏,选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义

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

Python 量化投资实战教程(1) — Backtrader 教程

量化投资系列文章:

Backtrader 教程 — Python 量化投资原来这么简单(1)

Python 量化投资原来这么简单(2) —MACD策略(+26.9%)

Python 量化投资原来这么简单(3) —A股回测MACD策略

Github仓库:https://github.com/Ckend/pythondict-quant


都说 Python 量化投资 非常好用,但是很多人都不知道该怎么做,甚至觉得是非常高深的知识,其实并非如此,任何人都可以在只有一点Python的基础上回测一个简单的策略。

Backtrader是一个基于Python的自动化回溯测试框架,作者是德国人 Daniel Rodriguez,是一个易懂、易上手的量化投资框架。今天我们就来试试用Backtrader进行简单的量化策略回溯。

当然,第一篇文章将会使用最简单的投资策略给大家起个头。通过学习这一篇文章,你将能学会以下这个简单的量化策略:

买入:五日价格移动平均线(MA5)和十日价格移动平均线(MA10)形成均线金叉(MA5上穿MA10)原理:最近处于涨势

卖出: 五日价格移动平均线(MA5)和十日价格移动平均线(MA10)形成均线死叉(MA5下穿MA10)原理:最近处于跌势

这个策略真的有用吗?普通人可能要炒一辈子股才能发现它的实际作用,而使用Python进行量化验证,则能迅速得到答案。

1.准备

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

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

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

输入以下命令安装本文所需要的依赖模块:

pip install backtrader

看到 Successfully installed xxx 则说明安装成功。本文完整数据和源代码可在公众号后台回复 量化投资一 进行下载。

2.基础使用

在开始之前,你必须要知道backtrader的数据结构特点:

self.dataclose[0] # 当日的收盘价
self.dataclose[-1] # 昨天的收盘价
self.dataclose[-2] # 前天的收盘价

这一点我在一开始使用的时候也被作者的逻辑震惊了,原来还能这么玩,总而言之,请记住这个特点,否则你可能会完全看不懂策略。

2.1 资金与佣金

Backtrader 初始化模型后,即可通过broker(经纪人)来设定初始资金,如下所示:

# -*- coding:utf-8 -*-
# Python 实用宝典
# 量化投资原来这么简单(1)
# 2020/04/12

import backtrader as bt

if __name__ == '__main__':

    # 初始化模型
    cerebro = bt.Cerebro()
    # 设定初始资金
    cerebro.broker.setcash(100000.0)

    # 策略执行前的资金
    print('Starting Portfolio Value: %.2f' % cerebro.broker.getvalue())

    cerebro.run()

    # 策略执行后的资金
    print('Final Portfolio Value: %.2f' % cerebro.broker.getvalue())

现实生活中的股票交易里,每次交易都需要支付一定的佣金,比如万五(交易额每满一万元收取5元佣金)万三等,在Backtrader里你只需要这么设定即可:

cerebro.broker.setcommission(0.005)

设定需要设定每次交易买入的股数,可以这样

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

2.2 加载数据

Backtrader 将数据集称作为 Data Feeds,默认的数据集是yahoo的股票数据,通过以下方式可以加载:

    data = bt.feeds.YahooFinanceCSVData(
        dataname='数据文件所在位置',
        fromdate=datetime.datetime(2000, 1, 1),
        todate=datetime.datetime(2000, 12, 31)
    )

当然,载入自己的数据也是可以的,只不过你需要设定每个列的含义,比如开盘价在第4列,则open=3(从0开始算起),如下所示:

    data = bt.feeds.GenericCSVData(
        dataname='数据文件所在位置',
        datetime=2,
        open=3,
        high=4,
        low=5,
        close=6,
        volume=10,
        dtformat=('%Y%m%d'),
        fromdate=datetime(2010, 1, 1),
        todate=datetime(2020, 4, 12)
    )

下面,咱会使用自己的数据进行回测,这样才够有代入感。

2.3 构建策略

使用backtrader构建策略是一件很简单的事情,你只需要继承backtrader的策略类,并重写部分方法,就能实现策略。比如说重写属于我们自己的log函数:

class TestStrategy(bt.Strategy):
    """
    继承并构建自己的bt策略
    """

    def log(self, txt, dt=None, doprint=False):
        ''' 日志函数,用于统一输出日志格式 '''
        if doprint:
            dt = dt or self.datas[0].datetime.date(0)
            print('%s, %s' % (dt.isoformat(), txt))

最重要的是,重写我们自己的交易策略,比如咱在开头提到的均线金叉死叉策略

class TestStrategy(bt.Strategy):
    """
    继承并构建自己的bt策略
    """

    def next(self):
        # 记录收盘价
        self.log('Close, %.2f' % self.dataclose[0])

        # 是否正在下单,如果是的话不能提交第二次订单
        if self.order:
            return

        # 是否已经买入
        if not self.position:

            # 还没买,如果 MA5 > MA10 说明涨势,买入
            if self.sma5[0] > self.sma10[0]:
                self.log('BUY CREATE, %.2f' % self.dataclose[0])
                self.order = self.buy()

        else:
            # 已经买了,如果 MA5 < MA10 ,说明跌势,卖出
            if self.sma5[0] < self.sma10[0]:
                self.log('SELL CREATE, %.2f' % self.dataclose[0])
                self.order = self.sell()

有用吗?待会儿我们回测后就知道了。

2.4 添加指标

backtrader内置了许多指标的计算方法,比如移动平均线、MACD、RSI等等,我们这一篇文章仅需要移动平均线MA,设置方法如下:

self.sma5 = bt.indicators.SimpleMovingAverage(
            self.datas[0], period=5)

其中,datas[0]是第一个数据集,period是指多少天的移动平均线,比如5,则返回MA5的相关数据。

3.策略回测

为了验证我们开头提到的策略,咱使用了 贵州茅台600519.SH 在2020年1月1日至今(2020/04/12)的股票数据,完整数据和源代码可在公众号后台回复 量化投资一 进行下载。

将数据命名为600519.csv,保存在当前文件夹下,主函数如下:

if __name__ == '__main__':

    # 初始化模型
    cerebro = bt.Cerebro()

    # 构建策略
    strats = cerebro.addstrategy(TestStrategy)
    # 每次买100股
    cerebro.addsizer(bt.sizers.FixedSize, stake=100)

    # 加载数据到模型中
    data = bt.feeds.GenericCSVData(
        dataname='600519.csv',
        fromdate=datetime.datetime(2010, 1, 1),
        todate=datetime.datetime(2020, 4, 12),
        dtformat='%Y%m%d',
        datetime=2,
        open=3,
        high=4,
        low=5,
        close=6,
        volume=10
    )

    cerebro.adddata(data)

    # 设定初始资金和佣金
    cerebro.broker.setcash(1000000.0)
    cerebro.broker.setcommission(0.005)

    # 策略执行前的资金
    print('启动资金: %.2f' % cerebro.broker.getvalue())

    # 策略执行
    cerebro.run()

最后补全策略就完成了,我们的backtrader策略如下,为了公众号的可读性,这里去掉了部分不重要的代码,详细的代码可阅读原文或后台回复量化投资一下载:

class TestStrategy(bt.Strategy):
    """
    继承并构建自己的bt策略
    """

    def log(self, txt, dt=None, doprint=False):
        ''' 日志函数,用于统一输出日志格式 '''
        if doprint:
            dt = dt or self.datas[0].datetime.date(0)
            print('%s, %s' % (dt.isoformat(), txt))

    def __init__(self):

        # 初始化相关数据
        self.dataclose = self.datas[0].close
        self.order = None
        self.buyprice = None
        self.buycomm = None

        # 五日移动平均线
        self.sma5 = bt.indicators.SimpleMovingAverage(
            self.datas[0], period=5)
        # 十日移动平均线
        self.sma10 = bt.indicators.SimpleMovingAverage(
            self.datas[0], period=10)

    def notify_order(self, order):
        """
        订单状态处理

        Arguments:
            order {object} -- 订单状态
        """
        if order.status in [order.Submitted, order.Accepted]:
            # 如订单已被处理,则不用做任何事情
            return

        # 检查订单是否完成
        if order.status in [order.Completed]:
            if order.isbuy():
                self.buyprice = order.executed.price
                self.buycomm = order.executed.comm
            self.bar_executed = len(self)

        # 订单因为缺少资金之类的原因被拒绝执行
        elif order.status in [order.Canceled, order.Margin, order.Rejected]:
            self.log('Order Canceled/Margin/Rejected')

        # 订单状态处理完成,设为空
        self.order = None

    def notify_trade(self, trade):
        """
        交易成果
        
        Arguments:
            trade {object} -- 交易状态
        """
        if not trade.isclosed:
            return

        # 显示交易的毛利率和净利润
        self.log('OPERATION PROFIT, GROSS %.2f, NET %.2f' %
                 (trade.pnl, trade.pnlcomm), doprint=True)

    def next(self):
        ''' 下一次执行 '''

        # 记录收盘价
        self.log('Close, %.2f' % self.dataclose[0])

        # 是否正在下单,如果是的话不能提交第二次订单
        if self.order:
            return

        # 是否已经买入
        if not self.position:
            # 还没买,如果 MA5 > MA10 说明涨势,买入
            if self.sma5[0] > self.sma10[0]:
                self.order = self.buy()
        else:
            # 已经买了,如果 MA5 < MA10 ,说明跌势,卖出
            if self.sma5[0] < self.sma10[0]:
                self.order = self.sell()

    def stop(self):
        self.log(u'(金叉死叉有用吗) Ending Value %.2f' %
                 (self.broker.getvalue()), doprint=True)

这份代码看起来很长,但其实把注释去掉后,实现的是很简单的逻辑。效果如何?看下图就知道了:

可以看到,我们初始资金是100万,每次交易100股,虽然偶尔有盈利,如果严格按照这个策略执行十年,最后会亏损5万元。当然,现实生活中,有时候情形好你肯定会加仓,情形差你会减仓,而这里暂时只是一个简单的买入卖出策略。

但是这种简单的实现方式,往往最能帮助你理性地分析该策略的合理性,如果说一个策略总是需要你主观地去加仓、减仓,那该策略势必存在问题。真正好的策略,从概率上来讲,简单回测的结果总会是盈利的。

所以这种单纯的、简单的均线金叉死叉策略有用吗? 我认为效果有限。网上策略很多,大家也可以试试别的策略,如果有好用的,记得告诉我(滑稽)。

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

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

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

给作者打赏,选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义

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