快来试试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实用宝典。

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

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

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

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

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

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

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

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

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

人人都能懂的 Python 自动发送邮件详细实战教程

自动发送邮件能应用于许多场景中,比如我想要知道股票策略中的股票池是否有实时的更新,这时候如果再拉一遍数据,跑一遍脚本,实在是太浪费时间了。为什么不把这一套流程放到服务器上,然后到点自动运行并发送邮件呢?

类似的应用场景还有很多,不仅仅是在股票策略提醒上,比如定时向某些人发送邮件;还比如网站宕机了,实时发送邮件提醒;又比如网站负载过高,发送邮件提醒……等等。

下面就来讲讲怎么用Python构建一个自动发送邮件的脚本。

1.开启SMTP服务

为了实现自动发送邮件的目的,我们需要在邮箱中开启SMTP服务:

这点很关键,别忘了去开启SMTP, 别忘了去开启SMTP,否则邮件是无法发送成功的 。然后你还需要点击下面生成授权码,这个授权码才是使用Python发送邮件时的真正密码。

邮箱设定成功后,就可以开始脚本开发了。

2.准备

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

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

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

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

pip install yagmail

看到 Successfully installed xxx 则说明安装成功。本文全部源代码可在公众号后台回复:自动发送邮件 获得。

3.编写脚本

今天需要用到的模块是yagmail,一个非常方便的Python邮件发送模块,用这个模块,你甚至能一行命令发送邮件:

yag = yagmail.SMTP(
    host='smtp.qq.com', user='你的邮箱',
    password='你的授权码', smtp_ssl=True
).send('发送对象', '主题', '内容')

为了让这个发送邮件的方法更加具备可用性,我们将其封装到一个类中:

import yagmail 
class Mail:
    """
    邮件相关类
    """ 
    def sendmail(self, msg, title, receivers):
        """
        发送邮件
        
        Arguments:
            msg {str} -- 邮件正文
            title {str} -- 邮件标题
            receivers {list} -- 邮件接收者,数组
        """

        yag = yagmail.SMTP(
            host='smtp.qq.com', user='你的邮箱',
            password='你的鉴权码', smtp_ssl=True
        )

        try:
            yag.send(receivers, title, msg)
            print("邮件发送成功")

        except BaseException as e:
            print (e)
            print("Error: 无法发送邮件") 

这个类里还可以封装很多其他东西,比如log函数,用于显示时间:

import time
class Mail:
    """
    邮件相关类
    """

    def log(self, content):
        now_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
        print(f'{now_time}: {content}')

这样,需要显示时间的时候只需要调用self.log即可,可将sendmail函数改成如下所示:

    def sendmail(self, msg, title, receivers):
        """
        发送邮件
        
        Arguments:
            msg {str} -- 邮件正文
            title {str} -- 邮件标题
            receivers {list} -- 邮件接收者,数组
        """

        yag = yagmail.SMTP(
            host='smtp.qq.com', user='你的邮箱',
            password='你的鉴权码', smtp_ssl=True
        )

        try:
            yag.send(receivers, title, msg)
            self.log("邮件发送成功")

        except BaseException as e:
            print (e)
            self.log("Error: 无法发送邮件")

发送成功时显示:

PS D:\CODE\stock\api> python .\sendmail_yagmail.py
2020-04-22 00:51:34: 邮件发送成功

4.小例子

将刚刚编写完的类保存为sendmail.py,接下来就可以尝试一个小例子。我们用一个自动监控网站是否宕机的小脚本做示例:

import time
import requests
from sendmail import Mail

while True:
    response = requests.get('https://pythondict.com')

    # 根据状态码判断网站是否正常
    if response.status_code != 200:
        Mail().sendmail(
            '哥, pythondict挂了', 'Python实用宝典网站异常监控', ['你的邮箱']
        )

    time.sleep(600)

通过requests.get请求网站,使用response.status_code即可得到状态码,200为正常,其他情况均为异常。这个检测每十分钟运行一次,因此 time.sleep(600).

就这样,我们构建起了一个非常简单的网站异常监控脚本,如果你真的要在服务器上运行这个脚本,请记得使用nohup让其在后台运行:

nohup python test.py &

