tqsdk.tafunc - 序列计算函数

Functions:

`ref`(series, n)	简单移动: 求series序列位移n个周期的结果
`std`(series, n)	标准差: 求series序列每n个周期的标准差
`ma`(series, n)	简单移动平均线: 求series序列n周期的简单移动平均
`sma`(series, n, m)	扩展指数加权移动平均: 求series序列n周期的扩展指数加权移动平均
`ema`(series, n)	指数加权移动平均线: 求series序列n周期的指数加权移动平均
`ema2`(series, n)	线性加权移动平均: 求series值的n周期线性加权移动平均 (也称WMA)
`crossup`(a, b)	向上穿越: 表当a从下方向上穿过b, 成立返回1, 否则返回0
`crossdown`(a, b)	向下穿越: 表示当a从上方向下穿b，成立返回1, 否则返回0
`count`(cond, n)	统计n周期中满足cond条件的个数
`trma`(series, n)	三角移动平均: 求series的n周期三角移动平均值
`harmean`(series, n)	调和平均值: 求series在n个周期内的调和平均值
`numpow`(series, n, m)	自然数幂方和
`abs`(series)	获取series的绝对值
`min`(series1, series2)	获取series1和series2中的最小值
`max`(series1, series2)	获取series1和series2中的最大值
`median`(series, n)	中位数: 求series在n个周期内居于中间的数值
`exist`(cond, n)	判断n个周期内, 是否有满足cond的条件, 若满足则值为1, 不满足为0
`every`(cond, n)	判断n个周期内, 是否一直满足cond条件, 若满足则值为1, 不满足为0
`hhv`(series, n)	求series在n个周期内的最高值
`llv`(series, n)	求在n个周期内的最小值
`avedev`(series, n)	平均绝对偏差: 求series在n周期内的平均绝对偏差
`time_to_ns_timestamp`(input_time)	将传入的时间转换为int类型的纳秒级时间戳
`time_to_s_timestamp`(input_time)	将传入的时间转换为int类型的秒级时间戳
`time_to_str`(input_time)	将传入的时间转换为 %Y-%m-%d %H:%M:%S.%f 格式的 str 类型
`time_to_datetime`(input_time)	将传入的时间转换为 datetime.datetime 类型
`barlast`(cond)	返回一个序列，其中每个值表示从上一次条件成立到当前的周期数
`get_t`(df, expire_datetime)	计算 K 线序列对应的年化到期时间，主要用于计算期权相关希腊指标时，需要得到计算出序列对应的年化到期时间
`get_his_volatility`(df, quote)	计算某个合约的历史波动率
`get_bs_price`(series, k, r, v, t, option_class)	计算期权 BS 模型理论价格
`get_delta`(series, k, r, v, t, option_class)	计算期权希腊指标 delta 值
`get_gamma`(series, k, r, v, t[, d1])	计算期权希腊指标 gamma 值
`get_theta`(series, k, r, v, t, option_class)	计算期权希腊指标 theta 值
`get_vega`(series, k, r, v, t[, d1])	计算期权希腊指标 vega 值
`get_rho`(series, k, r, v, t, option_class[, d1])	计算期权希腊指标 rho 值
`get_impv`(series, series_option, k, r, ...)	计算期权隐含波动率
`get_ticks_info`(df)	计算 ticks 开平方向
`get_dividend_df`(stock_dividend_ratio, ...)	计算复权系数矩阵
`get_dividend_factor`(dividend_df, last_item, item)	返回 item 项对应的复权因子。
`get_sharp`(series[, trading_days_of_year, r])	年化夏普率
`get_sortino`(series[, trading_days_of_year, r])	年化索提诺比率
`get_calmar`(series, max_drawdown[, ...])	年化卡玛比率

tqsdk.tafunc.ref(series, n)

简单移动: 求series序列位移n个周期的结果

注意: 当n为0, 函数返回原序列; 当n为有效值但当前的series序列元素个数不足 n + 1 个, 函数返回 NaN 序列

Args:

series (pandas.Series): 数据序列

n (int): 位移周期

Returns:

pandas.Series: 位移后的序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
pre_close = tafunc.ref(klines.close, 1)  # 将收盘价序列右移一位, 得到昨收盘序列
change = klines.close - pre_close        # 收盘价序列 - 昨收盘序列, 得到涨跌序列
print(list(change))

tqsdk.tafunc.std(series, n)

标准差: 求series序列每n个周期的标准差

注意: n为0的情况下, 或当n为有效值但当前的series序列元素个数不足n个, 函数返回 NaN 序列

Args:

series (pandas.Series): 数据序列

n (int): 标准差的周期

Returns:

pandas.Series: 标准差序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
std = tafunc.std(klines.close, 5)  # 收盘价序列每5项计算一个标准差
print(list(std))

