目录

概念 

一、数据为收盘价，计算最大回撤

二、数据为净值，计算最大回撤

概念 

计算方法

1. 将收益率做成时间序列
2. 计算财富指数(也就是净值)【PS:初始净值为1】
3. 计算上一个最高点
4. 计算回撤率
5. 找出最大回撤

一、数据为收盘价，计算最大回撤

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
df_aapl = pd.read_csv('AAPL.csv',encoding='utf-8')
df_aapl['ret'] = df_aapl['Close'].pct_change()
df_aapl['Date'] = pd.to_datetime(df_aapl['Date'])
df_aapl.set_index('Date',inplace=True)
df = df_aapl.iloc[-504:]
df.head()

# 构建财富指数
wealth = 1*(1+df['ret']).cumprod()
wealth.head()

wealth.plot()

# 计算上一个最高点
previos_max = wealth.cummax()
previos_max.plot()

# 计算回撤率
drawdowns = (wealth-previos_max)/previos_max
drawdowns.plot()

# 找出最大回撤
drawdowns.min()
# out: -0.30668685958066383

# 最大回撤对应的日期
drawdowns.idxmin()
# out: Timestamp('2020-03-23 00:00:00')

 将上面的计算过程组合成一个函数

def drawdown(return_series:pd.Series):
    '''
    把一个时间序列做成最大回撤的表格
    表格字段为：
    财富指数
    上一个最大值
    回撤率
    '''
    wealth = 1*(1+return_series).cumprod()
    previos_max = wealth.cummax()
    drawdowns = (wealth-previos_max)/previos_max
    return pd.DataFrame({'wealth':wealth,
                        'previos_max':previos_max,
                        'drawdowns':drawdowns})
res_df = drawdown(df['ret'])
res_df.head()

res_df.plot(y=['wealth','previos_max'],figsize=(8,4))

res_df.plot(y='drawdowns',figsize=(8,4),color='k')

二、数据为净值，计算最大回撤

前置： 

文章中用到的数据

链接：https://pan.baidu.com/s/1rKLM45dq_xIKxcI54Nq0qg 
提取码：c298

最终效果图：

计算过程（jupyter notebook）：

import matplotlib.pyplot as plt
import pylab as pl
import pandas as pd
import math

df = pd.read_csv('./temptemp.csv',encoding='utf-8')
df.head()

# 绘制折线图，标记回撤区域
def draw_trend_and_withdraw(xs,ys,title,res_points):
    plt.figure(figsize=(20,10))
    plt.rcParams['font.sans-serif'] = ['SimHei']
    plt.rcParams['axes.unicode_minus'] = False
    xs00 = range(len(xs))
    plt.plot(xs00,ys)
    
    # 只显示10个x轴刻度
    xs00_=[]
    xs_ =[]
    for i in range(0,len(xs),math.floor(len(xs)/10)):
        xs00_.append(i)
        xs_.append(xs[i])
    
    plt.xticks(xs00_,xs_,rotation=30)
    plt.title(title)
    for item in res_points:
        min_x = item['min_x']
        min_y = item['min_y']
        max_x = item['max_x']
        max_y = item['max_y']
        show_min_str = item['show_min_str']
        show_max_str = item['show_max_str']
        withdraw = item['withdraw']
        
        plt.scatter(min_x, min_y, color='r')  # 标记最低点
        plt.scatter(max_x, max_y, color='r')  # 标记最高点
        plt.annotate(show_min_str, xytext=(min_x, min_y), xy=(min_x, min_y))  # 标记提示
        plt.annotate(show_max_str, xytext=(max_x, max_y), xy=(max_x, max_y))  # 标记提示

        plt.plot([min_x, max_x], [min_y, max_y], color='b', linestyle='--')  # 连接最低净值点和最高净值点
        plt.annotate(withdraw, xytext=((max_x + min_x) / 2, (max_y + min_y) / 2), xy=((max_x + min_x) / 2, (max_y + min_y) / 2))  # 标记提示
        pass
    plt.show()

df['o_date'] = df['date']
df['o_date'] = pd.to_datetime(df['o_date'])
df.dropna(inplace=True)
df.sort_values(by='o_date',ascending=True,inplace=True)
df['count'] = range(len(df)) # count用于标识折线图x轴的位置

res_list = []
temp_hv = None # 记录当前最大值
temp_hv_date = None # 记录当前最大值对应的日期
temp_hv_loc = None # 记录当前最大值所在的位置
temp_lv = None # 记录当前最小值
temp_lv_date = None # 记录当前最小值对应的日期
temp_lv_loc = None # 记录当前最小值所在的位置
temp_duration = None # 最大值与最小值之间的差

for i,row in df.iterrows():
    if temp_hv is None:
        temp_hv = row['value']
        temp_hv_date = row['date']
        temp_hv_loc = row['count']
        temp_lv = row['value']
        temp_lv_date = row['date']
        temp_lv_loc = row['count']
        temp_duration = 0
    else:
        if row['value'] > temp_hv:
            # 如果值大于此前的最大值，说明要进行新一轮的回撤，记录当前这一轮回撤的信息
            # 计算回撤百分比
            temp_pct = (temp_duration/temp_hv)*100
            res_list.append([temp_hv_loc,temp_hv_date,temp_hv,temp_lv_loc,temp_lv_date,temp_lv,temp_pct,temp_duration])
            temp_hv = row['value']
            temp_hv_date = row['date']
            temp_hv_loc = row['count']
            temp_lv = row['value']
            temp_lv_date = row['date']
            temp_lv_loc = row['count']
            temp_duration = 0
            pass
        else:
            if row['value'] <= temp_lv:
                # 当前值小于此前的最小值，说明数值还在往下走
                temp_lv = row['value']
                temp_lv_date = row['date']
                temp_lv_loc= row['count']
                temp_duration = temp_hv-temp_lv