总之,自动发送邮件的用途非常广泛,不亚于手机自动通知,具体使用就要看各位自身的需求啦。

自动通知系列文章:

让Python自动提醒你:阿森纳进球啦!

Python 自动发送邮件详细教程

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

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

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

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

​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 快速绘制画出漂亮的系统架构图

Diagrams  是一个基于Python绘制云系统架构的模块,它能够通过非常简单的描述就能绘制画出可视化架构,其支持使用以下6种云产品的图标:

AWSAzureGCPKubernetes阿里云, Oracle Cloud

基于Diagrams提供的节点,你只需要指定一个云产品(实际上选哪个都一样,我们只需要那个产品相应的图标,你可以选一个自己觉得好看的),使用其内部自带的云产品的图标,就能简单绘制基于某云产品图标的架构图,比如下面的代码,绘制了一个简单的基于数据库集群的网络服务架构:

from diagrams import Cluster, Diagram
from diagrams.aws.compute import ECS
from diagrams.aws.database import RDS
from diagrams.aws.network import Route53

with Diagram("Simple Web Service with DB Cluster", show=False):
    dns = Route53("dns")
    web = ECS("service")

    with Cluster("DB Cluster"):
        db_master = RDS("master")
        db_master - [RDS("slave1"),
                     RDS("slave2")]

    dns >> web >> db_master

非常适合用来做毕业论文的架构图绘制,强烈推荐。

1.准备

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

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

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

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

pip install diagrams

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

2.基本使用与例子

2.1 初始化与导出

使用 Diagram 类初始化一个绘图上下文,这个类接收到的第一个参数将会成为架构图的文件名,而一当代码运行完毕,它将会以该文件名保存(空格会被下划线所替代):

from diagrams import Diagram
from diagrams.aws.compute import EC2

with Diagram("Simple Diagram"):
    EC2("web")

此外,它还可以选择导出的文件格式,在Diagram类里增加outformat参数,也可以不以第一个参数为文件保存名称,增加filename参数指定名称即可:

with Diagram("Simple Diagram", outformat="jpg", filename="my_diagram")

2.2 节点类型

由于节点类型比较多,我们无法一一展示出来,所有类型的节点里都可以在官方文档里找到,比如:

阿里云:https://diagrams.mingrammer.com/docs/nodes/alibabacloud
K8S: https://diagrams.mingrammer.com/docs/nodes/k8s
AWS: https://diagrams.mingrammer.com/docs/nodes/aws

接下来以AWS为例子,讲解几个基本的数据流例子:

from diagrams import Diagram
from diagrams.aws.compute import EC2
from diagrams.aws.database import RDS
from diagrams.aws.network import ELB
from diagrams.aws.storage import S3

# show参数表示是否自动打开图像
with Diagram("Web Services", show=False):
    ELB("lb") >> EC2("web") >> RDS("userdb") >> S3("store")
    ELB("lb") >> EC2("web") >> RDS("userdb") << EC2("stat")
    (ELB("lb") >> EC2("web")) - EC2("web") >> RDS("userdb")

几个操作符:

>> 表示从左到右的数据流
<< 表示从右到左的数据流
– 表示没有箭头的数据流

可以用变量赋值的形式简化代码:

from diagrams import Diagram
from diagrams.aws.compute import EC2
from diagrams.aws.database import RDS
from diagrams.aws.network import ELB

with Diagram("Workers", show=False, direction="TB"):
    lb = ELB("lb")
    db = RDS("events")
    lb >> EC2("worker1") >> db
    lb >> EC2("worker2") >> db
    lb >> EC2("worker3") >> db
    lb >> EC2("worker4") >> db
    lb >> EC2("worker5") >> db

可以看到这里箭头的方向变了,这是因为Diagram加了direction参数,TB 表示数据流向 top to bottm, 即从上到下,可选的其他参数还有:LR(左至右)、BT(底至上)、RL(右至左)。

上面的代码还可以用数组的形式进一步简化:

from diagrams import Diagram
from diagrams.aws.compute import EC2
from diagrams.aws.database import RDS
from diagrams.aws.network import ELB

with Diagram("Grouped Workers", show=False, direction="TB"):
    ELB("lb") >> [EC2("worker1"),
                  EC2("worker2"),
                  EC2("worker3"),
                  EC2("worker4"),
                  EC2("worker5")] >> RDS("events")

