分类目录归档：量化投资

量化投资

Easytrader 一个Python自动交易股票的神器

2021年1月11日 Python实用宝典留下评论

在量化投资系列教程中，我们从理论上介绍了量化回测的基本原理和思路，并进行了一定的实战分析和演练。但是并没有涉及到实际交易的场景。

在开始之前，我们需要明确什么策略需要使用自动交易的方式。我们前面的教程都是基于日线的策略，这样的日线策略并不需要自动化交易，因为你只需要提前一天算好第二天需要买入的股票即可。

什么情况下需要本文的自动交易？

1.你的策略是基于分钟线 (1,5,15,60) 的。
2.你的日线策略在购买的时候需要判断前一天封盘前的股票数据，并提前一天买入。
3.你希望能自动打新。

除了这两种情况，其他的策略都不适合使用本文的自动交易，包括秒级别的策略，因为Easytrader是基于GUI层面(图形界面)实现的自动化接口，而非API层面，因此实时性不会很高，而且是串行形式的，并不适合秒级策略。

此外，Easytrader对券商有一定的要求：

目前支持海通客户端、华泰客户端、国金客户端、雪球，还有通用同花顺客户端（指的是那些基于同花顺修改的券商软件版本）。

在开始自动交易前，请确认你的策略是可靠的，否则不要轻易尝试自动交易。另外交易逻辑的处理也需要非常谨慎，错一行代码可能损失的是几千块甚至不止。所以，一开始执行自动交易的时候，推荐只用很小一部分的本金。

本文只会介绍Easytrader的安装方法和基本使用方法及构建监控股票池的重要性，其他深入介绍将于后面的 量化投资系列教程10 中介绍，敬请期待。

一个小小的预告

1.准备

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

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

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

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

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

pip install easytrader

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

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

1.下载并安装tesseract

前往 tesseract-ocr 官网下载二进制包，此外你也可以在Python实用宝典公众号后台回复: tesseract，直接获得tesseract的安装包。

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

2.配置环境变量

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

3.判断是否安装成功

在命令行中输入：

tesseract --version

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

2.Easytrader 基本使用

这一章将介绍Easytrader的基本使用方法、包括客户端连接、获取资金状况、获取持仓、买入、卖出、一键打新、撤单。

在开始之前，请对客户端调整以下设置，不然会导致下单时价格出错以及客户端超时锁定。

系统设置 > 界面设置: 界面不操作超时时间设为 0
系统设置 > 交易设置: 默认买入价格/买入数量/卖出价格/卖出数量都设置为空

同时客户端不能最小化也不能处于精简模式。

2.1 自动登录客户端：

在Windows机器上下载好我们在文首提到的几个券商客户端、准备好Python相关的依赖，即可开始尝试自动登录客户端：

import easytrader

# 海通客户端
user = easytrader.use('htzq_client')
user.prepare(user='用户名', password='明文密码')

# 华泰客户端
user = easytrader.use('ht_client')
user.prepare(user='用户名', password='明文密码', comm_password='华泰通讯密码，其他券商不用')

# 国金客户端
user = easytrader.use('gj_client')
user.prepare(user='用户名', password='明文密码')

# 雪球
user = easytrader.use('xq')
user.prepare(user='用户名', password='明文密码')

# 通用同花顺客户端, 指对应券商官网提供的基于同花顺修改的软件版本, 如(银河的双子星)
user = easytrader.use('ths')
user.prepare(user='用户名', password='明文密码')

选择你的客户端，将其他的客户端去掉，运行这个py文件，程序就会开始自动登录，期间会识别很多次验证码，经常会识别错误，没关系，让他慢慢重试即可。

如果你识别验证码的时候报了错，程序停止了下来，那是因为你没安装 tesseract，回到第一步安装tesseract即可。

2.2 获取资金、持仓情况

获取资金、持仓情况的时候，程序都会自动化地进入相关界面获取信息。有时候也需要输入验证码，这时候easytrader也会自动识别，请不要介入。

import easytrader
# 国金客户端
user = easytrader.use('gj_client')
user.prepare(user='用户名', password='明文密码')

