所有由Python实用宝典发布的文章

量化投资

手把手教你使用QMT实现全自动买卖股票的策略

留下评论

很多玩股票的朋友都希望能通过计算机来自动买入卖出股票，这样的作法在美股中很常见，但在A股由于监管的问题，从前我们的做法是通过Easytrader来实现股票的自动买入和卖出，但是这种做法会让交易时延达到1秒左右，而现在，通过QMT我们能直接将这1秒的延迟直接消除。

通过QMT的交易接口，我们能实现毫秒级的交易时延，比Easytrader速度快不少。这非常重要，要知道对于交易热门的股票，差1秒，买入价差可能就差5档。

本文将教大家如何使用QMT进行基础的简单买入卖出和撤单的功能，在本文的最后会介绍仅需3万门槛且起步仅0.5元的QMT开通通道。

1.下载并使用QMT程序

QMT程序可以在我们公众号后台回复 QMT 下载。

下载登陆后，请先安装Python，在设置->模型设置中，点击Python库下载即可：

然后，要实现自动交易的功能，我们必须在模型研究中，新建一个策略：

然后就会弹出一个策略的编辑器，在这里会编辑我们的买入卖出策略：

 

 

2.QMT基本函数介绍

QMT的基本执行结构是：

# 公众号：二七阿尔量化

def init(ContextInfo):
	ContextInfo.accID = '你的账号ID'
    
def handlebar(ContextInfo):
    # 处理K线
    pass

下面会一步一步地讲解如何基于这个基本结构制作我们的根据信号买入卖出策略。

定时器

定时器是我们实现毫秒级策略的基础。在QMT中，执行是按照K线来的，比如分钟K线，日线等K线类型，新的一根bar到来后，就进入handle_bar函数被用户处理。但是这样按K线执行的逻辑有一个严重的问题，那就是无法执行秒级、毫秒级的策略。

如果你需要执行毫秒级的策略，就需要用到定时器了：

# 公众号：二七阿尔量化
ContextInfo.run_time("buy_logic", "100nMilliSecond", "2019-10-14 13:20:00")

这行代码的意思便是从2019-10-14 13:20:00开始，每隔100毫秒执行一次 buy_logic 函数。

只需要把这行代码放在 init 函数下，便会启动定时器。

买入卖出

首先介绍如何在QMT中实现自动买入卖出。QMT的买入卖出函数都是 passorder，通过传参实现不同的操作，比如：

passorder(23, 1102, account_id, "002587", 11, 6.80, 55000, "concepts_main", 1, "", ContextInfo)

看不懂不要紧，我们先往下看。

对于股票交易，它的参数列表如下：

passorder(opType, orderType, accountid, orderCode, prType, modelprice, volume, strategyName, quickTrade, ContextInfo)

opType: 我们上述例子中 opType 为 23，意思为 股票买入，或沪港通、深港通股票买入。对于股票的交易，它只有两种选项：

23: 股票买入，或沪港通、深港通股票买入
24: 股票卖出，或沪港通、深港通股票卖出

orderType: 这个参数是能让你指定 按股买入/按金额买入/按总资产比例买入/按可用比例买入某只股票，非常好用：

1101: 单股、单账号、普通、股/手方式下单(ETF申赎只能用此参数)
1102: 单股、单账号、普通、金额（元）方式下单（只支持股票）
1113: 单股、单账号、总资产、比例[0~1]方式下单
1123: 单股、单账号、可用、比例[0~1]方式下单

account_id: 用户ID，即你的股票账户名。

orderCode: 股票代码，不要添加任何后缀。

prType: 下单选价类型，可以选择以下委托方式

0:卖5价
1:卖4价
2:卖3价
3:卖2价
4:卖1价
5:最新价
6:买1价
7:买2价(组合不支持)
8:买3价(组合不支持)
9:买4价(组合不支持)
10:买5价(组合不支持)
11:（指定价）模型价（只对单股情况支持,对组合交易不支持）
12:涨跌停价
13:挂单价
14:对手价
26:限价即时全部成交否则撤单[上交所|深交所][期权]
27:市价即成剩撤[上交所][期权]
28:市价即全成否则撤[上交所][期权]
29:市价剩转限价[上交所][期权]
42:最优五档即时成交剩余撤销申报[上交所][股票]
43:最优五档即时成交剩转限价申报[上交所][股票]
44:对手方最优价格委托[深交所][股票][期权]
45:本方最优价格委托[深交所][股票][期权]
46:即时成交剩余撤销委托[深交所][股票][期权]
47:最优五档即时成交剩余撤销委托[深交所][股票][期权]
48:全额成交或撤销委托[深交所][股票][期权]

请注意，在今天全面注册制后，正常交易存在价格笼子（挂单最多只能在当前最新价上浮动2%），所以除了在集合竞价中使用涨跌停价(12)，其他情况都不要使用。

modelprice: 指定买入价格，只有当prType是模型价时price有效；其它情况无效。

volume: 决定买入的量，根据orderType值最后一位确定volume的单位：

# 当orderType最后一位为：
1：股/手
2：金额（元）
3：比例

strategyName: 策略名称，按你喜好来定即可

quickTrade: 是否立马触发下单，0 否，1 是

ContextInfo: QMT的上下文，必须传递，保持变量不变即可。

然后我们再回过头来看这行代码：

# 公众号: 二七阿尔量化
passorder(23, 1102, account_id, "002587", 11, 6.80, 55000, "concepts_main", 1, "", ContextInfo)

它的意思是，用户(参数2) 以指定金额的方式(参数1) 买入(参数0) 股票002587(参数3), 按照指定价(参数4) 6.80 元的价格(参数5), 希望可以成交 55000 元(参数6).

现在，不看我的答案的情况下，尝试理解下面这行卖出代码：

# 公众号: 二七阿尔量化
passorder(24, 1123, account_id, "002587", 12, 0, 1, "concepts_main", 1, "", ContextInfo)

答案是用户(参数2) 以可用比例的方式(参数1) 卖出(参数0) 股票002587(参数3), 按照涨跌停价(参数4) (参数5随意), 希望可以 100% (参数6) 成交。

获取仓位

仓位的获取也很简单，只需要传递account_id，第二个参数指定 “STOCK”(股票), 第三个参数指定为”POSITION”(仓位)即可：

# 公众号: 二七阿尔量化
positions = get_trade_detail_data(account_id, "STOCK", "POSITION")

获取委托

委托列表和仓位列表的获取方式都是通过get_trade_detail_data函数，只不过第三个参数改为”ORDER”

# 公众号: 二七阿尔量化
get_trade_detail_data(account_id, "STOCK", "ORDER"):

3.QMT买入、卖出、撤单并行运行

如果你希望一个线程检测是否买入某只股票、另一个线程检测是否需要撤单，还有一个线程进行卖出操作，那么你可以这么做：

# encoding:gbk
# 公众号: 二七阿尔量化
import time
import datetime


account_id = ""
def init(ContextInfo):
    ContextInfo.accID = account_id
    ContextInfo.max_buy = 3
    ContextInfo.run_time("buy_logic", "100nMilliSecond", "2019-10-14 13:20:00", 'SZ')
    ContextInfo.run_time("cancel_logic", "1000nMilliSecond", "2019-10-14 13:20:00", 'SZ')
    ContextInfo.run_time("sell_logic", "300nMilliSecond", "2019-10-14 13:20:00", 'SZ')


def handlebar(ContextInfo):
    pass


def buy_logic(ContextInfo):
    """
    你的买入逻辑
    """
    pass

def cancel_logic(ContextInfo):
    """
    你的撤单逻辑
    """
    pass

def sell_logic(ContextInfo):
    """
    你的卖出逻辑
    """
    pass

这三个run_time的意思是分别按每100毫秒执行买入逻辑、每1秒执行撤单逻辑，每300毫秒执行卖出逻辑。