2.3 集群块

使用Cluster 类 并用with以上下文的形式,你可以非常方便地生成一个集群块:

from diagrams import Cluster, Diagram
from diagrams.aws.compute import ECS
from diagrams.aws.database import RDS
from diagrams.aws.network import Route53

with Diagram("Simple Web Service with DB Cluster", show=False):
    dns = Route53("dns")
    web = ECS("service")

    with Cluster("DB Cluster"):
        db_master = RDS("master")
        db_master - [RDS("slave1"),
                     RDS("slave2")]

    dns >> web >> db_master

而且还可以做得相当复杂:

这里代码很简单,但是比较长,不展示了,有兴趣的话可以点击最下方阅读原文进行查看。

from diagrams import Cluster, Diagram
from diagrams.aws.compute import ECS, EKS, Lambda
from diagrams.aws.database import Redshift
from diagrams.aws.integration import SQS
from diagrams.aws.storage import S3

with Diagram("Event Processing", show=False):
    source = EKS("k8s source")

    with Cluster("Event Flows"):
        with Cluster("Event Workers"):
            workers = [ECS("worker1"),
                       ECS("worker2"),
                       ECS("worker3")]

        queue = SQS("event queue")

        with Cluster("Processing"):
            handlers = [Lambda("proc1"),
                        Lambda("proc2"),
                        Lambda("proc3")]

    store = S3("events store")
    dw = Redshift("analytics")

    source >> workers >> queue >> handlers
    handlers >> store
    handlers >> dw

2.4 自定义线的颜色与属性

使用Edge函数,你可以自定义线的颜色与属性以及备注,比如:

Edge(color="firebrick", style="dashed", label="test")
# 火砖色的虚线,备注为test

一个比较复杂,但是阅读起来很简单的例子如下:

from diagrams import Cluster, Diagram, Edge
from diagrams.onprem.analytics import Spark
from diagrams.onprem.compute import Server
from diagrams.onprem.database import PostgreSQL
from diagrams.onprem.inmemory import Redis
from diagrams.onprem.logging import Fluentd
from diagrams.onprem.monitoring import Grafana, Prometheus
from diagrams.onprem.network import Nginx
from diagrams.onprem.queue import Kafka

with Diagram(name="Advanced Web Service with On-Premise (colored)", show=False):
    ingress = Nginx("ingress")

    metrics = Prometheus("metric")
    metrics << Edge(color="firebrick", style="dashed") << Grafana("monitoring")

    with Cluster("Service Cluster"):
        grpcsvc = [
            Server("grpc1"),
            Server("grpc2"),
            Server("grpc3")]

    with Cluster("Sessions HA"):
        master = Redis("session")
        master - Edge(color="brown", style="dashed") - Redis("replica") << Edge(label="collect") << metrics
        grpcsvc >> Edge(color="brown") >> master

    with Cluster("Database HA"):
        master = PostgreSQL("users")
        master - Edge(color="brown", style="dotted") - PostgreSQL("slave") << Edge(label="collect") << metrics
        grpcsvc >> Edge(color="black") >> master

    aggregator = Fluentd("logging")
    aggregator >> Edge(label="parse") >> Kafka("stream") >> Edge(color="black", style="bold") >> Spark("analytics")

    ingress >> Edge(color="darkgreen") << grpcsvc >> Edge(color="darkorange") >> aggregator

3.总结

不得不说,这真是一个基于Python,且非常简单好用的开源免费架构图设计模块,用途其实非常广,包括不仅限于:计算机应用的架构图、毕业设计架构等等。希望大家能够学以致用。

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

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

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

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

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

利用 Python 理解设计模式之委托模式

有时候,我们想通过一个类来调用另一个类里的方法来处理请求,即这两个类对象参与处理同一个请求对象,只不过一个是委托者,一个是处理者

比如我们现在有一个名为Dog的类对象,我们希望通过它调用 voice 类产生“狗吠 ” 声,这时候就可以采用委托模式。下面就用Python来理解这个设计模式。

Python里,在委托者类对象中,需要这么设计:

1. 重写__getattr__方法,使得委托者获得处理者的属性。

