标签归档：quant

Python 制作CNN模型分类股市秒级数据

2023年3月16日 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 pandas
pip install numpy
pip install scikit-learn
pip install keras

2.CNN模型数据与预处理

获取数据

首先，你需要准备好股市秒级数据，这个文件的内容如下（可以在二七阿尔公众号后台回复秒级数据获取）：

ts_code,trade_time,open,high,low,close,volume,amount
000001.SH,2021-10-08 15:00:00.0000000+08:00,3599.8,3600.0,3599.8,3600.0,0,0
000001.SH,2021-10-08 14:59:59.0000000+08:00,3599.8,3599.8,3599.7,3599.7,0,0
000001.SH,2021-10-08 14:59:58.0000000+08:00,
...

其中包含了某只股票的每秒开盘价、最高价、最低价、收盘价和成交量等信息。

然后，你需要对数据进行预处理，例如归一化、划分训练集和测试集、构造输入和输出等。这里我们假设你想用前10秒的数据来预测下一秒的涨跌情况，即二分类问题。我们可以用以下代码实现：

import pandas as pd
import numpy as np
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split

# 读取数据
data = pd.read_csv("stock_data.csv")

# 归一化数据
scaler = MinMaxScaler()
data_scaled = scaler.fit_transform(data)

# 构造输入和输出
X = []
y = []
seq_len = 10 # 前10秒作为输入
for i in range(seq_len, len(data_scaled)):
    X.append(data_scaled[i-seq_len:i]) # 输入是10秒的数据
    y.append(1 if data_scaled[i][3] > data_scaled[i-1][3] else 0) # 输出是下一秒的涨跌情况

X = np.array(X)
y = np.array(y)

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

3.CNN模型搭建与评估

接下来，你需要搭建一个CNN模型来对输入进行特征提取和分类。这里我们使用Keras框架来实现一个简单的CNN模型，包含两个卷积层、两个池化层和一个全连接层：

from keras.models import Sequential
from keras.layers import Conv1D, MaxPooling1D, Flatten, Dense

# 定义模型参数
input_shape = (seq_len, 5) # 输入形状是(10, 5)，即10秒的5个特征值
num_classes = 2 # 输出类别数是2，即涨或跌

# 搭建模型结构
model = Sequential()
model.add(Conv1D(filters=32, kernel_size=3, activation="relu", input_shape=input_shape)) # 第一个卷积层，使用32个3大小的卷积核，并使用relu激活函数
model.add(MaxPooling1D(pool_size=2)) # 第一个池化层，使用2大小的池化窗口，并默认使用最大池化方法
model.add(Conv1D(filters=64, kernel_size=3, activation="relu")) # 第二个卷积层，使用64个3大小的卷积核，并使用relu激活函数
model.add(MaxPooling1D(pool_size=2)) # 第二个池化层，使用2大小的池化窗口，并默认使用最大池化方法
model.add(Flatten()) # 将多维度的输出展平为一维度的向量，以便输入全连接层
model.add(Dense(units=num_classes, activation="softmax")) # 全连接层，使用softmax激活函数输出类别概率

# 编译模型并查看摘要信息 
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
model.summary()

最后，你需要训练模型并评估其性能。这里我们使用20个epoch来训练模型，并在每个epoch结束后在测试集上进行评估：

# 定义训练参数
epochs = 20 # 训练轮数
batch_size = 32 # 批次大小

# 训练模型并在测试集上评估
for epoch in range(epochs):
    model.fit(X_train, y_train, batch_size=batch_size) # 在训练集上训练模型
    loss, acc = model.evaluate(X_test, y_test) # 在测试集上评估模型
    print(f"Epoch {epoch+1}: loss={loss:.4f}, acc={acc:.4f}") # 打印损失和准确率

这样，你就完成了一个Python的CNN模型分类股市秒级数据的示例。希望对你有帮助。👍

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

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

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

我要打赏

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

量化投资

Eiten 1 个构建美股投资组合的好帮手

2022年10月23日 Python实用宝典留下评论

Eiten是Tradytics的一个开源工具包，它实现了各种统计和算法投资策略，如Eigen组合、最小方差组合、最大夏普比率组合和基于遗传算法的组合。

Eiten允许你用自己的股票组合建立自己的投资组合。Eiten中自带的严格测试框架使你能够对你的投资组合更有自信。

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/tradytics/eiten.git
cd eiten
pip install -r requirements.txt
pip install yfinance --upgrade --no-cache-dir

目录结构如下：

路径	描述
eiten	主目录
└ figures	仓库用到的图表（无需关注）
└ stocks	你的用于创建投资组合的股票列表
└ strategies	python编写的策略代码
backtester.py	回测模块
data_loader.py	数据加载工具
portfolio_manager.py	生成投资组合的代码
simulator.py	使用历史回报生成投资组合的模拟器
strategy_manager.py	策略管理器

2.使用方法

把你想要构建投资组合的候选股票列表写入 stocks/stocks.txt 中，尽量保证股票数量在5~50只左右。

接下来就可以尝试构建投资组合了：

python portfolio_manager.py --is_test 1 --future_bars 90 --data_granularity_minutes 3600 --history_to_use all --apply_noise_filtering 1 --market_index QQQ --only_long 1 --eigen_portfolio_number 3 --stocks_file_path stocks/stocks.txt

各个参数的解释：

is_test: 该值决定了程序是否要保留一些数据用于未来的测试。当这个值为True时，future_bars的值应该大于5。
future_bars: 构建投资组合时将排除的最近n条K线。这也被称为样本外的数据。
data_granularity_minutes: 你想什么频率的数据来建立你的投资组合。对于长期投资组合，你应该使用每日数据，但对于短期策略，你可以使用分钟的数据(3600、60、30、15、5、1)。
history_to_use: 是使用特定数量的数据还是使用我们从雅虎财经下载的所有数据。对于分钟级别的数据，我们只下载了一个月的历史数据。对于日线，我们下载了5年的历史数据。如果你想使用所有可用的数据，该值应该是 all，但如果你想使用较小的数据量，你可以将其设置为一个整数，例如100，这将只使用最后100条k线来建立投资组合。
apply_noise_filtering: 它使用随机矩阵理论来过滤掉随机性的协方差矩阵，从而产生更好的投资组合。值为1将启用它。
market_index: 你想用哪个指数来作为你的投资组合的基准值。比如SPY/QQQ，由于我们分析的是科技股，所以例子中使用了QQQ。
only_long: 是否只做多。
eigen_portfolio_number: 可阅读这篇文章了解更多: eigen-portfolios.
stocks_file_path: 你想用来建立投资组合的股票列表的文件。

如果你出现了下面这样的报错：

As of November 1st, 2021 Yahooâs suite of services will no longer be accessi
ble from mainland China. Yahoo products and services remain unaffected in all other global locations. We thank you for your support and readership，

这是因为雅虎数据源从2021年开始不在向中国提供服务，你需要挂一个代理去下载数据，在data_loader.py的73行，增加proxy参数：

stock_prices = yf.download(
                tickers=symbol,
                period=period,
                interval=interval,
                auto_adjust=False,
                progress=False,
                proxy="http://127.0.0.1:10809" # 此处由你代理地址决定
			)

然后重新执行命令便能生成不同策略的投资组合权重分配结果：

同时，程序会弹出一个图表，这个图表能输出所有策略的权重比：

各个策略的累计净值收益曲线（5年）：

“未来测试”的累计投资回报（最近90天）：

模拟未来的累计投资回报：

感谢大家的阅读，本文关于Eiten使用方式的介绍就到这里。

下篇文章我们就告诉大家如何将Eiten用于A股，敬请期待。

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

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

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

我要打赏

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

量化投资

Alpha Vantage 获取实时美股及数字货币数据

2022年10月11日 Python实用宝典留下评论

Alpha Vantage 是一个能够让你通过 Json 和 Pandas DataFrame 格式获取免费实时金融数据的API。

它获取数据时需要使用API Key，你可以在这里申请：

https://www.alphavantage.co/support/#api-key

输入完相关信息后点击 GET FREE API KEY 后就能获取到API KEY，非常方便。

下面就教大家怎么使用 Alpha Vantage API.

1.准备

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

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

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

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

pip install alpha_vantage

2.基本使用

默认情况下，数据会以字典的形式返回：

from alpha_vantage.timeseries import TimeSeries
ts = TimeSeries(key='你的API Key')
data, meta_data = ts.get_intraday('OXY')
print(data)

如果你想要获取Dataframe版本的数据，请这样写：

from alpha_vantage.timeseries import TimeSeries
ts = TimeSeries(key='你的API Key', output_format='pandas', indexing_type='date')
data, meta_data = ts.get_intraday('OXY')
print(data)

你还可以指定数据的频率，比如获取分钟级数据：