只需要一个程序就能完成这三件事，用过Easytrader的同学一下就会明白这比Easytrader好用多了。

我们有一个相对完整的根据信号买入卖出的代码，在开户入金完成后，公众号后台回复：QMT代码 联系我获取代码。

4.运行QMT自动买入卖出程序

填充完你的各种逻辑后，保存程序，点击模型交易

选择左上角的新建策略交易，找到你刚刚保存的策略：

选择好账号类型和资金账号，确定后便可以准备开始运行策略，点击运行模式可以切换实盘/模拟盘。点击操作里的三角形便可以启动策略。

如果你是按本文定时器的方法使用QMT，你不需要在意策略周期。

本文对QMT的基本介绍结束，根据我这半个月的使用经历，我认为QMT对于我们量化交易而言是非常值得使用的，平均成交时间会比Easytrader方法快1秒左右。此外也不需要开启多个Easytrader进程去按键精灵般点点点，基本不会出现报错的情况。

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

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

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

我要打赏
给作者打赏，选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义
立即支付

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

Python 办公、云开发、工具、开发工具、生活智能化

Python 企业微信群通知原来这么简单

留下评论

上次介绍了如何通过钉钉进行群通知，有同学反馈自己更习惯使用企业微信或公司使用了企业微信，希望也能出个基于Python的企业微信的群通知教程，于是便有了本文。

事实上两者的配置方法和使用方法非常相似，都是通过机器人进行通知，下面就教大家如何使用Python对企业微信进行群通知。

1.准备

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

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

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

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

pip install requests

2.配置企业微信机器人

为了能够通过Python发送企业微信通知，首先我们需要在企业微信群聊（这个群里可以只有你和机器人）中添加一个群机器人：

然后填写机器人名称：

最后会获得一个webhook地址：

通过这个webhook地址，我们就能通过Python给企业微信发送通知了。

3.Python 发送企业微信通知

通过requests模块对webhook地址发送post请求就能发送通知：

# 公众号：Python实用宝典
import requests
def send_weixin(content):
    url = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=你的webhook密钥"  # 这里就是群机器人的Webhook地址
    headers = {"Content-Type": "application/json"}  # http数据头，类型为json
    data = {
        "msgtype": "text",
        "text": {
            "content": content,  # 让群机器人发送的消息内容。
            "mentioned_list": [],
        }
    }
    r = requests.post(url, headers=headers, json=data)  # 利用requests库发送post请求
send_weixin("人工智能: 175")

效果如下：

在 menthoned_list 参数中，你还可以增加 @所有人 的选项：

# 公众号：Python实用宝典
import requests
def send_weixin(content):
    url = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=你的webhook密钥"  # 这里就是群机器人的Webhook地址
    headers = {"Content-Type": "application/json"}  # http数据头，类型为json
    data = {
        "msgtype": "text",
        "text": {
            "content": content,  # 让群机器人发送的消息内容。
            "mentioned_list": ["@all", ],  # @全体成员
        }
    }
    r = requests.post(url, headers=headers, json=data)  # 利用requests库发送post请求
send_weixin("人工智能: 175")

这样会在消息发出的同时，提醒所有人查看信息。

此外，机器人的msgtype支持文本（text）、markdown（markdown）、图片（image）、图文（news）四种消息类型。

Markdown的发送方法如下：

# 公众号：Python实用宝典
import requests
def send_weixin_md(content):
    url = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=你的webhook密钥"  # 这里就是群机器人的Webhook地址
    headers = {"Content-Type": "application/json"}  # http数据头，类型为json
    data = {
        "msgtype": "markdown",
        "markdown": {
            "content": content,
            "mentioned_list": ["@all", ],  # @全体成员
        }
    }
    r = requests.post(url, headers=headers, json=data)  # 利用requests库发送post请求
send_weixin("实时新增用户反馈<font color=\"warning\">132例</font>，请相关同事注意。\n
         >类型:<font color=\"comment\">用户反馈</font>
         >普通用户反馈:<font color=\"comment\">117例</font>
         >VIP用户反馈:<font color=\"comment\">15例</font>")

如果你需要发单独的图片，请使用image类型，并将图片的md5和base64传入到image参数，完整的data的格式如下：

# 公众号：Python实用宝典
import requests
def send_weixin_images(MD5, base64data):
    url = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=你的webhook密钥"  # 这里就是群机器人的Webhook地址
    headers = {"Content-Type": "application/json"}  # http数据头，类型为json
    data = {
        "msgtype": "image",
        "image": {
            "base64": base64data,
            "md5": MD5
        }
    }
    r = requests.post(url, headers=headers, json=data)  # 利用requests库发送post请求
send_weixin(MD5, base64data)

注：图片（base64编码前）最大不能超过2M，支持JPG,PNG格式，效果如下：

图文类型你只需要配置图片、说明文字及跳转链接，也非常方便：

# 公众号：Python实用宝典
import requests
def send_weixin_images(title, description, url, picurl):
    url = "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=你的webhook密钥"  # 这里就是群机器人的Webhook地址
    headers = {"Content-Type": "application/json"}  # http数据头，类型为json
    data = {
        "msgtype": "news",
        "news": {
           "articles" : [
               {
                   "title" : title,
                   "description" : description,
                   "url" : url, 
                   "picurl" : picurl
               }
            ]
        }
    }
    r = requests.post(url, headers=headers, json=data)  # 利用requests库发送post请求
send_weixin("中秋节礼品领取", "今年中秋节公司有豪礼相送", "www.qq.com", "http://res.mail.qq.com/node/ww/wwopenmng/images/independent/doc/test_pic_msg1.png")

怎么样，上述四种通知类型中有你需要的吗？有的话就赶快拿去使用吧！

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

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

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

我要打赏
给作者打赏，选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义
立即支付

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

Python 数据分析、开发工具、性能优化

教你纯原生实现Redis简易客户端(绕过Qmt白名单)

留下评论

Redis 是我们在开发过程中经常会用到的内存数据库，尤其是在Python的第三方模块Redis-py的支持下，在Python中使用Redis及其方便。

但是在有些情况下，我们无法使用像Redis-py这样的第三方模块（比如QMT），这时候就需要自己实现一个简易版的Redis-py了。

本文将教大家如何用20行代码，制作一个简易版的Redis客户端，不过仅以GET命令为例，其他命令的用法也差不多。

1.准备

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

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

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

2.原理剖析

其实通过Redis GET返回的数据就是一些字符串，这些字符串的格式如下：

b'$466\r\n\x80\x04\x95\xc7\x01\x00\x00\x00\x00\x00\x00]\x94(\x8c\x06000957\x94\x8c\x06002031\x94\x8c\x06000899\x94\x8c\x06300339\x94\x8c\x06002090\x94\x8c\x06601016\x94\x8c\x06002547\x94\x8c\x06002863\x94\x8c\x06002591\x94\x8c\x06002514\x94\x8c\x06000629\x94\x8c\x06002204\x94\x8c\x06000544\x94\x8c\x06002374\x94\x8c\x06000821\x94\x8c\x06000625\x94\x8c\x06000158\x94\x8c\x06002703\x94\x8c\x06002866\x94\x8c\x06600686\x94\x8c\x06002796\x94\x8c\x06300598\x94\x8c\x06002101\x94\x8c\x06002454\x94\x8c\x06000970\x94\x8c\x06000631\x94\x8c\x06002121\x94\x8c\x06600348\x94\x8c\x06600996\x94\x8c\x06002080\x94\x8c\x06002194\x94\x8c\x06002466\x94\x8c\x06300663\x94\x8c\x06002616\x94\x8c\x06000665\x94\x8c\x06600992\x94\x8c\x06300750\x94\x8c\x06300059\x94\x8c\x06002047\x94\x8c\x06002997\x94\x8c\x06000521\x94\x8c\x06002594\x94\x8c\x06002261\x94\x8c\x06002125\x94\x8c\x06002085\x94\x8c\x06002168\x94\x8c\x06002665\x94\x8c\x06002523\x94\x8c\x06603067\x94\x8c\x06002432\x94e.\r\n'