# 获取资金状况
balance = user.balance
print(balance)
# [{'参考市值': 21642.0,
#   '可用资金': 28494.21,
#   '币种': '0',
#   '总资产': 50136.21,
#   '股份参考盈亏': -90.21,
#   '资金余额': 28494.21,
#   '资金帐号': 'xxx'}]

# 获取持仓情况
position = user.position
print(position)
# [{'买入冻结': 0,
#   '交易市场': '沪A',
#   '卖出冻结': '0',
#   '参考市价': 4.71,
#   '参考市值': 10362.0,
#   '参考成本价': 4.672,
#   '参考盈亏': 82.79,
#   '当前持仓': 2200,
#   '盈亏比例(%)': '0.81%',
#   '股东代码': 'xxx',
#   '股份余额': 2200,
#   '股份可用': 2200,
#   '证券代码': '601398',
#   '证券名称': '工商银行'}]

2.3 买入、卖出、一键打新、撤单

买入卖出时设定股票代码，价格和数量即可：

import easytrader
# 国金客户端
user = easytrader.use('gj_client')
user.prepare(user='用户名', password='明文密码')

# 买入
user.buy('162411', price=0.55, amount=100)
# {'entrust_no': 'xxxxxxxx'}

# 卖出
user.sell('162411', price=0.55, amount=100)
# {'entrust_no': 'xxxxxxxx'}

# 一键打新
user.auto_ipo()

# 撤单
user.cancel_entrust('buy/sell 获取的 entrust_no')
# {'message': '撤单申报成功'}

如果资金不足或可用证券数量不足，程序会报错，这时候请注意把错误except出来，不然你的检测周期可能因此中断，如果是无人值守的程序，可能整个程序都会停止。

3.构建监控股票池

为什么需要构建股票池？如我们前面提到的，Easytrader是基于GUI层面的自动化交易接口，它会进入如下模样的界面进行自动化操作：

如果你的监控对象太多，有多个对象同时符合策略，它会一个一个地进行操作，容易耽误下个周期的计算，因此推荐构建一个50只股票左右的股票池。

你可以根据基本面构造你的股票池，比如最近几年年报中，扣非净利润均有所增长的企业，或是在你的策略下表现最好的50只股票（当然未来不一定靠谱）。

无论你怎么构造，请记录下这些股票（最好是数组变量的形式），证券市场的前缀在前，代码在后，比如 sh600519:

# 以2000元的价格买入100股sh600519, 贵州茅台
user.buy('sh600519', 2000, 100)

当然，此时会报错：

毕竟我未实现100股自由，希望各位能在下方点个“在看”，让我尽早实现100股自由。

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

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

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

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

量化投资

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

2020年11月12日 Python实用宝典留下评论

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

此外，前面使用的数据源都是基于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实用宝典

量化投资

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

2020年10月16日 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)

2020年9月8日 Python实用宝典留下评论

上一篇文章《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)—孕线真的有用吗？

2020年8月20日 Python实用宝典留下评论

如上图就是所谓的孕线(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 数据分析、量化投资

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

2020年7月25日 Python实用宝典留下评论

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

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

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

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

1.准备

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

此外，本文章是 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实战教程

2020年7月19日 Python实用宝典留下评论

量化投资系列文章：

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

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

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

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

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

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

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

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

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

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

1.准备

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

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

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 量化投资实战教程(6) — 交易平均收益率

2020年5月26日 Python实用宝典留下评论

量化投资系列文章：

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

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

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

Python 量化投资原来这么简单(4) —KDJ 策略

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

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

在之前的五篇系列文章中，计算收益率时没有考虑每次按策略进行交易时的收益率，而是单纯回测一段时间后，通过计算最终价值和本金的差距并除以本金，得到最终收益率。这样的计算方法其实是不准确的，因为交易时每次都采用100股的形式进行，在没有引入调仓技术前，我们应该以每次交易的平均收益率为准。

具体计算方法如下：

在每次买入股票的时候，记录购买价格：self.buyprice
在每次卖出股票的时候，计算收益率：(卖出价格-买入价格)/买入价格，忽略佣金。
将每次交易收益存入params变量中，以便后续分析。

1.准备

开始之前，你要确保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实用宝典后台回复：量化投资6 进行下载。

2.交易收益率

以第二篇的macd策略为例，首先初始化策略变量，用于记录股票交易的每次收益率：

class TestStrategy(bt.Strategy):
    params = (
        ('code', 0),
        ('profits', [])
    )

第二，要在notify_order函数中记录购买时的价格：

    def notify_order(self, order):
        # 交易状态处理
        # Python实用宝典
        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]

