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

量化投资系列文章:

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实用宝典

Pandas 性能优化

Python 能用来干嘛?

Python 能用来干嘛?经常能遇到小伙伴在知乎上问这个问题,而每个这样的问题我都想回答,最终落得个重复答案被删除的下场。

我看到许多人只是千篇一律地回答:Web开发、自动化运维、网络爬虫、数据分析…等等。个人觉得这样的回答太过于抽象,也太敷衍了,没有抓到问题的关键点。

我今年写了许多有趣的小玩意儿,从web开发数据分析,从数据分析到量化投资,甚至还送特朗普上了太阳。但实际上,这些文章都围绕着一个主题:Python 是一个用来解决问题的好工具

学Python,学的可不止是编程语言,更重要的是学会使用这个解决问题的好工具,下面就是一系列解决问题的Python 实战教程。希望能帮你养成用Python解决问题的思维。

数据相关:

1.Python 多项式预测2019年天猫销售额

2.Python 百度指数突变值检测

3.Python 制作音乐高潮副歌提取器

4.Python 来算算一线城市的二手房价格指数相关性

5.Python 20行代码检测人脸是否佩戴口罩

6.比PS还好用!Python 20行代码批量抠图

7.Python 识别文本情感就这么简单

8.Python 计算 瑞幸和星巴克 谁的门店最多

9.Python 短文本自动识别个体是否有自杀倾向

10.如何基于Paddle训练一个98%准确率的抑郁文本预测模型

11.Python 机器学习预测泰坦尼克号存活概率

12.Python 一键吸猫!找出磁盘里所有猫照

13.你的10W块放哪里能赚最多钱?

14.Python 自动提取电影中所有人脸

可视化相关:

1.Python 绘制属于你的世界地图

2.Python 快速绘制画出漂亮的系统架构图

3.7行代码 Python热力图可视化分析缺失数据处理

Python热力图寻找缺失数据

4.Python 人口出生率数据预测及可视化

5.Python 提取音乐频谱并可视化

6.AO3被封的冤不冤?可视化数据分析《下坠》

7.Python 流程图 — 一键转化代码为流程图

8.Python 批量转化彩色图片为黑白图片

9.Blender, 用Python绘制宇宙飞船的3D建模软件

游戏相关:

1.庆祝胖五发射成功, 来用Python发射火箭!

2.Python 精美俄罗斯方块开源项目

3.Python 小游戏—加农炮送特朗普上太阳

4.快来用Python写一个简单版《我的世界》

树莓派与智能家居:

1.Python 树莓派智能音箱语音控制电脑开关机

2.Python 树莓派语音控制普通风扇实现教程

3.python 树莓派语音控制普通台灯教程

4.python 树莓派人脸识别自动开机教程

量化投资

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

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

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

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

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

其他

当然,还有一些有趣的Python教程实例,它不只属于简单的一类,我更倾向于称之为工具,包括数据爬虫、自动化、一键格式化代码等等:

1.Python 8行代码模拟鼠标自动删除微信收藏

2.Python 爬取“微博树洞”详细教程

3.Python 超简单爬取新浪微博数据 (高级版)

4.Python 一个超快的公共情报搜集爬虫

5.Python Black一键格式化美化代码(详细配置教程)

等等…更多的文章大家可以在Python实用宝典公众号历史页里查看,也可以到Python实用宝典网站上进行体验更好的阅读:
https://pythondict.com

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

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

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


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

Pandas 性能优化

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

量化投资系列文章:

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.准备

开始之前,你要确保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实用宝典后台回复:量化投资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实用宝典

Pandas 性能优化

Python 8行代码模拟鼠标自动删除微信收藏

上回我们提到了用 pyuserinput 进行模拟键盘鼠标操作,结果发现很多同学都回复无法安装成功,即便安装成功了还是存在很多问题。确实,pyuserinput存在不少问题,包括其安装的pymouse可能会有DLL加载失败的情况。因此,今天我们将换一个模块进行模拟鼠标操作,那就是pyautogui.