from alpha_vantage.timeseries import TimeSeries
ts = TimeSeries(key='你的API Key', output_format='pandas', indexing_type='date')
data, meta_data = ts.get_intraday('OXY', interval='1min', outputsize='full')
print(data)

可惜的是，alpha_vantage 不允许我们获取历史行情数据。

3.高级功能

没什么特别的高级功能，它支持异步获取数据：

import asyncio
from alpha_vantage.async_support.timeseries import TimeSeries

symbols = ['AAPL', 'GOOG', 'TSLA', 'MSFT']


async def get_data(symbol):
    ts = TimeSeries(key='YOUR_KEY_HERE')
    data, _ = await ts.get_quote_endpoint(symbol)
    await ts.close()
    return data

loop = asyncio.get_event_loop()
tasks = [get_data(symbol) for symbol in symbols]
group1 = asyncio.gather(*tasks)
results = loop.run_until_complete(group1)
loop.close()
print(results)

这样能异步获取不同股票的当前价格，减少了网络IO的等待时间。

如果你希望以最简单的方式每天按时获取分钟级数据，那么这个API是你值得尝试的。

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

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

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

我要打赏

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

量化投资

Exchange_calendars 一个能获取全世界所有市场交易日历的Python模块

2022年8月12日 Python实用宝典留下评论

Exchange_calendars 是一个用于查询证券交易日历的 Python 库。开箱即用，内含世界50+个交易所的交易日历，包括中国市场和港股市场，非常方便。

同时，如果你找到了Exchange_calendars 上没有的市场的交易日历，可以向他们提交PR，创建一个新的交易所日历。

注意，本模块最低支持的Python版本为3.8.

1.准备

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

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

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

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

pip install exchange_calendars

2.Exchange_calendars 基本使用

获取可用日历的列表：

import exchange_calendars as xcals
print(xcals.get_calendar_names(include_aliases=False))

结果如下：

['24/5', '24/7', 'AIXK', 'ASEX', 'BVMF', 'CMES', 'IEPA', 'XAMS', 'XASX', 'XBKK', 'XBOG', 'XBOM', 'XBRU', 'XBSE', 'XBUD', 'XBUE', 'XCBF', 'XCSE', 'XDUB', 'XETR', 'XFRA', 'XHEL', 'XHKG', 'XICE', 'XIDX', 'XIST', 'XJSE', 'XKAR', 'XKLS', 'XKRX', 'XLIM', 'XLIS', 'XLON', 'XMAD', 'XMEX', 'XMIL', 'XMOS', 'XNYS', 'XNZE', 'XOSL', 'XPAR', 'XPHS', 'XPRA', 'XSES', 'XSGO', 'XSHG', 'XSTO', 'XSWX', 'XTAE', 'XTAI', 'XTKS', 'XTSE', 'XWAR', 'XWBO', 'us_futures']

其中，XSHG就是中国的沪市、XHKG就是港股。

获取沪市日历：

import exchange_calendars as xcals
xshg = xcals.get_calendar("XSHG")

查询某个区间日程是否有开盘：

import exchange_calendars as xcals
xshg = xcals.get_calendar("XSHG")
print(xshg.schedule.loc["2021-12-29":"2022-08-12"])

                                open               break_start                 break_end                     close
2021-12-29 2021-12-29 01:30:00+00:00 2021-12-29 03:30:00+00:00 2021-12-29 05:00:00+00:00 2021-12-29 07:00:00+00:00
2021-12-30 2021-12-30 01:30:00+00:00 2021-12-30 03:30:00+00:00 2021-12-30 05:00:00+00:00 2021-12-30 07:00:00+00:00
2021-12-31 2021-12-31 01:30:00+00:00 2021-12-31 03:30:00+00:00 2021-12-31 05:00:00+00:00 2021-12-31 07:00:00+00:00
2022-01-04 2022-01-04 01:30:00+00:00 2022-01-04 03:30:00+00:00 2022-01-04 05:00:00+00:00 2022-01-04 07:00:00+00:00
2022-01-05 2022-01-05 01:30:00+00:00 2022-01-05 03:30:00+00:00 2022-01-05 05:00:00+00:00 2022-01-05 07:00:00+00:00
...                              ...                       ...                       ...                       ...
2022-08-08 2022-08-08 01:30:00+00:00 2022-08-08 03:30:00+00:00 2022-08-08 05:00:00+00:00 2022-08-08 07:00:00+00:00
2022-08-09 2022-08-09 01:30:00+00:00 2022-08-09 03:30:00+00:00 2022-08-09 05:00:00+00:00 2022-08-09 07:00:00+00:00
2022-08-10 2022-08-10 01:30:00+00:00 2022-08-10 03:30:00+00:00 2022-08-10 05:00:00+00:00 2022-08-10 07:00:00+00:00
2022-08-11 2022-08-11 01:30:00+00:00 2022-08-11 03:30:00+00:00 2022-08-11 05:00:00+00:00 2022-08-11 07:00:00+00:00
2022-08-12 2022-08-12 01:30:00+00:00 2022-08-12 03:30:00+00:00 2022-08-12 05:00:00+00:00 2022-08-12 07:00:00+00:00

[151 rows x 4 columns]

可见，他直接返回了这个区间中所有开盘的日期作为index，并附带了开盘和收盘的UTC时间（需要+8）。

如果你只需要开市的日期，可以这样：

# 公众号：二七阿尔量化
import exchange_calendars as xcals
xshg = xcals.get_calendar("XSHG")
xshg_range = xshg.schedule.loc["2021-12-29":"2022-08-12"]
print(xshg_range.index.strftime("%Y-%m-%d").tolist())

效果如下：

['2021-12-29', '2021-12-30', '2021-12-31', '2022-01-04', '2022-01-05', '2022-01-06', '2022-01-07', '2022-01-10', '2022-01-11', '2022-01-12', '2022-01-13', '2022-01-14', '2022-01-17', '2022-01-18', '2022-01-19', '2022-01-20', '2022-01-21', '2022-01-24', '2022-01-25', '2022-01-26', '2022-01-27', '2022-01-28', '2022-02-07', '2022-02-08', '2022-02-09', '2022-02-10', '2022-02-11', '2022-02-14', '2022-02-15', '2022-02-16', '2022-02-17', '2022-02-18', '2022-02-21', '2022-02-22', '2022-02-23', '2022-02-24', '2022-02-25', '2022-02-28', '2022-03-01', '2022-03-02', '2022-03-03', '2022-03-04', '2022-03-07', '2022-03-08', '2022-03-09', '2022-03-10', '2022-03-11', '2022-03-14', '2022-03-15', '2022-03-16', '2022-03-17', '2022-03-18', '2022-03-21', '2022-03-22', '2022-03-23', '2022-03-24', '2022-03-25', '2022-03-28', '2022-03-29', '2022-03-30', '2022-03-31', '2022-04-01', '2022-04-06', '2022-04-07', '2022-04-08', '2022-04-11', '2022-04-12', '2022-04-13', '2022-04-14', '2022-04-15', '2022-04-18', '2022-04-19', '2022-04-20', '2022-04-21', '2022-04-22', '2022-04-25', '2022-04-26', '2022-04-27', '2022-04-28', '2022-04-29', '2022-05-05', '2022-05-06', '2022-05-09', '2022-05-10', '2022-05-11', '2022-05-12', '2022-05-13', '2022-05-16', '2022-05-17', '2022-05-18', '2022-05-19', '2022-05-20', '2022-05-23', '2022-05-24', '2022-05-25', '2022-05-26', '2022-05-27', '2022-05-30', '2022-05-31', '2022-06-01', '2022-06-02', '2022-06-06', '2022-06-07', '2022-06-08', '2022-06-09', '2022-06-10', '2022-06-13', '2022-06-14', '2022-06-15', '2022-06-16', '2022-06-17', '2022-06-20', '2022-06-21', '2022-06-22', '2022-06-23', '2022-06-24', '2022-06-27', '2022-06-28', '2022-06-29', '2022-06-30', '2022-07-01', '2022-07-04', '2022-07-05', '2022-07-06', '2022-07-07', '2022-07-08', '2022-07-11', '2022-07-12', '2022-07-13', '2022-07-14', '2022-07-15', '2022-07-18', '2022-07-19', '2022-07-20', '2022-07-21', '2022-07-22', '2022-07-25', '2022-07-26', '2022-07-27', '2022-07-28', '2022-07-29', '2022-08-01', '2022-08-02', '2022-08-03', '2022-08-04', '2022-08-05', '2022-08-08', '2022-08-09', '2022-08-10', '2022-08-11', '2022-08-12']

3.高级使用

判断某一天是否为交易日：

# 公众号：二七阿尔量化

import exchange_calendars as xcals
xshg = xcals.get_calendar("XSHG")
print(xshg.is_session("2022-12-30"))
# True

获取某一天后的N个交易日：