可见其是一个bytes字符串，开头$xxx是此数据的长度，\r\n作为分割符，后面紧跟着的就是你的原始数据内容，最后才是\r\n作为结尾。

根据这个返回内容，我们就可以制作一个简易的客户端用于在无法引用第三方模块的环境中接收Redis信息。

3.编写简易Redis客户端

与Redis通信，我们只需要用Python原生的socket模块即可。

import socket
import pickle

REDIS_HOST = "127.0.0.1"
REDIS_PORT = 6379
# 创建 socket 对象
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接服务，指定主机和端口
s.connect((REDIS_HOST, REDIS_PORT))
s.close()

这样就与你的Redis服务器连接上了，接下来只需要向socket发送你的命令并receive即可获取对应的内容：

import socket
import pickle

REDIS_HOST = "127.0.0.1"
REDIS_PORT = 6379
# 创建 socket 对象
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接服务，指定主机和端口
s.connect((REDIS_HOST, REDIS_PORT))
# GET 某个 KEY 的内容
s.send("GET RQB_keys_20220719 \r\n".encode("utf-8"))
# 接收小于 1M 的数据
msg = s.recv(1024 * 1024) 
s.close()
print(msg)
# b'$466\r\n\x80\x04\x95\xc7\x01\x00\x00\x00\x00\x00\x00]\x94(\x8c\x06000957\x94\x8c\x06002031\x94\x8c\x06000899\x94\x8c\x06300339\x94\x8c\x06002090\x94\x8c\x06601016\x94\x8c\x06002547\x94\x8c\x06002863\x94\x8c\x06002591\x94\x8c\x06002514\x94\x8c\x06000629\x94\x8c\x06002204\x94\x8c\x06000544\x94\x8c\x06002374\x94\x8c\x06000821\x94\x8c\x06000625\x94\x8c\x06000158\x94\x8c\x06002703\x94\x8c\x06002866\x94\x8c\x06600686\x94\x8c\x06002796\x94\x8c\x06300598\x94\x8c\x06002101\x94\x8c\x06002454\x94\x8c\x06000970\x94\x8c\x06000631\x94\x8c\x06002121\x94\x8c\x06600348\x94\x8c\x06600996\x94\x8c\x06002080\x94\x8c\x06002194\x94\x8c\x06002466\x94\x8c\x06300663\x94\x8c\x06002616\x94\x8c\x06000665\x94\x8c\x06600992\x94\x8c\x06300750\x94\x8c\x06300059\x94\x8c\x06002047\x94\x8c\x06002997\x94\x8c\x06000521\x94\x8c\x06002594\x94\x8c\x06002261\x94\x8c\x06002125\x94\x8c\x06002085\x94\x8c\x06002168\x94\x8c\x06002665\x94\x8c\x06002523\x94\x8c\x06603067\x94\x8c\x06002432\x94e.\r\n'

请注意，recv里你设定的大小会直接占用内存，所以请设定一个适宜的数目，或者从返回值中的美元符后的数字判断你需要接收的数据大小。

比如第一次请求，你只接收1024个字节，拿到 $xxx 这个长度后，重新send一次命令，再 s.recv(xxx) 长度。

上述例子中得到的内容是redis的格式，我们需要把\r\n给去除掉，并只取中间的数据便是我们存入redis的原始数据。

import pickle
def get_msg(msg):
    msg_new = msg.split(b"\r\n")[1]
    msg = pickle.loads(msg_new)
    return msg

因为我的原始内容是pickle格式，因此我在取出原始数据后使用pickle.loads便能拿到我想要的内容，完整代码如下：

import socket
import pickle

REDIS_HOST = "127.0.0.1"
REDIS_PORT = 6379
# 创建 socket 对象
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接服务，指定主机和端口
s.connect((REDIS_HOST, REDIS_PORT))
# GET 某个 KEY 的内容
s.send("GET RQB_keys_20220719 \r\n".encode("utf-8"))
# 接收小于 1M 的数据
msg = s.recv(1024 * 1024) 
s.close()

def get_msg(msg):
    msg_new = msg.split(b"\r\n")[1]
    msg = pickle.loads(msg_new)
    return msg

print(get_msg(msg))

效果如下：

['000957', '002031', '000899', '300339', '002090', '601016', '002547', '002863', '002591', '002514', '000629', '002204', '000544', '002374', '000821', '000625', '000158', '002703', '002866', '600686', '002796', '300598', '002101', '002454', '000970', '000631', '002121', '600348', '600996', '002080', '002194', '002466', '300663', '002616', '000665', '600992', '300750', '300059', '002047', '002997', '000521', '002594', '002261', '002125', '002085', '002168', '002665', '002523', '603067', '002432']

在QMT等会限制第三方模块的软件中，使用这样的方式访问Redis，就不会再遇到白名单的限制了。

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

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

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

我要打赏
给作者打赏，选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义
立即支付

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

Python 数据分析

Polars 速度极快的数据处理第三方模块

留下评论

Polars 是一个速度极快的 DataFrames 库。

它拥有以下特性：

1.多线程

2.强大的表达式API

3.查询优化

下面给大家简单介绍一下这个模块的使用方式。

1.准备

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

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

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

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

pip install polars

2.Polars 使用介绍

在初始化变量的时候，Polars用起来的方式和Pandas没有太大区别，下面我们定义一个初始变量，后面所有示例都使用这个变量：

import polars as pl
df = pl.DataFrame(
    {
        "A": [1, 2, 3, 4, 5],
        "fruits": ["banana", "banana", "apple", "apple", "banana"],
        "B": [5, 4, 3, 2, 1],
        "cars": ["beetle", "audi", "beetle", "beetle", "beetle"],
    }
)

选择需要展示的数据：

(df.select([
    pl.col("A"),
    "B",      # the col part is inferred
    pl.lit("B"),  # we must tell polars we mean the literal "B"
    pl.col("fruits"),
]))

效果如下：

他还能使用正则表达式筛选值并进行求和等操作：

# 正则表达式
(df.select([
    pl.col("^A|B$").sum()
]))
# 或者多选
(df.select([
    pl.col(["A", "B"]).sum()
]))

Polars支持下面这样复杂且高效的查询及展示：

>>> df.sort("fruits").select(
...     [
...         "fruits",
...         "cars",
...         pl.lit("fruits").alias("literal_string_fruits"),
...         pl.col("B").filter(pl.col("cars") == "beetle").sum(),
...         pl.col("A").filter(pl.col("B") > 2).sum().over("cars").alias("sum_A_by_cars"),
...         pl.col("A").sum().over("fruits").alias("sum_A_by_fruits"),
...         pl.col("A").reverse().over("fruits").alias("rev_A_by_fruits"),
...         pl.col("A").sort_by("B").over("fruits").alias("sort_A_by_B_by_fruits"),
...     ]
... )
shape: (5, 8)
┌──────────┬──────────┬──────────────┬─────┬─────────────┬─────────────┬─────────────┬─────────────┐
│ fruits   ┆ cars     ┆ literal_stri ┆ B   ┆ sum_A_by_ca ┆ sum_A_by_fr ┆ rev_A_by_fr ┆ sort_A_by_B │
│ ---      ┆ ---      ┆ ng_fruits    ┆ --- ┆ rs          ┆ uits        ┆ uits        ┆ _by_fruits  │
│ str      ┆ str      ┆ ---          ┆ i64 ┆ ---         ┆ ---         ┆ ---         ┆ ---         │
│          ┆          ┆ str          ┆     ┆ i64         ┆ i64         ┆ i64         ┆ i64         │
╞══════════╪══════════╪══════════════╪═════╪═════════════╪═════════════╪═════════════╪═════════════╡
│ "apple"  ┆ "beetle" ┆ "fruits"     ┆ 11  ┆ 4           ┆ 7           ┆ 4           ┆ 4           │
│ "apple"  ┆ "beetle" ┆ "fruits"     ┆ 11  ┆ 4           ┆ 7           ┆ 3           ┆ 3           │
│ "banana" ┆ "beetle" ┆ "fruits"     ┆ 11  ┆ 4           ┆ 8           ┆ 5           ┆ 5           │
│ "banana" ┆ "audi"   ┆ "fruits"     ┆ 11  ┆ 2           ┆ 8           ┆ 2           ┆ 2           │
│ "banana" ┆ "beetle" ┆ "fruits"     ┆ 11  ┆ 4           ┆ 8           ┆ 1           ┆ 1           │
└──────────┴──────────┴──────────────┴─────┴─────────────┴─────────────┴─────────────┴─────────────┘