PyAutoGUI和PyUserInput有很大的不同,在windows系统上,它并不需要win32扩展,而是采用ctypes来调用动态链接库函数的功能模块的方式,因此安装起来非常方便!

1.准备

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

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

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

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

pip install pyautogui

看到 Successfully installed xxx 则说明安装成功。安装过程中如果提示缺少某些模块,pip install 缺少的模块即可。

2.基础使用

其实它与pymouse和pykeyboard差别不大,就是函数名变了。比如说移动鼠标到屏幕中央:

import pyautogui
screenWidth, screenHeight = pyautogui.size()
pyautogui.moveTo(screenWidth / 2, screenHeight / 2)

鼠标点击:

pyautogui.click()

鼠标移动,第一个参数是移动的x轴偏移量,第二个参数是y轴偏移量,第三个参数是移动耗时:

pyautogui.moveRel(xOffset, yOffset, duration=num_seconds)

右击、中键、双击、三击任意位置:

pyautogui.rightClick(x=moveToX, y=moveToY)
pyautogui.middleClick(x=moveToX, y=moveToY)
pyautogui.doubleClick(x=moveToX, y=moveToY)
pyautogui.tripleClick(x=moveToX, y=moveToY)

当然,还有很多其他有用的函数,相关的其他函数请见pyautogui的中文文档(没错,还有中文文档)。

3.删除微信收藏

虽然你可能觉得删除的过程中你无法再用电脑做任何事情,这样的删除没有意义,但是,你可以找一个不需要用到电脑的时间来做这个操作,启动脚本后去喝杯奶茶不香吗?

首先我们要找到操作目标的x,y值,用上回我们提到的看鼠标软件(软件下载:mousexy,也可在Python实用宝典公众号后台回复:看鼠标 下载)进行位置信息的采集:

然后找到右键后相关操作的位置:

最后还有一个确认选项的位置:

我们只需要将这系列操作连续起来自动化运行:

# Python实用宝典
# 2020/05/14
import pyautogui
import time
pyautogui.rightClick(706, 281)
time.sleep(0.5)
pyautogui.click(733, 351)
time.sleep(0.5)
pyautogui.click(768, 647)

没错,就是这么简单,演示一下:

然后我们再优化代码,让其可设定删除的条数:

# Python实用宝典
# 2020/05/14
import pyautogui
import time
DELETE = 5
delete_num = 0
while delete_num < DELETE:
    pyautogui.rightClick(706, 281)
    time.sleep(0.5)
    pyautogui.click(733, 351)
    time.sleep(0.5)
    pyautogui.click(768, 647)
    delete_num += 1

效果如下:

当然,你也可以 while 1 直接删除所有收藏哦。怎么样,学到了吗?如果有收获的话,记得点一下右下角的在看/赞哦,感谢各位。

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

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

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


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

Pandas 性能优化

Python 模拟键盘鼠标操作详细教程

在某些情况下,如果我们需要进行自动化操作的应用没有提供相应的接口,我们无法直接通过Python来调用API实现自动化。这种情况下,Python也不是完全没有办法的,我们可以采用模拟键盘和鼠标的方式实现自动化。

Python中模拟键盘和鼠标最著名的模块是:pymousepykeyboard。一次安装两个模块比较麻烦,而有一个库整合了这两个模块,而且能支持跨平台操作,这个库叫PyUserInput,通过安装PyUserInput就可以直接得到pymousepykeyboard

1.准备

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

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

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

PyUserInput 在不同系统下的安装需要使用不同的依赖:

  • Linux – Xlib (python-xlib)
  • Mac – Quartz, AppKit
  • Windows – pywin32, pyHook

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

pip install PyUserInput

看到 Successfully installed xxx 则说明安装成功。Windows系统下如果出现如以下的红色字体提示则需要安装pyHook:

