siat 3.10.132__py3-none-any.whl → 3.11.1__py3-none-any.whl

build/lib/build/lib/siat/option_pricing.py

@@ -1,1925 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-本模块功能：期权定价理论计算函数包
-所属工具包：证券投资分析工具SIAT 
-SIAT：Security Investment Analysis Tool
-创建日期：2020年7月16日
-最新修订日期：2020年8月5日
-作者：王德宏 (WANG Dehong, Peter)
-作者单位：北京外国语大学国际商学院
-作者邮件：wdehong2000@163.com
-版权所有：王德宏
-用途限制：仅限研究与教学使用，不可商用！商用需要额外授权。
-特别声明：作者不对使用本工具进行证券投资导致的任何损益负责！
-"""
-#==============================================================================
-#统一屏蔽一般性警告
-import warnings; warnings.filterwarnings("ignore")    
-from siat.common import *
-from siat.translate import *
-from siat.grafix import *
-from siat.security_prices import *
-from siat.security_trend2 import *
-from siat.yf_name import *
-#==============================================================================
-import matplotlib.pyplot as plt
-
-#处理绘图汉字乱码问题
-import sys; czxt=sys.platform
-if czxt in ['win32','win64']:
-    plt.rcParams['font.sans-serif'] = ['SimHei']  # 设置默认字体
-    mpfrc={'font.family': 'SimHei'}
-
-if czxt in ['darwin']: #MacOSX
-    plt.rcParams['font.family']= ['Heiti TC']
-    mpfrc={'font.family': 'Heiti TC'}
-
-if czxt in ['linux']: #website Jupyter
-    plt.rcParams['font.family']= ['Heiti TC']
-    mpfrc={'font.family':'Heiti TC'}
-
-# 解决保存图像时'-'显示为方块的问题
-plt.rcParams['axes.unicode_minus'] = False 
-
-#==============================================================================
-if __name__=='__main__':
-    direction='call'
-
-
-def bs_pricing(S0,X,Days,r0,sigma,direction='call',printout=True):
-    """
-    功能：计算无红利支付的欧式期权B-S定价模型，默认看涨期权
-    注意：
-    S0：标的物资产的当前价格，X为其行权价
-    sigma：标的物资产价格收益率的年化标准差
-    r0：年化无风险利率（程序中会转化为连续计算的无风险利率）
-    Days：距离到期日的天数（程序中会转换为距离到期日的年数=距离到期日的天数/365）
-    """
-    
-    direction=direction.upper()
-    
-    if direction=='CALL':
-       C0=bs_call(S0,X,Days,r0,sigma,printout=printout) 
-    else:
-       C0=bs_put(S0,X,Days,r0,sigma,printout=printout) 
-    
-    
-    return C0
-    
-#==============================================================================
-
-def bs_call(S0,X,Days,r0,sigma,printout=True):
-    """
-    功能：计算无红利支付的欧式期权B-S定价模型，看涨期权
-    注意：
-    S0：标的物资产的当前价格，X为其行权价
-    sigma：标的物资产价格收益率的年化标准差
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    Days：距离到期日的天数，需要转换为距离到期日的年数=距离到期日的天数/365
-    """
-    from scipy import stats
-    from numpy import log,exp,sqrt
-    
-    #Days为距离到期日的日历日天数
-    T=Days/365.
-    r=log(r0+1)
-    
-    d1=(log(S0/X)+(r+sigma*sigma/2.)*T)/(sigma*sqrt(T))
-    d2=d1-sigma*sqrt(T)
-    
-    C0=S0*stats.norm.cdf(d1)-X*exp(-r*T)*stats.norm.cdf(d2)
-    
-    if not printout: return C0
-    print("\n===== Black-Scholes期权定价 =====")
-    print("适用情形： 欧式期权，标的资产无红利收益")
-    print("标的资产行权价:",X)
-    print("标的资产现价  :",S0)
-    print("标的资产的年化波动率:",round(sigma,4))    
-    print("距离到期日的年数    :",round(T,4))
-    print("连续计算的无风险利率:",round(r*100,4),'\b%')
-    print("看涨期权的预期价格  :",round(C0,4))
-    
-    return C0
-    
-if __name__=='__main__':
-    S0=40
-    X=42
-    Days=183
-    r0=0.03
-    sigma=0.02
-    C0=bs_call(40,42,183,0.015,0.02)
-
-#==============================================================================
-def bsm_call(S0,X,Days,r0,sigma,Days1=0,div1=0,printout=True):
-    """
-    功能：计算有红利支付的欧式期权B-S定价模型，看涨期权
-    注意：
-    S0：标的物资产的当前价格，X为其行权价
-    sigma：标的物资产价格收益率的年化标准差
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    Days：距离到期日的天数，需要转换为距离到期日的年数=距离到期日的天数/365
-    Days1：红利发放时距离到期日的天数，需要转换为年数
-    div1：红利金额
-    """
-    from numpy import log,exp
-    #Days1为距离到期日的日历日天数
-    T=Days/365.
-    T1=Days1/365.
-    r=log(r0+1)    
-    #调整标的物当前价
-    S=S0-exp(-r*T1)*div1
-    
-    #调用BS模型计算
-    C=bs_call(S,X,Days,r0,sigma,printout=False)
-
-    if not printout: return C
-    print("\n=== Black-Scholes-Merton期权定价 ===")
-    print("适用情形： 欧式期权，标的资产有红利收益")
-    print("标的资产行权价:",X)
-    print("标的资产现价  :",S0)
-    print("标的资产的年化波动率  :",round(sigma,4))    
-    print("距离到期日的年数      :",round(T,4))
-    print("连续计算的无风险利率  :",round(r,4)*100,'\b%')    
-    print("红利及距离到期日的年数:",div1,"@",round(T1,4))
-    print("看涨期权的预期价格    :",round(C,4))
-    
-    return C
-    
-if __name__=='__main__':
-    S0=42
-    X=40
-    Days=183
-    r0=0.03
-    sigma=0.02
-    dv1=1.5
-    Days1=183
-    C=bsm_call(42,40,183,0.015,0.02,183,1.5)
-    C0=bsm_call(42,40,183,0.015,0.23)
-
-#==============================================================================
-def bs_put(S0,X,Days,r0,sigma,printout=True):
-    """
-    功能：计算无红利支付的欧式期权B-S定价模型，看跌期权
-    注意：
-    S0：标的物资产的当前价格，X为其行权价
-    sigma：标的物资产价格收益率的年化标准差
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    Days：距离到期日的天数，需要转换为距离到期日的年数=距离到期日的天数/365
-    """
-    from scipy import stats
-    from numpy import log,exp,sqrt
-    
-    #Days为距离到期日的日历日天数
-    T=Days/365.
-    r=log(r0+1)
-    
-    d1=(log(S0/X)+(r+sigma*sigma/2.)*T)/(sigma*sqrt(T))
-    d2=d1-sigma*sqrt(T)
-    
-    P0=-S0*stats.norm.cdf(-d1)+X*exp(-r*T)*stats.norm.cdf(-d2)
-
-    if not printout: return P0
-    print("\n===== Black-Scholes期权定价 =====")
-    print("适用情形： 欧式期权，标的资产无红利收益")
-    print("标的资产行权价:",X)
-    print("标的资产现价  :",S0)
-    print("标的资产的年化波动率:",round(sigma,4))    
-    print("距离到期日的年数    :",round(T,4))
-    print("连续计算的无风险利率:",round(r*100,4),'\b%')
-    print("看跌期权的预期价格  :",round(P0,4))
-    
-    return P0
-    
-if __name__=='__main__':
-    S0=40
-    X=42
-    Days=183
-    r0=0.03
-    sigma=0.02
-    P0=bs_put(40,42,183,0.015,0.02)    
-
-#==============================================================================
-def bsm_put(S0,X,Days,r0,sigma,Days1=0,div1=0,printout=True):
-    """
-    功能：计算有红利支付的欧式期权B-S定价模型，看跌期权
-    注意：
-    S0：标的物资产的当前价格，X为其行权价
-    sigma：标的物资产价格收益率的年化标准差
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    Days：距离到期日的天数，需要转换为距离到期日的年数=距离到期日的天数/365
-    Days1：红利发放时距离到期日的天数，需要转换为年数
-    div1：红利金额
-    """
-    from numpy import log,exp,sqrt
-    
-    #Days为距离到期日的日历日天数
-    T=Days/365.
-    T1=Days1/365.
-    r=log(r0+1)
-    
-    S=S0-exp(-r*T1)*div1
-    
-    #调用BS模型计算
-    P=bs_put(S,X,Days,r0,sigma,printout=False)
-
-    if not printout: return P
-    print("\n=== Black-Scholes-Merton期权定价 ===")
-    print("适用情形： 欧式期权，标的资产有红利收益")
-    print("标的资产行权价:",X)
-    print("标的资产现价  :",S0)
-    print("标的资产的年化波动率  :",round(sigma,4))    
-    print("距离到期日的年数      :",round(T,4))
-    print("连续计算的无风险利率  :",round(r,4)*100,'\b%')
-    print("红利及距离到期日的年数:",div1,"@",round(T1,2))
-    print("看跌期权的预期价格    :",round(P,4))
-    
-    return P
-    
-if __name__=='__main__':
-    S0=42
-    X=40
-    Days=183
-    r0=0.03
-    sigma=0.02
-    P=bsm_put(42,40,183,0.015,0.23,90,1.5)   
-    P0=bsm_put(42,40,183,0.015,0.23)
-
-#==============================================================================
-def bsm_put_aprice(Srange,X,Days,r0,sigma,Days1=0,div1=0,graph=True):
-    """
-    功能：计算有红利支付的欧式期权BSM定价模型，看跌期权，当前价格为变化范围
-    注意：
-    Srange：标的物资产的当前价格范围，默认20等分后作为横轴绘图
-    X：期权的行权价
-    sigma：标的物资产价格收益率的年化标准差
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    Days：距离到期日的天数，需要转换为距离到期日的年数=距离到期日的天数/365
-    Days1：红利发放时距离到期日的天数，需要转换为年数
-    div1：红利金额
-    """
-    #通用修改点
-    trange=Srange
-    #检查是否为列表
-    if not isinstance(trange,list):
-        print("#Error(bsm_put_aprice): target is not a range,",trange)
-        return
-    if len(trange) < 2:
-        print("#Error(bsm_put_aprice): not enough range for target,",trange)
-        return        
-    
-    #确定起始位置和间隔大小
-    tstart=trange[0]; tend=trange[1]
-    if len(trange) >=3: tstep=trange[2]    
-    else: tstep=(tend-tstart)/20.
-    #横轴点列表
-    import numpy as np
-    tlist=np.arange(tstart,tend+tstep,tstep)
-
-    #循环计算各点数值
-    import pandas as pd
-    df=pd.DataFrame(columns=['Option Price','Asset Price','Strike Price', \
-                             'Days to Maturity','Annual RF', \
-                             'Annual Sigma','Div to Maturity','Dividend'])
-    for t in tlist:
-        #通用修改点
-        op=bsm_put(t,X,Days,r0,sigma,Days1,div1,printout=False)
-        s=pd.Series({'Option Price':op,'Asset Price':t,'Strike Price':X, \
-                     'Days to Maturity':Days,'Annual RF':r0, \
-                     'Annual Sigma':sigma,'Div to Maturity':Days1, \
-                     'Dividend':div1})
-        try:
-            df=df.append(s,ignore_index=True)
-        except:
-            df=df._append(s,ignore_index=True)
-    #通用修改点
-    df2=df.set_index(['Asset Price'])  
-    if not graph: return df2      
-    
-    #绘图
-    #通用修改点
-    colname='Option Price'; collabel='看跌期权'
-    ylabeltxt='期权价格'
-    titletxt='期权价格的变化趋势图'
-    #通用修改点
-    fn1='标的物市场价格'
-    fn2='\n[期权信息]行权价='+str(X)+', 距离到期天数='+str(Days)
-    fn3='\n年化无风险利率%='+str(round(r0*100.,2))+', 年化波动率%='+str(round(sigma*100.,2))
-    if div1==0:
-        fn4='\n本产品无红利收益'
-    else:
-        fn4='\n发放红利时间距离到期天数='+str(Days1)+', 红利='+str(div1)
-    footnote=fn1+fn2+fn3+fn4
-    plot_line(df2,colname,collabel,ylabeltxt,titletxt,footnote)
-    
-    return df2
-    
-if __name__=='__main__':
-    Srange=[30,50,1]
-    X=40
-    Days=183
-    r0=0.03
-    sigma=0.02
-    Days1=0
-    div1=0
-    pdf=bsm_put_aprice(Srange,40,183,0.015,0.23,90,1.5)    
-
-#==============================================================================
-def bsm_call_aprice(Srange,X,Days,r0,sigma,Days1=0,div1=0,graph=True):
-    """
-    功能：计算有红利支付的欧式期权BSM定价模型，看涨期权，当前价格为变化范围
-    注意：
-    Srange：标的物资产的当前价格范围，默认20等分后作为横轴绘图
-    X：期权的行权价
-    sigma：标的物资产价格收益率的年化标准差
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    Days：距离到期日的天数，需要转换为距离到期日的年数=距离到期日的天数/365
-    Days1：红利发放时距离到期日的天数，需要转换为年数
-    div1：红利金额
-    """
-    #通用修改点
-    trange=Srange
-    #检查是否为列表
-    if not isinstance(trange,list):
-        print("#Error(bsm_call_aprice): target is not a range,",trange)
-        return
-    if len(trange) < 2:
-        print("#Error(bsm_call_aprice): not enough range for target,",trange)
-        return        
-    
-    #确定起始位置和间隔大小
-    tstart=trange[0]; tend=trange[1]
-    if len(trange) >=3: tstep=trange[2]    
-    else: tstep=(tend-tstart)/20.
-    #横轴点列表
-    import numpy as np
-    tlist=np.arange(tstart,tend+tstep,tstep)
-
-    #循环计算各点数值
-    import pandas as pd
-    df=pd.DataFrame(columns=['Option Price','Asset Price','Strike Price', \
-                             'Days to Maturity','Annual RF', \
-                             'Annual Sigma','Div to Maturity','Dividend'])
-    for t in tlist:
-        #通用修改点
-        op=bsm_call(t,X,Days,r0,sigma,Days1,div1,printout=False)
-        s=pd.Series({'Option Price':op,'Asset Price':t,'Strike Price':X, \
-                     'Days to Maturity':Days,'Annual RF':r0, \
-                     'Annual Sigma':sigma,'Div to Maturity':Days1, \
-                     'Dividend':div1})
-        try:
-            df=df.append(s,ignore_index=True)
-        except:
-            df=df._append(s,ignore_index=True)
-    #通用修改点
-    df2=df.set_index(['Asset Price'])  
-    if not graph: return df2      
-    
-    #绘图
-    #通用修改点
-    colname='Option Price'; collabel='看涨期权'
-    ylabeltxt='期权价格'
-    titletxt='期权价格的变化趋势图'
-    #通用修改点
-    fn1='标的物市场价格'
-    fn2='\n[期权信息]行权价='+str(X)+', 距离到期天数='+str(Days)
-    fn3='\n年化无风险利率%='+str(round(r0*100.,2))+', 年化波动率%='+str(round(sigma*100.,2))
-    if div1==0:
-        fn4='\n本产品无红利收益'
-    else:
-        fn4='\n发放红利时间距离到期天数='+str(Days1)+', 红利='+str(div1)
-    footnote=fn1+fn2+fn3+fn4
-    plot_line(df2,colname,collabel,ylabeltxt,titletxt,footnote)
-    
-    return df2
-    
-if __name__=='__main__':
-    Srange=[30,50,1]
-    X=40
-    Days=183
-    r0=0.03
-    sigma=0.02
-    Days1=0
-    div1=0
-    cdf=bsm_call_aprice(Srange,40,183,0.015,0.23,90,1.5)    
-
-#==============================================================================
-def bsm_aprice(Srange,X,Days,r0,sigma,Days1=0,div1=0,graph=True):
-    """
-    功能：计算有红利支付的欧式期权BSM定价模型，看涨/看跌期权，当前价格为变化范围
-    注意：
-    Srange：标的物资产的当前价格范围，默认20等分后作为横轴绘图
-    X：期权的行权价
-    sigma：标的物资产价格收益率的年化标准差
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    Days：距离到期日的天数，需要转换为距离到期日的年数=距离到期日的天数/365
-    Days1：红利发放时距离到期日的天数，需要转换为年数
-    div1：红利金额
-    """
-    #通用修改点
-    trange=Srange
-    #检查是否为列表
-    if not isinstance(trange,list):
-        print("#Error(bsm_aprice): target is not a range,",trange)
-        return
-    if len(trange) < 2:
-        print("#Error(bsm_aprice): not enough range for target,",trange)
-        return        
-    
-    #看涨期权
-    df1=bsm_call_aprice(Srange,X,Days,r0,sigma,Days1=0,div1=0,graph=False)
-    #看跌期权
-    df2=bsm_put_aprice(Srange,X,Days,r0,sigma,Days1=0,div1=0,graph=False)     
-    
-    #绘图
-    #通用修改点
-    ticker1='看涨期权'; colname1='Option Price'; label1='期权-C-'+str(X)
-    ticker2='看跌期权'; colname2='Option Price'; label2='期权-P-'+str(X)
-    ylabeltxt='期权价格'
-    titletxt='期权价格的变化趋势图'
-    #通用修改点
-    fn1='标的物市场价格-->'
-    fn2='\n[期权信息]行权价='+str(X)+', 距离到期天数='+str(Days)
-    fn3='\n年化无风险利率%='+str(round(r0*100.,2))+', 年化波动率%='+str(round(sigma*100.,2))
-    if div1==0:
-        fn4='\n本产品无红利收益'
-    else:
-        fn4='\n发放红利时间距离到期天数='+str(Days1)+', 红利='+str(div1)
-    footnote=fn1+fn2+fn3+fn4
-    plot_line2_coaxial(df1,ticker1,colname1,label1, \
-                       df2,ticker2,colname2,label2, \
-                    ylabeltxt,titletxt,footnote)
-    return
-    
-if __name__=='__main__':
-    Srange=[30,50,1]
-    X=40
-    Days=183
-    r0=0.03
-    sigma=0.02
-    Days1=0
-    div1=0
-    bsm_aprice(Srange,40,183,0.015,0.23,90,1.5)  
-    bsm_aprice([30,50],40,183,0.015,0.23,90,1.5)  
-
-#==============================================================================
-def bsm_put_maturity(S0,X,Dayrange,r0,sigma,Days1=0,div1=0,graph=True):
-    """
-    功能：计算有红利支付的欧式期权BSM定价模型，看跌期权，距离到期日天数为变化范围
-    注意：
-    S0：标的物资产的当前价格
-    X：期权的行权价
-    sigma：标的物资产价格收益率的年化标准差
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    Dayrange：距离到期日的天数范围，默认变化间隔为20分之一取整
-    Days1：红利发放时距离到期日的天数，需要转换为年数
-    div1：红利金额
-    """
-    #通用修改点
-    trange=Dayrange
-    #检查是否为列表
-    if not isinstance(trange,list):
-        print("#Error(bsm_put_maturity): target is not a range,",trange)
-        return
-    if len(trange) < 2:
-        print("#Error(bsm_put_maturity): not enough range for target,",trange)
-        return        
-    
-    #确定起始位置和间隔大小
-    tstart=int(trange[0]); tend=int(trange[1])
-    if len(trange) >=3: tstep=trange[2]    
-    else: tstep=int((tend-tstart)/20)
-    #横轴点列表
-    #import numpy as np
-    tlist=range(tstart,tend+tstep,tstep)
-
-    #循环计算各点数值
-    import pandas as pd
-    df=pd.DataFrame(columns=['Option Price','Asset Price','Strike Price', \
-                             'Days to Maturity','Annual RF', \
-                             'Annual Sigma','Div to Maturity','Dividend'])
-    for t in tlist:
-        #通用修改点
-        op=bsm_put(S0,X,t,r0,sigma,Days1,div1,printout=False)
-        s=pd.Series({'Option Price':op,'Asset Price':S0,'Strike Price':X, \
-                     'Days to Maturity':t,'Annual RF':r0, \
-                     'Annual Sigma':sigma,'Div to Maturity':Days1, \
-                     'Dividend':div1})
-        try:
-            df=df.append(s,ignore_index=True)
-        except:
-            df=df._append(s,ignore_index=True)
-    #通用修改点
-    df2=df.set_index(['Days to Maturity'])  
-    if not graph: return df2      
-    
-    #绘图
-    #通用修改点
-    colname='Option Price'; collabel='看跌期权'
-    ylabeltxt='期权价格'
-    titletxt='期权价格的变化趋势图'
-    #通用修改点
-    fn1='<--距离到期日的天数'
-    fn2='\n[期权信息]行权价='+str(X)+', 标的物市价='+str(S0)
-    fn3='\n年化无风险利率%='+str(round(r0*100.,2))+', 年化波动率%='+str(round(sigma*100.,2))
-    if div1==0:
-        fn4='\n本产品无红利收益'
-    else:
-        fn4='\n发放红利时间距离到期天数='+str(Days1)+', 红利='+str(div1)
-    footnote=fn1+fn2+fn3+fn4
-    plot_line(df2,colname,collabel,ylabeltxt,titletxt,footnote)
-    
-    return df2
-    
-if __name__=='__main__':
-    S0=42
-    X=40
-    Dayrange=[200,50]
-    r0=0.015
-    sigma=0.23
-    Days1=90
-    div1=1.5
-    pdf=bsm_put_maturity(42,40,[200,50],0.015,0.23,90,1.5)    
-
-#==============================================================================
-def bsm_call_maturity(S0,X,Dayrange,r0,sigma,Days1=0,div1=0,graph=True):
-    """
-    功能：计算有红利支付的欧式期权BSM定价模型，看涨期权，距离到期日天数为变化范围
-    注意：
-    S0：标的物资产的当前价格
-    X：期权的行权价
-    sigma：标的物资产价格收益率的年化标准差
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    Dayrange：距离到期日的天数范围，默认变化间隔为20分之一取整
-    Days1：红利发放时距离到期日的天数，需要转换为年数
-    div1：红利金额
-    """
-    #通用修改点
-    trange=Dayrange
-    #检查是否为列表
-    if not isinstance(trange,list):
-        print("#Error(bsm_call_maturity): target is not a range,",trange)
-        return
-    if len(trange) < 2:
-        print("#Error(bsm_call_maturity): not enough range for target,",trange)
-        return        
-    
-    #确定起始位置和间隔大小
-    tstart=int(trange[0]); tend=int(trange[1])
-    if len(trange) >=3: tstep=trange[2]    
-    else: tstep=int((tend-tstart)/20)
-    #横轴点列表
-    #import numpy as np
-    tlist=range(tstart,tend+tstep,tstep)
-
-    #循环计算各点数值
-    import pandas as pd
-    df=pd.DataFrame(columns=['Option Price','Asset Price','Strike Price', \
-                             'Days to Maturity','Annual RF', \
-                             'Annual Sigma','Div to Maturity','Dividend'])
-    for t in tlist:
-        #通用修改点
-        op=bsm_call(S0,X,t,r0,sigma,Days1,div1,printout=False)
-        s=pd.Series({'Option Price':op,'Asset Price':S0,'Strike Price':X, \
-                     'Days to Maturity':t,'Annual RF':r0, \
-                     'Annual Sigma':sigma,'Div to Maturity':Days1, \
-                     'Dividend':div1})
-        try:
-            df=df.append(s,ignore_index=True)
-        except:
-            df=df._append(s,ignore_index=True)
-    #通用修改点
-    df2=df.set_index(['Days to Maturity'])  
-    if not graph: return df2      
-    
-    #绘图
-    #通用修改点
-    colname='Option Price'; collabel='看涨期权'
-    ylabeltxt='期权价格'
-    titletxt='期权价格的变化趋势图'
-    #通用修改点
-    fn1='<--距离到期日的天数'
-    fn2='\n[期权信息]行权价='+str(X)+', 标的物市价='+str(S0)
-    fn3='\n年化无风险利率%='+str(round(r0*100.,2))+', 年化波动率%='+str(round(sigma*100.,2))
-    if div1==0:
-        fn4='\n本产品无红利收益'
-    else:
-        fn4='\n发放红利时间距离到期天数='+str(Days1)+', 红利='+str(div1)
-    footnote=fn1+fn2+fn3+fn4
-    plot_line(df2,colname,collabel,ylabeltxt,titletxt,footnote)
-    
-    return df2
-    
-if __name__=='__main__':
-    S0=42
-    X=40
-    Dayrange=[200,50]
-    r0=0.015
-    sigma=0.23
-    Days1=90
-    div1=1.5
-    cdf=bsm_call_maturity(42,40,[200,50],0.015,0.23,90,1.5)    
-
-#==============================================================================
-if __name__=='__main__':
-    S0=42
-    X=40
-    Dayrange=[200,50]
-    r0=0.015
-    sigma=0.23
-    Days1=90
-    div1=1.5
-
-def bsm_maturity(S0,X,Dayrange,r0,sigma,Days1=0,div1=0,graph=True):
-    """
-    功能：计算有红利支付的欧式期权BSM定价模型，看涨/看跌期权，距离到期日天数为变化范围
-    注意：
-    S0：标的物资产的当前价格
-    X：期权的行权价
-    sigma：标的物资产价格收益率的年化标准差
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    Dayrange：距离到期日的天数范围，默认间隔为20分之一取证
-    Days1：红利发放时距离到期日的天数，需要转换为年数
-    div1：红利金额
-    """
-    #通用修改点
-    trange=Dayrange
-    #检查是否为列表
-    if not isinstance(trange,list):
-        print("#Error(bsm_maturity): target is not a range,",trange)
-        return
-    if len(trange) < 2:
-        print("#Error(bsm_maturity): not enough range for target,",trange)
-        return        
-    
-    #看涨期权
-    df1=bsm_call_maturity(S0,X,Dayrange,r0,sigma,Days1=0,div1=0,graph=False)
-    df1.sort_index(ascending=False, inplace=True)
-    #看跌期权
-    df2=bsm_put_maturity(S0,X,Dayrange,r0,sigma,Days1=0,div1=0,graph=False)
-    df2.sort_index(ascending=False, inplace=True)  
-    #合并
-    import pandas as pd
-    df=pd.merge(df1,df2,how='inner',left_index=True,right_index=True,sort=True)
-    #df['到期日']=df.index
-    #df.sort_values('到期日',ascending=False,inplace=True)
-    
-    #绘图    
-    plt.title('期权价格的变化趋势图')
-    plt.ylabel('期权价格')
-    
-    df['Option Price_x'].plot(label='看涨期权',ls='-')
-    df['Option Price_y'].plot(label='看跌期权',ls='-.')
-    
-    fn1='距离到期日的天数-->'
-    fn2='\n[期权信息]行权价='+str(X)+', 标的物市价='+str(S0)
-    fn3='\n年化无风险利率%='+str(round(r0*100.,2))+', 年化波动率%='+str(round(sigma*100.,2))
-    if div1==0: fn4='\n本产品无红利收益'
-    else: fn4='\n发放红利时间距离到期天数='+str(Days1)+', 红利='+str(div1)
-    footnote=fn1+fn2+fn3+fn4
-    plt.xlabel(footnote)  
-    
-    #让横轴逆序从大到小显示，正常顺序为从小到大
-    plt.gca().invert_xaxis()
-    plt.legend()
-    
-    plt.gca().set_facecolor('whitesmoke')
-    plt.show()    
-    
-    return
-    
-if __name__=='__main__':
-    S0=42
-    X=40
-    Dayrange=[200,50]
-    r0=0.015
-    sigma=0.23
-    Days1=90
-    div1=1.5
-    bsm_maturity(S0,40,[200,5],0.015,0.23,90,1.5)  
-    bsm_maturity(42,40,[50,200],0.015,0.23,90,1.5)  
-
-#==============================================================================
-def bsm_put_sigma(S0,X,Days,r0,sigmarange,Days1=0,div1=0,graph=True):
-    """
-    功能：计算有红利支付的欧式期权BSM定价模型，看跌期权，年化波动率为变化范围
-    注意：
-    S0：标的物资产的当前价格
-    X：期权的行权价
-    sigmarange：标的物资产价格收益率的年化标准差范围，默认为区间的20分之一作为间隔
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    Days：距离到期日的天数
-    Days1：红利发放时距离到期日的天数，需要转换为年数
-    div1：红利金额
-    """
-    #通用修改点
-    trange=sigmarange
-    #检查是否为列表
-    if not isinstance(trange,list):
-        print("#Error(bsm_put_sigma): target is not a range,",trange)
-        return
-    if len(trange) < 2:
-        print("#Error(bsm_put_sigma): not enough range for target,",trange)
-        return        
-    
-    #确定起始位置和间隔大小
-    tstart=trange[0]; tend=trange[1]
-    if len(trange) >=3: tstep=trange[2]    
-    else: tstep=(tend-tstart)/20.
-    #横轴点列表
-    import numpy as np
-    tlist=np.arange(tstart,tend+tstep,tstep)
-
-    #循环计算各点数值
-    import pandas as pd
-    df=pd.DataFrame(columns=['Option Price','Asset Price','Strike Price', \
-                             'Days to Maturity','Annual RF', \
-                             'Annual Sigma','Div to Maturity','Dividend'])
-    for t in tlist:
-        #通用修改点
-        op=bsm_put(S0,X,Days,r0,t,Days1,div1,printout=False)
-        s=pd.Series({'Option Price':op,'Asset Price':S0,'Strike Price':X, \
-                     'Days to Maturity':Days,'Annual RF':r0, \
-                     'Annual Sigma':t,'Div to Maturity':Days1, \
-                     'Dividend':div1})
-        try:
-            df=df.append(s,ignore_index=True)
-        except:
-            df=df._append(s,ignore_index=True)
-    #通用修改点
-    df2=df.set_index(['Annual Sigma'])  
-    if not graph: return df2      
-    
-    #绘图
-    #通用修改点
-    colname='Option Price'; collabel='看跌期权'
-    ylabeltxt='期权价格'
-    titletxt='期权价格的变化趋势图'
-    #通用修改点
-    fn1='波动率-->'
-    fn2='\n[期权信息]行权价='+str(X)+', 标的物市价='+str(S0)
-    fn3='\n年化无风险利率%='+str(round(r0*100.,2))+', 距离到期日天数='+str(Days)
-    if div1==0:
-        fn4='\n本产品无红利收益'
-    else:
-        fn4='\n发放红利时间距离到期天数='+str(Days1)+', 红利='+str(div1)
-    footnote=fn1+fn2+fn3+fn4
-    plot_line(df2,colname,collabel,ylabeltxt,titletxt,footnote)
-    
-    return df2
-    
-if __name__=='__main__':
-    S0=42
-    X=40
-    Days=183
-    r0=0.015
-    sigmarange=[0.1,0.4]
-    Days1=90
-    div1=1.5
-    pdf=bsm_put_sigma(42,40,183,0.015,[0.1,0.4],90,1.5)    
-
-
-#==============================================================================
-def bsm_call_sigma(S0,X,Days,r0,sigmarange,Days1=0,div1=0,graph=True):
-    """
-    功能：计算有红利支付的欧式期权BSM定价模型，看涨期权，年化波动率为变化范围
-    注意：
-    S0：标的物资产的当前价格
-    X：期权的行权价
-    sigmarange：标的物资产价格收益率的年化标准差范围，默认为区间的20分之一作为间隔
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    Days：距离到期日的天数
-    Days1：红利发放时距离到期日的天数，需要转换为年数
-    div1：红利金额
-    """
-    #通用修改点
-    trange=sigmarange
-    #检查是否为列表
-    if not isinstance(trange,list):
-        print("#Error(bsm_call_sigma): target is not a range,",trange)
-        return
-    if len(trange) < 2:
-        print("#Error(bsm_call_sigma): not enough range for target,",trange)
-        return        
-    
-    #确定起始位置和间隔大小
-    tstart=trange[0]; tend=trange[1]
-    if len(trange) >=3: tstep=trange[2]    
-    else: tstep=(tend-tstart)/20.
-    #横轴点列表
-    import numpy as np
-    tlist=np.arange(tstart,tend+tstep,tstep)
-
-    #循环计算各点数值
-    import pandas as pd
-    df=pd.DataFrame(columns=['Option Price','Asset Price','Strike Price', \
-                             'Days to Maturity','Annual RF', \
-                             'Annual Sigma','Div to Maturity','Dividend'])
-    for t in tlist:
-        #通用修改点
-        op=bsm_call(S0,X,Days,r0,t,Days1,div1,printout=False)
-        s=pd.Series({'Option Price':op,'Asset Price':S0,'Strike Price':X, \
-                     'Days to Maturity':Days,'Annual RF':r0, \
-                     'Annual Sigma':t,'Div to Maturity':Days1, \
-                     'Dividend':div1})
-        try:
-            df=df.append(s,ignore_index=True)
-        except:
-            df=df._append(s,ignore_index=True)
-    #通用修改点
-    df2=df.set_index(['Annual Sigma'])  
-    if not graph: return df2      
-    
-    #绘图
-    #通用修改点
-    colname='Option Price'; collabel='看涨期权'
-    ylabeltxt='期权价格'
-    titletxt='期权价格的变化趋势图'
-    #通用修改点
-    fn1='波动率-->'
-    fn2='\n[期权信息]行权价='+str(X)+', 标的物市价='+str(S0)
-    fn3='\n年化无风险利率%='+str(round(r0*100.,2))+', 距离到期日天数='+str(Days)
-    if div1==0:
-        fn4='\n本产品无红利收益'
-    else:
-        fn4='\n发放红利时间距离到期天数='+str(Days1)+', 红利='+str(div1)
-    footnote=fn1+fn2+fn3+fn4
-    plot_line(df2,colname,collabel,ylabeltxt,titletxt,footnote)
-    
-    return df2
-    
-if __name__=='__main__':
-    S0=42
-    X=40
-    Days=183
-    r0=0.015
-    sigmarange=[0.1,0.4]
-    Days1=90
-    div1=1.5
-    cdf=bsm_call_sigma(42,40,183,0.015,[0.1,0.4],90,1.5)  
-
-#==============================================================================
-def bsm_sigma(S0,X,Days,r0,sigmarange,Days1=0,div1=0,graph=True):
-    """
-    功能：计算有红利支付的欧式期权BSM定价模型，看涨/看跌期权，波动率为变化范围
-    注意：
-    S0：标的物资产的当前价格
-    X：期权的行权价
-    sigmarange：标的物资产价格收益率的年化标准差范围
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    Days：距离到期日的天数
-    Days1：红利发放时距离到期日的天数，需要转换为年数
-    div1：红利金额
-    """
-    #通用修改点
-    trange=sigmarange
-    #检查是否为列表
-    if not isinstance(trange,list):
-        print("#Error(bsm_sigma): target is not a range,",trange)
-        return
-    if len(trange) < 2:
-        print("#Error(bsm_sigma): not enough range for target,",trange)
-        return        
-    
-    #看涨期权
-    df1=bsm_call_sigma(S0,X,Days,r0,sigmarange,Days1=0,div1=0,graph=False)
-    df1.sort_index(ascending=True, inplace=True)
-    #看跌期权
-    df2=bsm_put_sigma(S0,X,Days,r0,sigmarange,Days1=0,div1=0,graph=False)
-    df2.sort_index(ascending=True, inplace=True)  
-    
-    #绘制双线图
-    titletxt='期权价格的变化趋势图'
-    colname1='Option Price'; label1='看涨期权'
-    colname2='Option Price'; label2='看跌期权'
-    ylabeltxt='期权价格'
-    
-    fn1='波动率-->'
-    fn2='\n[期权信息]行权价='+str(X)+', 标的物市价='+str(S0)
-    fn3='\n年化无风险利率%='+str(round(r0*100.,2))+', 距离到期日天数='+str(Days)
-    if div1==0: fn4='\n本产品无红利收益'
-    else: fn4='\n发放红利时间距离到期天数='+str(Days1)+', 红利='+str(div1)
-    footnote=fn1+fn2+fn3+fn4
-    
-    plot_2lines(df1,colname1,label1,df2,colname2,label2, \
-                ylabeltxt,titletxt,footnote)
-    
-    return
-    
-if __name__=='__main__':
-    S0=42
-    X=40
-    Days=183
-    r0=0.015
-    sigmarange=[0.1,0.4]
-    Days1=90
-    div1=1.5
-    bsm_sigma(42,40,183,0.015,[0.1,0.4],90,1.5)  
-
-#==============================================================================
-def iv_call_bsm(aop,S0,X,Days,r0,Days1=0,div1=0,precision=0.01,printout=True):
-    """
-    功能：基于BSM模型，二分迭代法，计算隐含波动率，看涨期权
-    aop：实际期权价格
-    S0：标的物当前市价
-    X：标的物行权价
-    Days：距离到期日的天数
-    r0：年华无风险利率
-    Days1：预期红利收益发放日期距离到期日的天数，默认=0
-    div1：预期红利收益金额，默认=0
-    printout：是否显示计算结果，默认=True
-    """
-    k=1
-    volLow=0.001    #设置波动率的最低值
-    volHigh=1.0     #设置波动率的最高值
-    
-    #波动率最低值对应的期权价格
-    #cLow=bsCall(S,X,T,r,volLow)
-    cLow=bsm_call(S0,X,Days,r0,volLow,Days1,div1,printout=False)
-    
-    #波动率最高值对应的期权价格
-    #cHigh=bsCall(S,X,T,r,volHigh)  
-    cHigh=bsm_call(S0,X,Days,r0,volHigh,Days1,div1,printout=False)
-    
-    #防止出现死循环
-    if cLow > aop or cHigh < aop: 
-        print("#Error(iv_call_bsm): Option price not reasonable,",aop)
-        return None        
-        #raise ValueError    
-    
-    while k ==1:
-        #cLow=bsCall(S,X,T,r,volLow)
-        cLow=bsm_call(S0,X,Days,r0,volLow,Days1,div1,printout=False)
-        #cHigh=bsCall(S,X,T,r,volHigh)
-        cHigh=bsm_call(S0,X,Days,r0,volHigh,Days1,div1,printout=False)
-        
-        #取波动率的高低均值
-        volMid=(volLow+volHigh)/2.0
-        #cMid=bsCall(S,X,T,r,volMid) 
-        cMid=bsm_call(S0,X,Days,r0,volMid,Days1,div1,printout=False)
-        
-        #满足期权价格误差精度要求（0.01以下）则结束循环
-        if abs(cHigh-cLow) < precision: k=2
-        #否则，缩小范围，继续循环
-        elif cMid>aop: volHigh=volMid
-        else: volLow=volMid        
-    
-    iv=round(volMid,4)
-    if not printout: return iv
-    
-    #显示
-    print("\n=== 隐含波动率: 二叉树迭代 ===")
-    print("看涨期权:")
-    print("  期权现价        :",aop)
-    print("  标的资产现价    :",S0)
-    print("  标的资产行权价  :",X)
-    print("  距离到期日的天数:",Days)
-    if not (div1 == 0):
-        print("  预期红利                :",div1)
-        print("  红利发放距离到期日的天数:",Days1)
-    print("隐含波动率:")
-    print("  预计的年化波动率  :",iv)
-    print("  对应的期权价格范围:",round(cLow,3),'-',round(cHigh,3))
-    print("  迭代精度          :",precision)
-    return iv
-
-#==============================================================================
-def iv_put_bsm(aop,S0,X,Days,r0,Days1=0,div1=0,precision=0.01,printout=True):
-    """
-    功能：基于BSM模型，二分迭代法，计算隐含波动率，看跌期权
-    aop：实际期权价格
-    S0：标的物当前市价
-    X：标的物行权价
-    Days：距离到期日的天数
-    r0：年华无风险利率
-    Days1：预期红利收益发放日期距离到期日的天数，默认=0
-    div1：预期红利收益金额，默认=0
-    printout：是否显示计算结果，默认=True
-    """
-    k=1
-    volLow=0.001    #设置波动率的最低值
-    volHigh=1.0     #设置波动率的最高值
-    
-    #波动率最低值对应的期权价格
-    #cLow=bsCall(S,X,T,r,volLow)
-    cLow=bsm_put(S0,X,Days,r0,volLow,Days1,div1,printout=False)
-    
-    #波动率最高值对应的期权价格
-    #cHigh=bsCall(S,X,T,r,volHigh)  
-    cHigh=bsm_put(S0,X,Days,r0,volHigh,Days1,div1,printout=False)
-    
-    #防止出现死循环
-    if cLow > aop or cHigh < aop: 
-        print("#Error(iv_put_bsm): Option price not reasonable,",aop)
-        return None
-        #raise ValueError    
-    
-    while k ==1:
-        #cLow=bsCall(S,X,T,r,volLow)
-        cLow=bsm_put(S0,X,Days,r0,volLow,Days1,div1,printout=False)
-        #cHigh=bsCall(S,X,T,r,volHigh)
-        cHigh=bsm_put(S0,X,Days,r0,volHigh,Days1,div1,printout=False)
-        
-        #取波动率的高低均值
-        volMid=(volLow+volHigh)/2.0
-        #cMid=bsCall(S,X,T,r,volMid) 
-        cMid=bsm_put(S0,X,Days,r0,volMid,Days1,div1,printout=False)
-        
-        #满足期权价格误差精度要求（precision）则结束循环
-        if abs(cHigh-cLow) < precision: k=2
-        #否则，缩小范围，继续循环
-        elif cMid>aop: volHigh=volMid
-        else: volLow=volMid        
-    
-    iv=round(volMid,4)
-    if not printout: return iv
-    
-    #显示
-    print("\n=== 隐含波动率: 二叉树迭代 ===")
-    print("看跌期权:")
-    print("  期权现价        :",aop)
-    print("  标的资产现价    :",S0)
-    print("  标的资产行权价  :",X)
-    print("  距离到期日的天数:",Days)
-    if not (div1 == 0):
-        print("  预期红利                :",div1)
-        print("  红利发放距离到期日的天数:",Days1)
-    print("隐含波动率:")
-    print("  预计的年化波动率  :",iv)
-    print("  对应的期权价格范围:",round(cLow,3),'-',round(cHigh,3))
-    print("  迭代精度          :",precision)
-
-    return iv
-
-#==============================================================================
-def binomial_american_call(S0,X,Days,r0,sigma,q0=0,steps=200,printout=True):
-    """
-    功能：计算有红利支付的美式期权二叉树定价模型，看涨期权
-    注意：
-    S0：标的物资产的当前价格
-    X为其行权价
-    Days：距离到期日的天数，需要转换为距离到期日的年数=距离到期日的天数/365
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    sigma：标的物资产价格收益率的年化标准差
-    q0：年化红利收益率，由于美式期权可能提前行权，故不考虑发放日期
-    steps：二叉树的步骤
-    """
-    from numpy import log,exp
-    
-    #Days1为距离到期日的日历日天数
-    t=Days/365.
-    r=log(r0+1)  
-    q=log(q0+1)
-    #调整标的物当前价
-    S=S0    
-
-    import numpy as np
-    u=np.exp(sigma*np.sqrt(t/steps)); d=1/u
-	
-    P=(np.exp((r-q)*t/steps)-d)/(u-d)
-    prices=np.zeros(steps+1)
-    c_values=np.zeros(steps+1)
-    prices[0]=S*d**steps
-    c_values[0]=np.maximum(prices[0]-X,0)
-	
-    for i in range(1,steps+1):
-        prices[i]=prices[i-1]*(u**2)
-        c_values[i]=np.maximum(prices[i]-X,0)
-	
-    for j in range(steps,0,-1):
-        for i in range(0,j):
-            prices[i]=prices[i+1]*d
-            #c_values[i]=np.maximum((P*c_values[i+1]+(1-P)*c_values[i])/np.exp(r*t/steps),prices[i]-X)
-            c_values[i]=np.maximum((P*c_values[i+1]+(1-P)*c_values[i])/np.exp((r-q)*t/steps),prices[i]-X)
-    C=round(c_values[0],2)
-
-    if not printout: return C
-    print("\n===== 二叉树期权定价 =====")
-    print("适用情形： 美式期权，标的资产有红利")
-    print("标的资产行权价        :",X)
-    print("标的资产现价          :",S0)
-    print("标的资产年化波动率    :",round(sigma,4))    
-    print("距离到期日的年数      :",round(t,2))
-    print("连续计算的无风险收益率:",round(r,4)*100,'\b%')
-    print("连续计算的红利率      :",round(q,4)*100,'\b%')
-    print("二叉树迭代步数        :",steps)
-    print("看涨期权的预期价格    :",round(C,4))    
-    
-    return C
-
-#==============================================================================
-def binomial_american_put(S0,X,Days,r0,sigma,q0=0,steps=200,printout=True):
-    """
-    功能：计算有红利支付的美式期权二叉树定价模型，看跌期权
-    注意：
-    S0：标的物资产的当前价格
-    X为其行权价
-    Days：距离到期日的天数，需要转换为距离到期日的年数=距离到期日的天数/365
-    r0：年化无风险利率（需要转化为连续计算的无风险利率）
-    sigma：标的物资产价格收益率的年化标准差
-    q0：年化红利收益率，由于美式期权可能提前行权，故不考虑发放日期
-    steps：二叉树的步骤
-    """
-    from numpy import log,exp
-    
-    #Days1为距离到期日的日历日天数
-    t=Days/365.
-    r=log(r0+1)  
-    q=log(q0+1)
-    #调整标的物当前价
-    S=S0   
-    
-    import numpy as np
-    u=np.exp(sigma*np.sqrt(t/steps))
-    d=1/u
-    P=(np.exp((r-q)*t/steps)-d)/(u-d)
-    prices=np.zeros(steps+1)
-    c_values=np.zeros(steps+1)
-    prices[0]=S*d**steps
-    c_values[0]=np.maximum(X-prices[0],0)
-
-    for i in range(1,steps+1):
-        prices[i]=prices[i-1]*(u**2)
-        c_values[i]=np.maximum(X-prices[i],0)
-
-    for j in range(steps,0,-1):
-        for i in range(0,j):
-            prices[i]=prices[i+1]*d
-            #c_values[i]=np.maximum((P*c_values[i+1]+(1-P)*c_values[i])/np.exp(r*t/steps),X-prices[i])#检查是否提前行权
-            c_values[i]=np.maximum((P*c_values[i+1]+(1-P)*c_values[i])/np.exp((r-q)*t/steps),X-prices[i])#检查是否提前行权
-    C=round(c_values[0],2)
-
-    if not printout: return C
-    print("\n===== 二叉树期权定价 =====")
-    print("适用情形： 美式期权，标的资产有红利")
-    print("标的资产行权价        :",X)
-    print("标的资产现价          :",S0)
-    print("标的资产年化波动率    :",round(sigma,4))    
-    print("距离到期日的年数      :",round(t,2))
-    print("连续计算的无风险收益率:",round(r,4)*100,'\b%')
-    print("连续计算的红利率      :",round(q,4)*100,'\b%')
-    print("二叉树迭代步数        :",steps)
-    print("看跌期权的预期价格    :",round(C,4)) 
-
-    return C
-
-#==============================================================================
-#==============================================================================
-#==============================================================================
-#==============================================================================
-if __name__=='__main__':
-    ticker="AAPL"
-    ticker="SPY"
-
-def option_maturity(ticker,printout=True):
-    """
-    功能：获得期权的各个到期日期
-    注意：目前yfinance无法使用，股票期权链功能暂时不可用，可尝试yahooquery？
-    """
-    """
-    if not test_yahoo_access():
-        print("  #Warning(option_maturity): failed to access data source Yahoo Finance")
-        return None
-    """
-    import yfinance as yf
-    # yf.__version__
-    
-    opt = yf.Ticker(ticker)
-    
-    #获得期权的各个到期日
-    try:
-        exp_dates=opt.options
-    except:
-        print("  #Error(option_maturity): failed to get option maturity dates for underlying",ticker)
-        print("  Reasons: either",ticker,"does not exist or Yahoo Finance is currently inaccessible")
-        return None
-    
-    datelist=list(exp_dates)
-    if not printout:
-        return datelist
-    
-    tname=get_stock_name1_en(ticker)
-    
-    #显示结果
-    print("\n===== 期权的时间序列 =====")
-    print("标的资产:",tname)
-    print("到期日期:")
-    
-    num=len(datelist)
-    for d in datelist:
-        print(d,end='  ')
-        pos=datelist.index(d)+1
-        if (pos % 4 ==0) or (pos==num): print(' ')
-    
-    print("总计:",num,"个日期")
-    import datetime
-    today = datetime.date.today()    
-    print("\n*** 数据来源: 雅虎财经,",today)
-    
-    return datelist
-
-if __name__=='__main__':
-    ticker='AAPL'
-    datelist=option_maturity(ticker)
-    datelist=option_maturity('AAPL')
-    datelist=option_maturity('000001.SS')
-
-#================================================================
-if __name__=='__main__':
-    ticker="AAPL"
-    maturity_date="2025-2-21"
-
-def option_chain(ticker,maturity_date='today',printout=True):
-    """
-    功能：获得期权的各个到期日期，并列出某个到期日的期权合约
-    """
-    mdate=maturity_date
-    
-    if mdate=='today':
-        import datetime as dt; stoday=dt.date.today()
-        mdate=str(stoday)
-    
-    import yfinance as yf
-    opt = yf.Ticker(ticker)
-            
-    #处理称为规范日期
-    from datetime import datetime
-    mdate2 = datetime.strptime(mdate, '%Y-%m-%d')
-    mdate3 = datetime.strftime(mdate2,'%Y-%m-%d')
-    
-    #获得一个到期日的所有期权合约
-    try:
-        optlist = opt.option_chain(mdate3)
-    except:
-        if printout:
-            print("  #Error(option_chain): failed to get option chain for",ticker,'\b@',mdate)
-        return None,None    
-    
-    opt_call=optlist.calls
-    opt_call['underlyingAsset']=ticker
-    opt_call['optionType']='Call'
-    
-    inttodate=lambda x: int2date(x)
-    opt_call['date']=opt_call['lastTradeDate'].apply(inttodate)
-    opt_call['maturity']=mdate3
-    
-    collist=['contractSymbol','underlyingAsset','optionType','date', \
-             'maturity','strike','lastPrice','impliedVolatility','volume', \
-             'inTheMoney','currency']
-    opt_call2=opt_call[collist].copy()
-    num_call=len(opt_call2)
-    num_call_ITM=len(opt_call2[opt_call2['inTheMoney']==True])
-    num_call_OTM=num_call-num_call_ITM
-    
-    strike_min=min(opt_call2['strike'])
-    strike_max=max(opt_call2['strike'])
-    currency=opt_call2['currency'][0]
-    
-    opt_put=optlist.puts
-    opt_put['underlyingAsset']=ticker
-    opt_put['optionType']='Put'
-    opt_put['date']=opt_put['lastTradeDate'].apply(inttodate)
-    opt_put['maturity']=mdate3
-    opt_put2=opt_put[collist].copy()
-    num_put=len(opt_put2)
-    num_put_ITM=len(opt_put2[opt_put2['inTheMoney']==True])
-    num_put_OTM=num_put-num_put_ITM
-    
-    if not printout:
-        return  opt_call2, opt_put2
-    
-    tname=get_stock_name1_en(ticker)
-    
-    print("\n===== 期权链的结构 =====")
-    print("标的资产:",tname)
-    print("到期日期:",mdate)
-    print("看涨期权:",num_call)
-    print("    实值/虚值:",num_call_ITM,'/',num_call_OTM)
-    print("看跌期权:",num_put)
-    print("    实值/虚值:",num_put_ITM,'/',num_put_OTM)
-    print("最低/最高行权价:",strike_min,'/',strike_max,currency)
-    
-    import datetime
-    stoday = datetime.date.today()    
-    print("\n*数据来源: 雅虎财经,",stoday)
-    
-    #设置绘图数据
-    df1=opt_call2.copy()
-    df1.sort_values(by=['strike'],axis=0,ascending=[True],inplace=True) 
-    df1.set_index(['strike'],inplace=True)
-    df1['exercise']=df1.index
-    colname1='lastPrice'; label1='看涨期权价格'
-    
-    df2=opt_put2.copy()
-    df2.sort_values(by=['strike'],axis=0,ascending=[True],inplace=True) 
-    df2.set_index(['strike'],inplace=True)
-    df2['exercise']=df2.index
-    colname2='lastPrice'; label2='看跌期权价格'  
-    
-    ylabeltxt='期权价格('+currency+')'
-    titletxt="期权价格与标的行权价格的关系"
-    footnote="标的行权价("+currency+") -->\n"+ \
-        "标的资产: "+tname+ \
-        ", "+"到期日: "+mdate+ \
-        "\n数据来源: 雅虎财经, "+str(stoday)
-        
-    #绘图        
-    import matplotlib.pyplot as plt    
-    plt.plot(df1.index,df1[colname1],color='red',linestyle='-',linewidth=1.5, \
-             label=label1)        
-
-    plt.plot(df2.index,df2[colname2],color='blue',linestyle='-',linewidth=1.5, \
-             label=label2) 
-        
-    plt.ylabel(ylabeltxt,fontsize=ylabel_txt_size)    
-    plt.xlabel(footnote,fontsize=xlabel_txt_size)        
-    plt.title(titletxt,fontsize=title_txt_size)        
-    plt.legend(fontsize=legend_txt_size)
-    plt.show()    
-
-        
-    return  opt_call2, opt_put2
-
-if __name__=='__main__':
-    ticker='AAPL'    
-    mdate='2022-6-17'    
-    dfc,dfp=option_chain(ticker,mdate)
-
-#==============================================================================
-if __name__ =="__main__":
-    ticker='AAPL'
-    lastndays=7
-
-#def predict_stock_trend_by_option(ticker,lastndays=7,power=4):
-def market_prospect_via_option(ticker,lastdays=7):    
-    """
-    功能：根据期权行权价及交易量预测标的物价格
-    注意：本函数与price_prospect_via_option内容基本一致，图示方式略有不同
-    """
-    lastndays=lastdays
-    
-    DEBUG=False
-    try:
-        datelist=option_maturity(ticker,printout=False)
-    except:
-        print("  #Error(predict_stock_price_by_option): option info not found for",ticker)
-    if datelist is None:
-        print("  #Warning(predict_stock_price_by_option): options not found for",ticker)
-        return None
-    print("\nFound options with",len(datelist),"maturity dates for",ticker)
-
-    import pandas as pd
-    df=pd.DataFrame(columns=['Ticker','Date','WA Strike','Total Options', \
-                             'Calls in Total%','OTM in Calls%','OTM Calls in Total%', \
-                             'Puts in Total%','OTM in Puts%','OTM Puts in Total%'])    
-    for d in datelist:
-        print_progress_percent2(d,datelist,steps=5,leading_blanks=4)
-        
-        if DEBUG: print("Processing options matured on",d)
-        opt_call,opt_put=option_chain(ticker,d,printout=False)
-        
-        numofcalls=len(opt_call)
-        opt_call_otm=opt_call[opt_call['inTheMoney']==False]
-        numofotmcalls=len(opt_call_otm)
-        
-        numofputs=len(opt_put)
-        opt_put_otm=opt_put[opt_put['inTheMoney']==False]
-        numofotmputs=len(opt_put_otm)
-        
-        totalopts=numofcalls+numofputs
-        
-        callsintotal=round(numofcalls/totalopts*100,2)
-        if numofcalls != 0:
-            otmincalls=round(numofotmcalls/numofcalls*100,2)
-        else:
-            otmincalls=0
-        otmcallsintotal=round(numofotmcalls/totalopts*100,2)
-        
-        putsintotal=round(numofputs/totalopts*100,2)
-        if numofputs != 0:
-            otminputs=round(numofotmputs/numofputs*100,2)
-        else:
-            otminputs=0
-        otmputsintotal=round(numofotmputs/totalopts*100,2)
-        
-        opts=pd.concat([opt_call,opt_put])
-        opts.sort_values('date',ascending=False,inplace=True)
-        lasttradedate=list(opts['date'])[0]
-        lastndate=date_adjust(lasttradedate, adjust=-lastndays)
-        
-        #取最近几天的期权交易
-        opts2=opts[opts['date']>=lastndate] 
-        opts2.dropna(inplace=True)
-        wa_strike=round(((opts2['strike']*opts2['volume']).sum())/(opts2['volume'].sum()),2)
-        
-        s=pd.Series({'Ticker':ticker,'Date':d,'WA Strike':wa_strike, \
-                     'Total Options':totalopts, \
-                     'Calls in Total%':callsintotal,'OTM in Calls%':otmincalls,'OTM Calls in Total%':otmcallsintotal, \
-                     'Puts in Total%':putsintotal,'OTM in Puts%':otminputs,'OTM Puts in Total%':otmputsintotal})
-        try:
-            df=df.append(s,ignore_index=True)
-        except:
-            df=df._append(s,ignore_index=True)
-
-    #建立日期索引
-    todatetime=lambda x:pd.to_datetime(x)
-    df['date']=df['Date'].apply(todatetime)
-    df2=df.set_index(['date'])  
-    
-    #绘图1：Calls vs Puts比例
-    import datetime
-    today = datetime.date.today()    
-    
-    colname1='Calls in Total%'
-    label1='Calls in Total%'
-    colname2='Puts in Total%'
-    label2='Puts in Total%'
-    ylabeltxt='Percentage'
-    titletxt="Option Comparison: "+ticker+", Calls vs Puts"
-
-    footnote="Source: Yahoo Finance, "+str(today)
-    plot_line2(df2,ticker,colname1,label1, \
-               df2,ticker,colname2,label2, \
-               ylabeltxt,titletxt,footnote)
-    
-    #绘图2：OTM Calls vs OTM Puts相对比例
-    colname1='OTM in Calls%'
-    label1='OTM in Calls%'
-    colname2='OTM in Puts%'
-    label2='OTM in Puts%'
-    ylabeltxt='Percentage'
-    titletxt="Option Relative Proportion Comparison\n("+ticker+", OTM Calls vs OTM Puts)"
-
-    footnote="Source: Yahoo Finance, "+str(today)
-    plot_line2(df2,ticker,colname1,label1, \
-               df2,ticker,colname2,label2, \
-               ylabeltxt,titletxt,footnote)
-    
-    #绘图3：OTM Calls vs OTM Puts绝对比例
-    colname1='OTM Calls in Total%'
-    label1='OTM Calls in Total%'
-    colname2='OTM Puts in Total%'
-    label2='OTM Puts in Total%'
-    ylabeltxt='Percentage'
-    titletxt="Option Absolute Proportion Comparison\n("+ticker+", OTM Calls vs OTM Puts)"
-
-    footnote="Source: Yahoo Finance, "+str(today)
-    plot_line2(df2,ticker,colname1,label1, \
-               df2,ticker,colname2,label2, \
-               ylabeltxt,titletxt,footnote)
-
-    #绘图4：标的物价格预测
-    df2x=df2.drop(df2[df2['Total Options']<=1].index)
-    """
-    colname='WA Strike'
-    collabel='Predicted Price'
-    ylabeltxt=''
-    titletxt="Predicting Prices via Options: "+ticker
-    footnote="Source: Yahoo Finance, "+str(today)
-    plot_line(df2x,colname,collabel,ylabeltxt,titletxt,footnote,power=power)
-    """
-    
-    #打印预测结果
-    compotm=lambda x:compare_otm(x)
-    df2x['Trend']=df2x.apply(compotm,axis=1)  #axis=1表示按行操作
-    """
-    collist=['Date','Trend','WA Strike','Total Options','Calls in Total%','OTM in Calls%', \
-            'Puts in Total%','OTM in Puts%']
-    """
-    collist=['Date','Trend','Total Options','Calls in Total%','Puts in Total%', \
-             'OTM in Calls%','OTM in Puts%','OTM Calls in Total%','OTM Puts in Total%']
-    df3=df2x[collist]
-    df3.rename(columns={'Total Options':'TotalOptions'}, inplace = True)
-    df3.rename(columns={'Calls in Total%':'Calls%','Puts in Total%':'Puts%'}, inplace = True)
-    df3.rename(columns={'OTM in Calls%':'OTMinCalls%','OTM in Puts%':'OTMinPuts%'}, inplace = True)
-    df3.rename(columns={'OTM Calls in Total%':'OTM Calls/Total%','OTM Puts in Total%':'OTM Puts/Total%'}, inplace = True)
-    
-    """
-    print("\n ======= Predicting Price Trend via Option Configuration: "+ticker+" =======")
-    #设置打印对齐
-    pd.set_option('display.max_columns', 1000)
-    pd.set_option('display.width', 1000)
-    pd.set_option('display.max_colwidth', 1000)
-    pd.set_option('display.unicode.ambiguous_as_wide', True)
-    pd.set_option('display.unicode.east_asian_width', True)
-    print(df3.to_string(index=False))
-    """
-    #lastdate,lastprice=get_last_close1(ticker)
-    prices_tmp=security_trend(ticker,graph=False)
-    lastdate=str(prices_tmp.tail(1).index.values[0].date())
-    lastprice=str(prices_tmp.tail(1).Close.values[0])
-    """
-    print(" Note:")
-    print("   1) Recent price:",lastprice,"\b,",lastdate,'\b.')
-    print("   2) +(-) predicts higher(lower) price than recent, ++(--) for more likely, +/- for undetermined trend.")
-    print("   3) Option trade period: recent "+str(lastndays)+" days. No stock splits in the period. Dates with only 1 option removed.")
-    #print("   4) Removed those samples with only one option, if any.")
-    print(" "+footnote+'.')
-    """
-    tname=get_stock_name1_en(ticker,short_name=True)
-    titletxt="Predicting Price Trend via Option Configuration: "+tname
-    footnote1="Note:\n"
-    footnote2="1. Recent price: "+lastprice+", "+lastdate+'\n'
-    footnote3="2. +(-) predicts higher(lower) price than recent, ++(--) more likely, +/- undetermined\n"
-    footnote4="3. Period: recent "+str(lastndays)+" days. No stock splits in the period. Removed dates with 1 option only\n"
-    footnote9=footnote1+footnote2+footnote3+footnote4+footnote    
-    
-    df_display_CSS(df3,titletxt=titletxt,footnote=footnote9,facecolor='papayawhip',decimals=2, \
-           first_col_align='left',second_col_align='right', \
-           last_col_align='right',other_col_align='right', \
-           titile_font_size='15px',heading_font_size='13px', \
-           data_font_size='13px')
-    
-    return df2
-
-
-
-
-#================================================================
-if __name__=='__main__':
-    intdate=1604350755
-
-def int2date(intdate):
-    """
-    功能：将数字转换为日期，10位数字为秒级，13位的为毫秒级
-    输入：使用10位或13位整数表示的日期时间
-    返回：yyyy-mm-dd hh:mm:ss
-    """
-    import time
-    intstr=str(intdate)
-
-    if len(intstr) == 10:
-        tupTime = time.localtime(intdate)   #秒时间戳
-        #standardTime = time.strftime("%Y-%m-%d %H:%M:%S", tupTime)
-        standardTime = time.strftime("%Y-%m-%d", tupTime)
-        return standardTime    
-
-    if len(intstr)==13:
-        timeNum=intdate     #毫秒时间戳
-        timeTemp = float(timeNum/1000)
-        tupTime = time.localtime(timeTemp)
-        #standardTime = time.strftime("%Y-%m-%d %H:%M:%S", tupTime)
-        standardTime = time.strftime("%Y-%m-%d", tupTime)
-        return standardTime
-
-    #直接为日期时间结构
-    standardTime = intdate.strftime("%Y-%m-%d")
-    return standardTime
-
-if __name__=='__main__':
-    intdate1=1604349847
-    int2date(intdate1)
-    
-    intdate2=1566366547705
-    int2date(intdate2)
-    
-    import pandas as pd
-    intdate3=pd.to_datetime('2020-11-03')
-    int2date(intdate3)
-#==============================================================================
-#==============================================================================
-def compare_otm(row,spread=1.0):
-    """
-    功能：比较OTM Call vs OTM Put的绝对比例大小，赋值+/-
-    输入：df的一行
-    输出：+/-
-    """
-    if row['OTM Calls in Total%'] > row['OTM Puts in Total%']:
-        result='+'
-        if (row['Calls in Total%'] > row['Puts in Total%']) and ((row['OTM in Calls%'] > row['OTM in Puts%'])):
-                result='++'
-    
-    if row['OTM Calls in Total%'] < row['OTM Puts in Total%']:
-        result='-'
-        if (row['Calls in Total%'] < row['Puts in Total%']) and ((row['OTM in Calls%'] < row['OTM in Puts%'])):
-                result='--'
-
-    if abs(row['OTM Calls in Total%'] - row['OTM Puts in Total%']) < spread:
-        result='+/-'
-
-    return result
-
-#==============================================================================
-def call_timevalue(row):
-    """
-    功能：计算看涨期权的时间价值
-    输入：df的一行
-    输出：期权的时间价值
-    """
-    #是否实值期权
-    if row['inTheMoney']:
-        tv=row['lastPrice']-row['lastSPrice']+row['strike']
-    else:
-        tv=row['lastPrice']
-    return tv
-
-def put_timevalue(row):
-    """
-    功能：计算看跌期权的时间价值
-    输入：df的一行
-    输出：期权的时间价值
-    """
-    #是否实值期权
-    if row['inTheMoney']:
-        tv=row['lastPrice']+row['lastSPrice']-row['strike']
-    else:
-        tv=row['lastPrice']
-    return tv
-
-#==============================================================================   
-
-if __name__ =="__main__":
-    ticker='AAPL'
-    lastndays=2
-
-def price_prospect_via_option(ticker,lastdays=7,cutoff=[1.1,5.0,10.0]):    
-    """
-    功能：根据股票期权预测标的物价格
-    算法：
-    1、计算虚值看涨/看跌期权数量比例
-    2、计算虚值看涨/看跌期权交易金额比例
-    3、若虚值看涨期权占优，为看涨，并据此估计未来标的物价格；
-    4、若虚值看跌期权占优，为看跌，并据此估计未来标的物价格；
-    5、否则，为不明确
-    返回：期权明细
-    """
-    lastndays=lastdays
-    
-    DEBUG=False
-    print("Searching option chain for",ticker,'...',end='')
-    
-    try:
-        datelist=option_maturity(ticker,printout=False)
-    except:
-        print("\n  #Warning(price_prospect_via_option): option info not found for",ticker)
-        return None
-    if datelist is None:
-        print("\n  #Warning(price_prospect_via_option): options not found for",ticker)
-        return None
-    print("found",len(datelist),"maturity dates of options")
-
-    #最新的标的物价格
-    #print("Searching recent close price for",ticker,'...',end='')
-    try:
-        #lastsdate,lastsprice=get_last_close1(ticker)
-        prices_tmp=security_trend(ticker,graph=False)
-        lastsdate=str(prices_tmp.tail(1).index.values[0].date())
-        lastsprice=str(prices_tmp.tail(1).Close.values[0])
-
-    except:
-        print("\n  #Error(price_prospect_via_option): failed in retrieving close price for",ticker)
-        return None
-    if (lastsdate is None) or (lastsprice is None):
-        print("\n  #Error(price_prospect_via_option): retrieving close price failed for",ticker)
-        return None
-    if DEBUG: print(lastsprice,'\b,',lastsdate)
-
-    import pandas as pd
-    df=pd.DataFrame(columns=['Ticker','Date','Trend','Estimated Price', \
-                             'OTM Volume Call/Put','OTM Amount Call/Put','Spot Date','Spot Price'])    
-    for d in datelist:
-        print_progress_percent2(d,datelist,steps=5,leading_blanks=4)
-        
-        if DEBUG: print("Analyzing options matured on",d,'...')
-        opt_call,opt_put=option_chain(ticker,d,printout=False)
-        
-        if (opt_call is None) or (opt_put is None):
-            if DEBUG:
-                print("  #Warning(price_prospect_via_option): failed in retrieving options matured on",d)
-            """
-            break
-            return None        
-            """
-            continue
-        
-        if (len(opt_call) == 0) or (len(opt_put) == 0):
-            if DEBUG:
-                print("  #Warning(price_prospect_via_option): retrieved zero options matured on",d)
-            """
-            break
-            return None     
-            """
-            continue
-            
-        currency=list(opt_call['currency'])[0]
-        
-        ##########处理看涨期权##########
-        if DEBUG: print("  Call volume: ",end='')
-        opt_call['lastSDate']=lastsdate
-        opt_call['lastSPrice']=lastsprice
-        
-        #去掉无交易的期权
-        opt_call.dropna(inplace=True)
-        #只保留过去lastndays日历日的交易
-        lasttdate=max(list(opt_call['date']))
-        fromtdate=date_adjust(lasttdate, adjust=-lastndays)        
-        opt_call=opt_call[opt_call['date'] >= fromtdate]    
-        numofcalls=sum(opt_call['volume'])
-        
-        """
-        #计算期权的时间价值：不一致，无法进一步利用
-        calltv=lambda x:call_timevalue(x)
-        opt_call['timeValue']=opt_call.apply(calltv,axis=1)  #axis=1表示按行操作
-        """
-        
-        #计算虚值期权的交易数量、交易金额和加权价格
-        opt_call_otm=opt_call[opt_call['inTheMoney']==False]
-        numofotmcalls=sum(opt_call_otm['volume'])
-        amtofotmcalls=round(sum(opt_call_otm['lastPrice']*opt_call_otm['volume']),2)
-        avopofotmcalls=round((amtofotmcalls/numofotmcalls),2)
-        if DEBUG: print("total",int(numofcalls),'\b, OTM',int(numofotmcalls),end='')
-
-        #基于加权价格判断行权价
-        opt_call_otm.sort_values('lastPrice',ascending=True,inplace=True)
-        strikelist=list(opt_call_otm['strike'])
-        lastPricelist=list(opt_call_otm['lastPrice'])+[avopofotmcalls]
-        lastPricelist=sorted(lastPricelist,reverse=False)
-        avoppos=lastPricelist.index(avopofotmcalls)
-        if avoppos > 0:
-            op1=lastPricelist[avoppos-1]
-            strike1=strikelist[avoppos-1]
-            op2=lastPricelist[avoppos+1]
-            strike2=strikelist[avoppos]            
-            avspofotmcalls=round(min(strike1,strike2)+abs(strike1-strike2)*((avopofotmcalls-min(op1,op2))/abs(op1-op2)),2)
-        else:
-            avspofotmcalls=strikelist[avoppos]
-        if DEBUG: print(", done!")
-        
-        ##########处理看跌期权##########
-        if DEBUG: print("  Put volume: ",end='')
-        opt_put['lastSDate']=lastsdate
-        opt_put['lastSPrice']=lastsprice
-        
-        #去掉无交易的期权
-        opt_put.dropna(inplace=True)
-        #只保留过去lastndays日历日的交易
-        lasttdate=max(list(opt_put['date']))
-        fromtdate=date_adjust(lasttdate, adjust=-lastndays)        
-        opt_put=opt_put[opt_put['date'] >= fromtdate] 
-        numofputs=sum(opt_put['volume'])
-        
-        """        
-        #计算期权的时间价值：不一致，无法进一步利用
-        puttv=lambda x:put_timevalue(x)
-        opt_put['timeValue']=opt_put.apply(puttv,axis=1)  #axis=1表示按行操作
-        """
-        
-        #计算虚值期权的交易数量、交易金额和加权价格
-        opt_put_otm=opt_put[opt_put['inTheMoney']==False]
-        numofotmputs=sum(opt_put_otm['volume'])
-        amtofotmputs=round(sum(opt_put_otm['lastPrice']*opt_put_otm['volume']),2)
-        avopofotmputs=round((amtofotmputs/numofotmputs),2)
-        if DEBUG: print("total",int(numofputs),'\b, OTM',int(numofotmputs),end='')
-
-        #基于加权价格判断行权价
-        opt_put_otm.sort_values('lastPrice',ascending=True,inplace=True)
-        strikelist=list(opt_put_otm['strike'])
-        lastPricelist=list(opt_put_otm['lastPrice'])+[avopofotmputs]
-        lastPricelist=sorted(lastPricelist,reverse=False)
-        avoppos=lastPricelist.index(avopofotmputs)
-        if avoppos > 0:
-            op1=lastPricelist[avoppos-1]
-            strike1=strikelist[avoppos-1]
-            op2=lastPricelist[avoppos+1]
-            strike2=strikelist[avoppos]            
-            avspofotmputs=round(min(strike1,strike2)+abs(strike1-strike2)*((avopofotmputs-min(op1,op2))/abs(op1-op2)),2)
-        else:
-            avspofotmputs=strikelist[avoppos]            
-        if DEBUG: print(", done!")
-
-        #比较虚值看涨/看跌期权的数量和交易金额
-        if DEBUG: print("  Evaluating price trend ...",end='')
-        rateqty=round(numofotmcalls/numofotmputs,2)  
-        rateamt=round(amtofotmcalls/amtofotmputs,2)
-        trend='+/-'
-        star1=cutoff[0]; star2=cutoff[1]; star3=cutoff[2]
-        #加强判断：以rateamt为主，结合rateqty
-        if (rateqty > 1.0) and (rateamt > star1):
-            trend='+'
-        if (rateqty < 1.0) and (rateamt < 1.0/star1):
-            trend='-'        
-        if (rateqty > star2) and (rateamt > star2):
-            trend='++'
-        if (1/rateqty > star2) and (1/rateamt > star2):
-            trend='--'          
-        if (rateqty > star3) and (rateamt > star3):
-            trend='+++'
-        if (1/rateqty > star3) and (1/rateamt > star3):
-            trend='---'          
-        
-        estsprice=lastsprice
-        if (trend[0] == '+') and (trend != '+/-'):
-            estsprice=avspofotmcalls
-        if trend[0]=='-':
-            estsprice=avspofotmputs
-        if trend == '+/-':
-            estsprice=(avspofotmcalls + avspofotmputs)/2.0
-        
-        s=pd.Series({'Ticker':ticker,'Date':d,'Trend':trend,'Estimated Price':estsprice, \
-            'OTM Volume Call/Put':rateqty,'OTM Amount Call/Put':rateamt,'Spot Date':lastsdate,'Spot Price':lastsprice})
-        try:
-            df=df.append(s,ignore_index=True)
-        except:
-            df=df._append(s,ignore_index=True)
-        if DEBUG: print(", done!")
-
-    #建立日期索引
-    todatetime=lambda x:pd.to_datetime(x)
-    df['date']=df['Date'].apply(todatetime)
-    df2=df.set_index(['date'])  
-    
-    tname=get_stock_name1_en(ticker,short_name=True)
-    
-    #绘图1：虚值Calls vs Puts数量比例
-    import datetime
-    stoday = datetime.date.today()    
-    
-    df2['Benchmark']=1.0
-    colname1='OTM Volume Call/Put'
-    label1='虚值看涨/看跌期权合约数量比例'
-    colname2='Benchmark'
-    label2='等比例线'
-    ylabeltxt='比例'
-    titletxt="期权链中的合约数量: "+tname+", 虚值看涨/看跌期权比例"
-
-    footnote="数据来源：雅虎财经, "+str(stoday)
-    plot_line2(df2,ticker,colname1,label1, \
-               df2,ticker,colname2,label2, \
-               ylabeltxt,titletxt,footnote)
-    
-    #绘图2：OTM Calls vs OTM Puts交易金额比例
-    colname1='OTM Amount Call/Put'
-    label1='虚值看涨/看跌期权交易金额比例'
-    titletxt="期权链中的交易金额: "+tname+", 虚值看涨/看跌期权比例"
-
-    plot_line2(df2,ticker,colname1,label1, \
-               df2,ticker,colname2,label2, \
-               ylabeltxt,titletxt,footnote)
-    
-    #绘图3：预测的标的物价格
-    df2['Benchmark']=lastsprice
-    colname1='Estimated Price'
-    label1='预期价格'
-    colname2='Benchmark'
-    label2='当前价格'
-    ylabeltxt='价格('+currency+')'
-    titletxt="期权链与标的价格预期: "+tname
-
-    plot_line2(df2,ticker,colname1,label1, \
-               df2,ticker,colname2,label2, \
-               ylabeltxt,titletxt,footnote)
-    
-    #打印预测结果
-    collist=['Date','Trend','Estimated Price','OTM Volume Call/Put','OTM Amount Call/Put']
-    df3=df2[collist]
-    """
-    print("\n ======= 基于期权链结构的股票走势和价格预期: "+tname+" =======")
-    #设置打印对齐
-    pd.set_option('display.max_columns', 1000)
-    pd.set_option('display.width', 1000)
-    pd.set_option('display.max_colwidth', 1000)
-    pd.set_option('display.unicode.ambiguous_as_wide', True)
-    pd.set_option('display.unicode.east_asian_width', True)
-    df3.columns=['日期','标的物价格走势','标的物价格预期','虚值看涨/看跌合约数量比例','虚值看涨/看跌交易金额比例']
-    print(df3.to_string(index=False))
-    
-    print(" 注:")
-    print(" 1) 当前价格: "+currency+str(lastsprice),"\b,",lastsdate,'\b.')
-    print(" 2) +(-)表示价格将比当前变高(低), +/-表示趋势不明朗.")
-    print(" 3) 期权交易样本期间: 最近"+str(lastndays)+"个日历日，且期间内未发生分拆.")
-    print(" 4) 价格估计可能随时变化，越远期的估计可能准确度越欠佳.")
-    print(" "+footnote+'.')
-    """
-    titletxt="期权链与标的价格预期: "+tname
-    footnote1="注:\n"
-    footnote2="1、当前价格: "+currency+str(lastsprice)+", "+lastsdate+'\n'
-    footnote3="2、+(-)表示价格将比当前变高(低), +/-表示趋势不明朗\n"
-    footnote4="3、期权交易样本期间: 最近"+str(lastndays)+"个日历日，且期间内未发生分拆\n"
-    footnote5="4) 价格价格估计可能随时变化，越远期的估计可能准确度越欠佳\n"
-    
-    footnote9=footnote1+footnote2+footnote3+footnote4+footnote5+footnote
-    
-    df_display_CSS(df3,titletxt=titletxt,footnote=footnote9,facecolor='papayawhip',decimals=2, \
-               first_col_align='left',second_col_align='right', \
-               last_col_align='right',other_col_align='right', \
-               titile_font_size='15px',heading_font_size='13px', \
-               data_font_size='13px')
-    
-    return df2
-
-if __name__ =="__main__":
-    df=stock_trend_by_option('AAPL',7)
-
-#==============================================================================
-#==============================================================================   
-#==============================================================================   
-#==============================================================================
-
-#==============================================================================
-
-
-
-
-
-
-
-