3.Polars 高级使用

倒序操作，将值倒序后重新放回变量中，起名为xxx_reverse：

(df.select([
    pl.all(),
    pl.all().reverse().suffix("_reverse")
]))

对所有列求和，并放回变量中，起名为 xxx_sum：

(df.select([
    pl.all(),
    pl.all().sum().suffix("_sum")
]))

正则也能用于筛选：

predicate = pl.col("fruits").str.contains("^b.*")

(df.select([
    predicate
]))

在设定一个新列的时候，甚至可以根据条件来给不同的行设定值：

(df.select([
    "fruits",
    "B",
    pl.when(pl.col("fruits") == "banana").then(pl.col("B")).otherwise(-1).alias("b")
]))

fold 函数很强大，它能在列上执行操作，获得最快的速度，也就是矢量化执行：

df = pl.DataFrame({
        "a": [1, 2, 3],
        "b": [10, 20, 30],
    }
)

out = df.select(
    pl.fold(acc=pl.lit(0), f=lambda acc, x: acc + x, exprs=pl.col("*")).alias("sum"),
)
print(out)
#shape: (3, 1)
#┌─────┐
#│ sum │
#│ --- │
#│ i64 │
#╞═════╡
#│ 11  │
#├╌╌╌╌╌┤
#│ 22  │
#├╌╌╌╌╌┤
#│ 33  │
#└─────┘

Polars 还有许多其他有用的特性，大家感兴趣的可以访问他们的用户手册进行阅读和学习：

https://pola-rs.github.io/polars-book/user-guide

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

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

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

我要打赏
给作者打赏，选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义
立即支付

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

Python绘图、人工智能、深度学习

教你一行代码自动绘制艺术画 (Discoart)

留下评论

DiscoArt 是一个很牛逼的开源模块，它能根据你给定的关键词自动绘画。

绘制过程是完全可见的，你可以在 jupyter 页面上看见这个绘制的过程：

1.准备

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

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

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

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

pip install discoart

为了运行 Discoart， 你需要Python 3.7+ 和支持 CUDA 的 PyTorch.

2.开始使用 Discoart

你可以在Jupyter中运行Discoart，这样能方便地实时展示绘制过程：

from discoart import create

da = create()

这样将使用默认的 文本描述 和参数创建图像：

text_prompts:
  - A beautiful painting of a singular lighthouse, shining its light across a tumultuous sea of blood by greg rutkowski and thomas kinkade, Trending on artstation.
  - yellow color scheme

init_image:
width_height: [ 1280, 768 ]

skip_steps: 0
steps: 250

init_scale: 1000
clip_guidance_scale: 5000

tv_scale: 0
range_scale: 150
sat_scale: 0
cutn_batches: 4

diffusion_model: 512x512_diffusion_uncond_finetune_008100
use_secondary_model: True
diffusion_sampling_mode: ddim

perlin_init: False
perlin_mode: mixed
seed:
eta: 0.8
clamp_grad: True
clamp_max: 0.05

randomize_class: True
clip_denoised: False
rand_mag: 0.05

cut_overview: "[12]*400+[4]*600"
cut_innercut: "[4]*400+[12]*600"
cut_icgray_p: "[0.2]*400+[0]*600"
cut_ic_pow: 1.

save_rate: 20
gif_fps: 20
gif_size_ratio: 0.5
n_batches: 4
batch_size: 1
batch_name:
clip_models:
  - ViT-B-32::openai
  - ViT-B-16::openai
  - RN50::openai
clip_models_schedules:

use_vertical_symmetry: False
use_horizontal_symmetry: False
transformation_percent: [0.09]

on_misspelled_token: ignore
diffusion_model_config:
cut_schedules_group:
name_docarray:
skip_event:
stop_event:
text_clip_on_cpu: False
truncate_overlength_prompt: False
image_output: True
visualize_cuts: False
display_rate: 1

创建出来的就是这个图：

Create 支持的所有参数如下：

text_prompts:
  - A beautiful painting of a singular lighthouse, shining its light across a tumultuous sea of blood by greg rutkowski and thomas kinkade, Trending on artstation.
  - yellow color scheme

init_image:
width_height: [ 1280, 768 ]

skip_steps: 0
steps: 250

init_scale: 1000
clip_guidance_scale: 5000

tv_scale: 0
range_scale: 150
sat_scale: 0
cutn_batches: 4

diffusion_model: 512x512_diffusion_uncond_finetune_008100
use_secondary_model: True
diffusion_sampling_mode: ddim

perlin_init: False
perlin_mode: mixed
seed:
eta: 0.8
clamp_grad: True
clamp_max: 0.05

randomize_class: True
clip_denoised: False
rand_mag: 0.05

cut_overview: "[12]*400+[4]*600"
cut_innercut: "[4]*400+[12]*600"
cut_icgray_p: "[0.2]*400+[0]*600"
cut_ic_pow: 1.

save_rate: 20
gif_fps: 20
gif_size_ratio: 0.5
n_batches: 4
batch_size: 1
batch_name:
clip_models:
  - ViT-B-32::openai
  - ViT-B-16::openai
  - RN50::openai
clip_models_schedules:

use_vertical_symmetry: False
use_horizontal_symmetry: False
transformation_percent: [0.09]

on_misspelled_token: ignore
diffusion_model_config:
cut_schedules_group:
name_docarray:
skip_event:
stop_event:
text_clip_on_cpu: False
truncate_overlength_prompt: False
image_output: True
visualize_cuts: False
display_rate: 1

你可以这么使用：

from discoart import create

da = create(
    text_prompts='A painting of sea cliffs in a tumultuous storm, Trending on ArtStation.',
    init_image='https://d2vyhzeko0lke5.cloudfront.net/2f4f6dfa5a05e078469ebe57e77b72f0.png',
    skip_steps=100,
)

如果你不是用jupyter运行的，你也可以看到中间结果，因为最终结果和中间结果都会被创建在当前工作目录下，即

./{name-docarray}/{i}-done.png
./{name-docarray}/{i}-step-{j}.png
./{name-docarray}/{i}-progress.png
./{name-docarray}/{i}-progress.gif
./{name-docarray}/da.protobuf.lz4
  • name-docarray是运行时定义的名称，如果没有定义，则会随机生成。
  • i-* 第几个Batch。
  • *-done-* 是当前Batch完成后的最终图像。
  • *-step-* 是某一步的中间图像，实时更新。
  • *-progress.png 是到目前为止所有中间结果的png图像，实时更新。
  • *-progress.gif 是到目前为止所有中间结果的动画 gif，实时更新。
  • da.protobuf.lz4 是到目前为止所有中间结果的压缩 protobuf，实时更新。

3.显示/保存/加载配置

如果你想知道你当前绘图的配置，有三种方法：

from discoart import show_config

show_config(da)  # show the config of the first run
show_config(da[3])  # show the config of the fourth run
show_config(
    'discoart-06030a0198843332edc554ffebfbf288'
)  # show the config of the run with a known DocArray ID

要保存 Document/DocumentArray 的配置：

from discoart import save_config

save_config(da, 'my.yml')  # save the config of the first run
save_config(da[3], 'my.yml')  # save the config of the fourth run