2. 判断该属性是否为可调用函数,如果不是则直接返回,如果是,则用 wrapper 封装为可调用对象。

如下所示:

class Dog:
    def __init__(self, voice):
        self.voice = voice

    def __getattr__(self, name):
        """
        重写__getattr__方法
        获得相应的属性

        Arguments:
            name {str} -- 目标变量/函数名
        
        Returns:
            attr -- 处理者的变量/函数
        """

        attr = getattr(self.voice, name)

        if not callable(attr):
            return attr

        def wrapper(*args, **kwargs):
            return attr(*args, **kwargs)
        return wrapper 

这样做的好处是,处理者(被委托者)不需要做太多的更改,一般是一个公用类。我们的处理者如下:

class voice:
    def __init__(self):
        self.p1 = 'test'

    def words(self, something):
        print("voice: %s" % something)
        return "voice: %s" % something

这样就可以通过委托者来调用另一个类的方法来对请求进行处理:

if __name__ == '__main__':
    John = Dog(voice())
    John.words('汪汪')

实际上,如果你不重写__getattr__,一样可以用以下的方式调用到voice类:

if __name__ == '__main__':
    John = Dog(voice())
    John.voice.words('汪汪') 

这两种有什么区别呢?使用委托模式,可以简化代码,优化可读性,你不需要再调用voice对象, 委托者自己会利用 __getattr__ 找到相应的对象里的方法。

不过,在Python里,委托模式这样的写法其实是 un-pythonic 的,因为它将调用的方法隐藏在了执行者中, 可读性比较差。如果不是特殊需要,一般不会这么做,这里只是给大家展示如何用Python来理解这个设计模式。

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

Python 使用tablib库快速导出数据

Tablib是一个Python的第三方数据导出模块,它支持以下文件格式的导出:

  • Excel
  • JSON
  • YAML
  • Pandas DataFrames
  • HTML
  • Jira
  • TSV
  • ODS
  • CSV
  • DBF

这个工具能做到的东西,Pandas都能做到,但是有时候Pandas实在是过重了,如果我们只想实现轻量数据的导出,而非上千万级别的数据导出,该工具更能体现它的优势。

1.准备

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

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

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

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

pip install tablib

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

2.基本使用

这一块,官方文档已经有详细介绍,这里转载自xin053的翻译与介绍,有部分修改。

创建Dataset对象

import tablib
headers = ('first_name', 'last_name')
data = [
    ('John', 'Adams'),
    ('George', 'Washington')
]
data = tablib.Dataset(*data, headers=headers)

这样相当于构造了一张表:

first_namelast_name
JohnAdams
GeorgeWashington

其中最重要的就是Dataset对象,当然该对象的创建也可以不输入参数,直接

data = tablib.Dataset()

创建出一个Dataset对象,然后通过

data.headers = ['first_name', 'last_name']

设置表头,当然也可以使用

data.headers = ('first_name', 'last_name')

因为不管是用列表还是元组,tablib都会自动帮我们处理好,我们可以通过

data.append(['Henry', 'Ford'])

或者

data.append(('Henry', 'Ford'))

来向表中添加一条记录。

我们可以通过data.dict来查看目前表中的所有数据:

>>> data.dict
[OrderedDict([('First Name', 'John'), ('Last Name', 'Adams')]), OrderedDict([('First Name', 'George'), ('Last Name', 'Washington')]), OrderedDict([('First Name', 'Henry'), ('Last Name', 'Ford')])]

也可以通过print(data)显示更人性化的输出:

>>> print(data)
First Name|Last Name 
----------|----------
John      |Adams     
George    |Washington
Henry     |Ford 

Dataset属性

data.height输出当前记录(行)总数
data.width输出当前属性(列)总数

>>> print(data)
First Name|Last Name|age
----------|---------|---
John      |Adams    |90
Henry     |Ford     |83
>>> data.height
2
>>> data.width
3 

常用方法

详情可见官方文档:
https://tablib.readthedocs.io/en/stable/api/#tablib.Dataset.remove_duplicates