# 最后一次的回撤：最后的价格一直没有超过此前一次的最高价，最后一次的回撤会无法触发记录的条件
temp_pct = (temp_duration/temp_hv)*100
res_list.append([temp_hv_loc,temp_hv_date,temp_hv,temp_lv_loc,temp_lv_date,temp_lv,temp_pct,temp_duration])

# 抽取出回撤大于等于10%的区间，并在图中标出
final_list = []
for item in res_list:
    if item[-2]>=10:
        pct_ = round(item[-2],2)
        final_list.append({
            "min_x":item[0],
            "min_y":item[2],
            "max_x":item[3],
            "max_y":item[5],
            "show_min_str":item[1],
            "show_max_str":item[4],
            "withdraw":str(pct_)+'%'
        })

xs = df['date'].values.tolist()
ys = df['value'].values.tolist()
title_str = '回撤大于等于10%'
draw_trend_and_withdraw(xs,ys,title_str,final_list)

# -*- coding: utf-8 -*-
"""
Created on Wed Mar 14 21:38:49 2018
E-mail: Eric2014_Lv@sjtu.edu.cn
@author: DidiLv
"""

import pandas as pd
import numpy as np

from pandas import DataFrame

odata = pd.read_csv('investment_rate.csv')

Profit_pool = pd.DataFrame(odata)
# size

m, n = Profit_pool.shape
np_profit_pool = np.array(Profit_pool)

date = np_profit_pool[:,0]
num_date = m

# 确定跳跃点即时间不连续点
skip_id = [-1]
for id in range(num_date-1):
    if date[id + 1] - date[id] >= 3:
        skip_id.append(id)
skip_id.append(m-1)
skip_id = np.array(skip_id) 
# 确定添加复利和净值后的矩阵大小
num_skip = len(skip_id)-1
profit_pool_week_and_month_profit = np.zeros([1,n])

week_profit_month = np.ones([2,n-1])   
print("-----------skip-------------")    
print(skip_id)        
for count in range(len(skip_id)-1):
    np_week = np_profit_pool[skip_id[count]+1:skip_id[count+1]+1,1:n]
    profit_pool_week_and_month_profit = np.vstack((profit_pool_week_and_month_profit,np_profit_pool[skip_id[count]+1:skip_id[count+1]+1,:]))
    # 计算复利和净值
    mm,nn = np_week.shape
    np_week_new = np_week + np.ones([mm,nn])
    
    week_profit_month[0,:] = np_week_new.prod(axis = 0) 
    for ii in range(n-1):
        week_profit_month[0,ii] -= 1
        week_profit_month[1,ii] *= week_profit_month[0,ii] + 1  
        #这里只是用2e10和2e11做成一个表示符表示复利和净值
        temp = np.column_stack((np.array((2e10,2e11)),week_profit_month))
    profit_pool_week_and_month_profit = np.vstack((profit_pool_week_and_month_profit,temp))
    print("-----np_week-----------")
    print(np_week)    
    
        
print("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++")    
np.savetxt('profit_pool_week_and_month_profit.csv', profit_pool_week_and_month_profit, delimiter = ',')        
        
    

目录

 一、当数据为净值，求年化收益率

二、当数据为收盘价，求年化收益率

 一、当数据为净值，求年化收益率

前置：

文章中用到的数据

链接：https://pan.baidu.com/s/1rKLM45dq_xIKxcI54Nq0qg 
提取码：c298

公式:

计算过程（jupyter notebook）：

import pandas as pd
df = pd.read_csv('./temptemp.csv',encoding='utf-8')
df['o_date'] = df['date']
df['o_date'] = pd.to_datetime(df['o_date'])
df.dropna(inplace=True)
df.sort_values(by='o_date', ascending=True, inplace=True)
df.head()

# value值从1开始，每一日的value是当日的净值
# 对应到公式，第一行的value为初始净值，最后一行的value为最终净值
first_one = df.iloc[0]
last_one = df.iloc[-1]
annual_profilt = pow(last_one['value']/first_one['value'],250/len(df))-1
annual_profilt

二、当数据为收盘价，求年化收益率

推导：

设，

1. 周期为p，例如p可以是日、周、月、季度等，对应的就是日收益率、周收益率、月收益率、季度收益率等；数据个数为N

2. 每期收益率为Rp，每期平均收益率为，年化平均收益率为

3.  对应周期p,一年有m个周期p,例如：p为日，m为252；p为周，m为52；p为月，m为12等

求，

1. 每期平均收益率

2. 年化收益率

 代码：

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
df_aapl = pd.read_csv('AAPL.csv',encoding='utf-8')
df_aapl.head()

df_aapl['ret'] = df_aapl['Close'].pct_change()
df_aapl.head()

df_aapl['ret'].plot(figsize=(8,4))

# 计算日平均收益率
# prod() 将所有数值乘起来
r_daily_mean = ((1+df_aapl['ret']).prod())**(1/df_aapl.shape[0])-1
r_daily_mean
# out: 0.0006941719590121131

# 计算年收益率
annual_rets = (1+r_daily_mean)**252-1
annual_rets
# out: 0.19109213356890775

# 适用不同周期收益率计算年化收益率函数
def annualize_rets(returns,n_periods):
    '''
    给定一系列的收益率和期数，算出年化收益率
    '''
    # 每一期的平均收益
    r_periodic_mean = ((1+returns).prod())**(1/returns.shape[0])-1
    return (1+r_periodic_mean)**n_periods-1
annualize_rets(df_aapl['ret'],252) 
# out: 0.19109213356890775