从配置中导入：

from discoart import create, load_config

config = load_config('my.yml')
create(**config)

此外，你还能直接把配置导出为图像的形式

from discoart.config import save_config_svg

save_config_svg(da)

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

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

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

我要打赏
给作者打赏，选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义
立即支付

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

量化投资

Bulbea 让你轻而易举实现股票的深度学习量化

留下评论

Bulbea 是一个基于深度学习开发的，用于股票市场预测和建模的Python库。

Bulbea 自带了不少可用于股票深度学习训练及测试的API，并且易于对数据进行扩展和延申，构建属于我们自己的数据及模型。

下面就来介绍一下这个模块。

1.准备

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

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

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

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

git clone https://github.com/achillesrasquinha/bulbea.git && cd bulbea
pip install -r requirements.txt
python setup.py install

如果你无法访问Github，请在二七阿尔量化后台回复Bulbea下载项目镜像（2022-11-28）.

此外，你还需要安装 Tensorflow 的CPU版本或GPU版本:

pip install tensorflow     # CPU 版本
pip install tensorflow-gpu # GPU 版本 - 需要 CUDA, CuDNN

2.Bulbea 基本使用方法

Bulbea 和普通的深度学习研究项目一样，在做训练和测试时，分为四步（加载数据，预处理，建模，测试）。

2.1 加载数据

Bulbea内置了数据下载模块，让你很轻易地能够下载雅虎财经的股票数据，比如下面下载雅虎财经源的GOOGL股票数据：

>>> import bulbea as bb
>>> share = bb.Share('YAHOO', 'GOOGL')
>>> share.data
# Open        High         Low       Close      Volume  \
# Date                                                                     
# 2004-08-19   99.999999  104.059999   95.959998  100.339998  44659000.0   
# 2004-08-20  101.010005  109.079998  100.500002  108.310002  22834300.0   
# 2004-08-23  110.750003  113.479998  109.049999  109.399998  18256100.0   
# 2004-08-24  111.239999  111.599998  103.570003  104.870002  15247300.0   
# 2004-08-25  104.960000  108.000002  103.880003  106.000005   9188600.0
...

2.2 预处理

Bulbea 同样也内置了预处理模块，让你能够轻易地分割训练集和测试集：

>>> from bulbea.learn.evaluation import split
>>> Xtrain, Xtest, ytrain, ytest = split(share, 'Close', normalize = True)

2.3 建模

Bulbea自带了RNN模型可供使用：

>>> import numpy as np
>>> Xtrain = np.reshape(Xtrain, (Xtrain.shape[0], Xtrain.shape[1], 1))
>>> Xtest  = np.reshape( Xtest, ( Xtest.shape[0],  Xtest.shape[1], 1))

>>> from bulbea.learn.models import RNN
>>> rnn = RNN([1, 100, 100, 1]) # number of neurons in each layer
>>> rnn.fit(Xtrain, ytrain)
# Epoch 1/10
# 1877/1877 [==============================] - 6s - loss: 0.0039
# Epoch 2/10
# 1877/1877 [==============================] - 6s - loss: 0.0019
...

2.4 测试

通过调用sklearn的metrics就能对数据实现测试：

>>> from sklearn.metrics import mean_squared_error
>>> p = rnn.predict(Xtest)
>>> mean_squared_error(ytest, p)
0.00042927869370525931
>>> import matplotlib.pyplot as pplt
>>> pplt.plot(ytest)
>>> pplt.plot(p)
>>> pplt.show()

3.情感分析

Bulbea 能自动爬取相关股票在推特上的文字，并对这些文字做一个情感分析。

你只需要给Bulbea提供以下环境变量就能够进行感情色彩分析：

export BULBEA_TWITTER_API_KEY="<YOUR_TWITTER_API_KEY>"
export BULBEA_TWITTER_API_SECRET="<YOUR_TWITTER_API_SECRET>"

export BULBEA_TWITTER_ACCESS_TOKEN="<YOUR_TWITTER_ACCESS_TOKEN>"
export BULBEA_TWITTER_ACCESS_TOKEN_SECRET="<YOUR_TWITTER_ACCESS_TOKEN_SECRET>"

测试一下：

>>> import bulbea as bb
>>> share = bb.Share('YAHOO', 'GOOGL')
>>> bb.sentiment(share)
0.07580128205128206

当然，这个分析仅供参考，太粗略了。

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

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

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

我要打赏
给作者打赏，选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义
立即支付

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

Python 爬虫、工具

Python 教你批量下载多用户抖音去水印短视频

留下评论

TikTokDownload 是由国人开源的抖音去水印视频下载工具。开源地址是：

https://github.com/Johnserf-Seed/TikTokDownload

对于某些做视频分析和研究的同学来说，这个工具非常有用，可以快速获取到视频资料。

下面就来介绍一下这个工具的使用方法。

1.准备

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

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

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

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

git clone https://github.com/Johnserf-Seed/TikTokDownload.git
cd TikTokDownload
pip install -r requirements.txt

如果你的网络环境无法访问Github，你可以在Python实用宝典公众号后台回复 TikTokDownload 下载最新源代码（2022-11-26）。

2.抖音去水印短视频下载方法

运行软件前先打开目录下 conf.ini 文件按照要求进行配置：

配置完成后，在 TikTokDownload 目录下新建一个py文件，填入以下代码即可使用：

# example.py
import TikTokDownload as TK
import Util

# 单视频下载
# TK.video_download(*TK.main())

# 批量下载
if __name__ == '__main__':
    # 获取命令行参数
    cmd = Util.Command()
    # 获取用户主页数据
    profile = Util.Profile()
    # 使用参数，没有则使用默认参数并下载
    profile.getProfile(cmd.setting())
	# 如果需要定时下载则注释这个input
    input('[  完成  ]:已完成批量下载，输入任意键后退出:')

效果如下：

​视频会被默认保存在当前目录的Download目录下。

单个视频链接，你可以通过 TK.video_download 下载

import TikTokDownload as TK
TK.video_download("视频链接", "yes")

video_download 第一个参数是视频的原始链接，第二个参数表明是否下载音乐原声，yes为下载。

3.批量多用户下载

通过修改配置的方式，我们只能实现逐个的用户短视频下载，每次下载新的用户的短视频都得修改配置，这非常麻烦。

如果我们想要在一次运行中就下载到全部用户的短视频应该怎么做呢？

方法很简单，我们把想要下载的抖音号和对应的Userid放在rooms.txt中, 用逗号分隔：

1545798353,MS4wLjABAAAAdv-v-WcZO48UMZRDLB-huZxYObcxv5Z5FFWXKw4-o_8
135180247,MS4wLjABAAAAtmTX6GSVN_AFW792_8srxdu1kPNXkuSGoG8Xl8xDHbE

使用下方这份代码，就可以将两个作者的全部短视频下载下来。

# 公众号：Python实用宝典
import Util

def read_rooms():
    f = open("rooms.txt", "r", encoding="utf-8")
    short_rooms = ["https://www.douyin.com/user/" + l.strip("\n").split(",")[1] for l in f.readlines()]
    return short_rooms

# 批量下载
if __name__ == '__main__':
    userids = []
    cmd = Util.Command()
    for room in read_rooms():
        setting = cmd.setting()
        setting[0] = room
        # 获取用户主页数据
        profile = Util.Profile()
        # 使用参数，没有则使用默认参数并下载
        profile.getProfile(tuple(setting))

在TikTokDownload目录下保存为batch_download.py，然后使用Python运行这个py文件即可：

cd TikTokDownload
python batch_download.py

4.常见错误

  1. 单个视频链接与用户主页链接要分清，软件闪退可以通过终端运行查看报错信息（一般是链接弄错的问题）如：
    • 链接一定要输入仔细,配置文件只支持用户主页
  2. 配置文件一定要注意编码格式（推荐Notepad++）

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

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

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