tqsdk.tafunc.ma(series, n)

简单移动平均线: 求series序列n周期的简单移动平均

计算公式: ma(x, 5) = (x(1) + x(2) + x(3) + x(4) + x(5)) / 5

注意: 1. 简单移动平均线将设定周期内的值取平均值, 其中各元素的权重都相等 2. n为0的情况下, 或当n为有效值但当前的series序列元素个数不足n个, 函数返回 NaN 序列

Args:

series (pandas.Series): 数据序列

n (int): 周期

Returns:

pandas.Series: 简单移动平均值序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
ma = tafunc.ma(klines.close, 5)
print(list(ma))

tqsdk.tafunc.sma(series, n, m)

扩展指数加权移动平均: 求series序列n周期的扩展指数加权移动平均

计算公式: sma(x, n, m) = sma(x, n, m).shift(1) * (n - m) / n + x(n) * m / n

注意: n必须大于m

Args:

series (pandas.Series): 数据序列

n (int): 周期

m (int): 权重

Returns:

pandas.Series: 扩展指数加权移动平均序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
sma = tafunc.sma(klines.close, 5, 2)  # 收盘价序列每5项计算一个扩展指数加权移动平均值
print(list(sma))

tqsdk.tafunc.ema(series, n)

指数加权移动平均线: 求series序列n周期的指数加权移动平均

计算公式:
ema(x, n) = 2 * x / (n + 1) + (n - 1) * ema(x, n).shift(1) / (n + 1)

注意:

n 需大于等于1

对距离当前较近的k线赋予了较大的权重

Args:

series (pandas.Series): 数据序列

n (int): 周期

Returns:

pandas.Series: 指数加权移动平均线序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
ema = tafunc.ema(klines.close, 5)
print(list(ema))

tqsdk.tafunc.ema2(series, n)

线性加权移动平均: 求series值的n周期线性加权移动平均 (也称WMA)

计算公式:
ema2(x, n) = [n * x(0) + (n - 1) * x(1) + (x - 2) * x(2) + ... + 1 * x(n - 1)] / [n + (n - 1) + (n - 2) + ... + 1]

注意: 当n为有效值但当前的series序列元素个数不足n个, 函数返回 NaN 序列

Args:

series (pandas.Series): 数据序列

n (int): 周期

Returns:

pandas.Series: 线性加权移动平均线序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
ema2 = tafunc.ema2(klines.close, 5)  # 求收盘价在5个周期的线性加权移动平均值
print(list(ema2))

tqsdk.tafunc.crossup(a, b)

向上穿越: 表当a从下方向上穿过b, 成立返回1, 否则返回0

Args:

a (pandas.Series): 数据序列1

b (pandas.Series): 数据序列2

Returns:

pandas.Series: 上穿标志序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
crossup = tafunc.crossup(tafunc.ma(klines.close, 5), tafunc.ma(klines.close, 10))
print(list(crossup))

tqsdk.tafunc.crossdown(a, b)

向下穿越: 表示当a从上方向下穿b，成立返回1, 否则返回0

Args:

a (pandas.Series): 数据序列1

b (pandas.Series): 数据序列2

Returns:

pandas.Series: 下穿标志序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
crossdown = tafunc.crossdown(tafunc.ma(klines.close, 5), tafunc.ma(klines.close, 10))
print(list(crossdown))

tqsdk.tafunc.count(cond, n)

统计n周期中满足cond条件的个数

注意: 如果n为0, 则从第一个有效值开始统计

Args:

cond (array_like): 条件

n (int): 周期

Returns:

pandas.Series: 统计值序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
# 统计从申请到的行情数据以来到当前这段时间内, 5周期均线上穿10周期均线的次数:
count = tafunc.count(tafunc.crossup(tafunc.ma(klines.close, 5), tafunc.ma(klines.close, 10)), 0)
print(list(count))

tqsdk.tafunc.trma(series, n)

三角移动平均: 求series的n周期三角移动平均值

计算方法:
三角移动平均线公式, 是采用算数移动平均, 并且对第一个移动平均线再一次应用算数移动平均

注意: n为0的情况下, 或当n为有效值但当前的series序列元素个数不足n个, 函数返回 NaN 序列

Args:

series (pandas.Series): 数据序列

n (int): 周期

Returns:

pandas.Series: 三角移动平均值序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
trma = tafunc.trma(klines.close, 10)
print(list(trma))

tqsdk.tafunc.harmean(series, n)

调和平均值: 求series在n个周期内的调和平均值

计算方法:
harmean(x, 5) = 1 / [(1 / x(1) + 1 / x(2) + 1 / x(3) + 1 / x(4) + 1 / x(5)) / 5]