第三，在卖出的时候，根据卖出价格和买入价格计算收益率，并存入策略变量里的profits变量中：

    def notify_order(self, order):
        # 交易状态处理
        # Python实用宝典
        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)
                )
                # 收益率计算
                profit_rate = float(order.executed.price - self.buyprice)/float(self.buyprice)
                # 存入策略变量
                self.params.profits.append(profit_rate)
            self.bar_executed = len(self)

在策略运行完毕后，可以通过以下变量获得策略变量里profits的值：

cerebro.runstrats[0][0].params.profits

结果如下：

[0.021676761236850372, -0.1054225992123598, 0.10678571428571423, 0.11044953855314062, 0.21502209131075103, 0.15729837813819164, 0.10841304881039966, 0.16918294849023086]

可以看到，每次该策略进行交易时的收益率，第一次盈利2%、第二次亏损10%、第三次盈利10%、第四次盈利11%…

有趣的是第五次，盈利了21%，这个策略明明是在盈利10%的时候卖出，为什么这次交易能盈利21%？

主要是在涨停板之下，股票无法卖出导致的。

这也给我们一个hint：这个策略写死的涨/跌10%卖出是不是过于死板了，有没有更合适的卖出策略？

大家可以尝试一下找到更好的卖出策略，下一篇文章中我们将重点讨论这个问题。

3. 平均收益率

使用numpy的mean函数，可以直接算出数组的平均值：

print(np.mean(profits))

结果如下：

0.09792573520161482

平均下来，该策略在这只股票上的收益率为9.7%.

但是这并不代表这个策略是可用的，因为有可能它只是适用于这只股票，是否适合所有股票需要通过回测A股来决定：Python 量化投资原来这么简单(3) —A股回测MACD策略

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

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

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

我要打赏

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

量化投资

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

2020年5月16日 Python实用宝典留下评论

量化投资系列文章：

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

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

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

Python 量化投资原来这么简单(4) —KDJ 策略

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

许多技术投资方面的教材，经常会用几幅上涨的图来表明某些指标的用处，实际上那些上涨的图很可能只是假象。作者为了证明他所强调的指标的作用，选定了符合该指标策略的股票上升趋势图，但实际上这些策略并不一定适合全部股票，许多人被傻傻地骗了进去，血本无归。

因此，判断一个策略的好坏一定要有回测证据。我们将在A股中随机抽取1000只股票，在2010年1月1日至2020年5月10日期间采用上回的 Python 量化投资原来这么简单(4) —KDJ 策略进行交易，并计算得到其最终收益率。最后看正收益与负收益股票的对比，基于此来判断该策略是否具有通用性。

1.准备

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

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

pip install backtrader

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

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

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

2.编写策略

这一部分与 Python 量化投资原来这么简单(3) —A股回测MACD策略非常相似，不过有许多读者反映看不懂，事实上真的非常简单，可能是由于要显示许多交易日志，大家被代码弄晕了。因此这一篇文章我将详细解析每一个步骤，为了方便阅读，我把所有的日志显示代码都去除了，以清除地展示代码逻辑。

不过值得一提的是，我们在这采用的投资回报率的计算都是静态的，即本金多少，最后相比之下盈余多少作为我们的回报率，而且每次交易只买入100股，这是非常不智能的，在下一篇文章中，我们将实现动态买入股数计算投资回报率。

2.1 计算指标

第一步，构建我们的KDJ指标，在上篇Python KDJ量化投资中我们提到了KDJ的几个计算方法。此外，我们根据MACD指标优化了买入策略，你可以在 Python MACD量化投资中阅读详细的教程。

根据这两篇文章，我们知道KDJ指标计算方法如下：