# 公众号：二七阿尔量化

import exchange_calendars as xcals
xshg = xcals.get_calendar("XSHG")
print(xshg.sessions_window("2022-12-30", 7))
# DatetimeIndex(['2022-12-30', '2023-01-03', '2023-01-04', '2023-01-05',
#               '2023-01-06', '2023-01-09', '2023-01-10'],
#              dtype='datetime64[ns]', freq='C')

获取某一天后的下一个交易日：

# 公众号：二七阿尔量化

import exchange_calendars as xcals
xshg = xcals.get_calendar("XSHG")
print(xshg.date_to_session("2022-01-01", direction="next"))
# 2022-01-04 00:00:00

获取某一天后的上一个交易日：

# 公众号：二七阿尔量化

import exchange_calendars as xcals
xshg = xcals.get_calendar("XSHG")
print(xshg.date_to_session("2022-01-01", direction="previous"))
# 2021-12-31 00:00:00

获取分钟级交易区间：

import exchange_calendars as xcals
xshg = xcals.get_calendar("XSHG")
print(xshg.session_minutes("2022-01-04"))
# DatetimeIndex(['2022-01-04 01:30:00+00:00', '2022-01-04 01:31:00+00:00',
#                '2022-01-04 01:32:00+00:00', '2022-01-04 01:33:00+00:00',
#                '2022-01-04 01:34:00+00:00', '2022-01-04 01:35:00+00:00',
#                '2022-01-04 01:36:00+00:00', '2022-01-04 01:37:00+00:00',
#                '2022-01-04 01:38:00+00:00', '2022-01-04 01:39:00+00:00',
#                ...
#                '2022-01-04 06:50:00+00:00', '2022-01-04 06:51:00+00:00',
#                '2022-01-04 06:52:00+00:00', '2022-01-04 06:53:00+00:00',
#                '2022-01-04 06:54:00+00:00', '2022-01-04 06:55:00+00:00',
#                '2022-01-04 06:56:00+00:00', '2022-01-04 06:57:00+00:00',
#                '2022-01-04 06:58:00+00:00', '2022-01-04 06:59:00+00:00'],
#               dtype='datetime64[ns, UTC]', length=240, freq=None)

交易时间按指定数字分割：

import exchange_calendars as xcals
xshg = xcals.get_calendar("XSHG")
print(xshg.trading_index(
    "2021-12-30", "2021-12-31", period="30T", force=True
))
# IntervalIndex([[2021-12-30 01:30:00, 2021-12-30 02:00:00), [2021-12-30 02:00:00, 2021-12-30 02:30:00), [2021-12-30 02:30:00, 2021-12-30 03:00:00), [2021-12-30 03:00:00, 2021-12-30 03:30:00), [2021-12-30 05:00:00, 2021-12-30 05:30:00) ... [2021-12-31 03:00:00, 2021-12-31 03:30:00), [2021-12-31 05:00:00, 2021-12-31 05:30:00), [2021-12-31 05:30:00, 2021-12-31 06:00:00), [2021-12-31 06:00:00, 2021-12-31 06:30:00), [2021-12-31 06:30:00, 2021-12-31 07:00:00)],
#               closed='left',
#               dtype='interval[datetime64[ns, UTC]]')

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

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

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

我要打赏

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

量化投资

教你使用Akshare获取A股可转债相关信息

2022年7月23日 Python实用宝典留下评论

Akshare 是一个非常好用的开源A股数据获取模块，它是基于 Python 的财经数据接口库，目的是实现对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 akshare --upgrade

目前 AKShare 仅支持 Python 3.7(64 位) 及以上版本。如果遇到 xxx has no attribute xxx, 大概率是Python版本的问题。

2.Akshare 获取可转债基本信息

获取沪深可转债的基本信息，基本信息中包括债券代码、债券简称、申购日期、申购代码、申购上限、正股代码、正股简称、正股价、转股价、转股价值、债现价、转股溢价率、发行规模、中签号发布日、中签率、上市时间等信息。：

import akshare as ak

bond_zh_cov_df = ak.bond_zh_cov()
print(bond_zh_cov_df)

一个使用小示例：如果你想要将可转债代码和正股代码对应起来：

# 公众号：二七阿尔量化
import akshare as ak

bond_zh_cov_df = ak.bond_zh_cov()
code_map = bond_zh_cov_df.set_index("债券代码")
code_map = code_map.to_dict()
cb_stock_code = code_map["正股代码"]
print(cb_stock_code)

效果如下：

{'113652': '603568', '118015': '688595', '127067': '000703', '123153': '300956', '123152': '300727', '113651': '603992', '118014': '688556', '113061': '601689', '118013': '688208', '127066': '002850', '118012': '688321', '118011': '688689', '113650': '603916', '123151': '300869', '123150': '300406', '118010': '688026', '113649': '603810', '118009': '688059', .....}

在code_map.to_dict()后的变量里，我们可以获取可转债代码与其任意字段的map字典，比如转股溢价率：

# 公众号：二七阿尔量化
import akshare as ak

bond_zh_cov_df = ak.bond_zh_cov()
code_map = bond_zh_cov_df.set_index("债券代码")
code_map = code_map.to_dict()
cb_stock_code = code_map["正股代码"]
temp_data = code_map["转股溢价率"]
print(temp_data)
# {'113652': 4.55, '118015': 7.98, '127067': 12.66, '123153': 7.61, '123152': -4.81, '113651': 3.24, '118014': 1.19, '113061': -17.82, '118013': 10.36, '127066': 0.6, '118012': 2.55, '118011': 9.79, '113650': 19.75, '123151': 34.24, '123150': 26.08, '118010': 15.41, '113649': 34.8, '118009': 41.44, '111005': 15.72, '118008': 42.31, '110087': 31.92  ......

3.获取行情数据

获取可转债的日线行情：

import akshare as ak
bond_zh_hs_cov_daily_df = ak.bond_zh_hs_cov_daily(symbol="sh113542")
print(bond_zh_hs_cov_daily_df)
#            date    open    high     low   close   volume
# 4    2019-08-29  108.68  108.99  108.56  108.71    69900
# ..          ...     ...     ...     ...     ...      ...
# 705  2022-07-22  110.03  110.86  110.03  110.40    50830
# [706 rows x 6 columns]

获取可转债分钟级行情数据：

import akshare as ak

bond_zh_hs_cov_min_df = ak.bond_zh_hs_cov_min(symbol="sz123124", period='1', adjust='', start_date="1979-09-01 09:32:00", end_date="2222-01-01 09:32:00")
print(bond_zh_hs_cov_min_df)
#                       时间       开盘       收盘  ...  成交量       成交额       最新价
# 0    2022-07-22 09:30:00  116.200  116.200  ...   67   77854.0  116.2000
# ..                   ...      ...      ...  ...  ...       ...       ...
# 239  2022-07-22 14:59:00  116.000  116.000  ...    0       0.0  115.7802
# 240  2022-07-22 15:00:00  116.000  116.000  ...   97  112520.0  115.7819

bond_zh_hs_cov_min 支持以下参数：symbol(转债代码)、period(分钟级数据周期)、adjust(复权类型)、start_date(起始时间)、end_date(终止时间)。

其中 period 支持 ‘1’, ‘5’, ’15’, ’30’, ’60’ 分钟级数据。

adjust 支持前复权(“qfq”), 后复权(“hfq”), 或不复权(空值 “”)。

4.可转债比价表

可转债比价表中有转股溢价率、纯债溢价率以及赎回强赎的触发价，有时候也是我们参考的重要指标：

import akshare as ak

bond_cov_comparison_df = ak.bond_cov_comparison()
print(bond_cov_comparison_df)

#       序号    转债代码   转债名称 转债最新价  ...     纯债价值     开始转股日      上市日期      申购日期
# 0      1  113652  伟22转债     -  ...        -  20230130         -  20220722
# 1      2  127067   恒逸转2     -  ...  88.8369  20230127         -  20220721
# 2      3  123153   英力转债     -  ...  95.5621  20230130         -  20220721

除了这些数据以外，akshare中还有可转债价值分析、溢价率分析数据，以及集思录相关数据，大家有兴趣可以访问akshare文档查看：

https://www.akshare.xyz/data/bond/bond.html

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

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

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

我要打赏

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

量化投资

10行代码绘制漂亮金融K线图，Mplfinance 这个神器你不可错过

2022年7月17日 Python实用宝典 4条评论

近期发现许多小伙伴有绘制K线图的需求，甚至有些同学没有用第三方模块自己写代码绘制图表，其实这完全是重复性工作，网上有许多已经成熟的K线图绘制方案，比如我们今天要讲的 Mplfinance.

Mplfinance 其实是 Matplotlib 组织开源项目的一部分。相对于Matplotlib，Mplfinance这个处于金融行业的垂直领域的模块的关注度确实是少了一些，以至于很多朋友都不知道它的存在，实际上它非常实用且好用。