注意: 1. 调和平均值与倒数的简单平均值互为倒数 2. 当n为0, 或当n为有效值但当前的series序列元素个数不足n个, 函数返回 NaN 序列

Args:

series (pandas.Series): 数据序列

n (int): 周期

Returns:

pandas.Series: 调和平均值序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
harmean = tafunc.harmean(klines.close, 5)  # 求5周期收盘价的调和平均值
print(list(harmean))

tqsdk.tafunc.numpow(series, n, m)

自然数幂方和

计算方法:
numpow(x, n, m) = n ^ m * x + (n - 1) ^ m * x.shift(1) + (n - 2) ^ m * x.shift(2) + ... + 2 ^ m * x.shift(n - 2) + 1 ^ m * x.shift(n - 1)

注意: 当n为有效值但当前的series序列元素个数不足n个, 函数返回 NaN 序列

Args:

series (pandas.Series): 数据序列

n (int): 自然数

m (int): 实数

Returns:

pandas.Series: 幂方和序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
numpow = tafunc.numpow(klines.close, 5, 2)
print(list(numpow))

tqsdk.tafunc.abs(series)

获取series的绝对值

注意: 正数的绝对值是它本身, 负数的绝对值是它的相反数, 0的绝对值还是0

Args:: series (pandas.Series): 数据序列
Returns:: pandas.Series: 绝对值序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
abs = tafunc.abs(klines.close)
print(list(abs))

tqsdk.tafunc.min(series1, series2)

获取series1和series2中的最小值

Args:

series1 (pandas.Series): 数据序列1

series2 (pandas.Series): 数据序列2

Returns:

pandas.Series: 最小值序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
min = tafunc.min(klines.close, klines.open)
print(list(min))

tqsdk.tafunc.max(series1, series2)

获取series1和series2中的最大值

Args:

series1 (pandas.Series): 数据序列1

series2 (pandas.Series): 数据序列2

Returns:

pandas.Series: 最大值序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
max = tafunc.max(klines.close, klines.open)
print(list(max))

tqsdk.tafunc.median(series, n)

中位数: 求series在n个周期内居于中间的数值

注意:

当n为有效值但当前的series序列元素个数不足n个, 函数返回 NaN 序列

对n个周期内所有series排序后, 若n为奇数, 则选择第(n + 1) / 2个为中位数, 若n为偶数, 则中位数是(n / 2)以及(n / 2 + 1)的平均数

Args:

series (pandas.Series): 数据序列

n (int): 周期

Returns:

pandas.Series: 中位数序列

Example:

例1:
    # 假设最近3日的收盘价为2727, 2754, 2748, 那么当前 median(df["close"], 3) 的返回值是2748
    median3 = tafunc.median(df["close"], 3)

例2:
    # 假设最近4日的开盘价为2752, 2743, 2730, 2728, 那么当前 median(df["open"], 4) 的返回值是2736.5
    median4 = tafunc.median(df["open"], 4)

tqsdk.tafunc.exist(cond, n)

判断n个周期内, 是否有满足cond的条件, 若满足则值为1, 不满足为0

Args:

cond (array_like): 条件

n (int): 周期

Returns:

pandas.Series: 判断结果序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
# 判断4个周期中是否存在收盘价大于前一个周期的最高价, 存在返回1, 不存在则返回0
exist = tafunc.exist(klines.close > klines.high.shift(1), 4)
print(list(exist))

tqsdk.tafunc.every(cond, n)

判断n个周期内, 是否一直满足cond条件, 若满足则值为1, 不满足为0

Args:

cond (array_like): 条件

n (int): 周期

Returns:

pandas.Series: 判断结果序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
# 判断在4周期内, 3周期的简单移动平均是否一直大于5周期的简单移动平均
every = tafunc.every(tafunc.ma(klines.close, 3) > tafunc.ma(klines.close, 5), 4)
print(list(every))

tqsdk.tafunc.hhv(series, n)

求series在n个周期内的最高值

注意: n为0的情况下, 或当n为有效值但当前的series序列元素个数不足n个, 函数返回 NaN 序列

Args:

series (pandas.Series): 数据序列

n (int): 周期

Returns:

pandas.Series: 最高值序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
hhv = tafunc.hhv(klines.high, 4)  # 求4个周期最高价的最大值, 即4周期高点(包含当前k线)
print(list(hhv))

tqsdk.tafunc.llv(series, n)

求在n个周期内的最小值

注意: n为0的情况下, 或当n为有效值但当前的series序列元素个数不足n个, 函数返回 NaN 序列

Args:

series (pandas.Series): 数据序列

n (int): 周期

Returns:

pandas.Series: 最小值序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
llv = tafunc.llv(klines.low, 5)  # 求5根k线最低点(包含当前k线)
print(list(llv))

tqsdk.tafunc.avedev(series, n)