RSV = （收盘价-N周期最低价）/（N周期最高价-N周期最低价）*100
K值 = RSV的N周期加权移动平均值(EMA)
D值 = K值的N周期加权移动平均值(EMA)
J值 = 3K-2D

MACD指标计算方法如下（EMA后的括号表示周期）：

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

这样，我们就可以开始计算这些指标了，在Backtrader中计算这些指标非常方便，最高价、最低价、EMA都有内置函数计算，比如bt.indicators.EMA用于计算EMA的值，period参数表示周期。计算方法如下：

import datetime
import os.path
import sys
import pickle
import backtrader as bt
from backtrader.indicators import EMA

class TestStrategy(bt.Strategy):

    def __init__(self):
        self.dataclose = self.datas[0].close
        self.volume = self.datas[0].volume

        self.order = None
        self.buyprice = None
        self.buycomm = None

        # 9个交易日内最高价
        self.high_nine = bt.indicators.Highest(self.data.high, period=9)
        # 9个交易日内最低价
        self.low_nine = bt.indicators.Lowest(self.data.low, period=9)
        # 计算rsv值
        self.rsv = 100 * bt.DivByZero(
            self.data_close - self.low_nine, self.high_nine - self.low_nine, zero=None
        )
        # 计算rsv的3周期加权平均值，即K值
        self.K = bt.indicators.EMA(self.rsv, period=3, plot=False)
        # D值=K值的3周期加权平均值
        self.D = bt.indicators.EMA(self.K, period=3, plot=False)
        # J=3*K-2*D
        self.J = 3 * self.K - 2 * self.D

        # MACD策略参数
        me1 = EMA(self.data, period=12)
        me2 = EMA(self.data, period=26)
        self.macd = me1 - me2
        self.signal = EMA(self.macd, period=9)
        bt.indicators.MACDHisto(self.data)

2.2 策略买入卖出与运行

我们根据上一篇文章提到的，基于MACD金叉进行买入，基于KDJ死叉进行卖出 构建我们的买入卖出量化策略：

    # 接上部分代码
    # Python 实用宝典
    def next(self):

        if not self.position:
            # 买入：基于MACD策略
            condition1 = self.macd[-1] - self.signal[-1]
            condition2 = self.macd[0] - self.signal[0]
            if condition1 < 0 and condition2 > 0:
                self.order = self.buy()

        else:
            # 卖出：基于KDJ策略
            condition1 = self.J[-1] - self.D[-1]
            condition2 = self.J[0] - self.D[0]
            if condition1 > 0 or condition2 < 0:
                self.order = self.sell()

这样，我们的策略就构建完毕了，这个TestStrategy类至此结束。接下来让策略运行起来，为方便回测A股，我们把运行策略部分封装成了一个函数，以方便回测大量数据：

def run_cerebro(stock_file, result):
    """
    运行策略
    :param stock_file: 股票数据文件位置
    :param result: 回测结果存储变量
    """

    cerebro = bt.Cerebro()

    cerebro.addstrategy(TestStrategy)

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

    # 本金10000，每次交易100股
    cerebro.broker.setcash(10000)
    cerebro.addsizer(bt.sizers.FixedSize, stake=100)

    # 万五佣金
    cerebro.broker.setcommission(commission=0.0005)

    # 运行策略
    cerebro.run()

    # 剩余本金
    cerebro.broker.get_value()
    money_left = cerebro.broker.getvalue()

    # 获取股票名字
    stock_name = stock_file.split("\\")[-1].split(".csv")[0]

    # 将最终回报率以百分比的形式返回
    result[stock_name] = float(money_left - 10000) / 10000

将股票数据文件和一个变量传入该函数，你就能得到该股票使用此策略的整体回报率。这里回报率的计算其实并不准确，因为我们每次仅交易100股，有些股票其实走势不错，但是买的太少会出现投资回报率很低的情况，甚至有些股票100股的价格会超过本金导致交易无法进行。

这些问题我们将在下一篇文章中解决，本篇文章只考虑该策略在A股中的整体盈余和亏损情况。

3.A股回测