No matching distribution found for pyHook (from PyUserInput)

pyHook安装比较麻烦,给大家讲一下,安装成功或者非Windows系统的同学可以跳过这里的讲解:

1.安装pyHook需要前往 https://www.lfd.uci.edu/~gohlke/pythonlibs/#pyhook 找到你的Python版本对应的pyHook安装包,如我的是Python 3.6,系统是64位,则选择红框版本

2.输入以下命令安装该whl文件:

pip install pyHook-1.5.1-cp36-cp36m-win_amd64.whl

文件需要在输入命令的当前文件夹下。

3.出现Successfully installed pyHook-1.5.1则说明安装成功。

如果出现缺少pywin32依赖,或者pywin32无法正常使用,请前往https://github.com/mhammond/pywin32/releases 下载对应版本的pywin32安装包,这里的安装包是exe程序,直接双击安装即可。

安装pywin32的时候如果出现这样的错误(借他人图):

是因为你的Python没有被写入到注册表,需要将注册表写入Python,执行下方代码(可在Python实用宝典公众号后台回复:注册表 获得)就可成功注册。

import sys

from winreg import *

# tweak as necessary
version = sys.version[:3]
installpath = sys.prefix

regpath = "SOFTWARE\\Python\\Pythoncore\\%s\\" % (version)
installkey = "InstallPath"
pythonkey = "PythonPath"
pythonpath = "%s;%s\\Lib\\;%s\\DLLs\\" % (installpath, installpath, installpath)


def RegisterPy():
    try:
        reg = OpenKey(HKEY_CURRENT_USER, regpath)
    except EnvironmentError as e:
        try:
            reg = CreateKey(HKEY_CURRENT_USER, regpath)
            SetValue(reg, installkey, REG_SZ, installpath)
            SetValue(reg, pythonkey, REG_SZ, pythonpath)
            CloseKey(reg)
        except:
            print("*** Unable to register!")
            return
        print("--- Python", version, "is now registered!")
        return
    if (
        QueryValue(reg, installkey) == installpath
        and QueryValue(reg, pythonkey) == pythonpath
    ):
        CloseKey(reg)
        print("=== Python", version, "is already registered!")
        return
    CloseKey(reg)
    print("*** Unable to register!")
    print("*** You probably have another Python installation!")


if __name__ == "__main__":
    RegisterPy()

注册完毕后就可以正常安装pywin32了,然后再重新安装 PyUserInput 即可。macOS和Linux在安装的时候应该不会遇到太大问题,如果有遇到问题可以先搜索一下,网上解决方案都很全,或者在本文下方留言求解。

2.基本使用

pymouse模块相对简单,你只需要记以下几个函数即可满足基本的使用需求,如

1.鼠标移动:

# Python实用宝典
from pymouse import PyMouse

# 初始化鼠标对象
m = PyMouse()

# 移动鼠标到(x, y)绝对地址
m.move(200, 200)

中键滚动:

# Python实用宝典
from pymouse import PyMouse

# 初始化鼠标对象
m = PyMouse()

# 中键垂直滚动 10个单位
m.scroll(10, 0)

2.鼠标点击:

# Python实用宝典
from pymouse import PyMouse

# 初始化鼠标对象
m = PyMouse()

# 鼠标点击(500, 300), 第三个参数代表键位,1是左键,2是右键,3是中键
m.click(500, 300, 1)

鼠标拖拽:

# Python实用宝典
from pymouse import PyMouse

# 初始化鼠标对象
m = PyMouse()

# 鼠标从当前位置拖拽到(500, 300)
m.drag(500, 300)

3.获得当前屏幕大小:

# Python实用宝典
from pymouse import PyMouse

# 初始化鼠标对象
m = PyMouse()

# 当前屏幕大小
m.screen_size()

4.获得鼠标当前位置:

# Python实用宝典
from pymouse import PyMouse