平均绝对偏差: 求series在n周期内的平均绝对偏差

算法:
计算avedev(df["close"],3)在最近一根K线上的值: (abs(df["close"] - (df["close"] + df["close"].shift(1) + df["close"].shift(2)) / 3) + abs( df["close"].shift(1) - (df["close"] + df["close"].shift(1) + df["close"].shift(2)) / 3) + abs( df["close"].shift(2) - (df["close"] + df["close"].shift(1) + df["close"].shift(2)) / 3)) / 3

注意: n为0的情况下, 或当n为有效值但当前的series序列元素个数不足n个, 函数返回 NaN 序列

Args:

series (pandas.Series): 数据序列

n (int): 周期

Returns:

pandas.Series: 平均绝对偏差序列

Example:

from tqsdk import TqApi, TqAuth, TqSim, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("CFFEX.IF1908", 24 * 60 * 60)
# 计算收盘价在5周期内的平均绝对偏差, 表示5个周期内每个周期的收盘价与5周期收盘价的平均值的差的绝对值的平均值, 判断收盘价与其均值的偏离程度:
avedev = tafunc.avedev(klines.close, 5)
print(list(avedev))

tqsdk.tafunc.time_to_ns_timestamp(input_time)

将传入的时间转换为int类型的纳秒级时间戳

Args:

input_time (str/ int/ float/ datetime.datetime): 需要转换的时间:

str: str 类型的时间，如Quote行情时间的datetime字段 (eg. 2019-10-14 14:26:01.000000)
int: int 类型的纳秒级或秒级时间戳
float: float 类型的纳秒级或秒级时间戳，如K线或tick的datetime字段 (eg. 1.57103449e+18)
datetime.datetime: datetime 模块中的 datetime 类型时间

Returns:

int : int 类型的纳秒级时间戳

Example:

from tqsdk.tafunc import time_to_ns_timestamp
print(time_to_ns_timestamp("2019-10-14 14:26:01.000000"))  # 将%Y-%m-%d %H:%M:%S.%f 格式的str类型转为纳秒时间戳
print(time_to_ns_timestamp(1571103122))  # 将秒级转为纳秒时间戳
print(time_to_ns_timestamp(datetime.datetime(2019, 10, 14, 14, 26, 1)))  # 将datetime.datetime时间转为纳秒时间戳

tqsdk.tafunc.time_to_s_timestamp(input_time)

将传入的时间转换为int类型的秒级时间戳

Args:

input_time (str/ int/ float/ datetime.datetime): 需要转换的时间:

str: str 类型的时间，如Quote行情时间的datetime字段 (eg. 2019-10-14 14:26:01.000000)
int: int 类型的纳秒级或秒级时间戳
float: float 类型的纳秒级或秒级时间戳，如K线或tick的datetime字段 (eg. 1.57103449e+18)
datetime.datetime: datetime 模块中的 datetime 类型时间

Returns:

int : int类型的秒级时间戳

Example:

from tqsdk.tafunc import time_to_s_timestamp
print(time_to_s_timestamp(1.57103449e+18))  # 将纳秒级时间戳转为秒级时间戳
print(time_to_s_timestamp("2019-10-14 14:26:01.000000"))  # 将%Y-%m-%d %H:%M:%S.%f 格式的str类型时间转为秒级时间戳
print(time_to_s_timestamp(datetime.datetime(2019, 10, 14, 14, 26, 1)))  # 将datetime.datetime时间转为秒时间戳

tqsdk.tafunc.time_to_str(input_time)

将传入的时间转换为 %Y-%m-%d %H:%M:%S.%f 格式的 str 类型

Args:

input_time (int/ float/ datetime.datetime): 需要转换的时间:

int: int 类型的纳秒级或秒级时间戳

float: float 类型的纳秒级或秒级时间戳，如K线或tick的datetime字段 (eg. 1.57103449e+18)

datetime.datetime: datetime 模块中的 datetime 类型时间

Returns:

str : %Y-%m-%d %H:%M:%S.%f 格式的 str 类型时间

Example:

from tqsdk.tafunc import time_to_str
print(time_to_str(1.57103449e+18))  # 将纳秒级时间戳转为%Y-%m-%d %H:%M:%S.%f 格式的str类型时间
print(time_to_str(1571103122))  # 将秒级时间戳转为%Y-%m-%d %H:%M:%S.%f 格式的str类型时间
print(time_to_str(datetime.datetime(2019, 10, 14, 14, 26, 1)))  # 将datetime.datetime时间转为%Y-%m-%d %H:%M:%S.%f 格式的str类型时间

tqsdk.tafunc.time_to_datetime(input_time)

将传入的时间转换为 datetime.datetime 类型

Args:

input_time (int/ float/ str): 需要转换的时间:

int: int 类型的纳秒级或秒级时间戳