我们将遍历抽取出来的1000只股票数据，计算出该策略在这些股票上的投资回报率，我们重点观察的是盈余股票的数量和亏损股票的数量。

files_path = "./thoudsand_stocks/"
result = {}

# 遍历所有股票数据
for stock in os.listdir(files_path):
    modpath = os.path.dirname(os.path.abspath(sys.argv[0]))
    datapath = os.path.join(modpath, files_path + stock)
    print(datapath)
    try:
        run_cerebro(datapath, result)
    except Exception as e:
        print(e)

这样，针对每一只股票都会运行一遍策略，然后将最终的盈余值放入result变量中。

然后我们再针对result变量进行相应的最最最简单分析：

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

得到的结果如下，有些股票数据不足被遗弃：

正收益数量: 430, 负收益数量:568

从结果上看，显然，如果我们不考虑基本面，单纯地买入符合该策略的股票，最终很大可能是亏损的。许多技术投资方面的教材，用了几幅上涨的图来表明这些指标的用处，实际上那些上涨的图只是假象，但是许多人被傻傻地骗了进去，血本无归。

量化投资就是为了避免这种情况的发生，某些技术策略你觉得靠谱，那你就需要回测出一个证据来，靠几个上涨的图示来强调一个指标的好坏其实没有说服力，而根据没有证据的技术策略进行投资，和赌博无太大区别。

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

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

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

我要打赏

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

量化投资

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

2020年5月6日 Python实用宝典 3条评论

量化投资系列文章：

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

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

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

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

今天我们来使用backtrader试试另一个量化投资策略：KDJ策略，KDJ是最常用的指标之一，其中文名叫“随机指标”。它通过统计学原理，识别N个交易日内最高价、最低价、最新收盘价三者之间的比例关系来计算随机值（RSV），然后再根据加权移动平均线(EMA)的方法来计算K值、D值、J值。

具体计算方法如下：

RSV = （收盘价-N周期最低价）/（N周期最高价-N周期最低价）*100
K值 = RSV的N周期加权移动平均值
D值 = K值的N周期加权移动平均值
J值 = 3K-2D

一般来说，RSV的N周期选择9，K和D的N周期选择3。

基本概念大家都懂了，那如何根据KDJ值决定买入和卖出呢？

当J值上穿K值的时候，是买入信号，此时买入。

当J值下穿K值的时候，是卖出信号，此时卖出。

这个策略有用吗？让我们来试试看。

1.准备

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

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

pip install backtrader

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

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

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

2.单一KDJ策略

如果你以前没用过backtrader，请先看：

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

进行学习，不然你会有点蒙。直接下载代码学习也是一种方式，但前提是你的自学本领够强。

首先我们需要先计算K、D、J三个值，前面我们也说过了他们的计算方式：

RSV = （收盘价-N周期最低价）/（N周期最高价-N周期最低价）*100
K值 = RSV的N周期加权移动平均值
D值 = K值的N周期加权移动平均值
J值 = 3K-2D

知道了计算方式，那之后的工作就简单了：

        # 9个交易日内最高价
        self.high_nine = bt.indicators.Highest(self.data.high, period=9)
        # 9个交易日内最低价
        self.low_nine = bt.indicators.Lowest(self.data.low, period=9)
        # 计算rsv值
        self.rsv = 100 * bt.DivByZero(
            self.data_close - self.low_nine, self.high_nine - self.low_nine, zero=None
        )
        # 计算rsv的3周期加权平均值，即K值
        self.K = bt.indicators.EMA(self.rsv, period=3)
        # D值=K值的3周期加权平均值
        self.D = bt.indicators.EMA(self.K, period=3)
        # J=3*K-2*D
        self.J = 3 * self.K - 2 * self.D

最后决定买入点和卖出点：

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

        if not self.position:
            # J - D 值
            condition1 = self.J[-1] - self.D[-1]
            condition2 = self.J[0] - self.D[0]
            if condition1 < 0 and condition2 > 0:
                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()

不过从卖出策略中可以看到，我暂时没有使用J下穿K值的方式来卖出股票，而是采用涨跌10%的限制性条件作为卖出信号，看看这样的策略表现如何。

