python DataScience数据分析笔记day06

day06-矩阵-矢量函数转换-加法、除法、取余通用函数-三角函数-线性代数-傅里叶变换
        19、矩阵
            1、numpy.matrix 继承自 numpy.ndarray
                任何针对多维数值的操作，对矩阵同样有效，
                但作为子类矩阵又结合自身的特点，做了必要的
                扩充，比如：乘法、求逆
            2、矩阵对象三种创建方式：
                1、numpy.matrix(任何被解释为矩阵的二维容器，
                            copy=是否复制(默认为True))
                            返回矩阵对象
                            copy = False, 所得矩阵与源容器共享一份数据
                            copy = True，所得矩阵各自独立数据
                2、numpy.mat(...) <==> numpy.matrix (..., copy=False
                    mat不同于matrix之处在于其只能获取已有矩阵视图，
                    而无法得到拷贝。
                3、numpy.bmat(拼块规则)
                    函数可以将已定义的矩阵逐块拼接。
                    将小块矩阵拼接为大块矩阵
                    拼接块的维度必须相同
                以上三个都可接受字符串形式的矩阵描述，即：
                    数据项用空格分隔，数据行用分号分隔。
                                                                                 |1 2 3|
                    例如：'1 2 3; 4 5 6;7 8 9'<==> |4 5 6|   
                                                                                 |7 8 9|
                数组相乘：对应元素相乘
                矩阵相乘：Amp * Bpn = Cmn
                                    计算第C[m,n]位置的元素值为：
                                    [Am行]*[Bn列]对应元素相乘后之和
                        如：求C[2,3]元素的值，则为
                                A第2行 乘以 B第3列 后的值
                求逆矩阵：矩阵.I
                代码：mat.py
                示例：
                    import numpy as np
                    a = np.array([[1,2,6],
                                                [3,5,7],
                                                [4,8,9]])
                    b = np.matrix(a)
                    c = np.mat('1 4 7;2 5 8;3 6 9')
                    d = np.bmat('c b')
                    print(np.bmat('c b ; b c'))
                    print(a * b)
                    print(b.I)
        20.通用函数
            1、frompyfunc转为矢量函数
                numpy.frompyfunc(标量函数,参数个数，返回值个数)
                转为矢量函数
                与17、矢量函数 基本一致：numpy.vectorize(标量函数)(矢量)
                frompyfunc与vectorize比，比较早期应用。
            2.加法的通用函数add
                numpy.add.reduce() - 累加
                numpy.add.accumulate - 累加过程
                numpy.add.reduceat - 分段累加
                numpy.add.outer - 外和
                注意：numpy.outer - 外积
                代码：add.py
                示例：
                    import numpy as np
                    a = np.arange(1,7)
                    print(a)
                    b = np.add(a,a) # <==> a + a
                    print(np.add.reduce(a)) # 输出：21
                    print(np.add.accumulate(a)) #每次累加的过程：[ 1  3  6 10 15 21]
                    #按a的下标分为三段累加：第一段：a[0]及后面；第二段：a[2]及后面；第三段：a[4]及以后
                    print(np.add.reduceat(a,[0,2,4]))#分段累加，输出：[3 7 11]
                    #以下外和,输出：
                    #[11 12 13 14 15 16]
                    #[21 22 23 24 25 26]
                    #[31 32 33 34 35 36]]
                    print(np.add.outer([10,20,30],a))#外和
                    print(np.outer([10,20,30],a)) #外积
            3.除法的通用函数
                1)真除：numpy.divide、true_divide、/
                    无论运算数是整型还是浮点，运算结果都是浮点数，
                    保留小数。
                2)地板除(向下去整)：floor_divide、//
                    运算数是整型，运算结果也是整型，运算数是浮点，
                    运算结果也是浮点，向下去整。
                3)天花板取整
                    numpy.ceil()
                4)天花板除
                    先真除，然后天花板取整
                    numpy.ceil(numpy.divide(a))
                5)截断取整
                    numpy.trunc()
                6)截断除，也就是取整除
                    先真除，然后截断取整
                    numpy.trunc(numpy.divide(a))
                示例：
                    import numpy as np
                    a = np.array([5,5,-5,-5])
                    b = np.array([2,-2,2,-2])
                    print(np.true_divide(a,b))  #真除 输出：[ 2.5 -2.5 -2.5  2.5]
                    print(np.divide(a,b))       #真除 输出：[ 2.5 -2.5 -2.5  2.5]
                    print(a / b)                #真除 输出：[ 2.5 -2.5 -2.5  2.5]
                    print(np.floor_divide(a,b)) #地板除 输出：[ 2 -3 -3  2]
                    print(a // b)               #地板除 输出：[ 2 -3 -3  2]
                    print(np.ceil(a/b))         #天花板取整 输出：[ 3. -2. -2.  3.]
                    print(np.trunc(a / b))      #截断取整 输出：[ 2. -2. -2.  2.]
            4.取余的通用函数
                1)取余numpy.remainder
                2)取模numpy.mod
                3)python取模： %
                4)获得截断除的模numpy.fmod
                示例：
                    import numpy as np
                    a = np.array([5,5,-5,-5])
                    b = np.array([2,-2,2,-2])
                    print(np.remainder(a , b))  #取余，输出：[ 1 -1  1 -1]
                    print(np.mod(a,b))          #取余，输出：[ 1 -1  1 -1]
                    print(a % b)                #取余，输出：[ 1 -1  1 -1]
                    print(np.fmod(a , b))       #截断除后取余，输出：[ 1  1 -1 -1]
            5.Numpy将Python语言中针对标量的运算符，
                通过通用函数加以重载定义，以支持数组的矢量运算。
                斐波那契数列
                1 1 2 3 5 8 13 ... 
                Fn = Fn-1 + Fn-2, n>=3
                示例：
                    import numpy as np
                    n = 35
                    #方法一：递归
                    def fibo(n):
                            return 1 if n<3 else fibo(n-1) + fibo(n-2)
                    #方法二：循环
                    def fiboFor(n):
                            fn1,fn2=0,1
                            for i in range(n):
                                    fn = fn1 + fn2
                                    fn1,fn2 = fn,fn1
                            return int(fn)
                    #方法三：numpy矩阵
                    def fiboNumpy(n):
                            E = np.mat('1. 1. ; 1. 0.')
                            fibo = int((E ** (n-1))[0,0])
                            return fibo
                    #方法四：公式法
                    def fibogs(n):
                            r = np.sqrt(5)
                            return int((((1+r)/2) ** n - ((1-r)/2) ** n) / r)
                    print(fibogs(n))
                    print(fiboNumpy(n))
                    print(fiboFor(n))
                    print(fibo(n))
            6.三角函数
                在numpy中所有的标准三角函数都是通用函数，
                可对数组或矩阵中的每个元素求取其三角函数的值，
                构成值数组或值矩阵。
                李萨如曲线：
                x = Asin(at+pi/2)  A:正负，a:角频率, pi/2:初相位
                y = Bsin(bt)            
                代码：lissa.py
                示例李萨如：
                    import numpy as np
                    import matplotlib.pyplot as mp
                    t = np.linspace(0,2 * np.pi,201)
                    A,a,B,b = 10,1,5,2
                    x = A * np.sin(a * t + np.pi/2 )
                    y = B * np.sin(b * t)
                    mp.figure('Lissajous',facecolor='lightgray')
                    mp.title('Lissajous',fontsize=20)
                    mp.xlabel('x',fontsize=14)
                    mp.ylabel('y',fontsize=14)
                    mp.tick_params(labelsize=10)
                    mp.grid(linestyle=':')
                    mp.plot(x,y,c='orangered',label='Lissajous')
                    mp.legend()
                    mp.show()
                信号发生器方波：若干不同频率的正玄波叠加，就会形成方波
                y1 = 4/pi * sin(x)
                y2 = 4/(3pi) * sin(3x)
                yn...4/(奇数pi) * sin(奇数x)
                y1+y2+..+yn
                            将方波分解成正弦波，三角波等，叫：傅里叶分解
                是信号发生器方波的逆运算
                示例:
                    import numpy as np
                    import matplotlib.pyplot as mp
                    def squarewave(n):
                            k = np.arange(1,n+1)
                            def fun(x):
                                    return np.sum(4 / ((2 * k -1) * np.pi) *
                                                                np.sin((2*k - 1) * x ))
                            return np.frompyfunc(fun,1,1)
                    x = np.linspace(0,2 * np.pi,201)
                    y1 = squarewave(1)(x)
                    y2 = squarewave(2)(x)
                    y3 = squarewave(3)(x)
                    y4 = squarewave(10)(x)
                    y5 = squarewave(100)(x)
                    y6 = squarewave(1000)(x)
                    mp.figure('squarewave',facecolor='lightgray')
                    mp.title('squarewave',fontsize=20)
                    mp.xlabel('x',fontsize=14)
                    mp.ylabel('y',fontsize=14)
                    mp.tick_params(labelsize=10)
                    mp.grid(linestyle=':')
                    # mp.plot(x,y1,label='n=1')
                    # mp.plot(x,y2,label='n=2')
                    # mp.plot(x,y4,label='n=10')
                    # mp.plot(x,y5,label='n=100')
                    mp.plot(x,y6,label='n=1000')
                    mp.legend()
                    mp.show()
            7.位运算
                1)异或：^/__xor__/bitwise_xor
                    1^0=1
                    1^1=0
                    0^0=0
                    0^1=1
                    相异取真, 相同得假
                    如判断a b是否正负异号：
                        方法之一：a * b < 0 ，则a与b异号
                        方法之二：a ^ b < 0 , 则a与b异号，
                            这样的效率比方法一高
                    示例：
                        import numpy as np
                        a = np.array([0,-1,2,-3,4,-5])
                        b = np.array([0,1,2,3,4,5])
                        c = a ^ b
                        print (c)
                        print(np.where(c < 0)[0])
                2)与：& / __and__ / bitwise_and
                    1&0=0
                    1&1=1
                    0&0=0
                    0&1=0
                    都为真时，才是真
                    如果一个整数n和n-1位进行"与"运算的结果为0，
                    则n一定是2的整数次幂。
                    即：n & (n-1) = 0 ，则n是2的幂
                    示例：
                        d = np.arange(1,20)
                        e = d & (d -1)
                        print(e)
                        print(d[e == 0])
                3)或：| / or / bitwise_or
                    只要有一个为真，即为真
                4)取反： ~ / __not__ / bitwise_not
                5)移位：
                    左移位：<< / __lshift__ / bitwise_left
                        左移一位，则乘2，移多位，则为乘2的n次方
                    右移为：>> /__rshift__ / bitwise_right
                        右移一位，则除2，移多位，则为除以2的n次方
    五、numpy的模块
        1.线性代数模块(linalg)
            1)矩阵求逆：inv
                在线性代数中，
                矩阵A与矩阵B的乘积是一个单位矩阵E，
                那么A和B互为逆矩阵,即为：
                AxB=E ==> A^-1 = B
                B = numpy.linalg.inv(A)
                将以上定义推广到非方阵，则称为广义逆矩阵
                np.linalg.pinv(A) --> A^-1
                np.matrix.I(A)-->如果A是方阵，则可用inv
                                                如果非方阵，则可用pinv
                示例：
                    import numpy as np
                    A = np.mat('1 2 3;8 9 4;7 6 5')
                    B = np.linalg.inv(A) #A的逆矩阵
                    print(B)
                    print(A.I)#A的逆矩阵
                    c = np.mat('11 12 13 14;20 21 22 15;19 18 17 16')
                    print(c)
                    d = np.linalg.pinv(c)#广义逆矩阵
                    print(d)
                    print(c * d)
                    print(c.I)
            2)解线性方程组
                        x-2y+ z  =0
                            2y-8z-8=0
                    -4x+5y+9z+9=0

                     1x + -2y +   1z = 0
                     0x +  2y +  -8z = 8
                    -4x +  5y +   9z = -9

                    | 1 -2   1 |     | x |     |  0  |
                    | 0  2  -8 |  *  | y |  =  |  8  |
                    |-4  5   9 |     | z |     | -9  |

                            A              x           B
                    方法一：拟合方法
                        x = nump.linalg.lstsq(A,B)[0]    
                        未知数少于方程数时，会求近似值
                    方法二：解方程
                        x = numpy.linalg.solve(A, B)
                        得到精确值，如果未知数少于方程数，会报错
                示例：
                    import numpy as np
                    A = np.mat('1 -2   1;0  2  -8;-4  5   9')
                    B = np.mat('0;8;-9')
                    x1 = np.linalg.solve(A,B)
                    x2 = np.linalg.lstsq(A,B)[0]
                    print(x1)
                    print(x2)
            3)特征向量和特征值
                    对于n阶方阵A，如果存在数a和非零n维列向量x，
                    使得Ax=ax成立，则称a是矩阵A的一个特征值，
                    x是矩阵A属于特征值a的特征向量。
                    numpy.linalg.eigvals(A) ==> 输出特征值
                    numpy.linalg.eig(A) ==> 可得出a 和 x，
                                                即特征数组和特征向量数组
                        [ a1  a2] 
                        [x11 x12]
                        [x21 x22]
                    示例：
                        import numpy as np
                        A = np.mat('3 -2;1 0')
                        eigvals,eigvecs = np.linalg.eig(A) #输出特征值和特征向量
                        print(eigvals)  #输出特征值
                        print(eigvecs)  #输出特征向量
                        print(A * eigvecs[:,0]) # 即概念中的A*x
                        print(eigvals[0]*eigvecs[:,0])  #即概念中的ax
                        #即：A*x = a*x
            4)奇异分解(矩阵中的因式分解)
                 若：M=U * S * V，
                其中U和V是正交矩阵，即U*U.T=E=V*V.T，
                        U.T，V.T为转置矩阵， E是单位矩阵
                S被称为M的奇异值矩阵。
                U, s, V = numpy.linalg.svd(M,full_matrices=False)
                full_matrices是否填充，False表示自然状态，不填充
                其中的s只是奇异值矩阵的主对角线，
                S=numpy.diag(s) 获得奇异值
                应用场景：人脸识别，要忽略细微差异，
                        获得关键因素，要降低维度
                代码：usv.py
                示例：
                    import numpy as np
                    M = np.mat('4 11 14;8 7 -2')
                    U , s, V = np.linalg.svd(M, full_matrices=False)
                    print(U * U.T)
                    print(s) #输出奇异值对角线
                    print(V * V.T)
                    S = np.diag(s)
                    print(S)#输出奇异值
                    print(U * S * V)
            6)行列式的值
                | a b | = ad - bc
                | c d |
                | a b c | =  a |e f|  -  b |d f|  +  c |d e|
                | d e f |      |h i|       |g i|       |g h|
                | g h i |   a的(余子式) b的(余子式) c的(余子式)
                                    =a(ei-fh)-b(di-fg)+c(dh-eg)
                                            =aei-afh-bdi+bfg+cdh-ceg
                numpy.linalg.det(矩阵) -> 行列式值
                示例：
                    import numpy as np
                    A = np.mat('2 1;3 4')
                    print(np.linalg.det(A))
                    B = np.mat('3 2 1;4 9 8;5 6 7')
                    print(np.linalg.det(B))
        2.快速傅立叶变换(Fast Fourier Transform, FFT)
            傅立叶定理：任何一个函数，都可以分解为一系列正玄函数的叠加
                即：原函数：y = f(x) ,也叫时空域函数
                可分解为：一系列正玄函数的叠加，
                                只是这些正玄函数的角频率ω，相位φ
                y=A1sin(ω1x+φ1)+A2sin(ω2x+φ2)+ ...+
                    Ansin(ωnx+φn)+ R
                    当n-> ∞ 时，R 会逼近于0
                意义：将一个复杂函数用无数个简单函数(sin函数)表示
            快速傅里叶：
                通过已知的样本，[x1,x2,...,xn] [y1,y2,...,yn]，即离散的样本值
                获得离散傅里叶，再进行优化，就成了快速傅里叶
                ω1 --> A1,φ1  \
                ω2 --> A2,φ2  |  即转为：A,φ = f(ω) 频率域函数
                ...           |   A是振幅， φ是初相位，ω是频率
                ωn --> An,φn  /
            即：傅立叶变换实际就是：将时空域函数转变为频率域函数，是一个分解过程
                    傅里叶逆变换就是：将频率域函数转变为时空域函数，是一个合成的过程
            numpy.fft.fftfreq(样本数n, 采样周期dt) --> 输出频率序列ω
            numpy.fft.fft(原函数序列f) --> 获得目标函数值序列,是一个复数序列
                复数的模反映了振幅A，辐角反映了初相位φ
                即：傅里叶变换
            numpy.fft.ifft(目标函数值序列(复数))-->获得原函数值序列
                即：傅里叶逆变换
            示例：
                import numpy as np
                import numpy.fft as nf
                import matplotlib.pyplot as mp
                times = np.linspace(0,2 * np.pi,201)
                sigs1 = 4/(1*np.pi) * np.sin(1*times)
                sigs2 = 4/(3*np.pi) * np.sin(3*times)
                sigs3 = 4/(5*np.pi) * np.sin(5*times)
                sigs4 = 4/(7*np.pi) * np.sin(7*times)
                sigs5 = 4/(9*np.pi) * np.sin(9*times)
                #合成原函数
                sigs6 = sigs1 + sigs2 + sigs3 + sigs4 + sigs5
                #将原函数进行傅里叶变换
                freqs = nf.fftfreq(times.size,times[1] - times[0])
                ffts = nf.fft(sigs6)
                pows = np.abs(ffts) #得复数模
                #傅里叶逆变换
                sigs7 = nf.ifft(ffts).real #real，要实部
                mp.figure('快速傅里叶变换',facecolor='lightgray')
                mp.subplot(121)
                mp.title('TimeDomain',fontsize=16)
                mp.xlabel('Time',fontsize=12)
                mp.ylabel('Signal',fontsize=12)
                mp.tick_params(labelsize=10)
                mp.grid(linestyle=':')
                mp.plot(times,sigs1,label='{:.4f}'.format(1/(2*np.pi)))
                mp.plot(times,sigs2,label='{:.4f}'.format(3/(2*np.pi)))
                mp.plot(times,sigs3,label='{:.4f}'.format(5/(2*np.pi)))
                mp.plot(times,sigs4,label='{:.4f}'.format(7/(2*np.pi)))
                mp.plot(times,sigs5,label='{:.4f}'.format(9/(2*np.pi)))
                mp.plot(times,sigs6,label='{:.4f}'.format(1/(2*np.pi)))
                mp.plot(times,sigs7,label='{:.4f}'.format(1/(2*np.pi)),
                                alpha=0.5,linewidth=6)
                mp.legend()
                mp.subplot(122)
                mp.title('Frequency',fontsize=16)
                mp.xlabel('Frequency',fontsize=12)
                mp.ylabel('Power',fontsize=12)
                mp.tick_params(labelsize=10)
                mp.grid(linestyle=':')
                mp.plot(freqs[freqs >= 0],pows[freqs >= 0],label='Frequency')
                mp.legend()
                mp.tight_layout()
                mp.show()            
            代码：fourier.py
                                                                            逆向傅立叶变换
            低频信号<------------------------------------------------低
                         | 叠加                   傅立叶变换                   低通滤波   频
                         +----> 含噪信号 ------------> 含噪频谱 ---------->频
                         |                                                                                 谱
            高频噪声
            代码：filter.py
            fftfreq/fft : 0 1 2 3 ... 1000 -1000 ... -3 -2 -1 0
            由numpy.fft.fftfreq/numpy.fft.fft函数返回的频谱数组，按照从0到+max再从-max到0的顺序排列，
            通过numpy.fft.fftshift函数做移频操作，可将其变为-max到+max的排列顺序，
            numpy.fft.ifftshift可完成相反的移频操作。
            day07---------------------------------------------------
            基于傅里叶变换的频域滤波：
                            ______________________________________
                         |            IFFT                      |
                         V                                      |
                    高能信号\                                 |
                                     |>含噪信号---->含噪频谱-------->高能频谱
                    低能噪声/          FFT           频域滤波
                    
                    numpy.fft.FFT(原函数序列f)：傅里叶变换
                    numpy.fft.IFFT()：傅里叶逆变换
                    numpy.fft.fftfreq(样本数量，采样周期)：
                        获得频谱数组,从0到+max再从-max到0排列
                    numpy.fft.fftshift：移频操作，变为-max到+max顺序
                    numpy.fft.ifftshift:与fftshift相反的移频操作。
                    
                    代码：filter.py
                    示例(音频去噪)：
                        import numpy as np
                        import numpy.fft as nf
                        import matplotlib.pyplot as mp
                        import scipy.io.wavfile as wf #scipy主要用于多媒体处理
                        #sample_rate,采样率,noised_sigs信号
                        sample_rate,noised_sigs = wf.read('./noised.wav')
                        #print(sample_rate) #输出44100，表示每秒钟采样的数量
                        #noised_sigs.shape为样本总数，将总数除以采样率，就是时间
                        #print(noised_sigs.shape)#输出格式：(声道1总数,声道2总数,声道3总数,声道4总数,..)
                        #dtype输出int16，数据实际为浮点数，该模块处理为：int16(数据*2**15)，使用时需要还原
                        #print(noised_sigs.dtype)
                        noised_sigs = noised_sigs / 2**15 #数据还原
                        times = np.arange(len(noised_sigs))/sample_rate #获得采样点时间
                        #获得频谱数组，代表能量强度
                        freqs = nf.fftfreq(times.size,1/sample_rate) #sample_rate采样频率的倒数即为采样周期
                        #print(times.size,noised_sigs.shape) #times.size也是样本总数
                        noised_ffts = nf.fft(noised_sigs)#进行傅里叶变换,获得复数形式的离散函数组
                        noised_pows =np.abs(noised_ffts) #对复数取模，获得能量值
                        #开始滤波
                        pow_max = noised_pows.argmax() #获得最大值下标
                        fund_freq = np.abs(freqs[pow_max])#获得能量最大值对应的频率,基频
                        #print(fund_freq)
                        noised_indices = np.where(np.abs(freqs) != fund_freq) #得到噪声频率
                        filter_ffts = noised_ffts.copy()#复制一份函数组
                        filter_ffts[noised_indices] = 0 #将噪声对应的频率函数去除，即：过滤
                        filter_pows = np.abs(filter_ffts) #获得去噪后的能量曲线
                        #将去噪后的信号进行傅里叶逆变换，还原成时空域函数
                        filter_sigs = nf.ifft(filter_ffts).real
                        #将去噪后的信号保存为文件，样本数不变，转换数据类型为int16
                        wf.write('./filter.wav',sample_rate,
                                         (filter_sigs * 2 ** 15).astype(np.int16))
                        mp.figure('filter',facecolor='lightgray')
                        mp.subplot(221)
                        mp.title('timeDoDomain',fontsize=16)
                        mp.ylabel('Sigal',fontsize=12)
                        mp.tick_params(labelsize=10)
                        mp.grid(linestyle=':')
                        mp.plot(times[:178],noised_sigs[:178],label='Noised')
                        mp.legend()
                        mp.subplot(222)
                        mp.ylabel('Power',fontsize=12)
                        mp.tick_params(labelsize=10)
                        mp.grid(linestyle=':')
                        #用plot直接按以下这样显示，差别太大，看不出区别，可用半对数坐标方式显示
                        #mp.plot(freqs[freqs>=0],noised_pows[freqs>=0],label='Freqs')
                        #semilogy半对数坐标
                        mp.semilogy(freqs[freqs>=0],noised_pows[freqs>=0],label='noised')
                        #通过以上观察可发现：低能频谱基本在10**3以下
                        mp.legend()
                        mp.subplot(223)#绘制去噪后的时空域函数曲线
                        mp.title('timeDoDomain',fontsize=16)
                        mp.xlabel('time',fontsize=12)
                        mp.ylabel('Sigal',fontsize=12)
                        mp.tick_params(labelsize=10)
                        mp.grid(linestyle=':')
                        mp.plot(times[:178],filter_sigs[:178],label='filter_sigs')
                        mp.legend()
                        mp.subplot(224)#绘制去噪后的能量曲线
                        mp.xlabel('frequercy',fontsize=12)
                        mp.ylabel('Power',fontsize=12)
                        mp.tick_params(labelsize=10)
                        mp.grid(linestyle=':')
                        mp.plot(freqs[freqs>=0],filter_pows[freqs>=0],label='filter')
                        mp.legend()
                        mp.tight_layout()
                        mp.show()
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