float: float 类型的纳秒级或秒级时间戳，如K线或tick的datetime字段 (eg. 1.57103449e+18)

str: str 类型的时间，如Quote行情时间的 datetime 字段 (eg. 2019-10-14 14:26:01.000000)

Returns:

datetime.datetime : datetime 模块中的 datetime 类型时间

Example:

from tqsdk.tafunc import time_to_datetime
print(time_to_datetime(1.57103449e+18))  # 将纳秒级时间戳转为datetime.datetime时间
print(time_to_datetime(1571103122))  # 将秒级时间戳转为datetime.datetime时间
print(time_to_datetime("2019-10-14 14:26:01.000000"))  # 将%Y-%m-%d %H:%M:%S.%f 格式的str类型时间转为datetime.datetime时间

tqsdk.tafunc.barlast(cond)

返回一个序列，其中每个值表示从上一次条件成立到当前的周期数

(注：如果从cond序列第一个值到某个位置之间没有True，则此位置的返回值为 -1；条件成立的位置上的返回值为0)

Args:: cond (pandas.Series): 条件序列(序列中的值需为 True 或 False)
Returns:: pandas.Series : 周期数序列（其长度和 cond 相同；最后一个值即为最后一次条件成立到最新一个数据的周期数）

Example:

from tqsdk import TqApi, TqAuth
from tqsdk.tafunc import barlast

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
klines = api.get_kline_serial("SHFE.cu1912", 60)
# print(list(klines.close))
# print(list(klines.open))
# print(list(klines.close > klines.open))
n = barlast(klines.close > klines.open)  # 获取周期数序列
print(list(n))
print(n.iloc[-1])  # 获取最后一根k线到上一次满足 "收盘价大于开盘价" 条件的k线的周期数
api.close()

tqsdk.tafunc.get_t(df, expire_datetime)

计算 K 线序列对应的年化到期时间，主要用于计算期权相关希腊指标时，需要得到计算出序列对应的年化到期时间

Args:

df (pandas.DataFrame): Dataframe 格式的 K 线序列

expire_datetime (int): 到期日, 秒级时间戳

Returns:

pandas.Series : 返回的 df 对应的年化时间序列

Example:

from tqsdk import TqApi, TqAuth, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote('SHFE.cu2006C45000')
klines = api.get_kline_serial(['SHFE.cu2006C45000', 'SHFE.cu2006'], 24 * 60 * 60, 50)
t = tafunc.get_t(klines, quote.expire_datetime)
print(t)
api.close()

tqsdk.tafunc.get_his_volatility(df, quote)

计算某个合约的历史波动率

Args:

df (pandas.DataFrame): Dataframe 格式的 K 线序列

quote (tqsdk.objs.Quote): df 序列对应合约对象

Returns:

float : 返回的 df 对应的历史波动率

Example:

from tqsdk import TqApi, TqAuth, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote('SHFE.cu2006')
klines = api.get_kline_serial('SHFE.cu2006', 24 * 60 * 60, 50)
v = tafunc.get_his_volatility(klines, quote)
print(v)
api.close()

tqsdk.tafunc.get_bs_price(series, k, r, v, t, option_class)

计算期权 BS 模型理论价格

Args:

series (pandas.Series): 标的价格序列

k (float): 期权行权价

r (float): 无风险利率

v (float / pandas.Series): 波动率

float: 对于 series 中每个元素都使用相同的 v 计算理论价

pandas.Series: 其元素个数应该和 series 元素个数相同，对于 series 中每个元素都使用 v 中对应的值计算理论价

t (float / pandas.Series): 年化到期时间，例如：还有 100 天到期，则年化到期时间为 100/360

float: 对于 series 中每个元素都使用相同的 t 计算理论价

pandas.Series: 其元素个数应该和 series 元素个数相同，对于 series 中每个元素都使用 t 中对应的值计算理论价

option_class (str / pandas.Series): 期权方向，必须是两者其一，否则返回的序列值全部为 nan

str: "CALL" 或者 "PUT"

pandas.Series: 其元素个数应该和 series 元素个数相同，每个元素的值为 "CALL" 或者 "PUT"

Returns:

pandas.Series: 返回该序列理论价

Example:

import pandas as pd
from tqsdk import TqApi, TqAuth, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SHFE.cu2006")
ks = api.get_kline_serial("SHFE.cu2006", 24 * 60 * 60, 10)
v = tafunc.get_his_volatility(ks, quote)  # 历史波动率

option = api.get_quote("SHFE.cu2006C45000")
klines = api.get_kline_serial(["SHFE.cu2006C45000", "SHFE.cu2006"], 24 * 60 * 60, 10)
t = tafunc.get_t(klines, option.expire_datetime)
bs_price = tafunc.get_bs_price(klines["close1"], 45000, 0.025, v, t, option.option_class)  # 理论价
print(list(bs_price.round(2)))
api.close()