# 初始化鼠标对象
m = PyMouse()

# 当前位置
m.position()

只要记住以上4个方法,pymouse模块你就掌握了。接下来是比较复杂的pykeyboard模块:

1.键入字符串

# Python实用宝典
from pykeyboard import PyKeyboard

# 初始化键盘对象
k = PyKeyboard()

# 键入Hello, World!
k.type_string('Hello, World!')

2.按下按键与释放按键

# Python实用宝典
from pykeyboard import PyKeyboard

# 初始化键盘对象
k = PyKeyboard()

# 按下H键
k.press_key('H')

# 释放H键
k.release_key('H')

# 你也可以使用tap_key函数直接实现按下和释放
k.tap_key('H')

# 支持自定义按下次数和其间隔时间,单位:秒
k.tap_key('l',n=2,interval=5)

3.特殊按键的输入:

# Python实用宝典
from pykeyboard import PyKeyboard

# 初始化键盘对象
k = PyKeyboard()

# 按住alt键
k.press_key(k.alt_key)
# tab键
k.tap_key(k.tab_key)
# 释放alt键
k.release_key(k.alt_key)

# F5键
k.tap_key(k.function_keys[5])
# Home键
k.tap_key(k.numpad_keys['Home']) 
# 按数字5三次
k.tap_key(k.numpad_keys[5], n=3)

3.小练习

微信的收藏功能相当好用,我收藏了几百个链接和推送,但是微信官方却没有提供批量删除的功能。。这么明显的痛点都没有修复,也许这就是微信的“任性”吧,优秀。

没事,有了Python,我们完全可以自己干。开始之前,需要下载一个叫看鼠标的软件,查找微信中某些组件所对应的当前屏幕的坐标(软件下载:mousexy)。

比如红点处位置为(574, 202). 所以为了实现批量删除,我们只需要从这个位置开始,右键删除,然后滚动相同宽度,重复这个操作即可。

为了避免文章篇幅过长,这里留给大家做练习,我们在下篇推送中将详细解析做法,敬请期待。

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

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

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


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

Pandas 性能优化

Python Black一键格式化美化代码(详细配置教程)

复制别人的代码进行使用的时候,最烦的就是看到编辑器上显示的各种红色的、橙色的线吧?尤其是那些不遵守PEP8规则的代码,等号两边的空格会加到你手软…真希望哪天全世界写Python的小伙伴们都能统一代码规范啊!

没事,现在有black这个神器,我们可以在终端中输入一句命令就自动格式化代码!而且对于初学者来说,用Black来学习代码规范也是一个非常不错的选择。

1.准备

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

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

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

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

pip install black

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

安装完成之后,你有两种使用black的方式,一种是直接在命令里输入:

black 你的文件路径.py

它就会自动格式化该Python文件,如果你是使用VSCode,我推荐使用这种方法来格式化。

如果你使用Pycharm,那么需要这么设置:

在PyCharm菜单 File->Setting->Tools->External Tools->单击按钮“+”号:

在弹出窗口里的Name中输入一个名字作为在以后在Pycharm菜单->Tools->External Tools中显示的名字,作为方便的工具入口,例如在此输入名字为BlackFormatter:

在Programs中输入black安装后的black.exe文件所在目录。该目录在Windows的cmd窗口中通过命令where black查找到,在Linux中用命令which black查找。

例如我的路径是:C:\Users\Ckend\Anaconda3\Scripts\black.exe,将此包含balck.exe文件名的全路径填入到Programs框中。在Arguments中填入$FilePath$,在Working Directory中填入$ProjectFileDir$。然后单击OK即可。

2.使用

如前所述,两种使用方法,先介绍Vscode的,比如说下面这个糟糕的格式:

真的各种线条都出现了,不过你只需要在终端中输入:

black test.py

就能一键美化到符合PEP8标准的代码格式:

