python DataScience数据分析笔记day07

day07-随机数-超几何分布-标准正态分布-排序-插值-积分-图像处理-金融计算    
        3.随机数(random)
            生成服从特定统计规律的随机数序列
                统计规律如:正态、均匀、离散分布规律等等
            1)二项分布
                numpy.random.binomial (n, p, size) -> [size个随机数]
                size：产生随机个数，
                n：尝试次数
                p：成功的概率            
                如猜硬币的游戏：初始筹码1000，每轮猜9次，猜对5次
                    或5次以上为赢，筹码加1，否则为输，筹码减1。
                    求：10000轮的过程中手中筹码的变化。
                        binomial(9, 0.5 10000)
                代码：bi.py
                示例：
                    import numpy as np
                    import matplotlib.pyplot as mp
                    outcomes = np.random.binomial(9,0.5,10000)
                    chips = [1000]
                    for outcome in outcomes:
                            if outcome >= 5:
                                    chips.append(chips[-1]+1)
                            else:
                                    chips.append(chips[-1]-1)
                    chips = np.array(chips)
                    o,h,l,c = 0,chips.argmax(),chips.argmin(),chips.size-1
                    if chips[o] < chips[c]: #赚
                            color = 'orangered'
                    elif chips[c] < chips[o]: #赔
                            color = 'limegreen'
                    else:
                            color = 'dodgerblue'
                    mp.figure('bi',facecolor='lightgray')
                    mp.title('bi',fontsize=20)
                    mp.xlabel('Round',fontsize=14)
                    mp.ylabel('chip',fontsize=14)
                    mp.tick_params(labelsize=10)
                    mp.grid(linestyle=':')
                    mp.plot(chips,c=color,label='bi')
                    mp.axhline(y=chips[o],linestyle = '--',linewidth = 1,color = 'deepskyblue')
                    mp.axhline(y=chips[h],linestyle = '--',linewidth = 1,color = 'crimson')
                    mp.axhline(y=chips[l],linestyle = '--',linewidth = 1,color = 'seagreen')
                    mp.axhline(y=chips[c],linestyle = '--',linewidth = 1,color = 'orange')
                    mp.legend()
                    mp.tight_layout()
                    mp.show()
            2)超几何分布
                numpy.random.hypergeometric(ngood, nbad,
                    nsample, size)
                    size：产生的随机次数
                    nsample：随机抽取好样本的个数
                    nbad：总样本中坏样本的个数
                    ngood：总样本中好样本的个数
                    产生size个随机数，
                    每个随机数来自随机抽取的nsample个样本中好样本个数，
                    总体样本有ngood个好样本和nbad个坏样本组成。
                模球游戏：
                    25个好球和1个坏球放在一起，
                    每次摸3个球，全为好球加1分，摸到坏球减6分
                    求100轮过程中分值的变化
                    np.random.hypergeometric(25,1,3,100)
                示例：
                    import numpy as np
                    import matplotlib.pyplot as mp
                    outcomes = np.random.hypergeometric(25,1,3,100)
                    #print(outcomes)
                    scores = [0]
                    for outcome in outcomes:
                            if outcome == 3:
                                    scores.append(scores[-1]+1)
                            else:
                                    scores.append(scores[-1]-6)
                    scores = np.array(scores)
                    #print(scores)
                    o,h,l,c = 0,scores.argmax(),scores.argmin(),scores.size-1
                    if scores[o] < scores[c]: #赚
                            color = 'orangered'
                    elif scores[c] < scores[o]: #赔
                            color = 'limegreen'
                    else:
                            color = 'dodgerblue'
                    mp.figure('hypergeometric',facecolor='lightgray')
                    mp.title('bi',fontsize=20)
                    mp.xlabel('Round',fontsize=14)
                    mp.ylabel('scores',fontsize=14)
                    mp.tick_params(labelsize=10)
                    mp.grid(linestyle=':')
                    mp.plot(scores,c=color,label='scores')
                    mp.axhline(y=scores[o],linestyle = '--',linewidth = 1,color = 'deepskyblue')
                    mp.axhline(y=scores[h],linestyle = '--',linewidth = 1,color = 'crimson')
                    mp.axhline(y=scores[l],linestyle = '--',linewidth = 1,color = 'seagreen')
                    mp.axhline(y=scores[c],linestyle = '--',linewidth = 1,color = 'orange')
                    mp.legend()
                    mp.tight_layout()
                    mp.show()
            3)标准正态分布
                numpy.random.normal(size)
                产生size个随机数，服从标准正态(平均值0,标准差1)分布。
                    正态分布函数概率密度：        e^((-x^2)/2)/√2π
                    见：正态分布函数.png        
                代码：normal.py 
                示例，正态分布直方图：
                    import numpy as np
                    import matplotlib.pyplot as mp
                    samples = np.random.normal(size=1000)
                    mp.figure('Normal',facecolor='lightgray')
                    mp.title('Normal',fontsize=20)
                    mp.xlabel('Sample',fontsize=14)
                    mp.ylabel('Occ',fontsize=14)#出现的机会
                    mp.tick_params(labelsize=10)
                    mp.grid(axis='y',linestyle=':')
                    #画直方图，将样本分成100份(100个直方条)
                    bins = mp.hist(samples,100,normed=True,edgecolor='steelblue',
                                    facecolor='deepskyblue',label='Normal')[1]
                    #画函数曲线
                    probs = np.exp(-bins**2/2)/np.sqrt(2*np.pi)#概率函数
                    mp.plot(bins,probs,'o-',c='orangered',label='Probability')
                    mp.legend()
                    mp.tight_layout()
                    mp.show()    
    六、numpy的其他函数
        1.排序和查找
            1)联合间接排序:
                numpy.lexsort((参考序列,待排序列)) -->返回有序的索引
                    例如：numpy.lexsort((年龄,成绩))
                                --->获得成绩排名，
                                        之后可根据成绩排名获得对应的姓名
                            首先按成绩排序，相同成绩的，按照年龄排序
                    相当于是：首要排序成绩，次要排序年龄
                返回a数组按升序排列的索引数组，
                对于a数组中值相同的元素参考其在b数组中对应元素的升序排列。
                示例：
                    ages = np.array([30,20,30,20])
                    scores = np.array([70,60,80,70])
                    names = np.array(['zhang','li','wang','zhao'])
                    #先按scores排序，然后按ages排序
                    l=np.lexsort((ages,scores))
                    print(l)
                    name = np.take(names,l)
                    print(name) #输出对应排序的姓名
            2)sort_complex(复数数组)
                按照复数实部的升序排序，
                对于实部相同的元素参考其虚部的升序。
                示例：
                    ages = np.array([30,20,30,20])
                    scores = np.array([70,60,80,70])
                    names = np.array(['zhang','li','wang','zhao'])
                    complexes = scores + ages * 1j#创建复数数组
                    print(np.sort_complex(complexes))#对复数排序
            3)argmax/argmin/max/min: 将nan值视为最大和最小值
            4)nanargmax/nanargmin/nanmax/nanmin: 将nan值直接忽略不计
            5)有序插入：searchsorted / insert
                searchsorted(有序序列,待查序列)
                    将待插序列插入有序序列后，结果依然有序
                    返回分别应该放在哪个位置的数组
                有序插入： insert(被插序列,位置序列，待插序列）
                    将待插序列按照位置序列插入被插序列，并返回
                示例：
                    a = np.array([1,2,4,5,6,8,9])
                    b = np.array([7,3])
                    c = np.searchsorted(a,b) #获得位置数组
                    d = np.insert(a,c,b)#将b按照c的位置插入到a中
                    print(d)
            6)where/掩码/extract/nonzero: 根据条件选择元素
        2.插值
            收集到的有限样本数据，很难形成曲线，
            通过插值方式，插入多个模拟数据，最终形成近似接近的曲线
            import scipy.interpolate as si
            一维插值si.interp1d(离散x坐标，离散y坐标,
                            kind=插值算法(默认为线性插值)) -->返回茶之器
                    插值器(x坐标)-->得出y坐标
            二维插值si.interp2d 
            三维插值si.interp3d 
            示例：
                import numpy as np
                import scipy.interpolate as si
                import matplotlib.pyplot as mp
                min_x,max_x = -2.5,2.5
                con_x = np.linspace(min_x,max_x,1001)
                con_y = np.sinc(con_x)
                #生成有限个离散样本
                dis_x = np.linspace(min_x,max_x,11)
                dis_y = np.sinc(dis_x)
                #通过得到的有限样本数据，通过插值的方式模拟出曲线
                linear = si.interp1d(dis_x,dis_y)#构造线性插值器
                lin_x = np.linspace(min_x,max_x,51) # 比dis_x多了40个，则多余的就需要插值去完成
                lin_y = linear(lin_x)
                cubic = si.interp1d(dis_x,dis_y,kind='cubic')#构造三次样条插值器
                cub_x = np.linspace(min_x,max_x,51)
                cub_y = cubic(cub_x)
                mp.figure('interpolate',facecolor='lightgray')
                mp.subplot(221)
                mp.title('interpolate',fontsize=16)
                mp.xlabel('x',fontsize=12)
                mp.ylabel('y',fontsize=12)
                mp.tick_params(labelsize=10)
                mp.grid(linestyle=':')
                mp.plot(con_x,con_y,c='hotpink',label='Cont')
                mp.subplot(222)
                mp.title('Discrete',fontsize=16)
                mp.tick_params(labelsize=10)
                mp.grid(linestyle=':')
                mp.scatter(dis_x,dis_y,c='orangered',s=60,label='dis')
                mp.subplot(223)
                mp.title('Linear',fontsize=16)
                mp.xlabel('X',fontsize=12)
                mp.ylabel('Y',fontsize=12)
                mp.tick_params(labelsize=10)
                mp.grid(linestyle=':')
                #绘制插值后的曲线
                mp.plot(lin_x,lin_y,'o-',label='linear')
                mp.scatter(dis_x,dis_y,c='orangered',s=60,zorder=3)
                mp.subplot(224)
                mp.title('Cubic',fontsize=16)
                mp.xlabel('X',fontsize=12)
                mp.ylabel('Y',fontsize=12)
                mp.tick_params(labelsize=10)
                mp.grid(linestyle=':')
                #绘制插值后的曲线
                mp.plot(cub_x,cub_y,'o-',label='cubic')
                mp.scatter(dis_x,dis_y,c='orangered',s=60,zorder=3)
                mp.legend()
                mp.tight_layout()
                mp.show()
        3.积分
            import matplotlib.pyplot as mp #用于绘制曲线，散点等
            import matplotlib.patches as mc #用于绘制几何图形，如三角，园等
            import scipy.integrate as si
            si.quad(积分函数,积分下限，积分上限)，返回积分值、最大误差
            示例：
                import numpy as np
                import scipy.integrate as si
                import matplotlib.pyplot as mp #用于绘制曲线，散点等
                import matplotlib.patches as mc #用于绘制几何图形，如三角，园等
                def f(x):
                        return 2 * x ** 2 + 3 * x + 4 #一个典型的二次多项式 ，抛物线
                a , b = -5,5
                #按scipy计算积分
                area1 = si.quad(f,a,b)
                print(area1)
                #按照古典方式计算积分
                n = 300
                x2 = np.linspace(a,b,n+1)
                y2 = f(x2)
                area = 0
                for i in range(n):
                        #梯形面积公式：(上底 + 下底)* 高 / 2
                        area += (y2[i] + y2[i+1]) * (x2[i+1]-x2[i]) / 2
                print(area)
                mp.figure('Integral',facecolor='lightgray')
                mp.title('Integral',fontsize=16)
                mp.xlabel('x',fontsize=12)
                mp.ylabel('y',fontsize=12)
                mp.tick_params(labelsize=10)
                mp.grid(linestyle=':')
                #绘制曲线
                x1 = np.linspace(a , b, 1001)
                y1 = f(x1)
                mp.plot(x1,y1,label=r'$y=2x^2+3x+4$')
                #绘制古典积分方法用的多边形
                for i in range(n):
                        mco = mc.Polygon([[x2[i],0],[x2[i],y2[i]],
                                             [x2[i+1],y2[i+1]],[x2[i+1],0]],
                                             fc='deepskyblue',ec='dodgerblue',
                                             alpha=0.5)#绘制多边形，定点坐标数量，由图形顶点数决定
                        mp.gca().add_patch(mco)
                mp.legend()
                mp.tight_layout()
                mp.show()
        4.图像
            import scipy.ndimage as sn #可进行颜色变换
            import scipy.misc as sm 
            #相对scipy，opencv的图像处理更强大
            #pip install opencv-python 
            示例：
                import scipy.misc as sm 
                import scipy.ndimage as sn #可进行颜色变换
                import matplotlib.pyplot as mp
                originalt = sm.imread('./lily.jpg')#读取图片的源格式
                #print(originalt.shape,originalt.dtype) #(512, 512, 3) 表示(高度,宽度,颜色通道) 3，表示红绿蓝
                original = sm.imread('./lily.jpg',True)#读取图片的灰度格式
                #print(original.shape,original.dtype) #(512, 512) float32，没有颜色维了
                median = sn.median_filter(original,(20,20))#中值滤波,实际是二维卷积模糊化，也叫高斯模糊
                #卷积模糊通常用于去除杂质
                rotate = sn.rotate(originalt,45) #旋转45度
                prewitt = sn.prewitt(original)#索贝尔边缘识别，索贝尔微分，浮雕效果，找物体轮廓
                mp.figure('Image',facecolor='lightgray')
                mp.subplot(221)
                mp.title('Original',fontsize=16)
                mp.axis('off')
                mp.imshow(original,cmap='gray')
                mp.subplot(222)
                mp.title('prewitt',fontsize=16)
                mp.axis('off')
                mp.imshow(prewitt)
                mp.subplot(223)
                mp.title('mediane',fontsize=16)
                mp.axis('off')
                mp.imshow(median,cmap='gray')
                mp.subplot(224)
                mp.title('rotate',fontsize=16)
                mp.axis('off')
                mp.imshow(rotate,cmap='gray')
                mp.tight_layout()
                mp.show()
        5.金融计算
            1)终值fv(利率,期数,每期支付,现值)
                如：将1000元存入银行，利率为1%，存5年，每年加存100
                        到期后本息合计多少
                    np.fv(0.01,5,-100,-1000) #资金流出为负，流入为正
                示例：
                    fv = np.fv(0.01,5,-100,-1000)
                    print(round(fv,2)) #输出：1561.11
            2)现值pv(利率,期数,每期支付,终值)
                如：银行利率为1%，存5年，每年加存100
                        到期后能拿到2000元，请问现在应该存多少
                    np.pv(0.01,5,-100,2000) 
                示例：
                    pv = np.pv(0.01,5,-100,2000)
                    print(round(pv,2)) #输出：-1417.59
            3)净现值npv(利率,现金流)
                如：将1000元存入银行，利率为1%，存5年，每年加存100
                        相当于现在一次性存入多少
                    npv(0.01,[-1000,-100,-100,-100,-100,-100])
                示例：
                    npv = np.npv(0.01,[-1000,-100,-100,-100,-100,-100])
                    print(round(npv,2))#输出：-1485.34-
            4)内部收益率IRR(现金流)
                如：将1000元存入银行存5年，以后逐年提取100,200，300，400,
                    500，之后银行利率达到多少，可在最后一次体现尝清本息
                    即净现值为0
                    irr([-1000,100,200,300,400,500])
                示例：
                    irr = np.irr([-1000,100,200,300,400,500])
                    print(round(irr,2))#输出：0.12
            5)每期支付pmt(利率,期数,现值)
                如：以1%的年利率从银行贷款1万，分5年还清，
                    平均每年还多少钱
                    pmt(0.01,5,10000)
                示例：
                    pmt = np.pmt(0.01,5,10000)
                    print(round(pmt,2))#输出：-2060.4
            6)还款期数nper(利率,每期支付,现值)
                如：以1%的年利率从银行贷款1万，平均每年还2060.4
                    多少年还清，
                    nper(0.01,-2060.4,10000)
                示例：
                    nper = np.nper(0.01,-2060.4, 10000)
                    print(nper)#输出：约5
            7)贷款利率rate(期数，每期支付，现值，终值)
                示例：
                    rate = np.rate(5,-2060.4,10000,0)
                    print(rate)#输出：0.01
        6.窗函数
            1)巴特莱特窗：numpy.bartlett
            2)布莱克曼窗：numpy.blackman
            3)哈明窗：numpy.hamming
            4)汉宁窗：numpy.hanning
            5)凯瑟窗：numpy.kaiser