tqsdk.tafunc.get_delta(series, k, r, v, t, option_class, d1=None)

计算期权希腊指标 delta 值

Args:

series (pandas.Series): 标的价格序列

k (float): 期权行权价

r (float): 无风险利率

v (float / pandas.Series): 波动率

float: 对于 series 中每个元素都使用相同的 v 计算理论价

pandas.Series: 其元素个数应该和 series 元素个数相同，对于 series 中每个元素都使用 v 中对应的值计算理论价

t (float / pandas.Series): 年化到期时间，例如：还有 100 天到期，则年化到期时间为 100/360

float: 对于 series 中每个元素都使用相同的 t 计算理论价

pandas.Series: 其元素个数应该和 series 元素个数相同，对于 series 中每个元素都使用 t 中对应的值计算理论价

option_class (str / pandas.Series): 期权方向，必须是两者其一，否则返回的序列值全部为 nan

str: "CALL" 或者 "PUT"

pandas.Series: 其元素个数应该和 series 元素个数相同，每个元素的值为 "CALL" 或者 "PUT"

d1 (None | pandas.Series): [可选] 序列对应的 BS 公式中 b1 值

Returns:

pandas.Series: 该序列的 delta 值

Example:

import pandas as pd
from tqsdk import TqApi, TqAuth, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SHFE.cu2006")
ks = api.get_kline_serial("SHFE.cu2006", 24 * 60 * 60, 10)
v = tafunc.get_his_volatility(ks, quote)  # 历史波动率

option = api.get_quote("SHFE.cu2006C45000")
klines = api.get_kline_serial(["SHFE.cu2006C45000", "SHFE.cu2006"], 24 * 60 * 60, 10)
t = tafunc.get_t(klines, option.expire_datetime)
impv = tafunc.get_impv(klines["close1"], klines["close"], 45000, 0.025, v, t, "CALL")
delta = tafunc.get_delta(klines["close1"], 45000, 0.025, v, t, "CALL")
print("delta", list(delta))
api.close()

tqsdk.tafunc.get_gamma(series, k, r, v, t, d1=None)

计算期权希腊指标 gamma 值

Args:

series (pandas.Series): 标的价格序列

k (float): 期权行权价

r (float): 无风险利率

v (float / pandas.Series): 波动率

float: 对于 series 中每个元素都使用相同的 v 计算理论价

pandas.Series: 其元素个数应该和 series 元素个数相同，对于 series 中每个元素都使用 v 中对应的值计算理论价

t (float / pandas.Series): 年化到期时间，例如：还有 100 天到期，则年化到期时间为 100/360

float: 对于 series 中每个元素都使用相同的 t 计算理论价

pandas.Series: 其元素个数应该和 series 元素个数相同，对于 series 中每个元素都使用 t 中对应的值计算理论价

d1 (None | pandas.Series): [可选] 序列对应的 BS 公式中 b1 值

Returns:

pandas.Series: 该序列的 gamma 值

Example:

import pandas as pd
from tqsdk import TqApi, TqAuth, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SHFE.cu2006")
ks = api.get_kline_serial("SHFE.cu2006", 24 * 60 * 60, 10)
v = tafunc.get_his_volatility(ks, quote)  # 历史波动率

option = api.get_quote("SHFE.cu2006C45000")
klines = api.get_kline_serial(["SHFE.cu2006C45000", "SHFE.cu2006"], 24 * 60 * 60, 10)
t = tafunc.get_t(klines, option.expire_datetime)
impv = tafunc.get_impv(klines["close1"], klines["close"], 45000, 0.025, v, t, "CALL")
gamma = tafunc.get_gamma(klines["close1"], 45000, 0.025, v, t)
print("gamma", list(gamma))
api.close()

tqsdk.tafunc.get_theta(series, k, r, v, t, option_class, d1=None)

计算期权希腊指标 theta 值

Args:

series (pandas.Series): 标的价格序列

k (float): 期权行权价

r (float): 无风险利率

v (float / pandas.Series): 波动率

float: 对于 series 中每个元素都使用相同的 v 计算理论价

pandas.Series: 其元素个数应该和 series 元素个数相同，对于 series 中每个元素都使用 v 中对应的值计算理论价

t (float / pandas.Series): 年化到期时间，例如：还有 100 天到期，则年化到期时间为 100/360

float: 对于 series 中每个元素都使用相同的 t 计算理论价

pandas.Series: 其元素个数应该和 series 元素个数相同，对于 series 中每个元素都使用 t 中对应的值计算理论价

option_class (str / pandas.Series): 期权方向，必须是两者其一，否则返回的序列值全部为 nan

str: "CALL" 或者 "PUT"