1.准备

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

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

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

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

pip install --upgrade mplfinance

2.Mplfinance 基本使用

我们以沪深300分钟线为例，使用mplfinance绘制各类金融图形。

首先看看数据结构：

import pandas as pd
mins = pd.read_csv('sh300_1min.csv',index_col=0,parse_dates=True)
print(mins)

结构如下：

                       day      open      high       low     close     volume
0      2022-03-07 10:47:00  4406.223  4406.352  4405.662  4405.922   54345400
1      2022-03-07 10:48:00  4406.172  4406.175  4403.834  4403.918   70803100
2      2022-03-07 10:49:00  4403.333  4403.333  4402.235  4402.340   49632500
3      2022-03-07 10:50:00  4402.330  4402.519  4401.838  4402.519   48159200

我们用于mplfinance的数据必须是 Pandas DataFrame. 字段则按需提供，至少要有时间字段和一列数据。另外原始数据如果是其他的数据类型，你必须得先转成DataFrame格式。

此外，时间字段必须转为DatetimeIndex：

# 公众号：二七阿尔量化
import pandas as pd
import mplfinance as mpf
mins = pd.read_csv('sh300_1min.csv',index_col=0,parse_dates=True)
mins["day"] = pd.to_datetime(mins["day"])
mins = mins.set_index("day")
mins.index.name = 'Time'
print(mins)

效果如下：

                         open      high       low     close     volume
Time
2022-03-07 10:47:00  4406.223  4406.352  4405.662  4405.922   54345400
2022-03-07 10:48:00  4406.172  4406.175  4403.834  4403.918   70803100
2022-03-07 10:49:00  4403.333  4403.333  4402.235  4402.340   49632500
2022-03-07 10:50:00  4402.330  4402.519  4401.838  4402.519   48159200

准备完成后就可以绘制图表了：

# 公众号：二七阿尔量化
import pandas as pd
import mplfinance as mpf
mins = pd.read_csv('sh300_1min.csv',index_col=0,parse_dates=True)
mins["day"] = pd.to_datetime(mins["day"])
mins = mins.set_index("day")
mins.index.name = 'Time'

# 绘制默认图像（美国线）
mpf.plot(mins)

绘制蜡烛图（K线图），为了避免图表过大，我这里只取了240条K线：

# 公众号：二七阿尔量化
import pandas as pd
import mplfinance as mpf
mins = pd.read_csv('sh300_1min.csv',index_col=0,parse_dates=True)
mins["day"] = pd.to_datetime(mins["day"])
mins = mins.set_index("day")
mins.index.name = 'Time'

candle_chart = mins.tail(240)
mpf.plot(candle_chart, type='candle')

黑白颜色太单调了，我们可以换成“雅虎”配色：

mpf.plot(candle_chart, type='candle', style='yahoo')

绘制线型图：

# 公众号：二七阿尔量化
import pandas as pd
import mplfinance as mpf
mins = pd.read_csv('sh300_1min.csv',index_col=0,parse_dates=True)
mins["day"] = pd.to_datetime(mins["day"])
mins = mins.set_index("day")
mins.index.name = 'Time'
mpf.plot(mins, type='line')

除了美国线、蜡烛图（K线）、线型图外，mplfinance还支持 renko、pnf 等图形。有兴趣的同学可以改个type看看效果：

3.添加技术指标

绘制简单移动平均线MA5，我们只需要多加一个参数：

# 公众号：二七阿尔量化
import pandas as pd
import mplfinance as mpf
mins = pd.read_csv('sh300_1min.csv',index_col=0,parse_dates=True)
mins["day"] = pd.to_datetime(mins["day"])
mins = mins.set_index("day")
mins.index.name = 'Time'
candle_chart = mins.tail(240)
mpf.plot(candle_chart, type='candle', mav=5)

如果你需要多条移动平均线，只需要将mav改为元组参数，传入你需要的周期参数：

如果你还需要显示成交量(volume), mplfinance 也能实现：

# 公众号：二七阿尔量化
import pandas as pd
import mplfinance as mpf
mins = pd.read_csv('sh300_1min.csv',index_col=0,parse_dates=True)
mins["day"] = pd.to_datetime(mins["day"])
mins = mins.set_index("day")
mins.index.name = 'Time'
candle_chart = mins.tail(240)
mpf.plot(candle_chart, type='candle', mav=(5, 10, 20), volume=True)

如果你还想给蜡烛上色、想更改线条颜色、想增加其他指标，请看第三部分高级使用。

3.高级使用

上色是非常简单的，正如我们之前换成雅虎配色一样，你只需要添加style参数即可换成我们传统的技术指标颜色。但如果你想自定义颜色也是可以做到的，这里我将前120根柱子设置为蓝黄相间，后120根柱子保留原形：

# 公众号：二七阿尔量化
import pandas as pd
import mplfinance as mpf
mins = pd.read_csv('sh300_1min.csv',index_col=0,parse_dates=True)
mins["day"] = pd.to_datetime(mins["day"])
mins = mins.set_index("day")
mins.index.name = 'Time'
candle_chart = mins.tail(240)
mco = ['yellow','blue'] * 60 + [None] * 120
mpf.plot(candle_chart, volume=True, style='yahoo', type='candle', marketcolor_overrides=mco)

效果如下：

有些同学还希望能够绘制自己的技术指标，mplfinance也可以做到：

# 公众号：二七阿尔量化
# https://github.com/matplotlib/mplfinance/blob/master/examples/mpf_animation_macd.py#L28

import pandas as pd
import mplfinance as mpf
import matplotlib.animation as animation

mins = pd.read_csv('sh300_1min.csv',index_col=0,parse_dates=True)
mins["day"] = pd.to_datetime(mins["day"])
mins = mins.set_index("day")
mins.index.name = 'Time'
candle_chart = mins.tail(240)

df = candle_chart

exp12     = df['close'].ewm(span=12, adjust=False).mean()
exp26     = df['close'].ewm(span=26, adjust=False).mean()
macd      = exp12 - exp26
signal    = macd.ewm(span=9, adjust=False).mean()
histogram = macd - signal

apds = [mpf.make_addplot(exp12,color='lime'),
        mpf.make_addplot(exp26,color='c'),
        mpf.make_addplot(histogram,type='bar',width=0.7,panel=1,
                         color='dimgray',alpha=1,secondary_y=False),
        mpf.make_addplot(macd,panel=1,color='fuchsia',secondary_y=True),
        mpf.make_addplot(signal,panel=1,color='b',secondary_y=True),
       ]

s = mpf.make_mpf_style(base_mpf_style='classic',rc={'figure.facecolor':'lightgray'})

fig, axes = mpf.plot(df,type='candle',addplot=apds,figscale=1.5,figratio=(7,5),title='\n\nMACD',
                     style=s,volume=True,volume_panel=2,panel_ratios=(6,3,2),returnfig=True)

mpf.show()

mpf.make_addplot 支持添加任意图形到任意panel上，panel参数默认为0，如果设为1则将图形添加到第二个图上，color参数能设置图形颜色，secondary_y 能将图形的值设置到y轴上。效果如下：

此外，如果你希望能动态看到整个绘制过程，增加个animation即可：

# 公众号：二七阿尔量化
import pandas as pd
import mplfinance as mpf
import matplotlib.animation as animation

mins = pd.read_csv('sh300_1min.csv',index_col=0,parse_dates=True)
mins["day"] = pd.to_datetime(mins["day"])
mins = mins.set_index("day")
mins.index.name = 'Time'
candle_chart = mins.tail(240)

df = candle_chart

exp12     = df['close'].ewm(span=12, adjust=False).mean()
exp26     = df['close'].ewm(span=26, adjust=False).mean()
macd      = exp12 - exp26
signal    = macd.ewm(span=9, adjust=False).mean()
histogram = macd - signal

apds = [mpf.make_addplot(exp12,color='lime'),
        mpf.make_addplot(exp26,color='c'),
        mpf.make_addplot(histogram,type='bar',width=0.7,panel=1,
                         color='dimgray',alpha=1,secondary_y=False),
        mpf.make_addplot(macd,panel=1,color='fuchsia',secondary_y=True),
        mpf.make_addplot(signal,panel=1,color='b',secondary_y=True),
       ]

s = mpf.make_mpf_style(base_mpf_style='classic',rc={'figure.facecolor':'lightgray'})

fig, axes = mpf.plot(df,type='candle',addplot=apds,figscale=1.5,figratio=(7,5),title='\n\nMACD',
                     style=s,volume=True,volume_panel=2,panel_ratios=(6,3,2),returnfig=True)

mpf.show()

ax_main = axes[0]
ax_emav = ax_main
ax_hisg = axes[2]
ax_macd = axes[3]
ax_sign = ax_macd
ax_volu = axes[4]