我要打赏
给作者打赏，选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义
立即支付

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

工具

Yapf 又一个格式化代码的好帮手

留下评论

大部分人使用Python中的代码格式化工具时都会选择autopep8之类的工具，这些工具可能有一定的局限性，比如不会重新格式化已经符合PEP 8指南的代码。

而本文即将介绍的Yapf，不仅能将代码格式化为符合PEP8指南的格式，还能格式化为符合Google指南的格式，可选项更多，让你的代码更加漂亮。

1.准备

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

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

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

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

pip install yapf

YAPF 支持 Python 2.7 和 3.6.4+。

2.Yapf 使用方法

你可以在命令行中直接使用 Yapf, 参数如下：

yapf [-h] [-v] [-d | -i | -q] [-r | -l START-END] [-e PATTERN]
            [--style STYLE] [--style-help] [--no-local-style] [-p]
            [-vv]
            [files ...]

必选参数:

files 需要被格式化的文件

可选参数：
-h, –help 显示帮助信息
-v, –version 显示程序的版本号
-d, –diff 打印格式化前后差异
-i, –in-place 格式化文件并替换
-q, –quiet 什么都不输出
-r, –recursive 在目录上递归运行
-l START-END, –lines START-END 重新格式化的行范围，基于一个
-e PATTERN, –exclude PATTERN 需要排除的文件
–style STYLE 指定格式化样式（例如“pep8”或“google”）
-p, –parallel 并行格式化（多个文件时有效）
-vv, –verbose 在处理时打印出文件名

举个例子，如果我们有以下的混乱格式代码 1.py ：

x = {  'a':37,'b':42,

'c':927}

y = 'hello ''world'
z = 'hello '+'world'
a = 'hello {}'.format('world')
class foo  (     object  ):
  def f    (self   ):
    return       37*-+2
  def g(self, x,y=42):
      return y
def f  (   a ) :
  return      37+-+a[42-x :  y**3]

为了格式化它，我们可以在命令行中执行以下命令：

yapf -i 1.py

效果如下：

3.Yapf 作为模块使用

Yapf 不仅可以在命令行中使用，我们还可以在项目运行时使用。

一个比较常见的场景是用户在你的web网站上提交了python代码，你希望能一件格式化这些代码，那将yapf作为格式化的模块则再好不过。

Yapf 最主要的两个 API 是 FormatCode 和 FormatFile:

from yapf.yapflib.yapf_api import FormatCode

formatted_code, changed = FormatCode("f ( a = 1, b = 2 )")
print(formatted_code)
# 'f(a=1, b=2)\n'
print(changed)
# True

你还可以传递 style_config 决定使用哪种指南做格式化：

from yapf.yapflib.yapf_api import FormatCode

print(FormatCode("def g():\n  return True", style_config='pep8')[0])
# 'def g():\n    return True\n'

FormatFile，这个函数可以从文件中读取代码并格式化：

from yapf.yapflib.yapf_api import FormatFile 
print(open("foo.py").read())
# a==b
reformatted_code, encoding, changed = FormatFile("foo.py")
print(formatted_code)
# 'a == b\n'
print(encoding)
# 'utf-8'
print(changed)
# True

如果你添加in_place参数，它将把格式化后的代码写回文件中：

from yapf.yapflib.yapf_api import FormatFile 
print(FormatFile("foo.py", in_place=True)[:2])
# (None, 'utf-8')

print(open("foo.py").read()) 
# a == b

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

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

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

我要打赏
给作者打赏，选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义
立即支付

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

量化投资

Zvt 集成A股数据下载及策略开发的好工具

留下评论

Zvt 既提供了可视化的历史数据浏览方式（web），又提供了A股历史数据的获取接口，是一个好用的股票数据下载工具。

它的使用方式非常简单，下面就教大家如何安装使用这个模块。

1.准备

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

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

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

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

pip install -U zvt

注意，Python版本最好大于等于Python3.6.

2.Zvt Web 界面

如果你想要进入web界面，在安装完成模块后，重启终端，进入你的zvt所属Python环境，执行下面这行命令：

zvt

然后打开  http://127.0.0.1:8050/ 就能看到相关的图表：

3.Zvt 获取数据

想要通过Zvt获取A股股票的基本数据，你只需要这样：

from zvt.domain import *
Stock.record_data(provider="em")
df = Stock.query_data(provider="em", index='code')
print(df)
"""
                     id        entity_id  timestamp entity_type exchange    code   name  list_date end_date
code
000001  stock_sz_000001  stock_sz_000001 1991-04-03       stock       sz  000001   平安银行 1991-04-03     None
000002  stock_sz_000002  stock_sz_000002 1991-01-29       stock       sz  000002  万  科Ａ 1991-01-29     None
000004  stock_sz_000004  stock_sz_000004 1990-12-01       stock       sz  000004   国华网安 1990-12-01     None
000005  stock_sz_000005  stock_sz_000005 1990-12-10       stock       sz  000005   世纪星源 1990-12-10     None
000006  stock_sz_000006  stock_sz_000006 1992-04-27       stock       sz  000006   深振业Ａ 1992-04-27     None
...                 ...              ...        ...         ...      ...     ...    ...        ...      ...
605507  stock_sh_605507  stock_sh_605507 2021-08-02       stock       sh  605507   国邦医药 2021-08-02     None
605577  stock_sh_605577  stock_sh_605577 2021-08-24       stock       sh  605577   龙版传媒 2021-08-24     None
605580  stock_sh_605580  stock_sh_605580 2021-08-19       stock       sh  605580   恒盛能源 2021-08-19     None
605588  stock_sh_605588  stock_sh_605588 2021-08-12       stock       sh  605588   冠石科技 2021-08-12     None
605589  stock_sh_605589  stock_sh_605589 2021-08-10       stock       sh  605589   圣泉集团 2021-08-10     None

[4136 rows x 9 columns]
"""

注意, provider = “em” 指的是 东方财富(eastmoney).

历史数据获取：

from zvt.domain import *
Stock1dHfqKdata.record_data(code='000338', provider='em')
df = Stock1dHfqKdata.query_data(code='000338', provider='em')
print(df)
"""
                              id        entity_id  timestamp provider    code  name level    open   close    high     low     volume      turnover  change_pct  turnover_rate
0     stock_sz_000338_2007-04-30  stock_sz_000338 2007-04-30     None  000338  潍柴动力    1d   70.00   64.93   71.00   62.88   207375.0  1.365189e+09      2.1720         0.1182
1     stock_sz_000338_2007-05-08  stock_sz_000338 2007-05-08     None  000338  潍柴动力    1d   66.60   64.00   68.00   62.88    86299.0  5.563198e+08     -0.0143         0.0492
2     stock_sz_000338_2007-05-09  stock_sz_000338 2007-05-09     None  000338  潍柴动力    1d   63.32   62.00   63.88   59.60    93823.0  5.782065e+08     -0.0313         0.0535
3     stock_sz_000338_2007-05-10  stock_sz_000338 2007-05-10     None  000338  潍柴动力    1d   61.50   62.49   64.48   61.01    47720.0  2.999226e+08      0.0079         0.0272
4     stock_sz_000338_2007-05-11  stock_sz_000338 2007-05-11     None  000338  潍柴动力    1d   61.90   60.65   61.90   59.70    39273.0  2.373126e+08     -0.0294         0.0224
...                          ...              ...        ...      ...     ...   ...   ...     ...     ...     ...     ...        ...           ...         ...            ...
3426  stock_sz_000338_2021-08-27  stock_sz_000338 2021-08-27     None  000338  潍柴动力    1d  331.97  345.95  345.95  329.82  1688497.0  3.370241e+09      0.0540         0.0398
3427  stock_sz_000338_2021-08-30  stock_sz_000338 2021-08-30     None  000338  潍柴动力    1d  345.95  342.72  346.10  337.96  1187601.0  2.377957e+09     -0.0093         0.0280
3428  stock_sz_000338_2021-08-31  stock_sz_000338 2021-08-31     None  000338  潍柴动力    1d  344.41  342.41  351.02  336.73  1143985.0  2.295195e+09     -0.0009         0.0270
3429  stock_sz_000338_2021-09-01  stock_sz_000338 2021-09-01     None  000338  潍柴动力    1d  341.03  336.42  341.03  328.28  1218697.0  2.383841e+09     -0.0175         0.0287
3430  stock_sz_000338_2021-09-02  stock_sz_000338 2021-09-02     None  000338  潍柴动力    1d  336.88  339.03  340.88  329.67  1023545.0  2.012006e+09      0.0078         0.0241

[3431 rows x 15 columns]
"""