pandas.Series: 其元素个数应该和 series 元素个数相同，每个元素的值为 "CALL" 或者 "PUT"

d1 (None | pandas.Series): [可选] 序列对应的 BS 公式中 b1 值

Returns:

pandas.Series: 该序列的 theta 值

Example:

import pandas as pd
from tqsdk import TqApi, TqAuth, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SHFE.cu2006")
ks = api.get_kline_serial("SHFE.cu2006", 24 * 60 * 60, 10)
v = tafunc.get_his_volatility(ks, quote)  # 历史波动率

option = api.get_quote("SHFE.cu2006C45000")
klines = api.get_kline_serial(["SHFE.cu2006C45000", "SHFE.cu2006"], 24 * 60 * 60, 10)
t = tafunc.get_t(klines, option.expire_datetime)
impv = tafunc.get_impv(klines["close1"], klines["close"], 45000, 0.025, v, t, "CALL")
theta = tafunc.get_theta(klines["close1"], 45000, 0.025, v, t, "CALL")
print("theta", list(theta))
api.close()

tqsdk.tafunc.get_vega(series, k, r, v, t, d1=None)

计算期权希腊指标 vega 值

Args:

series (pandas.Series): 标的价格序列

k (float): 期权行权价

r (float): 无风险利率

v (float / pandas.Series): 波动率

float: 对于 series 中每个元素都使用相同的 v 计算理论价

pandas.Series: 其元素个数应该和 series 元素个数相同，对于 series 中每个元素都使用 v 中对应的值计算理论价

t (float / pandas.Series): 年化到期时间，例如：还有 100 天到期，则年化到期时间为 100/360

float: 对于 series 中每个元素都使用相同的 t 计算理论价

pandas.Series: 其元素个数应该和 series 元素个数相同，对于 series 中每个元素都使用 t 中对应的值计算理论价

d1 (None | pandas.Series): [可选] 序列对应的 BS 公式中 b1 值

Returns:

pandas.Series: 该序列的 vega 值

Example:

import pandas as pd
from tqsdk import TqApi, TqAuth, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SHFE.cu2006")
ks = api.get_kline_serial("SHFE.cu2006", 24 * 60 * 60, 10)
v = tafunc.get_his_volatility(ks, quote)  # 历史波动率

option = api.get_quote("SHFE.cu2006C45000")
klines = api.get_kline_serial(["SHFE.cu2006C45000", "SHFE.cu2006"], 24 * 60 * 60, 10)
t = tafunc.get_t(klines, option.expire_datetime)
impv = tafunc.get_impv(klines["close1"], klines["close"], 45000, 0.025, v, t, "CALL")
vega = tafunc.get_vega(klines["close1"], 45000, 0.025, v, t)
print("vega", list(vega))
api.close()

tqsdk.tafunc.get_rho(series, k, r, v, t, option_class, d1=None)

计算期权希腊指标 rho 值

Args:

series (pandas.Series): 标的价格序列

k (float): 期权行权价

r (float): 无风险利率

v (float / pandas.Series): 波动率

float: 对于 series 中每个元素都使用相同的 v 计算理论价

pandas.Series: 其元素个数应该和 series 元素个数相同，对于 series 中每个元素都使用 v 中对应的值计算理论价

t (float / pandas.Series): 年化到期时间，例如：还有 100 天到期，则年化到期时间为 100/360

float: 对于 series 中每个元素都使用相同的 t 计算理论价

pandas.Series: 其元素个数应该和 series 元素个数相同，对于 series 中每个元素都使用 t 中对应的值计算理论价

option_class (str / pandas.Series): 期权方向，必须是两者其一，否则返回的序列值全部为 nan

str: "CALL" 或者 "PUT"

pandas.Series: 其元素个数应该和 series 元素个数相同，每个元素的值为 "CALL" 或者 "PUT"

d1 (None | pandas.Series): [可选] 序列对应的 BS 公式中 b1 值

Returns:

pandas.Series: 该序列的 rho 值

Example:

import pandas as pd
from tqsdk import TqApi, TqAuth, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SHFE.cu2006")
ks = api.get_kline_serial("SHFE.cu2006", 24 * 60 * 60, 10)
v = tafunc.get_his_volatility(ks, quote)  # 历史波动率

option = api.get_quote("SHFE.cu2006C45000")
klines = api.get_kline_serial(["SHFE.cu2006C45000", "SHFE.cu2006"], 24 * 60 * 60, 10)
t = tafunc.get_t(klines, option.expire_datetime)
impv = tafunc.get_impv(klines["close1"], klines["close"], 45000, 0.025, v, t, "CALL")
rho = tafunc.get_rho(klines["close1"], 45000, 0.025, v, t, "CALL")
print("rho", list(rho))
api.close()