def animate(ival):
    if (20+ival) > len(df):
        print('no more data to plot')
        ani.event_source.interval *= 3
        if ani.event_source.interval > 12000:
            exit()
        return
    data = df.iloc[0:(30+ival)]
    exp12     = data['close'].ewm(span=12, adjust=False).mean()
    exp26     = data['close'].ewm(span=26, adjust=False).mean()
    macd      = exp12 - exp26
    signal    = macd.ewm(span=9, adjust=False).mean()
    histogram = macd - signal
    apds = [mpf.make_addplot(exp12,color='lime',ax=ax_emav),
            mpf.make_addplot(exp26,color='c',ax=ax_emav),
            mpf.make_addplot(histogram,type='bar',width=0.7,
                             color='dimgray',alpha=1,ax=ax_hisg),
            mpf.make_addplot(macd,color='fuchsia',ax=ax_macd),
            mpf.make_addplot(signal,color='b',ax=ax_sign),
           ]

    for ax in axes:
        ax.clear()
    mpf.plot(data,type='candle',addplot=apds,ax=ax_main,volume=ax_volu)

ani = animation.FuncAnimation(fig,animate,interval=100)

mpf.show()

还有许多更有趣的玩法，你可以阅读mplfinance的examples学习更多的使用技巧：

https://github.com/matplotlib/mplfinance/tree/master/examples

本文的全部代码和数据包括mplfinance的examples都可以在【二七阿尔量化】公众号后台回复：mplfinance 下载。

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

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

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

我要打赏

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

深度学习、量化投资

Python 量化投资的强化学习神器！FinRL 入门指南

2022年7月5日 Python实用宝典留下评论

关于强化学习的基础知识，可以阅读我们以前发表的一篇基础文章：

《什么是强化学习？预测股票的效果如何？》

使用强化学习预测股价，类似于心理学中的操作性条件反射原理，你需要在决策的时候采取合适的行动 (Action) 使奖励最大化。与监督学习预测未来的数值不同，强化学习根据输入的状态（如当日开盘价、收盘价等），输出系列动作（例如：买进、持有、卖出），并对好的动作结果不断进行奖励，对差的动作结果不断进行惩罚，使得最后的收益最大化，实现自动交易。

如果你从头开始编写一套强化学习的代码，时间成本和试错成本会比较高。而本文的主角 FinRL 框架，能够帮助你极大地减少学习成本、时间成本和试错成本。下面就介绍一下 FinRL 的使用方法。

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/AI4Finance-Foundation/FinRL.git
# 进入刚克隆的项目，安装依赖
cd FinRL
pip install

请注意 Python 版本要大于等于 3.7。此外，如果你的当前Python环境下安装了 zipline，请 pip uninstall 掉 zipline，因为Zipline与FinRL不兼容。

可能出现的错误：

如果你出现以下红字提示：

error: command 'swig.exe' failed: No such file or directory

请使用conda安装swig：

conda install swig

然后重新执行 pip install . 即可。

2.模型训练

运行官方示例的时候会使用到雅虎财经的数据，雅虎财经在中国已经关闭服务，因此你会需要VPN才能下载雅虎财经的数据。

cd FinRL
python Stock_NeurIPS2018.py

运行的时候大概率会遇到这个问题(2022-07-03)：

FileNotFoundError: Please set your own ALPACA_API_KEY and ALPACA_API_SECRET in config_private.py

这是官网的一个不严谨实现导致的，你可以将 finrl/main.py 中25~30行的代码移动到第100行，如下所示：

此外，在运行代码的时候，你可能会遇到无法下载数据的问题，这是因为雅虎财经在中国已经关闭服务，你需要在 Stock_NeurIPS2018.py 的第172行代码 fetch_data 函数中添加proxy参数：

# 公众号：二七阿尔量化
# 此处我的代理是10809端口，你应该按需修改
df = YahooDownloader(start_date = '2009-01-01',
                     end_date = '2021-10-31',
                     ticker_list = config_tickers.DOW_30_TICKER
                     ).fetch_data(proxy={"http": "http://127.0.0.1:10809", "https": "https://127.0.0.1:10809"})

此外，在 finrl/finrl_meta/preprocessor/preprocessors.py 的第191行，你也需要增加proxy参数：

# 公众号：二七阿尔量化
# 此处我的代理是10809端口，你应该按需修改
df_vix = YahooDownloader(
            start_date=df.date.min(), end_date=df.date.max(), ticker_list=["^VIX"]
        ).fetch_data(proxy={"http": "http://127.0.0.1:10809", "https": "https://127.0.0.1:10809"})

正常运行起来的模型训练如下图所示：

下面是我简化版的到SAC模型训练为止的全部代码：

# 公众号：二七阿尔量化
from finrl import config
from finrl import config_tickers
from finrl.main import check_and_make_directories

import pandas as pd

from finrl.finrl_meta.preprocessor.yahoodownloader import YahooDownloader
from finrl.finrl_meta.preprocessor.preprocessors import FeatureEngineer, data_split
from finrl.finrl_meta.env_stock_trading.env_stocktrading import StockTradingEnv
from finrl.agents.stablebaselines3.models import DRLAgent

import sys
sys.path.append("../FinRL-Library")

import itertools

from finrl.config import (
    DATA_SAVE_DIR,
    TRAINED_MODEL_DIR,
    TENSORBOARD_LOG_DIR,
    RESULTS_DIR,
)

check_and_make_directories([DATA_SAVE_DIR, TRAINED_MODEL_DIR, TENSORBOARD_LOG_DIR, RESULTS_DIR])


'''
# Part 1. 下载数据
'''

df = YahooDownloader(
    start_date='2009-01-01',
    end_date='2021-10-31',
    ticker_list=config_tickers.DOW_30_TICKER
).fetch_data(proxy={"http": "http://127.0.0.1:10809", "https": "https://127.0.0.1:10809"})


print(f"config_tickers.DOW_30_TICKER: {config_tickers.DOW_30_TICKER}")


print(f"df.shape: {df.shape}")


df.sort_values(['date','tic'],ignore_index=True).head()


'''
# Part 2: 数据预处理
'''

fe = FeatureEngineer(
                    use_technical_indicator=True,
                    tech_indicator_list=config.INDICATORS,
                    use_vix=True,
                    use_turbulence=True,
                    user_defined_feature = False)

processed = fe.preprocess_data(df)


list_ticker = processed["tic"].unique().tolist()
list_date = list(pd.date_range(processed['date'].min(),processed['date'].max()).astype(str))
combination = list(itertools.product(list_date,list_ticker))

processed_full = pd.DataFrame(combination,columns=["date","tic"]).merge(processed,on=["date","tic"],how="left")
processed_full = processed_full[processed_full['date'].isin(processed['date'])]
processed_full = processed_full.sort_values(['date','tic'])

processed_full = processed_full.fillna(0)


processed_full.sort_values(['date','tic'],ignore_index=True).head(10)

# 训练集
train = data_split(processed_full, '2009-01-01','2020-07-01')
# 测试集
trade = data_split(processed_full, '2020-07-01','2021-10-31')

print(f"len(train): {len(train)}")
print(f"len(trade): {len(trade)}")
print(f"train.tail(): {train.tail()}")
print(f"trade.head(): {trade.head()}")
print(f"config.INDICATORS: {config.INDICATORS}")
stock_dimension = len(train.tic.unique())
state_space = 1 + 2*stock_dimension + len(config.INDICATORS)*stock_dimension
print(f"Stock Dimension: {stock_dimension}, State Space: {state_space}")

buy_cost_list = sell_cost_list = [0.001] * stock_dimension
num_stock_shares = [0] * stock_dimension

env_kwargs = {
    "hmax": 100,
    "initial_amount": 1000000,
    "num_stock_shares": num_stock_shares,
    "buy_cost_pct": buy_cost_list,
    "sell_cost_pct": sell_cost_list,
    "state_space": state_space,
    "stock_dim": stock_dimension,
    "tech_indicator_list": config.INDICATORS,
    "action_space": stock_dimension,
    "reward_scaling": 1e-4
}


e_train_gym = StockTradingEnv(df = train, **env_kwargs)

env_train, _ = e_train_gym.get_sb_env()
print(f"type(env_train): {type(env_train)}")


'''
# Part 3: 模型训练
'''
agent = DRLAgent(env = env_train)
SAC_PARAMS = {
    "batch_size": 128,
    "buffer_size": 1000000,
    "learning_rate": 0.0001,
    "learning_starts": 100,
    "ent_coef": "auto_0.1",
}

model_sac = agent.get_model("sac", model_kwargs = SAC_PARAMS)


trained_sac = agent.train_model(model=model_sac,
                             tb_log_name='sac',
                             total_timesteps=60000)

3.模型测试