lpop(),lpush(row, tags=[]),lpush_col(col, header=None)
是对列的相关操作
pop(),rpop(),rpush(row, tags=[]),rpush_col(col, header=None)
是对行的相关操作
remove_duplicates() 去除重复的记录
sort(col, reverse=False) 根据列进行排序
subset(rows=None, cols=None) 返回子Dataset
wipe() 清空Dataset,包括表头和内容

新增列

>>> data.append_col((90, 67, 83), header='age')

这样表就变成了:

first_namelast_nameage
JohnAdams90
GeorgeWashington67
HenryFord83
>>> print(data)
First Name|Last Name |age
----------|----------|---
John      |Adams     |90
George    |Washington|67
Henry     |Ford      |83 

对记录操作

>>> print(data[:2])
[('John', 'Adams', 90), ('George', 'Washington', 67)]
>>> print(data[2:])
[('Henry', 'Ford', 83)]

对属性操作

>>> print(data['first_name'])
['John', 'George', 'Henry']

>>> print(data)
First Name|Last Name |age
----------|----------|---
John      |Adams     |90
George    |Washington|67
Henry     |Ford      |83
>>> data.get_col(1)
['Adams', 'Washington', 'Ford'] 

删除记录

>>> del data[1]
>>> print(data)
First Name|Last Name|age
----------|---------|---
John      |Adams    |90
Henry     |Ford     |83 

可见记录也是从0开始索引的

删除记录操作也支持切片

删除属性

del data['Col Name']

导入数据

imported_data = tablib.Dataset().load(open('data.csv').read())

导出数据

csv

>>> data.csv
'First Name,Last Name,age\r\nJohn,Adams,90\r\nHenry,Ford,83\r\n'
>>> print(data.csv)
First Name,Last Name,age
John,Adams,90
Henry,Ford,83 
>> f = open('data.csv', 'w', encoding='utf-8')
>> f.write(data.csv)
>> f.close() 

这样便可成功将数据导出为csv文件。

json

>>> data.json
'[{"First Name": "John", "Last Name": "Adams", "age": 90}, {"First Name": "Henry", "Last Name": "Ford", "age": 83}]'
>>> print(data.json)
[{"First Name": "John", "Last Name": "Adams", "age": 90}, {"First Name": "Henry", "Last Name": "Ford", "age": 83}] 
>> f = open('data.json', 'w', encoding='utf-8')
>> f.write(data.json)
>> f.close()  

yaml

>>> data.yaml
'- {First Name: John, Last Name: Adams, age: 90}\n- {First Name: Henry, Last Name: Ford, age: 83}\n'
>>> print(data.yaml)
- {First Name: John, Last Name: Adams, age: 90}
- {First Name: Henry, Last Name: Ford, age: 83} 
>> f = open('data.yaml', 'w', encoding='utf-8')
>> f.write(data.yaml)
>> f.close()   

excel

>>> with open('people.xls', 'wb') as f:
...     f.write(data.xls) 

注意要以二进制形式打开文件

dbf

>>> with open('people.dbf', 'wb') as f:
...     f.write(data.dbf) 

高级使用

动态列

可以将一个函数指定给Dataset对象

import random

def random_grade(row):
    """Returns a random integer for entry."""
    return (random.randint(60,100)/100.0)

data.append_col(random_grade, header='Grade')

>>> data.yaml
- {Age: 22, First Name: Kenneth, Grade: 0.6, Last Name: Reitz}
- {Age: 20, First Name: Bessie, Grade: 0.75, Last Name: Monke} 

函数的参数row传入的是每一行记录,所以可以根据传入的记录进行更一步的计算:

def guess_gender(row):
	"""Calculates gender of given student data row."""
	m_names = ('Kenneth', 'Mike', 'Yuri')
	f_names = ('Bessie', 'Samantha', 'Heather')
	name = row[0]
	if name in m_names:
		return 'Male'
	elif name in f_names:
		return 'Female'
	else:
		return 'Unknown'
>>> data.yaml
- {Age: 22, First Name: Kenneth, Gender: Male, Last Name: Reitz}
- {Age: 20, First Name: Bessie, Gender: Female, Last Name: Monke}

tag

可以给记录添加tag,之后通过tag来过滤记录:

students = tablib.Dataset()
students.headers = ['first', 'last']
students.rpush(['Kenneth', 'Reitz'], tags=['male', 'technical'])
students.rpush(['Bessie', 'Monke'], tags=['female', 'creative'])
>>> students.filter(['male']).yaml
- {first: Kenneth, Last: Reitz}

