siat 3.7.1__py3-none-any.whl → 3.7.3__py3-none-any.whl

siat/event_study.py

@@ -43,6 +43,7 @@ if __name__=='__main__':
     start='2024-3-1'; end='2024-4-30'
     event_window=[1,1] #事件发生时股市已经收盘，故检测下一个交易日的股市反应
     market_index='000001.SS' #贵州茅台在上交所上市，故使用上证综合指数
+    RF=0
     
     #测试组2
     ticker=['600519.SS','399997.SZ']
@@ -51,6 +52,17 @@ if __name__=='__main__':
     start='2024-3-1'; end='2024-3-30'
     event_window=[1,2]
     market_index='000300.SS'
+    RF="market model"
+    
+    #测试组3
+    ticker=['600519.SS','399997.SZ']
+    
+    event_date='2024-4-2' #贵州茅台2023年报披露日
+    start='auto'; end='auto'
+    event_window=[0,1]
+    method='CAPM'
+    market_index='000001.SS'
+    RF="1YCNY.B"   
     
     #共同部分
     post_event_days=7
@@ -58,11 +70,11 @@ if __name__=='__main__':
     early_response_days=-2
     estimation_window_days=-365
     
-    RF=0
     ret_type="Daily Adj Ret%"
     ticker_type='stock' #贵州茅台为股票
     facecolor="whitesmoke"
-    show_AR='auto'
+    show_AR=True
+    show_RF=True
     loc='best'
     
     es=event_study("600519.SS",event_date="2024-4-2", \
@@ -89,17 +101,18 @@ if __name__=='__main__':
         
         
 def event_study(ticker,event_date, \
-                start='MRM',end='today', \
-                event_window=[0,0], \
-                post_event_days=7, \
+                start='auto',end='auto', \
+                event_window=[1,3], \
+                post_event_days=0, \
                 method='CAPM', \
                 early_response_days=-2, \
                 estimation_window_days=-365, \
                 market_index='000300.SS', \
-                RF=0, \
+                RF="market index", \
                 ret_type="Daily Adj Ret%", \
                 ticker_type='auto', \
-                facecolor="whitesmoke",show_AR='auto',loc='best'):
+                facecolor="whitesmoke",show_AR='auto',show_RF=False, \
+                loc='best'):
     """
     
     功能：展示事件研究法的累计异常收益率CAR。
@@ -113,7 +126,7 @@ def event_study(ticker,event_date, \
         注意：事件窗口不一定包括事件日（适用于事件日在非交易日的情形，例如周末或假日）
         如果事件日为非交易日，事件窗口需要后移至事件日后的第一个交易日。
         如果怀疑市场提前对事件发生反应，可以考虑前移事件窗口的开始日期。
-    post_event_days：用于分析事件窗口后的漂移效应，取事件窗口后多少天，默认取7天。
+    post_event_days：用于分析事件窗口后的漂移效应，取事件窗口后多少天。默认不分析，取0天。
     method：估计事件窗口以及事件后窗口收益率预期值的方法，默认为CAPM（主要用于ticker为股票等）
         如果ticker为股票等，也可以直接使用指数的收益率为其预期收益率，此时method为Market或Index。
         如果ticker为指数，无法再借助指数，method只能使用Random Walk，即使用前一个收益率为预期收益率。
@@ -125,12 +138,17 @@ def event_study(ticker,event_date, \
         默认在事件窗口开始日期+提前反应天数前的365个自然日（约250个交易日）。
     market_index：当method为CAPM时，用于计算市场收益率。默认中国市场采用000300.SS。
         注意：需要根据不同市场采取不同的市场指数，例如香港市场为恒生指数，美国市场为标普500指数等。
+    RF：年化无风险收益率，默认使用市场模型"market index"，无需指定；可直接指定具体数值；
+        也可指定特定指标，例如一年期中国国债收益率"1YCNY.B"或一年期美债收益率"1YUSY.B"等。
+    show_RF：在使用市场模型或指定指标时是否显示计算出的RF均值，默认为False。
     ticker_type：显式指明ticker的证券类型，当siat误判其类型（中国内地股票/债券/基金）时使用，默认'auto'。
     facecolor：显式指定绘图背景颜色，默认"whitesmoke"。
-    show_AR：是否绘图时绘制异常收益率AR，默认'auto'（单个ticker时绘制，多个时不绘制），也可指定True/False强行绘制/不绘制。
+    show_AR：是否绘图时绘制异常收益率AR，默认'auto'（单个ticker时绘制，多个时不绘制）。
+        也可指定True/False强行绘制/不绘制。
     """
     
     DEBUG=False