在这一部分，我们将使用测试集进行模拟交易，检验模型的效果。

在env_kwargs中，我们设置了初始资金为1000000美元，测试也会以这个初始资金为起点。

# 测试
e_trade_gym = StockTradingEnv(df=trade, turbulence_threshold=70, risk_indicator_col='vix', **env_kwargs)
df_account_value, df_actions = DRLAgent.DRL_prediction(
    model=trained_sac,
    environment=e_trade_gym
)
print(f"df_account_value.tail(): {df_account_value.tail()}")

如下：

此外，df_actions内保存了每天的持仓记录：

print(f"df_actions.head(): {df_actions.head()}")

调用 backtest_stats 函数，能获得完整的回测结果：

print("==============Get Backtest Results===========")
now = datetime.datetime.now().strftime('%Y%m%d-%Hh%M')

perf_stats_all = backtest_stats(account_value=df_account_value)
perf_stats_all = pd.DataFrame(perf_stats_all)
perf_stats_all.to_csv("./"+config.RESULTS_DIR+"/perf_stats_all_"+now+'.csv')

结果如下所示：

可以见到，模型的年化收益为30%，累计净值收益为43%.

但是这段时间为美股的牛市，我们还需要以道琼斯指数为基准计算超额收益，才能更直观地展示模型的效果：

print("==============Get Baseline Stats===========")
baseline_df = get_baseline(
        ticker="^DJI",
        start = df_account_value.loc[0,'date'],
        end = df_account_value.loc[len(df_account_value)-1,'date'])

stats = backtest_stats(baseline_df, value_col_name = 'close')

可见模型还是具有超额收益的，我们将其绘制为图表更清晰地表达：

backtest_result = backtest_plot(df_account_value, 
             baseline_ticker = '^DJI', 
             baseline_start = df_account_value.loc[0,'date'],
             baseline_end = df_account_value.loc[len(df_account_value)-1,'date'])
with open("backtest_result.html", "w") as file:
    file.write(backtest_result)

作者给我们内置了许多漂亮的回测图表，非常好用。但我们只需要看最关键的cumulative returns. 从图中可以看到这个模型（绿色的线条）一开始的表现并不如指数，但是到了后面，它的表现渐渐优于指数。

当然，这是官方给的示例数据，大家可以用自己的因子补充数据，将模型完善地更好。本文的示例中使用的是SAC模型，你也可以尝试其他的强化学习模型。

总之，Finrl 只能提供你一双”巨人的肩膀“，你应该根据自己的实际业务场景和数据类型使用不同的优化方法。

4.其他

FinRL不只能支持美股，它还支持A股的部分数据源，如聚宽、米筐和Tushare：

以downloader为例，用法很简单，库中提供了 Tushare 的 downloader, 你只需要把：

from finrl.finrl_meta.preprocessor.yahoodownloader import YahooDownloader

替换为：

from finrl.finrl_meta.preprocessor.tusharedownloader import TushareDownloader

并进行相应的代码修改即可，当然，除此之外还有许多细节问题需要处理，由于文章篇幅的问题，我们留到下篇文章再给大家介绍。

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

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

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

我要打赏

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

量化投资

教你用Python计算对量化交易至关重要的VWAP指标

2022年3月27日 Python实用宝典留下评论

成交量加权平均价格 (VWAP) 在金融业中是指特定时间范围内交易价值与交易总数量的比率。它具有三个重要的特点和优势，为交易者提供了对价格趋势的洞察方法。机构和交易者使用 VWAP 来识别买卖区域，并帮助衡量市场情绪。

1.为什么要用VWAP？

VWAP有三个重要的特点：

1. VWAP可以帮助我们了解市场情绪。当证券价格高于VWAP线时，市场对它是乐观看涨的。当价格低于VWAP线时，市场是悲观看跌的。这一点我们可以从下图直观地了解。

2. 许多日内交易者和大型机构投资者以及养老金计划都使用VWAP来作为衡量自己的交易是否会影响市场的重要指标。比如机构交易者想要卖出自己重要的头寸时，他们的目标是以VWAP或更高的价格卖出。他们会用几种VWAP盘中策略来确定三件事（趋势、谁在影响价格、确定支撑位和压力位）。

3. VWAP及其与证券价格平均值（HLC）的1个标准差可以作为潜在的支撑和阻力，如下图所示。

2 如何用Python计算VWAP

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

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

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

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

pip install pandas

VWAP的计算公式如下：

TP =（最高价+最低价+收盘价）/3

V = 成交量

VWAP = (TP_1 * V_1 + TP_2 * V_2 + TP_n * V_n)/n

例如，如果一只股票以 10 美元交易 1000 股，然后以 11 美元交易 100 股，则最终交易价格为 11 美元；但是，VWAP 将更接近 10：

(1000 * 10 + 100 * 11)/(1000 + 100)) = 10.09

接下来，我们制造一些假数据来准备计算VWAP：

# Get imports
import datetime
import pandas as pd

# Create example dataframe
df = pd.DataFrame(
index=[datetime.datetime(2021,1,1,1),
datetime.datetime(2021,1,1,2),
datetime.datetime(2021,1,1,3),
datetime.datetime(2021,1,1,4)],
data={
  'low':[9,10,11,12],
  'close':[10,11,12,13],
  'high':[11,12,13,14],
  'volume':[1000,750,500,250]
  }
)
df.index.rename('date', inplace=True)

数据如下：

                    low  close  high  volume
date
2021-01-01 01:00:00    9     10    11    1000
2021-01-01 02:00:00   10     11    12     750
2021-01-01 03:00:00   11     12    13     500
2021-01-01 04:00:00   12     13    14     250

VWAP的计算方法如下，这里采用了HLC（open、low、close）的平均值作为基准计算对象：

# Create VWAP function
def vwap(df):
    v = df['volume'].values
    tp = (df['low'] + df['close'] + df['high']).div(3).values
    return df.assign(vwap=(tp * v).cumsum() / v.cumsum())

vwap(df)

计算完成后会在原来的数据上添加一列vwap列：

                     low  close  high  volume       vwap
date
2021-01-01 01:00:00    9     10    11    1000  10.000000
2021-01-01 02:00:00   10     11    12     750  10.428571
2021-01-01 03:00:00   11     12    13     500  10.777778
2021-01-01 04:00:00   12     13    14     250  11.000000

验证一下：

# Verify VWAP
## 以第二行为例
(10*1000 + 11*750) / (1000+750)
10.428571 # 正确

3.VWAP的缺点

没有全能的指标，VWAP也有其自身的缺点。

1.滞后性。和其他的移动平均线一样，VWAP也是一个滞后的指标，而且随着日内交易量的累计，滞后性会越来越严重。

2.仅适用于短期图表，如秒级、分钟级。

4.VWAP 策略

我们已经知道VWAP的运行特点，那么如何利用这些特点进行交易呢？

利用其回调的特点。当股价在一天内显着超过 VWAP 和移动平均线时，它们可能会回调。你可以选择在股价大幅度上涨时卖空股票，也可以选择在回调时等待入场。

Fade策略。这个策略是一个逆势策略，它在强劲势头的运动后采取相反的立场。利用VWAP发的支撑和压力作为其入场和出场的信号。

午后走高策略。这是一个油管老哥(Tim Bohen)观察出来的策略，他发现热门股票早盘走高，并且价格持续保持在vwap上方的股票，午后走高突破的几率非常大。

当然，所有策略都应该被回测后再确定是否有效。以上策略只是一个根据VWAP做交易的思路，你还可以结合其他指标进行策略的开发和回测，有兴趣的同学可以试试看。

本文参考文章：https://analyzingalpha.com/blog/vwap

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

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

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

我要打赏

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

量化投资

FreqTrade—又强又简单的Python加密货币自动交易机器人

2022年2月17日 Python实用宝典留下评论

Freqtrade 是一个用 Python 编写的免费开源加密货币交易机器人。它旨在支持所有主要交易所并通过 Telegram 或 webUI 进行控制。功能包含回测、绘图和资金管理工具以及通过机器学习的策略优化。

目前支持的交易所：

特性：

基于 Python 3.8+：适用于任何操作系统 – Windows、macOS 和 Linux。
持久性：持久性是通过 sqlite 实现的。
Dry-run：不花钱运行机器人。
回测：模拟买入/卖出策略。
通过机器学习进行策略优化：使用机器学习通过真实的交易所数据优化买入/卖出策略参数。
边缘头寸规模计算您的胜率、风险回报率、最佳止损位并在为每个特定市场建立头寸之前调整头寸规模。
白名单加密货币：选择你要交易的加密货币或使用动态白名单。
黑名单加密货币：选择你想要避免的加密货币。
内置 WebUI：内置 Web UI 来管理你的机器人。
可通过 Telegram管理：使用 Telegram 管理机器人。
以法定货币显示盈亏：以法定货币显示你的盈亏。
表现状态报告：提供你当前交易的表现状态。