tqsdk.tafunc.get_impv(series, series_option, k, r, init_v, t, option_class)

计算期权隐含波动率

Args:

series (pandas.Series): 标的价格序列

series_option (pandas.Series): 期权价格序列，与 series 长度应该相同

k (float): 期权行权价

r (float): 无风险利率

init_v (float / pandas.Series): 初始波动率，迭代初始值

float: 对于 series 中每个元素都使用相同的 init_v 计算隐含波动率

pandas.Series: 其元素个数应该和 series 元素个数相同，对于 series 中每个元素都使用 init_v 中对应的值计算隐含波动率

t (float / pandas.Series): 年化到期时间，例如：还有 100 天到期，则年化到期时间为 100/360

float: 对于 series 中每个元素都使用相同的 t 计算理论价

pandas.Series: 其元素个数应该和 series 元素个数相同，对于 series 中每个元素都使用 t 中对应的值计算理论价

option_class (str / pandas.Series): 期权方向，必须是两者其一，否则返回的序列值全部为 nan

str: "CALL" 或者 "PUT"

pandas.Series: 其元素个数应该和 series 元素个数相同，每个元素的值为 "CALL" 或者 "PUT"

Returns:

pandas.Series: 该序列的隐含波动率

Example:

import pandas as pd
from tqsdk import TqApi, TqAuth, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
quote = api.get_quote("SHFE.cu2006")
ks = api.get_kline_serial("SHFE.cu2006", 24 * 60 * 60, 10)
v = tafunc.get_his_volatility(ks, quote)  # 历史波动率

option = api.get_quote("SHFE.cu2006C45000")
klines = api.get_kline_serial(["SHFE.cu2006C45000", "SHFE.cu2006"], 24 * 60 * 60, 10)
t = tafunc.get_t(klines, option.expire_datetime)
impv = tafunc.get_impv(klines["close1"], klines["close"], 45000, 0.025, v, t, "CALL")
print("impv", list((impv * 100).round(2)))
api.close()

tqsdk.tafunc.get_ticks_info(df)

计算 ticks 开平方向

Args:: df (pandas.DataFrame): Dataframe 格式的 ticks 序列
Returns:: pandas.Series: 返回序列的开平方向序列

Example:

from tqsdk import TqApi, TqAuth, tafunc

api = TqApi(auth=TqAuth("快期账户", "账户密码"))
ticks = api.get_tick_serial('SHFE.cu2006', 100)
ticksinfo = tafunc.get_ticks_info(ticks)
for i, v in ticksinfo.items():
    print(f"{tafunc.time_to_str(ticks['datetime'][i])[5:21]}  {ticks['last_price'][i]}  {v}")
api.close()

# 预计的输出是这样的:
04-27 10:54:11.5   42640.0   多换
04-27 10:54:12.0   42640.0   多换
04-27 10:54:16.5   42640.0   多换
......
04-27 10:55:10.0   42660.0   双平
04-27 10:55:10.5   42660.0   双平
04-27 10:55:14.0   42670.0   双平

tqsdk.tafunc.get_dividend_df(stock_dividend_ratio, cash_dividend_ratio)

计算复权系数矩阵

Args:

stock_dividend_ratio (list): 除权表（可以由 quote.stock_dividend_ratio 取得）

cash_dividend_ratio (list): 除息表（可以由 quote.cash_dividend_ratio 取得）

Returns:

pandas.Dataframe: 复权系数矩阵， Dataframe 对象有 ["datetime", "stock_dividend", "cash_dividend"] 三列。

tqsdk.tafunc.get_dividend_factor(dividend_df, last_item, item)

返回 item 项对应的复权因子。

Args:

dividend_df (pandas.Dataframe): 除权除息矩阵表

last_item (dict): 前一个 tickItem / klineItem

item (dict): 当前 tickItem / klineItem

Returns:

float: 复权因子

tqsdk.tafunc.get_sharp(series, trading_days_of_year=250, r=0.025)

年化夏普率

Args:

series (pandas.Series): 每日收益率序列

trading_days_of_year (int): 年化交易日数量

r (float): 无风险利率

Returns:

float: 年化夏普率

tqsdk.tafunc.get_sortino(series, trading_days_of_year=250, r=0.025)

年化索提诺比率

Args:

series (pandas.Series): 每日收益率序列

trading_days_of_year (int): 年化交易日数量

r (float): 无风险利率

Returns:

float: 年化索提诺比率

tqsdk.tafunc.get_calmar(series, max_drawdown, trading_days_of_year=250, r=0.025)

年化卡玛比率

Args:

series (pandas.Series): 每日收益率序列

max_drawdown (float): 最大回撤

trading_days_of_year (int): 年化交易日数量

r (float): 无风险利率

Returns:

float: 年化夏普率