财务数据获取：

from zvt.domain import *
FinanceFactor.record_data(code='000338')
FinanceFactor.query_data(code='000338',columns=FinanceFactor.important_cols(),index='timestamp')
"""
            basic_eps  total_op_income    net_profit  op_income_growth_yoy  net_profit_growth_yoy     roe    rota  gross_profit_margin  net_margin  timestamp
timestamp
2002-12-31        NaN     1.962000e+07  2.471000e+06                   NaN                    NaN     NaN     NaN               0.2068      0.1259 2002-12-31
2003-12-31       1.27     3.574000e+09  2.739000e+08              181.2022               109.8778  0.7729  0.1783               0.2551      0.0766 2003-12-31
2004-12-31       1.75     6.188000e+09  5.369000e+08                0.7313                 0.9598  0.3245  0.1474               0.2489      0.0868 2004-12-31
2005-12-31       0.93     5.283000e+09  3.065000e+08               -0.1463                -0.4291  0.1327  0.0603               0.2252      0.0583 2005-12-31
2006-03-31       0.33     1.859000e+09  1.079000e+08                   NaN                    NaN     NaN     NaN                  NaN      0.0598 2006-03-31
...               ...              ...           ...                   ...                    ...     ...     ...                  ...         ...        ...
2020-08-28       0.59     9.449000e+10  4.680000e+09                0.0400                -0.1148  0.0983  0.0229               0.1958      0.0603 2020-08-28
2020-10-31       0.90     1.474000e+11  7.106000e+09                0.1632                 0.0067  0.1502  0.0347               0.1949      0.0590 2020-10-31
2021-03-31       1.16     1.975000e+11  9.207000e+09                0.1327                 0.0112  0.1919  0.0444               0.1931      0.0571 2021-03-31
2021-04-30       0.42     6.547000e+10  3.344000e+09                0.6788                 0.6197  0.0622  0.0158               0.1916      0.0667 2021-04-30
2021-08-31       0.80     1.264000e+11  6.432000e+09                0.3375                 0.3742  0.1125  0.0287               0.1884      0.0653 2021-08-31

[66 rows x 10 columns]
"""

资产负债表、利润表、现金流表：

from zvt.domain import *
BalanceSheet.record_data(code='000338')
IncomeStatement.record_data(code='000338')
CashFlowStatement.record_data(code='000338')

更多数据请看

from zvt.domain import *
print(zvt_context.schemas)
"""
[zvt.domain.dividend_financing.DividendFinancing,
 zvt.domain.dividend_financing.DividendDetail,
 zvt.domain.dividend_financing.SpoDetail...]
"""

4.Zvt 市场筛选

基于query_data的filters参数，你还能实现筛选，比如2018年年报中roe>8%、营收增速>8%的前20只股票：

from zvt.domain import *
df = FinanceFactor.query_data(filters=[FinanceFactor.roe>0.08,FinanceFactor.report_period=='year',FinanceFactor.op_income_growth_yoy>0.08],start_timestamp='2019-01-01',order=FinanceFactor.roe.desc(),limit=20,columns=["code"]+FinanceFactor.important_cols(),index='code')
print(df)
"""
          code  basic_eps  total_op_income    net_profit  op_income_growth_yoy  net_profit_growth_yoy     roe    rota  gross_profit_margin  net_margin  timestamp
code
000048  000048     2.7350     4.919000e+09  1.101000e+09                0.4311                 1.5168  0.7035  0.1988               0.5243      0.2355 2020-04-30
000912  000912     0.3500     4.405000e+09  3.516000e+08                0.1796                 1.2363  4.7847  0.0539               0.2175      0.0795 2019-03-20
002207  002207     0.2200     3.021000e+08  5.189000e+07                0.1600                 1.1526  1.1175  0.1182               0.1565      0.1718 2020-04-27
002234  002234     5.3300     3.276000e+09  1.610000e+09                0.8023                 3.2295  0.8361  0.5469               0.5968      0.4913 2020-04-21
002458  002458     3.7900     3.584000e+09  2.176000e+09                1.4326                 4.9973  0.8318  0.6754               0.6537      0.6080 2020-02-20
...        ...        ...              ...           ...                   ...                    ...     ...     ...                  ...         ...        ...
600701  600701    -3.6858     7.830000e+08 -3.814000e+09                1.3579                -0.0325  1.9498 -0.7012               0.4173     -4.9293 2020-04-29
600747  600747    -1.5600     3.467000e+08 -2.290000e+09                2.1489                -0.4633  3.1922 -1.5886               0.0378     -6.6093 2020-06-30
600793  600793     1.6568     1.293000e+09  1.745000e+08                0.1164                 0.8868  0.7490  0.0486               0.1622      0.1350 2019-04-30
600870  600870     0.0087     3.096000e+07  4.554000e+06                0.7773                 1.3702  0.7458  0.0724               0.2688      0.1675 2019-03-30
688169  688169    15.6600     4.205000e+09  7.829000e+08                0.3781                 1.5452  0.7172  0.4832               0.3612      0.1862 2020-04-28

[20 rows x 11 columns]
"""

5.Zvt 编写策略

Zvt还能编写策略，然后能在页面上查看你策略产生的买入信号和卖出信号：

# -*- coding: utf-8 -*-
import pandas as pd

from zvt.api import get_recent_report_date
from zvt.contract import ActorType, AdjustType
from zvt.domain import StockActorSummary, Stock1dKdata
from zvt.trader import StockTrader
from zvt.utils import pd_is_not_null, is_same_date, to_pd_timestamp


class FollowIITrader(StockTrader):
    finish_date = None

    def on_time(self, timestamp: pd.Timestamp):
        recent_report_date = to_pd_timestamp(get_recent_report_date(timestamp))
        if self.finish_date and is_same_date(recent_report_date, self.finish_date):
            return
        filters = [StockActorSummary.actor_type == ActorType.raised_fund.value,
                   StockActorSummary.report_date == recent_report_date]

        if self.entity_ids:
            filters = filters + [StockActorSummary.entity_id.in_(self.entity_ids)]

        df = StockActorSummary.query_data(filters=filters)

        if pd_is_not_null(df):
            self.logger.info(f'{df}')
            self.finish_date = recent_report_date

        long_df = df[df['change_ratio'] > 0.05]
        short_df = df[df['change_ratio'] < -0.5]
        try:
            self.trade_the_targets(due_timestamp=timestamp, happen_timestamp=timestamp,
                                   long_selected=set(long_df['entity_id'].to_list()),
                                   short_selected=set(short_df['entity_id'].to_list()))
        except Exception as e:
            self.logger.error(e)


if __name__ == '__main__':
    entity_id = 'stock_sh_600519'
    Stock1dKdata.record_data(entity_id=entity_id, provider='em')
    StockActorSummary.record_data(entity_id=entity_id, provider='em')
    FollowIITrader(start_timestamp='2002-01-01', end_timestamp='2021-01-01', entity_ids=[entity_id],
                   provider='em', adjust_type=AdjustType.qfq, profit_threshold=None).run()

它将能输出如下所示的信号图：

更多的功能请见 Zvt 官方文档：zvt.readthedocs.io/en/latest/

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

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

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