1.准备

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

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

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

在Linux/MacOS下，三行命令就能完成安装：

git clone -b develop https://github.com/freqtrade/freqtrade.git
cd freqtrade
./setup.sh --install

如果你无法克隆此项目，请在Python实用宝典公众号后台回复：freqtrade 下载。

Windows环境下打开Cmd(开始—运行—CMD)，输入命令安装依赖：

git clone https://github.com/freqtrade/freqtrade.git
cd freqtrade
# 安装ta-lib
pip install build_helpers/TA_Lib-0.4.24-cp38-cp38-win_amd64.whl
pip install -r requirements.txt
pip install -e .
freqtrade

请注意，此处安装ta-lib时项目方提供了python3.8/3.9/3.10，其他Python版本请自行搜索下载。

输入freqtrade时，显示以下信息说明安装成功：

(freqtrade) D:\CODE\trader\freqtrade>freqtrade
2022-02-17 19:40:50,174 - freqtrade - ERROR - Usage of Freqtrade requires a subcommand to be specified.
To have the bot executing trades in live/dry-run modes, depending on the value of the `dry_run` setting in the config, run Freqtrade as `freqtrade trade [options...]`.
To see the full list of options available, please use `freqtrade --help` or `freqtrade <command> --help`.

2.Freqtrade 快速开始

下面教你如何开发一个简单的交易策略。

一个策略文件往往包含这些东西：

指标
购买规则
卖出规则
建议最低投资回报率
强烈推荐止损

Freqtrade使用 Pandas 作为基础数据结构，它底层的OHLCV都是以Dataframe的格式存储的。

Dataframe数据流中每一行数据代表图表上的一根K线，最新的K线始终是数据库中最后一根。

> dataframe.head()
                       date      open      high       low     close     volume
0 2021-11-09 23:25:00+00:00  67279.67  67321.84  67255.01  67300.97   44.62253
1 2021-11-09 23:30:00+00:00  67300.97  67301.34  67183.03  67187.01   61.38076
2 2021-11-09 23:35:00+00:00  67187.02  67187.02  67031.93  67123.81  113.42728
3 2021-11-09 23:40:00+00:00  67123.80  67222.40  67080.33  67160.48   78.96008
4 2021-11-09 23:45:00+00:00  67160.48  67160.48  66901.26  66943.37  111.39292

Pandas 提供了计算指标的快速方法。为了从这种速度中受益，建议不要使用循环，而是使用矢量化方法。

矢量化操作在整个数据范围内执行计算，因此，与遍历每一行相比，在计算指标时要快得多。

dataframe.loc[(dataframe['rsi'] > 30), 'buy'] = 1

类似于上面这样的赋值方法，会自动设置rsi大于30的数据的buy列的值为1。

买入规则

def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
    """
    Based on TA indicators, populates the buy signal for the given dataframe
    :param dataframe: DataFrame populated with indicators
    :param metadata: Additional information, like the currently traded pair
    :return: DataFrame with buy column
    """
    dataframe.loc[
        (
            (qtpylib.crossed_above(dataframe['rsi'], 30)) &  # Signal: RSI crosses above 30
            (dataframe['tema'] <= dataframe['bb_middleband']) &  # Guard
            (dataframe['tema'] > dataframe['tema'].shift(1)) &  # Guard
            (dataframe['volume'] > 0)  # Make sure Volume is not 0
        ),
        'buy'] = 1

    return dataframe

请注意，一定要不修改并返回”open”, “high”, “low”, “close”, “volume”列，这些是基础行情数据，如果返回错误的数据将可能会导致一些奇怪数据的产生。

如上所示的方法中，符合条件的数据的buy值会被设为1代表买入，否则为0或nan值。

卖出规则

def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
    """
    Based on TA indicators, populates the sell signal for the given dataframe
    :param dataframe: DataFrame populated with indicators
    :param metadata: Additional information, like the currently traded pair
    :return: DataFrame with buy column
    """
    dataframe.loc[
        (
            (qtpylib.crossed_above(dataframe['rsi'], 70)) &  # Signal: RSI crosses above 70
            (dataframe['tema'] > dataframe['bb_middleband']) &  # Guard
            (dataframe['tema'] < dataframe['tema'].shift(1)) &  # Guard
            (dataframe['volume'] > 0)  # Make sure Volume is not 0
        ),
        'sell'] = 1
    return dataframe

与买入类似，这里不赘述了。

最小投资回报率

在类中增加这个初始化变量，能控制投资回报率：

minimal_roi = {
    "40": 0.0,
    "30": 0.01,
    "20": 0.02,
    "0": 0.04
}

上述配置意味着：

只要达到 4% 的利润就卖出
达到 2% 利润时卖出（20 分钟后生效）
达到 1% 利润时卖出（30 分钟后生效）
交易未亏损时卖出（40 分钟后生效）

此处的计算包含费用。

要完全禁用 ROI，请将其设置为一个非常高的数字：

minimal_roi = {
    "0": 100
}

虽然从技术上讲并没有完全禁用，但一旦交易达到 10000% 利润，它就会卖出。

止损

强烈建议设置止损，以保护资金免受不利的剧烈波动。

设置 10% 止损的示例：

stoploss = -0.10

一个完整代码如下：

# pragma pylint: disable=missing-docstring, invalid-name, pointless-string-statement
# flake8: noqa: F401
# isort: skip_file
# --- Do not remove these libs ---
from re import A
import numpy as np  # noqa
import pandas as pd  # noqa
from pandas import DataFrame

from freqtrade.strategy import (BooleanParameter, CategoricalParameter, DecimalParameter,
                                IStrategy, IntParameter)

# --------------------------------
# 你自己所需要的模块放在这里
import talib.abstract as ta
import freqtrade.vendor.qtpylib.indicators as qtpylib