3.举个小例子

现在有一个场景,我们需要将一份股票数据csv文件转化为json数据:

你只需要这样操作:

import tablib

data = tablib.Dataset().load(open('1.csv').read())

with open('data.json', 'w', encoding='utf-8') as f:
    f.write(data.json)

即可将其转化为json格式,它的特点在于轻量、简单。Pandas如果用来做这样的转化,则有些大材小用。

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

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

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

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

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

Python 数据分析与挖掘好帮手—Anaconda

用Python进行数据分析的时候,你会不会烦恼要安装那么多的模块?比如Pandas、Numpy、matplotlib、scipy等等,而当你接手的项目是由不同的Python版本编写的时候你又得下载那个Python版本,然后安装所需要的依赖,非常麻烦。

而使用Anaconda则能减少许多这样的烦恼,因为Anaconda具有以下特点:

1.自带180多个科学包,包括conda、numpy、scipy、pandas等。

2.极其方便的环境管理工具,可以创建**任意**版本的Python虚拟环境

为什么第2点的任意要加粗呢?其他的虚拟环境管理工具,如virtualenv是无法随意选择Python版本构建虚拟环境的,它们只能使用目前电脑上已有的Python版本构建虚拟环境。而Anaconda的环境管理工具则可以任意选择Python版本,它会自动下载相应的Python版本到虚拟环境中,免去用户自己手动下载安装Python的麻烦。

1.安装Anaconda

首先,前往Anaconda官方下载地址:
https://www.anaconda.com/distribution/#download-section

选择最新版本的Anaconda进行下载,要注意选择 64-Bit Graphical Installer. 当然这里指的只是Anaconda的默认Python版本,安装成功后,你可以创建任意版本的Python虚拟环境。

安装的过程中一路默认即可,不过如果是Windows用户,建议不要将Anaconda装在C盘,否则随着安装的包越来越多,会出现C盘空间不足的情况。

Windows用户注意:如果在 “Advanced Installation Options”中没有勾选“Add Anaconda to my PATH environment variable.”(添加Anaconda至我的环境变量),则无法在CMD或者powershell中使用conda命令,需要打开菜单中的 Anaconda Prompt 才能使用conda命令,因此请各位根据自己的情况选择勾不勾选。如果没勾选,但是后来又反悔了,可以通过配置环境变量来解决这个问题:

此处借用了别人的图,请注意路径要换成自己的路径。

相比之下,macOS系统就没有这么多繁琐的操作了,在终端(Terminal)中即可使用conda命令。

2.修改镜像源

这点很关键,由于conda默认镜像源是国外的,因此你 pip install 或者 conda install 安装模块的时候可能会等待非常久,如果你不想装个包比敲代码花费的时间还长,请一定要修改镜像源。

首先,在CMD(Windows)或Terminal(macOS)中,输入:

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --set show_channel_urls yes

Windows用户前往目录 C:\Users<你的用户名> 下显示隐藏文件会看到配置文件.condarc .

macOS用户则是在 ~/.condarc 中,可以在终端中用 sudo open ~/.condarc 打开。

然后会看到文件内容类似:

channels:
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
  - defaults
show_channel_urls: true

– defaults 就是原来的源,我们可以直接把它去掉(建议去掉),只用清华源。然后保存,重启终端即可。

3.使用及切换环境

到这里,我们就可以开始使用conda环境了,默认情况下,现在Python命令都是基于conda的,因此你的终端或CMD前都会带有(base)的字样:

如果没有的话,可能是你在安装的时候把 “Register Anaconda as my default Python 3.7”去掉了。没关系,我们也可以用以下命令切换环境,Windows下在CMD中使用:

activate base

可切换到Anaconda默认环境, macOS和Linux则是:

conda activate base

其实两者是一样的原理,均通过conda来控制环境的使用。因为Windows中,输入完activate base后,它会自动补全一句conda.bat activate base, 如下图所示​:

在base环境下,默认自带pandas等180+个科学工具包,因此如果没有特别的需求,在这个环境下进行数据分析的开发即可。

4.创建虚拟环境