使用Pycharm的话则更方便了(当然前提是你配置好了),你只需要按 Tools->External Tools -> BlackFormatter(你刚配置时输入的名称) 即可直接格式化当前文件。

Pycharm下方如图所示则说明格式化成功:

当然,Pycharm也可以使用命令的方式格式化,在Terminal里输入即可,因为它其实和Vscode的终端是一个东西,注意black安装的环境和你终端使用的虚拟环境是一致的就行。

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

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

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


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

Pandas 性能优化

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

量化投资系列文章:

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.准备

开始之前,你要确保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实用宝典后台回复:量化投资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实用宝典

Pandas 性能优化

Python 流程图 — 一键转化代码为流程图

Graphviz是一个可以对图进行自动布局的绘图工具,由贝尔实验室开源。我们在上次 Python 快速绘制画出漂亮的系统架构图 提到的diagrams,其内部的编排逻辑就用到了这个开源工具包。

而今天我们要介绍的项目,就是基于Python和Graphviz开发的,能将源代码转化为流程图的工具:pycallgraph

1.准备

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

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

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

输入以下命令安装 pycallgraph 模块。

pip install pycallgraph

看到 Successfully installed xxx 则说明安装成功。除此之外,你还需要安装graphviz

macOS用户请使用brew安装:

brew install graphviz

windows用户请点击链接:graphviz-2.38.msi 下载安装,安装完成后需要将其写入到环境变量中:

2.生成流程图

该模块有两种调用方式,一种是在代码里通过上下文调用:

from pycallgraph import PyCallGraph
from pycallgraph.output import GraphvizOutput

with PyCallGraph(output=GraphvizOutput()):
    # 需要绘制流程图的代码,可以是函数
    # ... ...

比如说,绘制一下咱上回的《Python 我的世界》源代码的流程图:

# ...省略大部分代码...
if __name__ == '__main__':
    from pycallgraph import PyCallGraph
    from pycallgraph.output import GraphvizOutput

    with PyCallGraph(output=GraphvizOutput()):
        main()

在运行该Python文件后,会在当前文件夹下产生一个pycallgraph.png的文件,这个就是该代码的流程图:

还有一种是使用命令的方式调用,这个方式必须使用bash才能运行,macOS用户可以忽视这个问题,但如果你是windows用户,请通过以下方式打开bash(以VS Code为例):