# This class is a sample. Feel free to customize it.
class SampleStrategy(IStrategy):
    """
    This is a sample strategy to inspire you.
    More information in https://www.freqtrade.io/en/latest/strategy-customization/
    You can:
        :return: a Dataframe with all mandatory indicators for the strategies
    - Rename the class name (Do not forget to update class_name)
    - Add any methods you want to build your strategy
    - Add any lib you need to build your strategy
    You must keep:
    - the lib in the section "Do not remove these libs"
    - the methods: populate_indicators, populate_buy_trend, populate_sell_trend
    You should keep:
    - timeframe, minimal_roi, stoploss, trailing_*
    """
    # Strategy interface version - allow new iterations of the strategy interface.
    # Check the documentation or the Sample strategy to get the latest version.
    INTERFACE_VERSION = 2

    # 设定最小投资回报
    minimal_roi = {
        "60": 0.01,
        "30": 0.02,
        "0": 0.04
    }

    # 止损
    stoploss = -0.10

    # 指标参数
    buy_rsi = IntParameter(low=1, high=50, default=30, space='buy', optimize=True, load=True)
    sell_rsi = IntParameter(low=50, high=100, default=70, space='sell', optimize=True, load=True)

    # K线时间
    timeframe = '5m'

    # 在新K线出现时执行
    process_only_new_candles = False

    # These values can be overridden in the "ask_strategy" section in the config.
    use_sell_signal = True
    sell_profit_only = False
    ignore_roi_if_buy_signal = False

    # 预准备K线数
    startup_candle_count: int = 30

    # 下单类型
    order_types = {
        'buy': 'limit',
        'sell': 'limit',
        'stoploss': 'market',
        'stoploss_on_exchange': False
    }

    # 订单有效时间(gtc: 除非取消否则一直有效)
    order_time_in_force = {
        'buy': 'gtc',
        'sell': 'gtc'
    }

    plot_config = {
        'main_plot': {
            'tema': {},
            'sar': {'color': 'white'},
        },
        'subplots': {
            "MACD": {
                'macd': {'color': 'blue'},
                'macdsignal': {'color': 'orange'},
            },
            "RSI": {
                'rsi': {'color': 'red'},
            }
        }
    }

    def informative_pairs(self):
        """
        Define additional, informative pair/interval combinations to be cached from the exchange.
        These pair/interval combinations are non-tradeable, unless they are part
        of the whitelist as well.
        For more information, please consult the documentation
        :return: List of tuples in the format (pair, interval)
            Sample: return [("ETH/USDT", "5m"),
                            ("BTC/USDT", "15m"),
                            ]
        """
        return []

    def populate_indicators(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        Adds several different TA indicators to the given DataFrame
        Performance Note: For the best performance be frugal on the number of indicators
        you are using. Let uncomment only the indicator you are using in your strategies
        or your hyperopt configuration, otherwise you will waste your memory and CPU usage.
        :param dataframe: Dataframe with data from the exchange
        :param metadata: Additional information, like the currently traded pair
        :return: a Dataframe with all mandatory indicators for the strategies
        """

        # Momentum Indicators
        # ------------------------------------

        dataframe['adx'] = ta.ADX(dataframe)
        dataframe['rsi'] = ta.RSI(dataframe)
        stoch_fast = ta.STOCHF(dataframe)
        dataframe['fastd'] = stoch_fast['fastd']
        dataframe['fastk'] = stoch_fast['fastk']

        # MACD
        macd = ta.MACD(dataframe)
        dataframe['macd'] = macd['macd']
        dataframe['macdsignal'] = macd['macdsignal']
        dataframe['macdhist'] = macd['macdhist']

        # MFI
        dataframe['mfi'] = ta.MFI(dataframe)

        # Bollinger Bands
        bollinger = qtpylib.bollinger_bands(qtpylib.typical_price(dataframe), window=20, stds=2)
        dataframe['bb_lowerband'] = bollinger['lower']
        dataframe['bb_middleband'] = bollinger['mid']
        dataframe['bb_upperband'] = bollinger['upper']
        dataframe["bb_percent"] = (
            (dataframe["close"] - dataframe["bb_lowerband"]) /
            (dataframe["bb_upperband"] - dataframe["bb_lowerband"])
        )
        dataframe["bb_width"] = (
            (dataframe["bb_upperband"] - dataframe["bb_lowerband"]) / dataframe["bb_middleband"]
        )

        # Parabolic SAR
        dataframe['sar'] = ta.SAR(dataframe)

        # TEMA - Triple Exponential Moving Average
        dataframe['tema'] = ta.TEMA(dataframe, timeperiod=9)

        hilbert = ta.HT_SINE(dataframe)
        dataframe['htsine'] = hilbert['sine']
        dataframe['htleadsine'] = hilbert['leadsine']

        return dataframe

    def populate_buy_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        Based on TA indicators, populates the buy signal for the given dataframe
        :param dataframe: DataFrame populated with indicators
        :param metadata: Additional information, like the currently traded pair
        :return: DataFrame with buy column
        """
        dataframe.loc[
            (
                # Signal: RSI crosses above 30
                (qtpylib.crossed_above(dataframe['rsi'], self.buy_rsi.value)) &
                (dataframe['tema'] <= dataframe['bb_middleband']) &  # Guard: tema below BB middle
                (dataframe['tema'] > dataframe['tema'].shift(1)) &  # Guard: tema is raising
                (dataframe['volume'] > 0)  # Make sure Volume is not 0
            ), 'buy'] = 1

        return dataframe

    def populate_sell_trend(self, dataframe: DataFrame, metadata: dict) -> DataFrame:
        """
        Based on TA indicators, populates the sell signal for the given dataframe
        :param dataframe: DataFrame populated with indicators
        :param metadata: Additional information, like the currently traded pair
        :return: DataFrame with sell column
        """
        dataframe.loc[
            (
                # Signal: RSI crosses above 70
                (qtpylib.crossed_above(dataframe['rsi'], self.sell_rsi.value)) &
                (dataframe['tema'] > dataframe['bb_middleband']) &  # Guard: tema above BB middle
                (dataframe['tema'] < dataframe['tema'].shift(1)) &  # Guard: tema is falling
                (dataframe['volume'] > 0)  # Make sure Volume is not 0
            ), 'sell'] = 1
        return dataframe

3.启动机器人

启动机器人前还需要设定配置，配置模板在 config/examples 下面。

比如币安的配置，你还需要输入key和secret：

"exchange": {
        "name": "binance",
        "key": "your_exchange_key",
        "secret": "your_exchange_secret",
  	    ......
	}
}

启动机器人：

freqtrade trade --strategy AwesomeStrategy --strategy-path /some/directory  -c path/far/far/away/config.json

–strategy-path 指定策略文件位置

-c 参数指定配置文件位置

比如我把策略放在了user_data/strategies下，配置放在了config_examples下，这么输入命令启动机器人即可：

freqtrade trade --strategy SampleStrategy --strategy-path user_data/strategies  -c config_examples/config_binance.example.json

由于篇幅问题，本文只是介绍了freqtrade的冰山一角，在启动机器人前，一定要进行回测并进行模拟交易。它还有TG通知功能、WebUI管理界面，详细的使用方法大家可以参考官方教程：

https://www.freqtrade.io/en/stable/

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

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

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

我要打赏

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

github

Tqsdk-python-天勤量化开发包，期货量化，实时行情/历史数据/实盘交易

2021年8月21日 Python实用宝典

TqSdk天勤量化交易策略程序开发包

TqSdk是一个由信易科技发起并贡献主要代码的开源Python库.依托快期多年积累成熟的交易及行情服务器体系，TqSdk支持用户使用极少的代码量构建各种类型的量化交易策略程序，并提供包含期货、期权、股票的历史数据-实时数据-开发调试-策略回测-模拟交易-实盘交易-运行监控-风险管理全套解决方案

from tqsdk import TqApi, TqAuth, TqAccount, TargetPosTask

api = TqApi(TqAccount("H海通期货", "4003242", "123456"), auth=TqAuth("信易账户", "账户密码"))      # 创建 TqApi 实例, 指定交易账户
q_1910 = api.get_quote("SHFE.rb1910")                         # 订阅近月合约行情
t_1910 = TargetPosTask(api, "SHFE.rb1910")                    # 创建近月合约调仓工具
q_2001 = api.get_quote("SHFE.rb2001")                         # 订阅远月合约行情
t_2001 = TargetPosTask(api, "SHFE.rb2001")                    # 创建远月合约调仓工具

while True:
  api.wait_update()                                           # 等待数据更新
  spread = q_1910["last_price"] - q_2001["last_price"]        # 计算近月合约-远月合约价差
  print("当前价差:", spread)
  if spread > 250:
    print("价差过高: 空近月，多远月")                            
    t_1910.set_target_volume(-1)                              # 要求把1910合约调整为空头1手
    t_2001.set_target_volume(1)                               # 要求把2001合约调整为多头1手
  elif spread < 200:
    print("价差回复: 清空持仓")                               # 要求把 1910 和 2001合约都调整为不持仓
    t_1910.set_target_volume(0)
    t_2001.set_target_volume(0)

要快速了解如何使用TqSdk，可以访问我们的十分钟快速入门指南

架构

行情网关 (Open Md Gateway)负责提供实时行情和历史数据
交易中继网关 (Open Trade Gateway)负责连接到期货公司交易系统
这两个网关统一以Diff协议对下方提供服务
TqSdk按照Diff协议连接到行情网关和交易中继网关，实现行情和交易功能

功能

TqSdk提供的功能可以支持从简单到复杂的各类策略程序

公司级数据运维，提供当前所有可交易合约从上市开始的全部Tick数据和K线数据
支持市场上90%的期货公司实盘交易
支持模拟交易
支持Tick级和K线级回测，支持复杂策略回测
提供近百个技术指标函数及源码
用户无须建立和维护数据库，行情和交易数据全在内存数据库，无访问延迟
优化支持熊猫和麻木的库
无强制框架结构，支持任意复杂度的策略，在一个交易策略程序中使用多个品种的K线/实时行情并交易多个品种
配合开发者支持工具，能够进行交易信号打点，支持自定义指标画图

安装

TqSdk仅支持Python3.6及更高版本。要安装TqSdk，可使用PIP：

$ pip install tqsdk

文档

在线阅读HTML版本文档：https://doc.shinnytech.com/tqsdk/latest

在线问答社区：https://www.shinnytech.com/qa

知乎账户[天勤量化]：https://www.zhihu.com/org/tian-qin-liang-hua/activities

用户交流QQ群：619870862(目前只允许给我们点过STAR的同学加入，加群时请提供GitHub用户名)

GUI

TqSdk本身自带的WEB_GUI功能，简单一行参数即可支持调用图形化界面，详情参考web_gui

关于我们

信易科技是专业的期货软件供应商和交易所授权行情服务商.旗下的快期系列产品已为市场服务超过10年。TqSdk是公司开源计划的一部分

1.准备

2.CNN模型数据与预处理

3.CNN模型搭建与评估

1.准备

2.使用方法

1.准备

2.基本使用

3.高级功能

1.准备

2.Exchange_calendars 基本使用

3.高级使用

1.准备

2.Akshare 获取可转债基本信息

3.获取行情数据

4.可转债比价表

1.准备

2.Mplfinance 基本使用

3.添加技术指标

3.高级使用

1.准备

2.模型训练

3.模型测试

4.其他

1.为什么要用VWAP？

2 如何用Python计算VWAP

3.VWAP的缺点

4.VWAP 策略

1.准备

2.Freqtrade 快速开始

3.启动机器人

TqSdk天勤量化交易策略程序开发包

架构

功能

安装

文档

GUI

关于我们

有趣好用的Python教程