+    DEBUG2=False
     
     #=====事件研究各个日期的计算与调整===========================================
     if isinstance(event_date,str):
@@ -142,34 +160,45 @@ def event_study(ticker,event_date, \
         return None
     event_date.sort() #升序排序
     
-    #事件窗口日期计算与调整
+    #事件窗口日期：遇到周末需要调整，提前或顺延至最近的工作日
     event_window_new=event_window.copy() #列表的普通赋值仅为指针，新列表的改动也会影响原列表
     adjust_start=0
     event_window_start=date_adjust(event_date[0],adjust=event_window[0])
     if week_day(event_window_start) == 5: #周六
-        adjust_start=2
+        if event_window[0] >= 0:
+            adjust_start=2
+        else:
+            adjust_start=-1
     elif week_day(event_window_start) == 6: #周日
-        adjust_start=1
+        if event_window[0] >= 0:
+            adjust_start=1
+        else:
+            adjust_start=-2
     event_window_start=date_adjust(event_window_start,adjust=adjust_start)
     event_window_new[0]=event_window[0]+adjust_start
 
     adjust_end=0
     event_window_end=date_adjust(event_window_start,adjust=event_window[1]-event_window[0])
     if week_day(event_window_end) == 5: #周六
-        adjust_end=2
+        if event_window[1] >= 0:
+            adjust_end=2
+        else:
+            adjust_end=-1
     elif week_day(event_window_end) == 6: #周日
-        adjust_end=1
+        if event_window[1] >= 0:
+            adjust_end=1
+        else:
+            adjust_end=-2
     event_window_end=date_adjust(event_window_end,adjust=adjust_end)
     event_window_new[1]=event_window[1]+adjust_start+adjust_end
-
     
     if DEBUG:
         print("  DEBUG: event window is between {0} to {1}".format(event_window_start,event_window_end))
 
     if event_window_new != event_window:
-        print("  #Notice: event window adjusted to {} because of crossing weekend".format(event_window_new))
+        print("  #Notice: event window adjusted from {0} to {1} because of weekend".format(event_window,event_window_new))
 
-    #事件后窗口日期的计算与调整
+    #事件后窗口日期
     post_event_start=date_adjust(event_window_end,adjust=0)
     if week_day(post_event_start) == 5: #周六
         post_event_start=date_adjust(post_event_start,adjust=2)
@@ -189,7 +218,7 @@ def event_study(ticker,event_date, \
         print("  DEBUG: post event window is between {0} to {1}".format(post_event_start,post_event_end))
     
 
-    #事件窗口前日期计算与调整
+    #事件窗口前日期
     event_eve_date=date_adjust(event_window_start,adjust=-1)
     if week_day(event_eve_date) == 5: #周六
         event_eve_date=date_adjust(event_eve_date,adjust=-1)
@@ -199,7 +228,7 @@ def event_study(ticker,event_date, \
     if DEBUG:
         print("  DEBUG: event eve is on {}".format(event_eve_date))
     
-    #提前反应日期计算与调整
+    #提前反应日期
     early_response_date=date_adjust(event_date[0],adjust=early_response_days)
     if week_day(early_response_date) == 5: #周六
         early_response_date=date_adjust(early_response_date,adjust=-1)
@@ -211,7 +240,18 @@ def event_study(ticker,event_date, \
         
     #估计窗口日期的计算
     est_window_end=date_adjust(early_response_date,adjust=-1)
-    est_window_start=date_adjust(est_window_end,adjust=estimation_window_days)        
+    est_window_start=date_adjust(est_window_end,adjust=estimation_window_days)   
+    if DEBUG:
+        print("  DEBUG: regression period starts from {0} to {1}".format(est_window_start,est_window_end))
+     
+    #处理绘图时显示的日期范围
+    if start=='auto':
+        start=date_adjust(early_response_date,adjust=-7)
+    if end=='auto':
+        if len(ticker) == 1 or show_AR:
+            end=date_adjust(post_event_end,adjust=7)
+        else:
+            end=date_adjust(post_event_end,adjust=2)
     
     #=====判断ticker是否为指数，调整预期收益率计算方法============================
     if isinstance(ticker,str):
@@ -223,45 +263,84 @@ def event_study(ticker,event_date, \
         return None
         
     if market_index in ticker:
-        print("  #Warning(event_study): market_index {0} in ticker {1}, removed from ticker".format(market_index,ticker))
+        print("  #Warning(event_study): market_index {0} duplicated in and removed from ticker {1}".format(market_index,ticker))
         ticker.remove(market_index)        
     
-    tname=ticker_name(ticker[0],ticker_type)
+    #tname=ticker_name(ticker[0],ticker_type)
     #检查ticker是否为指数或国债收益率
     """
     if ("指数" in tname or "index" in tname.lower()) or ("收益率" in tname or "yield" in tname.lower()):
         if not ("random" in method.lower() or "walk" in method.lower()):
             print("  #Notice: check the applicability of ticker {0}, method {1} with market index {2}".format(ticker[0],method,market_index))
     """
+    
     #=====获取证券价格和/或相关指数数据==========================================
-    if 'capm' in method.lower() or 'market' in method.lower() or 'index' in method.lower(): 
+    #基于CAPM获取数据
+    if 'capm' in method.lower(): 
+        method_type="capm"
+        df_ret=compare_msecurity(tickers=ticker+[market_index],measure=ret_type, \
+                                 start=est_window_start,end=end, \
+                                 ticker_type=ticker_type, \
+                                 graph=False)
+        
+        if isinstance(RF,int) or isinstance(RF,float):
+            #RF为具体数值
+            RF_type="value"
+        
+        elif "market" in (str(RF)).lower() or "index" in (str(RF)).lower():
+            #RF通过市场模型计算，无需指定
+            RF_type="model"
+        else:
+            #指定RF代码，例如1YCNY.B，注意1：得到的是年化收益率%，注意2：中国的只有近一年的数据
+            RF_type="code"
+
+        if RF_type=="code":
+            df_rf=compare_msecurity(tickers=RF,measure='Close', \
+                                     start=est_window_start,end=end, \
+                                     graph=False)
+            RF=df_rf[list(df_rf)[0]].mean() / 100.0
+            
+    #基于市场指数获取数据
+    elif 'market' in method.lower() or 'index' in method.lower(): 
+        method_type="market"
         df_ret=compare_msecurity(tickers=ticker+[market_index],measure=ret_type, \
                                    start=est_window_start,end=end, \
                                    ticker_type=ticker_type, \
                                    graph=False)
-        """
-        for t in ticker+[market_index]:
-            df_ret.rename(columns={ticker_name(t,ticker_type):t},inplace=True)
-        """
-    if 'random' in method.lower() or 'walk' in method.lower(): 
+            
+    elif 'random' in method.lower() or 'walk' in method.lower(): 
+        method_type="random"
         df_ret=compare_msecurity(tickers=ticker,measure=ret_type, \
                                    start=est_window_start,end=end, \
                                    ticker_type=ticker_type, \
                                    graph=False)
         for t in ticker_name(ticker,ticker_type):
-            #df_ret.rename(columns={ticker_name(t,ticker_type):t},inplace=True)
-            df_ret[t+"_predicted"]=df_ret[t].shift(1)
+            try:
+                df_ret[t+"_predicted"]=df_ret[t].shift(1)
+            except:
+                #print("  #Warning(event_study): info not found for ticker {}".format(t))
+                continue
+
+    else:
+        print("  #Warning(event_study): unexpected type of AR method {}".format(method))
+        return None
         
     #=====计算异常收益率AR=====
     df_cols=list(df_ret)
-    if 'market' in method.lower() or 'index' in method.lower(): 
+    if method_type=='market': 
         for t in ticker_name(ticker,ticker_type):
-            df_ret[t+'_AR']=df_ret[t]-df_ret[ticker_name(market_index)]
-    elif 'random' in method.lower() or 'walk' in method.lower():
+            try:
+                df_ret[t+'_AR']=df_ret[t] - df_ret[ticker_name(market_index)]
+            except: continue
+        
+    elif method_type=='random':
         for t in ticker_name(ticker,ticker_type):
-            df_ret[t+'_AR']=df_ret[t]-df_ret[t+"_predicted"]
+            try:
+                df_ret[t+'_AR']=df_ret[t] - df_ret[t+"_predicted"]
+            except: continue
+            
     else: #按CAPM计算
-        #回归CAPM
+        #CAPM回归期间数据
         est_window_startpd=pd.to_datetime(est_window_start)
         est_window_endpd  =pd.to_datetime(est_window_end)
         df_reg=df_ret[(df_ret.index >=est_window_startpd) & (df_ret.index <=est_window_endpd)].copy()
@@ -270,49 +349,111 @@ def event_study(ticker,event_date, \
         df_reg=df_reg.replace([np.nan, None], np.nan).dropna()
         
         import statsmodels.api as sm
-        X=df_reg[ticker_name(market_index)] - RF #无截距项回归，需要RF
-        beta_dict={}
+        if RF_type in ["value","code"]:
+            if not ("%" in ret_type): #注意：RF是年化收益率(需要转化为日收益率)，这里不是百分比
+                X=df_reg[ticker_name(market_index)] - RF/365.0 #无截距项回归，指定RF具体数值
+            else:
+                X=df_reg[ticker_name(market_index)] - RF/365.0 * 100.0 #这里需要转化为日收益率百分比%
+                
+        else: #RF_type=="model"
+            X=df_reg[ticker_name(market_index)]
+            X=sm.add_constant(X) #有截距项回归，基于市场模型 
+
+        if DEBUG:
+            print("  DEBUG: method_type={0}, RF_type={1}, RF={2}".format(method_type,RF_type,RF))
+        
+        #CAPM回归
+        beta_dict={}; intercept_dict={}; pvalue_dict={}; rf_dict={}
         for t in ticker_name(ticker,ticker_type):
-            y=df_reg[t] - RF
-            model = sm.OLS(y,X)	#定义回归模型R-Rf=beta(Rm-Rf)，X可为多元矩阵
+            try:
+                if RF_type in ["value","code"]:
+                    if not ("%" in ret_type): #注意：RF是年化收益率(需要转化为日收益率)，不是百分比
+                        y=df_reg[t] - RF/365.0
+                    else:
+                        y=df_reg[t] - RF/365.0 * 100.0
+                
+                else: #RF_type=="model"
+                        y=df_reg[t]
+            except: continue
+            
+            model = sm.OLS(y,X)	#定义回归模型y=X
             results = model.fit()	#进行OLS回归
-            beta=results.params[0]	#提取回归系数
             
-            beta_dict[t] = beta
-
-        #有截距回归，无需RF
-        #from scipy import stats 
-        #(beta,alpha,r_value,p_value,std_err)=stats.linregress(df_reg[market_index],df_reg[ticker])
-
-        if DEBUG:
-            print("  DEBUG: RF={0}, beta={1}".format(RF,beta_dict))
+            if DEBUG2:
+                print("  DEBUG: RF_type={0}, results.params={1},results.pvalues={2}".format(RF_type,results.params,results.pvalues))
+            
+            #提取回归系数，详细信息见results.summary()
+            if RF_type=="model":
+                intercept=results.params[0]
+                beta=results.params[1]; pvalue=results.pvalues[1]
+                try:
+                    #此处回归得到的rf应该为日收益率，转为年化收益率。
+                    #注意：不同证券回归出的结果可能差异较大，原因可能是混入了回归残差！
+                    if not ("%" in ret_type):
+                        rf=intercept / (1-beta) * 365.0
+                    else:
+                        rf=intercept / (1-beta) / 100.0 * 365.0
+                except: rf=0
+                
+            else: #RF_type in ["value","code"]
+                intercept=0
+                beta=results.params[0]; pvalue=results.pvalues[0]
+                rf=RF
+            
+            beta_dict[t] = beta; intercept_dict[t] = intercept; pvalue_dict[t] = pvalue; rf_dict[t]=rf
+            if DEBUG2:
+                print("  DEBUG: t={0}, intercept={1}, beta={2}, pvalue={3}, annualized rf={4}".format(t,round(intercept,4),round(beta,4),round(pvalue,4),round(rf,4)))
 
+        #计算收益率预期和AR
         for t in ticker_name(ticker,ticker_type):
-            df_ret[t+"_predicted"]=(df_ret[ticker_name(market_index)] - RF)*beta_dict[t] + RF   
-            df_ret[t+"_AR"]=df_ret[t]-df_ret[t+"_predicted"]
+            try:
+                if RF_type in ["value","code"]:
+                    #CAPM模型：E(R) = RF + (Rm-RF)*beta
+                    RF_text=str(round(RF*100.0,4))[:6]+'%'
+                    if not ("%" in ret_type): #注意：RF是年化收益率，此处不是百分比
+                        df_ret[t+"_predicted"]=(df_ret[ticker_name(market_index)] - RF/365.0)*beta_dict[t] + RF/365.0  
+                    else:
+                        df_ret[t+"_predicted"]=(df_ret[ticker_name(market_index)] - RF*100.0/365.0)*beta_dict[t] + RF*100.0/365.0
+                        
+                else: #RF_type=="model"
+                    #市场模型：E(R) = intercept + Rm*beta
+                    RF_text="基于市场模型回归"
+                    df_ret[t+"_predicted"]=df_ret[ticker_name(market_index)]*beta_dict[t] + intercept_dict[t]
+                        
+                df_ret[t+"_AR"]=df_ret[t] - df_ret[t+"_predicted"]
+            except: continue
             
-    #=====计算CAR=====
+        if DEBUG2:
+            print("  DEBUG: RF_type={0}, RF_text={1}, rf_dict={2}".format(RF_type,RF_text, rf_dict))
+        
+    #=====计算CAR==============================================================
     for t in ticker_name(ticker,ticker_type):
-        df_ret[t+"_CAR"]=0
+        try:
+            df_ret[t+"_CAR"]=0
+        except: continue
+        
     event_window_startpd=pd.to_datetime(event_window_start)
     event_window_endpd=pd.to_datetime(event_window_end)
     post_event_endpd=pd.to_datetime(post_event_end)
-    
     startpd=pd.to_datetime(start); endpd=pd.to_datetime(end)
-    #df_ret_event=df_ret[(df_ret.index >=event_window_startpd) & (df_ret.index <=post_event_endpd)]
+    
+    #计算CAR
     df_ret_event=df_ret[(df_ret.index >=event_window_startpd) & (df_ret.index <=endpd)]
     for t in ticker_name(ticker,ticker_type):
-        df_ret_event[t+'_CAR'] = df_ret_event[t+'_AR'].cumsum()
+        try:
+            df_ret_event[t+'_CAR'] = df_ret_event[t+'_AR'].cumsum()
+        except: continue
     
+    #合成事件前期间
     df_ret_before_event=df_ret[(df_ret.index >=startpd) & (df_ret.index < event_window_startpd)]
     for t in ticker_name(ticker,ticker_type):
-        df_ret_before_event[t+'_CAR']=np.nan
+        try:
+            df_ret_before_event[t+'_CAR']=np.nan
+        except: continue
     
-    #df_ret_after_event=df_ret[(df_ret.index >post_event_endpd)]
-    #df_ret_after_event['CAR']=np.nan
-    
-    #df_show=pd.concat([df_ret_before_event,df_ret_event,df_ret_after_event])
     df_show=pd.concat([df_ret_before_event,df_ret_event])
+    
+    #是否显示AR：默认单证券显示，多证券不显示
     df_show_cols=[]
     for c in list(df_show):
         if show_AR=='auto':
@@ -339,28 +480,38 @@ def event_study(ticker,event_date, \
     
     y_label="收益率%"
     
-    
+    #横轴注释    
     footnote1="首事件日{0}，事件窗口{1}，事件后窗口天数{2}，市场提前反应天数{3}".format(event_date[0],event_window_new,post_event_days,early_response_days)
     footnote2="收益率类型："+ectranslate(ret_type)
     
-    if "market" in method.lower() or "index" in method.lower():
-        method_name="市场指数"
-    elif "random" in method.lower() or "walk" in method.lower():
-        method_name="随机漫步"
+    if method_type == "market":
+        method_name="市场指数基准"
+    elif method_type == "random":
+        method_name="随机漫步模型"
     else:
-        method_name="CAPM"
+        method_name="CAPM模型"
         
     footnote3="，收益率预期方法："+method_name
-    if not ('random' in method.lower() or 'walk' in method.lower()):
+    if not method_type == "random":
         footnote4='，市场指数：'+ticker_name(market_index)
     else:
         footnote4=''
     
-    #显著性检验：异于零的t检验
+    #显著性检验：异于零的t检验，事件窗口
     df_event_window=df0[(df0.index >=event_window_start) & (df0.index <=event_window_end)]
-    footnote5="事件窗口CAR的p值："
+    footnote5="事件窗口CAR(终值，p值)："
     for c in list(df_event_window):
         if 'CAR' in c.upper():
+            c_name=c[:-4]
+            
+            event_window_endpd=pd.to_datetime(event_window_end)
+            #car_value=df_event_window[df_event_window.index == event_window_endpd][c].values[0]
+            car_value=df_event_window[c][-1]
+            if car_value > 0:
+                car_value_str=str(round(car_value,4))[:6]
+            else:
+                car_value_str=str(round(car_value,4))[:7]
+            
             if len(df_event_window[c])==1:
                 if  abs(df_event_window[c].values[0]) > 0.01:
                     p_value=0.0
@@ -368,22 +519,51 @@ def event_study(ticker,event_date, \
                     p_value=1.0
             else:
                 p_value=ttest(df_event_window[c],0)
-            footnote5=footnote5+c[:-4]+str(p_value)[:6]+"，"
-    footnote5=footnote5.strip("，")
+            if p_value > 0:
+                p_value_str=str(round(p_value,4))[:6]
+            else:
+                p_value_str=str(round(p_value,4))[:7]
+            #footnote5=footnote5+c_name+p_value_str+"，"
+            footnote5=footnote5+"{0}({1}, {2}), ".format(c_name,car_value_str,p_value_str)
+    footnote5=footnote5.strip(", ")
 
+    #显著性检验：异于零的t检验，事件后窗口
     df_post_event_window=df0[(df0.index >event_window_end) & (df0.index <=post_event_end)]
-    footnote6="事件后窗口CAR的p值："
-    for c in list(df_post_event_window):
-        if 'CAR' in c.upper():
-            if len(df_post_event_window[c])==1:
-                if  abs(df_post_event_window[c].values[0]) > 0.01:
-                    p_value=0.0
+    if len(df_post_event_window) == 0:
+        footnote6=''
+
+    elif len(df_post_event_window) == 0:
+        footnote6=''
+    else:
+        footnote6="事件后窗口CAR(终值，p值)："
+        for c in list(df_post_event_window):
+            if 'CAR' in c.upper():
+                c_name=c[:-4]
+                post_event_endpd=pd.to_datetime(post_event_end)
+                if DEBUG2:
+                    print("  DEBUG: c={0},post_event_end={1},df_post_event_window={2}".format(c,post_event_end,df_post_event_window))
+                #car_value=df_post_event_window[df_post_event_window.index == post_event_endpd][c].values[0]
+                car_value=df_post_event_window[c][-1]
+                if car_value > 0:
+                    car_value_str=str(round(car_value,4))[:6]
                 else:
-                    p_value=1.0
-            else:
-                p_value=ttest(df_post_event_window[c],0)
-            footnote6=footnote6+c[:-4]+str(p_value)[:6]+"，"
-    footnote6=footnote6.strip("，")
+                    car_value_str=str(round(car_value,4))[:7]
+                
+                if len(df_post_event_window[c])==1:
+                    if  abs(df_post_event_window[c].values[0]) > 0.01:
+                        p_value=0.0
+                    else:
+                        p_value=1.0
+                else:
+                    p_value=ttest(df_post_event_window[c],0)
+                if p_value > 0:
+                    p_value_str=str(round(p_value,4))[:6]
+                else:
+                    p_value_str=str(round(p_value,4))[:7]
+                    
+                #footnote6=footnote6+c[:-4]+str(p_value)[:6]+"，"
+                footnote6=footnote6+"{0}({1}, {2}), ".format(c_name,car_value_str,p_value_str)
+        footnote6=footnote6.strip(", ")
     
     footnote7="数据来源：Sina/EM/Yahoo/Stooq/SWHY，"+stoday
 
@@ -467,20 +647,25 @@ def event_study(ticker,event_date, \
                 event_text="事件日"+str(pos+1)
         df1["事件标记"]=df1.apply(lambda x: event_text if x["日期"]==d else x["事件标记"],axis=1)
 
-    event_text="，事件窗口开始日"
+    #event_text="，事件窗口开始日"
+    event_text="\n事件窗开始"
     df1["事件标记"]=df1.apply(lambda x: x["事件标记"]+event_text if x["日期"]==event_window_start else x["事件标记"],axis=1)
-    event_text="，事件窗口结束日"
+    #event_text="，事件窗口结束日"
+    event_text="\n事件窗结束"
     df1["事件标记"]=df1.apply(lambda x: x["事件标记"]+event_text if x["日期"]==event_window_end else x["事件标记"],axis=1)
-    event_text="事件后窗口结束日"
-    df1["事件标记"]=df1.apply(lambda x: x["事件标记"]+event_text if x["日期"]==post_event_end else x["事件标记"],axis=1)
+    
+    #event_text="，事件后窗口结束日"
+    if post_event_end > event_window_end:
+        event_text="\n事件后窗结束"
+        df1["事件标记"]=df1.apply(lambda x: x["事件标记"]+event_text if x["日期"]==post_event_end else x["事件标记"],axis=1)
         
-    event_text="，事件窗口"
+    event_text="\n事件窗"
     df1["事件标记"]=df1.apply(lambda x: x["事件标记"]+event_text if (x["日期"] > event_window_start) and (x["日期"] < event_window_end) else x["事件标记"],axis=1)
         
-    event_text="，事件后窗口"
+    event_text="\n事件后窗"
     df1["事件标记"]=df1.apply(lambda x: x["事件标记"]+event_text if (x["日期"] > event_window_end) and (x["日期"] < post_event_end) else x["事件标记"],axis=1)
 
-    df1["事件标记"]=df1["事件标记"].apply(lambda x: x.strip('，'))
+    df1["事件标记"]=df1["事件标记"].apply(lambda x: x.strip('\n'))
     
     #显示表格
     df0_list=list(df0)
@@ -489,18 +674,26 @@ def event_study(ticker,event_date, \
     #title_txt=title_txt+"，窗口收益率"
     
     if "CAPM" in method.upper():
-        footnotex="CAPM回归期间：{0}至{1}".format(est_window_start,est_window_end)
+        footnotex="CAPM回归期间：{0}至{1}，无风险收益率{2}".format(est_window_start,est_window_end,RF_text)
         footnotey="CAPM贝塔系数："
         for k in beta_dict:
             footnotey=footnotey+k+str(round(beta_dict[k],4))[:6]+"，"
         footnotey=footnotey.strip("，")
-    
-        footnote=footnote2+footnote3+footnote4+'\n'+footnotex+'\n'+footnotey+'\n'+footnote5+'\n'+footnote6
+        
+        if show_RF:
+            footnotez="无风险收益率均值："
+            for r in rf_dict:
+                footnotez=footnotez+r+str(round(rf_dict[r]*100.0,4))[:6]+"%, "
+                
+            footnotez=footnotez.strip(", ")
+            footnote=footnote2+footnote3+footnote4+'\n'+footnotex+'\n'+footnotey+'\n'+footnotez+'\n'+footnote5+'\n'+footnote6
+        else:
+            footnote=footnote2+footnote3+footnote4+'\n'+footnotex+'\n'+footnotey+'\n'+footnote5+'\n'+footnote6
     else:
         footnote=footnote2+footnote3+footnote4+'\n'+footnote5+'\n'+footnote6
     
-    
-    df_display_CSS(df1,titletxt=title_txt,footnote=footnote,facecolor='papayawhip',decimals=4, \
+    #显示结果表格
+    df_display_CSS(df1,titletxt=title_txt,footnote=footnote,facecolor=facecolor,decimals=4, \
                    first_col_align='left',second_col_align='left', \
                    last_col_align='center',other_col_align='center')
 

{siat-3.7.1.dist-info → siat-3.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: siat
-Version: 3.7.1
+Version: 3.7.3
 Summary: Securities Investment Analysis Tools (siat)
 Home-page: https://pypi.org/project/siat/
 Author: Prof. WANG Dehong, International Business School, Beijing Foreign Studies University

{siat-3.7.1.dist-info → siat-3.7.3.dist-info}/RECORD

@@ -32,7 +32,7 @@ siat/economy.py,sha256=ijMAVA5ydghbQDgNDDdz8fz9NPd2eq90RzpJSRGWz5c,78638
 siat/economy_test.py,sha256=6vjNlPz7W125pJb7simCddobSEp3jmLIMvVkLRZ7zW8,13339
 siat/esg.py,sha256=GMhaonIKtvOK83rhpQUH5aJt2OL3HQBSVfD__Yw-0oo,19040
 siat/esg_test.py,sha256=Z9m6GUt8O7oHZSEG9aDYpGdvvrv2AiRJdHTiU6jqmZ0,2944
-siat/event_study.py,sha256=GCZSMGOAxthVEcRVv9eerIX4RYT_9cnnR6PvIx2mMXE,23833
+siat/event_study.py,sha256=Q_AdnJzxxL6udCjn5LP6rdhOngsDRWPu5udFkK1CJZw,32223
 siat/exchange_bond_china.pickle,sha256=zDqdPrFacQ0nqjP_SuF6Yy87EgijIRsFvFroW7FAYYY,1265092
 siat/fama_french.py,sha256=aUTC-67t_CEPbLk4u79woW_zfZ7OCP6Fo4z5EdWCSkQ,48051
 siat/fama_french_test.py,sha256=M4O23lBKsJxhWHRluwCb3l7HSEn3OFTjzGMpehcevRg,4678
@@ -141,8 +141,8 @@ siat/valuation_china.py,sha256=CVp1IwIsF3Om0J29RGkyxZLt4n9Ug-ua_RKhLwL9fUQ,69624
 siat/valuation_market_china_test.py,sha256=gbJ0ioauuo4koTPH6WKUkqcXiQPafnbhU5eKJ6lpdLA,1571
 siat/var_model_validation.py,sha256=R0caWnuZarrRg9939hxh3vJIIpIyPfvelYmzFNZtPbo,14910
 siat/yf_name.py,sha256=r0Q67cSMMlfebEkI9h9pdGlJCooEq7hw_3M5IUs4cSI,20081
-siat-3.7.1.dist-info/LICENSE,sha256=NTEMMROY9_4U1szoKC3N2BLHcDd_o5uTgqdVH8tbApw,1071
-siat-3.7.1.dist-info/METADATA,sha256=QEq7a5uvfG4GBQLwJDP2ARnKHjAG-4T_A16Bp45lBZc,8009
-siat-3.7.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-siat-3.7.1.dist-info/top_level.txt,sha256=r1cVyL7AIKqeAmEJjNR8FMT20OmEzufDstC2gv3NvEY,5
-siat-3.7.1.dist-info/RECORD,,
+siat-3.7.3.dist-info/LICENSE,sha256=NTEMMROY9_4U1szoKC3N2BLHcDd_o5uTgqdVH8tbApw,1071
+siat-3.7.3.dist-info/METADATA,sha256=CTwHox9UQtS4g3RRebTz5dH5GgC62g4WOxJr8mr1tEo,8009
+siat-3.7.3.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+siat-3.7.3.dist-info/top_level.txt,sha256=r1cVyL7AIKqeAmEJjNR8FMT20OmEzufDstC2gv3NvEY,5
+siat-3.7.3.dist-info/RECORD,,

{siat-3.7.1.dist-info → siat-3.7.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: bdist_wheel (0.41.2)
 Root-Is-Purelib: true
 Tag: py3-none-any