这里和上篇文章一样，咱用10000元作为本金，对002859这只股票，回测其2010年1月1日至2020年4月21日期间的走势：

效果不是很好，本金10000元，最后剩余9892元，也就是还亏损了。从盈利和亏损点上来看，该策略确实亏损次数更多，比盈利次数多了一次。

不过这是我们基于限制性卖出的条件，如果是J值下穿K值作为卖出信号呢？

基于backtrader，我们做这样的买入卖出信号调整真的非常简单：

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

        condition1 = self.J[-1] - self.D[-1]
        condition2 = self.J[0] - self.D[0]
        if not self.position:
            # J - D 值
            if condition1 < 0 and condition2 > 0:
                self.log("BUY CREATE, %.2f" % self.dataclose[0])
                self.order = self.buy()

        else:
            if condition1 > 0 or condition2 < 0:
                self.log("SELL CREATE, %.2f" % self.dataclose[0])
                self.order = self.sell()

效果如何？

我勒个去，您这个不太靠谱啊，10000元本金只剩9029元了。

但是这样并没有足够证据否认这个策略的价值，接下来我们尝试将它和MACD策略结合在一起使用。

3.多策略回测

通过回测得到的图表，我发现，KDJ指标在决定买入信号的时候有很大的延迟，比MACD的买入信号延迟重得多，但是它的卖出信号却不错，很敏感。

所以我们可以考虑将MACD策略也引入进来，使用MACD决策买入，KDJ信号决策卖出。引入MACD策略相关变量：

        # MACD策略参数
        me1 = EMA(self.data, period=12)
        me2 = EMA(self.data, period=26)
        self.macd = me1 - me2
        self.signal = EMA(self.macd, period=9)
        bt.indicators.MACDHisto(self.data)

至于为什么MACD策略是这么计算的，请看我们上一篇文章：Python 量化投资原来这么简单(2) —MACD策略(+26.9%)。所以我们的文章是环环相扣的哦，如果没有阅读，请记得回头补上。

从上面两张图中，大家可以看到两条变化非常大的线，这是两条3日EMA的线。我们可以将其取消掉，因为它们没有太多价值。加一个plot=False参数即可让它们不显示：

        # 计算rsv的3周期加权平均值，即K值
        self.K = bt.indicators.EMA(self.rsv, period=3, plot=False)
        # D值=K值的3周期加权平均值
        self.D = bt.indicators.EMA(self.K, period=3, plot=False)

基于MACD策略的买入信号进行买入，KDJ策略的卖出信号进行卖出：

        if not self.position:
            # 买入基于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:
            # 卖出基于KDJ策略
            condition1 = self.J[-1] - self.D[-1]
            condition2 = self.J[0] - self.D[0]
            if condition1 > 0 or condition2 < 0:
                self.log("SELL CREATE, %.2f" % self.dataclose[0])
                self.order = self.sell()

回测效果如下：

最终得到10057.06，赚了57块钱。。当然，总比单纯KDJ策略不赚的好。但是这个策略依然存在问题，它在很多能赚大钱的时候，过于保险地将股票卖出了，以至于其亏损的次数其实大于盈利的次数。

当然，单纯从一只股票上我们是无法看出这个策略的整体好坏的，下一篇量化投资文章（大约在2020/05/09），我们将在A股中随机取1000只股票，来验证这个复合策略的整体收益。敬请期待Python实用宝典的最新更新哦。

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

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

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

我要打赏

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

1.准备

2.Easytrader 基本使用

2.1 自动登录客户端：

2.2 获取资金、持仓情况

2.3 买入、卖出、一键打新、撤单

3.构建监控股票池

1.准备

2.自定义DataFeed

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

1.准备

2.策略

3.总结

1.基础版

2.优化版

3.加强版

1.准备

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

2.1 创建Celery任务实例：

2.2 启动worker

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

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

1.准备

2.编写代码

3.可视化查看数据

1.准备

2.交易收益率

3. 平均收益率

1.准备

2.编写策略

2.1 计算指标

2.2 策略买入卖出与运行

3.A股回测

1.准备

2.单一KDJ策略

3.多策略回测

有趣好用的Python教程