然后通过Ctrl + shift + ` 打开一个新的终端,即可看到以bash启动的命令行。

通过输入以下命令生成流程图:

pycallgraph graphviz -- ./你需要生成流程图的.py文件

完成后会在当前文件夹下生成一个pycallgraph.png的文件,这个就是这份代码的流程图。

通过这个方法,你可以清晰地看到这份源代码里面的调用逻辑和其每个模块的运行时间,是一个很方便的小工具,非常适合初学者学习他人的开源模块。大家有需要研究的代码可以用这个工具试一试,说不定有意外的收获呢。

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

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

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


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

Pandas 性能优化

快来试试Python写的游戏《我的世界》

《我的世界 Minecraft》大家应该都听说过,但你有没有想过自己用Python写一个这样的游戏呢?太难、太复杂了?也许吧,但是不试一试你怎么知道能不能成呢?

国外有位叫fogleman的开发者就用Python做了这样的一件事——自制《我的世界 Minecraft》,谁能想到,仅仅900行的代码,玩起来竟然还像模像样的:

接下来,我们就带你运行这个项目,并对这个开源的小游戏做一下简单的更改,让它变成“你的”世界。

1.准备

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

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

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

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

pip install pyglet

看到 Successfully installed xxx 则说明安装成功。然后需要下载这个游戏的源代码,你可以通过输入命令下载:

git clone https://github.com/fogleman/Minecraft.git

也可以在Python实用宝典公众号后台回复:MC 下载。

2.运行及操作

运行这个项目非常简单,你只需要进入源代码文件夹输入以下命令:

python main.py

即可成功运行该游戏项目,然后体验一下这个游戏:

移动

  • W: 前进
  • S: 后退
  • A: 往左
  • D: 往右
  • 鼠标移动: 视角
  • 空格: 跳跃
  • Tab: 切换到飞行模式

建筑

  • 选择建造类型:
    • 1: 砖块
    • 2: 草丛
    • 3: 沙丘
  • 鼠标左键:去除建筑
  • 鼠标右键:增加建筑

退出

  • ESC: 关闭窗口

来看看我的实画:

这个“实”字着实难画,宝典两个字被我略去了,因为我选的地儿右边空位不够。

3.代码解读与自定义

接下来让我们看看这份游戏的代码,整个游戏代码只有902行,真优秀:

在上图红框的位置可以设定默认的窗口大小。作者还给了一些参数以供自定义速度、重力、跳跃高度等:

# 每秒帧数
TICKS_PER_SEC = 60

# 砖块大小
SECTOR_SIZE = 16

# 行走速度与飞行速度
WALKING_SPEED = 5
FLYING_SPEED = 15

# 重力与跳跃高度
GRAVITY = 20.0
MAX_JUMP_HEIGHT = 1.0

我们能不能自定义砖块类型呢?注意,源代码文件夹下有一个texture图片:

而在源代码中,涉及到用户增加区块的代码只有3行,如SAND:

SAND = tex_coords((1, 1), (1, 1), (1, 1))
# ... ...
t = random.choice([GRASS, SAND, BRICK])
# ... ...
self.inventory = [BRICK, GRASS, SAND]
# 1.brick, 2.grass, 3.sand

也就是说,我们增加自己的区块是完全可能的,那么这个tex_coords((1, 1), (1, 1), (1, 1))是什么意思呢?

def tex_coord(x, y, n=4):
    """ Return the bounding vertices of the texture square.

    """
    m = 1.0 / n
    dx = x * m
    dy = y * m
    return dx, dy, dx + m, dy, dx + m, dy + m, dx, dy + m


def tex_coords(top, bottom, side):
    """ Return a list of the texture squares for the top, bottom and side.

    """
    top = tex_coord(*top)
    bottom = tex_coord(*bottom)
    side = tex_coord(*side)
    result = []
    result.extend(top)
    result.extend(bottom)
    result.extend(side * 4)
    return result


TEXTURE_PATH = 'texture.png'

GRASS = tex_coords((1, 0), (0, 1), (0, 0))
SAND = tex_coords((1, 1), (1, 1), (1, 1))
BRICK = tex_coords((2, 0), (2, 0), (2, 0))
STONE = tex_coords((2, 1), (2, 1), (2, 1))

看完tex_coords函数的参数你大概就知道了,这里第一个参数,代表砖块的顶部图像,第二个参数代表底部图像,第三个参数代表四个边的图像。而传入的参数中,(1, 0) 则表示为texture.png 的第(1,0)个图:

比如沙子,顶边、底边、四边都为一样的(1,1)这个图像,因此是:

SAND = tex_coords((1, 1), (1, 1), (1, 1))

相信明白了这个原理后,你自己加一个自定义图形的砖块也不难了吧?大家可以动手试一试。

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

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

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


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

Pandas 性能优化

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

量化投资系列文章:

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

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

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

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


上一回,我们基于简单的MACD策略回测了华正新材这只股票的收益率,发现效果非常好,收益达到了26.9%,但这个策略放到其他股票上会不会有这么高的收益呢?我们今天就来试试看这个策略在不考虑基本面,只考虑技术面的情况下,在A股上的平均表现。

为了回测该策略在A股上的平均表现,我们从A股随机选取了1000只股票,使用MACD策略回测其2010年1月1日至今,使用MACD策略进行投资的表现。其中,以一万元作为本金,佣金为万分之五,每次交易100股。

最终发现,使用该策略最终亏损的股票有626只,盈利的有372只,有2只股票数据不足被去除。最高盈利有84%,最差亏损也达-34%。盈利超过10%的股票有30只,亏损超过30%的有29只。并总结了这30只盈利超过10%的股票的特点。

下面是用Python和backtrader分析这些股票的详细教程。在公众号后台回复:量化投资3 可获得本文全部代码及数据。本系列文章github仓库:
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

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

2.改造策略

最方便的回测股票数据的形式是将股票数据存储在MySQL数据库中,每次回测从数据库中拉取数据即可。但为了能够方便地让大家复现实验,我们将这些股票的数据以文件的形式存储下来。

策略上,我们不需要做改变,但是需要将运行策略的这一部分封装起来,用于批量执行策略:

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, 4, 25),
        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()

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

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

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

然后遍历所有股票,运行策略,结果保存在result变量中:

files_path = '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)

最后,我们使用pickle将变量结果保存为文件,以方便后续分析:

f = open('./batch_macd_result.txt', 'wb')
pickle.dump(result, f)
f.close()

随后,我们就可以随意分析这个结果,而不用重新跑一遍策略了。

3.结果分析

接下来,使用最简单的方法分析结果:

import pickle

# 加载保存的结果
f = open('./batch_macd_result.txt', 'rb')
data = pickle.load(f)
f.close()

# 计算
pos = []
neg = []
ten_pos = []
ten_neg = []
for result in data:
    res = data[result]
    if res > 0:
        pos.append(res)
    else:
        neg.append(res)

    if res > 0.1:
        ten_pos.append(result)
    elif res < -0.1:
        ten_neg.append(result)

max_stock = max(data, key=data.get)

print(f'最高收益的股票: {max_stock}, 达到 {data[max_stock]}')
print(f'正收益数量: {len(pos)}, 负收益数量:{len(neg)}')
print(f'+10%数量: {len(ten_pos)}, -10%数量:{len(ten_neg)}')
print(f'收益10%以上的股票: {ten_pos}')

随机抽取的1000千股票,回测结果如下:

D:\CODE\stock\backtrader&gt;python analysis.py
最高收益 600745.SH, 达到 0.8413365999999998
正收益数量: 372, 负收益数量:626
+10%数量: 30, -10%数量:29
收益10%以上的股票: ['000403.SZ', '000858.SZ', '002271.SZ', '002311.SZ', '002475.SZ', '002555.SZ', '002568.SZ', '002605.SZ', '002714.SZ', '300007.SZ', '300136.SZ', '300220.SZ', '300347.SZ', '300476.SZ', '300482.SZ', '300566.SZ', '300601.SZ', '300613.SZ', '300630.SZ', '300725.SZ', '600570.SH', '600585.SH', '600745.SH', '601231.SH', '601799.SH', '603297.SH', '603378.SH', '603655.SH', '603737.SH', '603823.SH']

显然,在不考虑基本面的情况下,该策略的收益并不高,因此不建议用该策略进行A股整体回测并作交易。但是我们可以观察一下收益10%以上的股票的基本面特点。

你会发现大部分使用MACD策略收益10%以上的股票,其同比年利润增长都是大于0的,只有2只股票例外。此外,大部分股票平均年利润同比增长都在20%到30%左右,而且不会有太大的波动。

所以,MACD策略只有在股票的基本面优秀的情况下,才能发挥最大的价值。而在股票基本面比较差的情况下,这个策略的表现非常差,因此对于投机者而言,它并不是一个好的策略,但是对于价值投资者而言,其具备一定的参考价值。

好了,我们关于MACD策略的分析就到这里,如果大家有进一步的兴趣的话,记得关注Python实用宝典哦,我们将每周更新一期量化投资相关的推送,希望大家喜欢,本文的代码及数据,请在公众号后台回复:量化投资3 下载。

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

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

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


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

Pandas 性能优化

有趣好用的Python教程