理想情况下,一直在base环境下开发是美滋滋的,但有时候我们会遇到开发的项目需要特别的版本,甚至是上古时期的2.x版本,这个时候anaconda强大之处也体现出来了,比如我的项目是 old_git, 需要Python2.7版本:

conda create --name old_git python=2.7

这时候便创建了一个python2.7的环境,叫做old_git,通过调用

activate old_git
# macOS/Linux则输入: conda activate old_git 

即可切换到这个环境,不过注意,这个新的环境是没有自带180+个科学工具包的,你需要自行安装所需模块。

5.其他命令

最常用的是显示已创建环境:

conda info --envs

其次是删除环境:

conda remove --name 环境名 --all

(由于我这里环境都比较重要就不演示了)

最后是安装包:

conda install xxx

其实conda install 和 pip install 都能达到安装包的效果,区别在于,前者使用conda的镜像源,后者使用pip镜像源。一般而言,推荐pip install,因为包更全一点。

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

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

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

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

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

Python 提取音乐频谱并可视化

你有没有经常好奇一些音乐软件的频谱特效是怎么做的,为什么做的这么好看?有没有想试试自己提取音乐频谱并可视化展现出来?今天,咱就结合上次的音乐剪辑操作:

Python 剪辑音乐就是这么简单

来可视化下面这首歌曲的频谱!

https://pythondict-1252734158.file.myqcloud.com/home/www/pythondict/wp-content/uploads/2020/04/2020040520354021.mp3

1.准备工作

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

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

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

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

pip install pydub
pip install librosa

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

2.频谱展示

使用librosa和matplot,我们可以用10行代码完整地展示整个频谱:

import matplotlib.pyplot as plt
import librosa.display

# 音乐文件载入
audio_path = 'Fenn.mp3'
music, sr = librosa.load(audio_path)

# 宽高比为14:5的图
plt.figure(figsize=(14, 5))
librosa.display.waveplot(music, sr=sr)

# 显示图
plt.show()

不过,这样的频谱是整段音乐的,看起来非常难看,接下来我们使用 pydub 切割频谱,以获得更佳的效果。我们细分到0到1秒的区段来查看频谱:

import matplotlib.pyplot as plt
import librosa.display
import numpy as np
from pydub import AudioSegment

# 1秒=1000毫秒
SECOND = 1000
# 音乐文件
AUDIO_PATH = 'Fenn.mp3'

def split_music(begin, end, filepath):
    # 导入音乐
    song = AudioSegment.from_mp3(filepath)
    
    # 取begin秒到end秒间的片段
    song = song[begin*SECOND: end*SECOND]
    
    # 存储为临时文件做备份
    temp_path = 'backup/'+filepath
    song.export(temp_path)

    return temp_path

music, sr = librosa.load(split_music(0, 1, AUDIO_PATH))

# 宽高比为14:5的图
plt.figure(figsize=(14, 5))
librosa.display.waveplot(music, sr=sr)
plt.show() 

这下细是细了,但是还是太复杂了,其实我们做频谱的展示,只需要正值即可:

然后我们还可以进一步放大,比如说0.9秒到1秒之间的频谱:

# 放大
n0 = 9000
n1 = 10000

music = np.array([mic for mic in music if mic > 0])
plt.figure(figsize=(14, 5))
plt.plot(music[n0:n1])
plt.grid()

# 显示图
plt.show() 

这样好看许多,不过如果要达成QQ音乐那种效果,还是需要进行大量改造。

比如用精美的图像元素来填充替代、然后零值如何处理?如何让频谱更加平稳?此外,我们是静态的图像,还需要根据事件动态地延续波段。

用于生产的代码肯定比我们这简易的代码更加复杂,而且也不应该是暴力去除负值绘制图像。这些有兴趣的读者可以自行研究啦。

音乐相关教程:

Python 批量下载网易云音乐歌单

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

Python Django快速开发音乐高潮提取网(1)

Python Django快速开发音乐高潮提取网(2)

Python Django快速开发音乐高潮提取网(3)

Python 超方便超快速剪辑音乐

Python 提取音乐频谱并可视化

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

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

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

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

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

有趣好用的Python教程

退出移动版
微信支付
请使用 微信 扫码支付