我要打赏
给作者打赏，选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义
立即支付

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

Python 数据分析、Python绘图

Manim 一个特漂亮的Python数学教学动画开发模块

留下评论

Manim 是3b1b开源的一个特别漂亮的数学动画模块。

我们能够基于Manim绘制许多解释性的动画，比如下面这个：

也支持函数图像：

甚至是一些3D视图和矩阵变换，Manim都可以轻易实现：

如果你是一个数学课程的演讲者，或者你需要给观众演示某些数学公式的图形，那么Manim就是你的不二之选。

Manim 支持 Python 3.7 及以上版本，推荐Python3.8.

1.准备

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

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

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

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

conda create --name manim python=3.8 # 创建虚拟环境
conda activate manim # 切换到此虚拟环境
pip install manimgl # 安装manim

安装完毕后在终端输入 manimgl，会出现如下的界面，说明安装完成。

2. Manim 基本使用

首先学会画一个基本的数学图形，如圆圈：

from manimlib import *

class SquareToCircle(Scene):
    def construct(self):
        circle = Circle()
        circle.set_fill(BLUE, opacity=0.5)
        circle.set_stroke(BLUE_E, width=4)

        self.add(circle)

编写完毕后，在终端里敲下这行命令：

manimgl 你的py文件名.py SquareToCircle

就能弹出一个图形界面，绘制完成：

你还可以操作弹出的这个窗口：

  • 滚动鼠标中键来上下移动画面
  • 按住键盘上 z 键的同时滚动鼠标中键来缩放画面
  • 按住键盘上 f 键的同时移动鼠标来平移画面
  • 按住键盘上 d 键的同时移动鼠标来改变三维视角
  • 按下键盘上 r 键恢复到最初的视角

最后，你可以通过按 q 来关闭窗口并退出程序。

接下来，我们学习如何让圆形变成方形：

# 公众号: Python实用宝典
from manimlib import *

class CircleToSquare(Scene):
    def construct(self):
        square = Square()
        square.set_fill(BLUE, opacity=0.5)
        square.set_stroke(BLUE_E, width=4)
        circle = Circle()

        self.play(ShowCreation(circle))
        self.wait()
        self.play(ReplacementTransform(circle, square))
        self.wait()

ShowCreation: 演示圆圈绘制过程。

ReplacementTransform: 延时从第一个参数的图形变化到第二个参数的图形的过程。

self.wait(): 等待上个play操作执行完成。

终端运行命令：

manimgl 你的py文件名.py CircleToSquare

效果如下：

再来一个复杂一点的演示，增加拉伸、旋转和变换：

# 公众号: Python实用宝典
from manimlib import *

class CircleToSquare(Scene):
    def construct(self):
        square = Square()
        square.set_fill(BLUE, opacity=0.5)
        square.set_stroke(BLUE_E, width=4)
        circle = Circle()

        self.play(ShowCreation(circle))
        self.wait()
        self.play(ReplacementTransform(circle, square))
        self.wait()
        # 在水平方向上拉伸到四倍
        self.play(square.animate.stretch(4, dim=0))
        self.wait()
        # 旋转90°
        self.play(Rotate(square, TAU / 4))
        self.wait()
        # 在向右移动2单位同时缩小为原来的1/4
        self.play(square.animate.shift(2 * RIGHT), square.animate.scale(0.25))
        self.wait()
        # 为了非线性变换，给square增加10段曲线（不会播放动画）
        square.insert_n_curves(10)
        # 给square上的所有点施加f(z)=z^2的复变换
        self.play(square.animate.apply_complex_function(lambda z: z**2))
        self.wait()

square.animate.stretch: 将图形拉伸第一个参数的倍数，第二个维度指明方向，dim=0为水平方向，dim=1为垂直方向。

square.animate.shift: 可以调整图形位置和大小。

square.animate.apply_complex_function: 增加函数复变换。

效果如下：

3. Manim 坐标轴与函数图像

想要实现函数图像绘制，我们需要先添加坐标轴：

# 公众号: Python实用宝典
from manimlib import *

class GraphExample(Scene):
    def construct(self):
        axes = Axes((-3, 10), (-1, 8))
        axes.add_coordinate_labels()

        self.play(Write(axes, lag_ratio=0.01, run_time=1))

运行以下命令显示坐标轴：

manimgl 你的py文件名.py GraphExample

坐标轴绘制完成后，就可以开始绘制图像了：

class GraphExample(Scene):
    def construct(self):
        axes = Axes((-3, 10), (-1, 8))
        axes.add_coordinate_labels()

        self.play(Write(axes, lag_ratio=0.01, run_time=1))

        # Axes.get_graph会返回传入方程的图像
        sin_graph = axes.get_graph(
            lambda x: 2 * math.sin(x),
            color=BLUE,
        )
        # 默认情况下，它在所有采样点(x, f(x))之间稍微平滑地插值
        # 但是，如果图形有棱角，可以将use_smoothing设为False
        relu_graph = axes.get_graph(
            lambda x: max(x, 0),
            use_smoothing=False,
            color=YELLOW,
        )
        # 对于不连续的函数，你可以指定间断点来让它不试图填补不连续的位置
        step_graph = axes.get_graph(
            lambda x: 2.0 if x > 3 else 1.0,
            discontinuities=[3],
            color=GREEN,
        )

        # Axes.get_graph_label可以接受字符串或者mobject。如果传入的是字符串
        # 那么将将其当作LaTeX表达式传入Tex中
        # 默认下，label将生成在图像的右侧，并且匹配图像的颜色
        sin_label = axes.get_graph_label(sin_graph, "\\sin(x)")
        relu_label = axes.get_graph_label(relu_graph, Text("ReLU"))
        step_label = axes.get_graph_label(step_graph, Text("Step"), x=4)

        self.play(
            ShowCreation(sin_graph),
            FadeIn(sin_label, RIGHT),
        )
        self.wait(2)
        self.play(
            ReplacementTransform(sin_graph, relu_graph),
            FadeTransform(sin_label, relu_label),
        )
        self.wait()
        self.play(
            ReplacementTransform(relu_graph, step_graph),
            FadeTransform(relu_label, step_label),
        )
        self.wait()

        parabola = axes.get_graph(lambda x: 0.25 * x**2)
        parabola.set_stroke(BLUE)
        self.play(
            FadeOut(step_graph),
            FadeOut(step_label),
            ShowCreation(parabola)
        )
        self.wait()

        # 你可以使用Axes.input_to_graph_point（缩写Axes.i2gp）来找到图像上的一个点
        dot = Dot(color=RED)
        dot.move_to(axes.i2gp(2, parabola))
        self.play(FadeIn(dot, scale=0.5))

        # ValueTracker存储一个数值，可以帮助我们制作可变参数的动画
        # 通常使用updater或者f_always让其它mobject根据其中的数值来更新
        x_tracker = ValueTracker(2)
        f_always(
            dot.move_to,
            lambda: axes.i2gp(x_tracker.get_value(), parabola)
        )

        self.play(x_tracker.animate.set_value(4), run_time=3)
        self.play(x_tracker.animate.set_value(-2), run_time=3)
        self.wait()

在这份代码中，我们先绘制了Sinx的图像，通过 ReplacementTransform 和 FadeTransform 转换成 ReLu 函数，然后通过同样的步骤转换成了Step图像。最后实现点在曲线上的移动。

manimgl 你的py文件名.py GraphExample

效果如下：

如果在运行的时候你出现了这样的错误：

请下载安装MiKTex和dvisvgm.

MiKTex: https://miktex.org/download

Dvisvgm: https://dvisvgm.de/Downloads/

还有更多有趣的绘制案例，你可以在Manim官网上学习：

https://docs.manim.org.cn/getting_started/example_scenes.html

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

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

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

我要打赏
给作者打赏，选择打赏金额
¥1¥5¥10¥20¥50¥100¥200 自定义
立即支付

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