统计学与线性代数

统计学与线性代数在这两个数学分支在进行数据分析时非常有用。
当我们从原生数据进行推断时，统计学是必不可少的。比如，通过数据求出变量的算术平均值和标准差，并由此推出该变量的取值范围和期望值后，就可以利用统计检验来评估所得结论的可信度了。

3.1NumPy和Scipy模块

首先看一下Numpy和Scipy模块的相关文档。下面的代码将为我们展示Numpy和Scipy各个字库的相关描述信息：

import numpy as np
import scipy as sp
import pkgutil as pu
import matplotlib as mpl
import pydoc


print('NumPy version', np.__version__)    #打印模块的版本信息
print("SciPy version", sp.__version__)
print("Matplotlib version", mpl.__version__)

def clean(astr):
    s = astr
    s = ' '.join(s.split())    #用空格将s的字符串拆开后合并
    s = s.replace(' = ', '')    #用 = 代替 空格
    return s 

def print_desc(prefix, pkg_path):
    for pkg in pu.iter_modules(path = pkg_path):
        name = prefix + "." + pkg[1]
        
        if pkg[2] == True:
            try:
                docstr = pydoc.plain(pydoc.render_doc(name))
                docstr = clean(docstr)
                start = docstr.find("DESCRIPTION")
                docstr = docstr[start: start + 140]
                print(name, docstr)
            except:
                continue

print(print_desc("numpy", np.__path__))
print(print_desc("scipy", sp.__path__))

同时利用pkgutil模块的iter_modules()函数来遍历指定目录下面的所有字库，该函数将会返回一个由元组构成的列表，其中每个元组包含三个元素。对于我们，目前对第二个和第三个元素感兴趣，第二个元素存放的是子程序包的名称，而第三个元素存放的是一个指示这是个子程序包的布尔值。
函数pydoc.render_doc()可以返回指定子程序包或打印函数的文件字串。当然，这些字符串中可能包含有非打印字符，这时可以利用pydoc.plain()函数来剔除这些内容。

运行结果：

NumPy version 1.14.5
SciPy version 1.1.0
Matplotlib version 2.2.2
numpy.compat DESCRIPTION This module contains duplicated code from Python itself or 3rd party extensions, which may be included for the following reasons
numpy.core DESCRIPTION Functions - array - NumPy Array construction - zeros - Return an array of all zeros - empty - Return an uninitialized array - sh
numpy.distutils 
numpy.doc DESCRIPTION Topical documentation ===================== The following topics are available: - basics - broadcasting - byteswapping - constan
numpy.f2py 
numpy.fft DESCRIPTION Discrete Fourier Transform (:mod:`numpy.fft`) ============================================= .. currentmodule:: numpy.fft Standar
numpy.lib DESCRIPTION Basic functions used by several sub-packages and useful to have in the main name-space. Type Handling ------------- ============
numpy.linalg DESCRIPTION Core Linear Algebra Tools ------------------------- Linear algebra basics: - norm Vector or matrix norm - inv Inverse of a squar
numpy.ma DESCRIPTION ============= Masked Arrays ============= Arrays sometimes contain invalid or missing data. When doing operations on such arrays
numpy.matrixlib 
numpy.polynomial DESCRIPTION Within the documentation for this sub-package, a "finite power series," i.e., a polynomial (also referred to simply as a "series
numpy.random DESCRIPTION ======================== Random Number Generation ======================== ==================== ================================
numpy.testing DESCRIPTION This single module should provide all the common functionality for numpy tests in a single location, so that test scripts can ju
numpy.tests 
None
scipy._build_utils 
scipy._lib DESCRIPTION Module containing private utility functions =========================================== The ``scipy._lib`` namespace is empty (f
scipy.cluster DESCRIPTION ========================================= Clustering package (:mod:`scipy.cluster`) ========================================= ..
scipy.constants DESCRIPTION ================================== Constants (:mod:`scipy.constants`) ================================== .. currentmodule:: scip
scipy.fftpack DESCRIPTION ================================================== Discrete Fourier transforms (:mod:`scipy.fftpack`) ==========================
scipy.integrate DESCRIPTION ============================================= Integration and ODEs (:mod:`scipy.integrate`) ====================================
scipy.interpolate DESCRIPTION ======================================== Interpolation (:mod:`scipy.interpolate`) ======================================== .. cu
scipy.io DESCRIPTION ================================== Input and output (:mod:`scipy.io`) ================================== .. currentmodule:: scip
scipy.linalg DESCRIPTION ==================================== Linear algebra (:mod:`scipy.linalg`) ==================================== .. currentmodule:
scipy.misc DESCRIPTION ========================================== Miscellaneous routines (:mod:`scipy.misc`) ==========================================
scipy.ndimage DESCRIPTION ========================================================= Multi-dimensional image processing (:mod:`scipy.ndimage`) ============
scipy.odr DESCRIPTION ================================================= Orthogonal distance regression (:mod:`scipy.odr`) ============================
scipy.optimize DESCRIPTION ===================================================== Optimization and root finding (:mod:`scipy.optimize`) ====================
scipy.signal DESCRIPTION ======================================= Signal processing (:mod:`scipy.signal`) ======================================= Convolut
scipy.sparse DESCRIPTION ===================================== Sparse matrices (:mod:`scipy.sparse`) ===================================== .. currentmodu
scipy.spatial DESCRIPTION ============================================================= Spatial algorithms and data structures (:mod:`scipy.spatial`) ====
scipy.special DESCRIPTION ======================================== Special functions (:mod:`scipy.special`) ======================================== .. mo
scipy.stats DESCRIPTION ========================================== Statistical functions (:mod:`scipy.stats`) ==========================================
None

3.2用NumPy进行简单的描述性统计计算

在本章中，我们学一下如何将逗号分隔值文件载入NumPy数组，以进行数据分析。
首先去https://extranet.who.int/tme/generateCSV.asp？ds=mdr_estimates处的WHO网站下载CSV文件，这个文件存放的是与结核病有关的数据，进行删减后，最后保留两列：国家和新病例百分比。如下图所示：

下面来计算NumPy数组的平均值、中位数、最大值、最小值以及标准差。

import numpy as np
from scipy.stats import  scoreatpercentile

data = np.loadtxt("C:/Users/Administrator/Desktop/MDR2018.csv", delimiter = ',',
usecols = (1,), skiprows = 1, unpack = True)

print("Max nethod", data.max())
print("Max function", np.max(data))

print('Min method', data.min())
print("Min function", np.min(data))

print('Mean method', data.mean())
print("Mean function", np.mean(data))

print('Std method', data.std())
print("Std function", np.std(data))

print('Median', np.median(data))
print("Score at percentile 50", scoreatpercentile(data, 50))

输出结果：

Max nethod 38.0
Max function 38.0
Min method 0.0
Min function 0.0
Mean method 3.645774647887324
Mean function 3.645774647887324
Std method 5.511371768091664
Std function 5.511371768091664
Median 2.3
Score at percentile 50 2.3

在上面的程序中：
（1）首先，调用函数加载数据时，规定：用逗号作为分隔符，从第二列加载数据，并且忽略表头。此外，制定了文件名和相应路径。
（2）数组的最大值、最小值、平均值、标准差、中位数都可以用NumPy或者SciPy函数获得。

3.3用NumPy进行线性代数运算

线性代数是数学的一个分支，比如，我们可以使用线性代数来解决线性回归问题。子程序包numpy.linalg提供了许多线性代数例程，我们可以用它来计算矩阵的逆、计算特征值、求解线性方程或者计算行列式等。

3.3.1用NumPy求矩阵的逆

在线性代数中，假设A是一个方阵或可逆方阵，如果存在一个矩阵A-1，是A的逆，相应的数学方程式是：
AA-1 = I
子程序包numpy.linalg中的inv()函数就是用来求矩阵的逆的。
1.创建一个实例矩阵
利用mat()函数创建一个示例矩阵
2.求矩阵的逆
可以利用inv()子例程来计算逆矩阵
3.利用乘法进行验算
将inv()函数的计算结果乘以原矩阵，验算结果是否正确，得到的单位矩阵减去3X3单位矩阵，就可以得到求逆过程中出现的误差。

import numpy as np

A = np.mat('2 4 6; 4 2 6; 10 -4 18')
print("A\n", A)

inverse = np.linalg.inv(A)
print("inverse of A\n", inverse)

print("Chek\n", A * inverse)
print("Error\n", A * inverse - np.eye(3))

计算结果：

A
 [[ 2  4  6]
 [ 4  2  6]
 [10 -4 18]]
inverse of A
 [[-0.41666667  0.66666667 -0.08333333]
 [ 0.08333333  0.16666667 -0.08333333]
 [ 0.25       -0.33333333  0.08333333]]
Chek
 [[ 1.00000000e+00  0.00000000e+00  0.00000000e+00]
 [-2.22044605e-16  1.00000000e+00  0.00000000e+00]
 [-8.88178420e-16  8.88178420e-16  1.00000000e+00]]
Error
 [[-1.11022302e-16  0.00000000e+00  0.00000000e+00]
 [-2.22044605e-16  4.44089210e-16  0.00000000e+00]
 [-8.88178420e-16  8.88178420e-16 -1.11022302e-16]]

3.3.2用NumPy解线性方程组

矩阵可以通过线性方式把一个向量变换成另一个向量，因此从数值计算的角度看，这种操作对应于一个线性方程组。Numpy.linalg中的solve()子例程可以求解类似于Ax = b这种形式的线性方程组，其中A是一个矩阵，b是一维或者二维数组，而x是未知量。
1.创建矩阵A和数组b
2.调用solve()函数，用solve()函数解这个线性方程组
3.利用dot()函数验算这个解是否正确

A = np.mat("1 -2 1; 0 2 -8; -4 5 9")
print("A\n", A)
b = np.array([0, 8, -9])
print("b\n", b)
x = np.linalg.solve(A, b)
print("Solution", x)
print("Check\n", np.dot(A, x))

输出结果：

A
 [[ 1 -2  1]
 [ 0  2 -8]
 [-4  5  9]]
b
 [ 0  8 -9]
Solution [29. 16.  3.]
Check
 [[ 0.  8. -9.]]

3.4用NumPy计算特征值和特征向量

特征值是方程式Ax = ax的标量解，其中A是一个二维矩阵，而x是一维向量。特征向量实际上就表示特征值的向量。
特征值和特征向量都是基本的数学概念，并且常用于一些重要的算法中，如主成分分析（PCA）算法。PCA可以极大地简化大规模数据集的分析过程。（表示还不太明白）
计算特征值时，可以求助于numpy.linalg程序包提供的eigvals()子例程。函数eig()的返回值是一个元组，其元素为特征值和特征向量。

import numpy as np

A = np.mat("3 -2; 1 0")
print("A\n", A)

print("eigenvalues", np.linalg.eigvals(A))

eigenvalues, eigenvetors = np.linalg.eig(A)
print("First tuple of eig", eigenvalues)
print("Second tuple of eig\n", eigenvetors)

for i in range(len(eigenvalues)):
    print("Left", np.dot(A, eigenvetors[:, i]))
    print("Right", eigenvalues[i] * eigenvetors[:, i])

输出结果：

A
 [[ 3 -2]
 [ 1  0]]
eigenvalues [2. 1.]
First tuple of eig [2. 1.]
Second tuple of eig
 [[0.89442719 0.70710678]
 [0.4472136  0.70710678]]
Left [[1.78885438]
 [0.89442719]]
Right [[1.78885438]
 [0.89442719]]
Left [[0.70710678]
 [0.70710678]]
Right [[0.70710678]
 [0.70710678]]

计算一个矩阵特征值的步骤：
1.创建矩阵。
2.利用eig()函数计算特征值
3.利用eig函数去取得特征值和特征向量
4.验算结果

3.5NumPy随机数

随机数常用于蒙特卡罗法、随机微积分等方面。对于NumPy，与随机数有关的函数都在random子程序包里。
我们既可以生成连续分布的随机数，也可以生成非连续分布的随机数。分布函数有一个可选的size参数，它能通知NumPy要创建多少数字。我们可以用整型或者元组来给这个参数赋值，这时会得到相应形状的数组，其值由随机数填充。离散分布包括几何分布、超几何分布和二项式分布。连续分布包括正态分布和对数正态分布。

3.5.1用二项式分布进行博弈

二项式分布模拟的是正在进行整数次独立实验中成功的次数。
假如我们身在17世纪的赌场，正在对8片笔玩法下注。当时流行用9枚硬币来玩。如果人头朝上的硬币少于5枚，那么我们将输掉一个8分币，否则，我们赢得一个8分币，下面开始模拟这个游戏，假设我们手上有一千枚硬币作为赌资。

import numpy as np
from matplotlib.pyplot import  plot, show
cash = np.zeros(10000)
cash[0] = 1000
outcome = np.random.binomial(9, 0.5, size = len(cash))

for i in range(1, len(cash)):
    
    if outcome[i] < 5:
        cash[i] = cash[i - 1] - 1
    elif outcome[i] < 10:
        cash[i] = cash[i - 1] + 1
    else:
        raise AssertionError("Unexpected outcome" + outcome)
        
print(outcome.min(), outcome.max())
plot(np.arange(len(cash)), cash)
show()        

输出结果：

0 9

1.首先用binomial()函数。将数组初始化为0，即现金余额为0。调用binomial()函数，将size参数设为10000，这就表示我们要掷10000次硬币。
2.更新现金余额。利用抛掷硬币的结果来更新cash数组。显示outcome数组中的最大值和最小值，只要保证没有罕见的异常值即可。
3.用matplotlib绘制出cash数组的图像。
从图中我们可以看出：现金余额的曲线类似于随机行走（既不按照固定模式，而是随机游走）

3.5.2正态分布采样

连续分布是通过概率密度函数进行建模的。在特定区间发生某事件的可能性可以通过概率密度分布函数的积分运算求出。NumPy的random模块提供了许多表示连续分布的函数，如beta、chisquare、exponential、f、gammma、gumbel、labplace。lognormal等。

import numpy as np
import matplotlib.pyplot as plt

N =10000

normal_values = np.random.normal(size = N)
dummy, bins, dummy = plt.hist(normal_values, int(np.sqrt(N)), normed = True, lw = 1)
sigma = 1
mu = 0
plt.plot(bins, 1/(sigma * np.sqrt(2 * np.pi)) * np.exp( - (bins - mu) ** 2 / (2 * sigma ** 2)), lw = 2)
plt.show()

输出结果：

书中代码有点问题：在Python3之后除法自动转成float类型，强转int类型或者整除就可以解决这个报错。

 'numpy.float64' object cannot be interpreted as an integer

随机数可以按照正态分布的要求生成，它们的分布情况可以用条形图来显示。
1.成数值。
借助于NumPy的random子程序包提供的normal()函数，可以创建指定数量的随机数。
2.画出条形图和理论上的pdf。
其中中心值为0，标准差为1，钟形图如上图所示。

2.5.3用Scipy进行正态检验

正态分布被广泛应用到科学和统计学领域，按照中心极限定理，随着独立观测的随机样本数量的增加，它们会呈正态分布。正态分布的特性已经被大家所熟知，并且它还非常便于应用，不过，它需要满足很多必要条件，如数据点的数量要足够大，并且还要求这些数据点必须是相互独立的。工作中，我们需要养成检查数据是否符合正态分布的好习惯。正态检验的方法有很多，其中有一些已经在scipy.stats程序包中实现了，本文将用到这些检验方法。

实例来自于：
http：//www.google.org/flutrends/data.txt
因为很多文件按照网址下载不到，像这个疾病预测谷歌已经不干了，所以源代码可以到这个百度网盘下载。
链接: https://pan.baidu.com/s/1F3KZeAEIF6FdJemZbmF0hQ 提取码: 6q9f

import numpy as np
from scipy.stats import  shapiro
from scipy.stats import  anderson
from scipy.stats import  normaltest

flutrends = np.loadtxt("C:/Users/Administrator/Desktop/goog_flutrends.csv", delimiter = ",",
                      usecols = (1,), skiprows = 1, converters = {1: lambda s: float(s or 0)},
                      unpack = True)
N = len(flutrends)
normal_values = np.random.normal(size = N)
zero_values = np.zeros(N)

print("Normal Values Shapiro", shapiro(normal_values))
print("Zeroes Shapiro", shapiro(zero_values))
print("Flu Shapiro", shapiro(flutrends))

print("Normal Values Anderson", anderson(normal_values))
print("Zeroes Anderson", anderson(zero_values))
print("Flu Anderson", anderson(flutrends))


print("Normal Values normaltest", normaltest(normal_values))
print("Zeroes normaltest", normaltest(zero_values))
print("Flu normaltest", normaltest(flutrends))

运行结果：

Normal Values Shapiro (0.9974890947341919, 0.5143387913703918)
Zeroes Shapiro (1.0, 1.0)
Flu Shapiro (0.9351997971534729, 2.295085533771178e-15)


Normal Values Anderson AndersonResult(statistic=0.3671407104740183, critical_values=array([0.572, 0.652, 0.782, 0.912, 1.085]), significance_level=array([15. , 10. ,  5. ,  2.5,  1. ]))
Zeroes Anderson AndersonResult(statistic=nan, critical_values=array([0.572, 0.652, 0.782, 0.912, 1.085]), significance_level=array([15. , 10. ,  5. ,  2.5,  1. ]))
Flu Anderson AndersonResult(statistic=8.258614154768793, critical_values=array([0.572, 0.652, 0.782, 0.912, 1.085]), significance_level=array([15. , 10. ,  5. ,  2.5,  1. ]))
Normal Values normaltest NormaltestResult(statistic=1.364152978587686, pvalue=0.5055660990668097)
Zeroes normaltest NormaltestResult(statistic=1.0095473240349975, pvalue=0.6036421871210353)
Flu normaltest NormaltestResult(statistic=99.64373336356954, pvalue=2.304826411536872e-22)

打开这种小概率事件的数据（如世界疫情的爆发）时，就可能遇到这种数据。在这个数据文件中，一些单元是空的，所以必须习惯于清洗数据。我们假定正确的数值是0，使用转换器来填上这些0值。
这里详细看一下np.loadtxt()函数：
loadtxt(fname, dtype=<class 'float'>, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False, ndmin=0)

• fname要读取的文件、文件名、或生成器。
• dtype数据类型，默认float。还可以控制每一列的数据类型和精度等信息。

np.loadtxt(d, dtype={'names': ('gender', 'age', 'weight'),
                  'formats': ('S1', 'i4', 'f4')})

• comments注释。
• delimiter分隔符，默认是空格。
• skiprows跳过前几行读取，默认是0，必须是int整型。
• usecols：要读取哪些列，0是第一列。例如，usecols = （1,4,5）将提取第2，第5和第6列。默认读取所有列。
• unpack如果为True，将分列读取。
  所以这里对数据进行清洗是采用float(s or 0)！

夏皮罗-威尔克检验法可以对正态性进行检验。相应的Scipy函数将返回一个元组，其中第一个元素是一个检验统计量，第二个数值是p值（这点后面说）。需要注意的是，这种填满了0的数组会引发警告。

Anderson-Darling检验可以检验正态分布以及其他分布，如指数分布、对数分布和冈贝尔分布等。相关的Scipy函数设计一个检验统计量和一个数组，该数组存放了百分之15、10、5、2.5和1等显著性水平所对应的临界值。如果该统计量大于显著性水平的临界值。就可以判断它不具有正态性。

Scipy的normaltest()函数还是闲了D‘Agostino检验和Pearson检验功能。这个函数返回的元素和shapiro()函数一样，也包括一个统计量和P值。这里的P值是双边卡方概率，卡方分布是另一种著名的分布，这种检验本身是基于偏度和峰度检验的z分数的。偏度系数用来表示分布的对称程度的，这样，由于正态分布是对称的，所以偏度洗漱为0。峰度洗漱描述的是分布的形状。

这里看着有些蒙！知乎上有一个对P值的解释：
https://www.zhihu.com/question/23149768
我的理解就是我们可以用正态分布的规律去看待一件事，但是我们很难得到一个结论，所以我们需要一个“显著水平”作为分界线去区别正态分布，认为这不是一个随机规律事件，比如硬币抛很多次以后，正+反等于1，但是我可以通过上述的分析证明这是个偶发事件还是随机几率事件。当然我没查资料，只是自己的理解，不一定正确~。

3.6创建掩码式NumPy数组

数据常常是凌乱的，并且含有空白项或者无法处理的字符，好在掩码式数组可以忽略残缺的或无效的数据点。NumPy.ma子程序包提供的掩码式数组隶属于ndarray，带有一个掩码。

import numpy
import scipy.misc  
import scipy
import matplotlib.pyplot as plt

ascent = scipy.misc.ascent()
random_mask = numpy.random.randint(0, 2, size = ascent.shape)
plt.subplot(221)
plt.title("Original")
plt.imshow(ascent)
plt.axis('off')

masked_array = numpy.ma.array(ascent, mask = random_mask)
print(masked_array)

plt.subplot(222)
plt.title("Masked")
plt.imshow(masked_array)
plt.axis("off")

plt.subplot(223)
plt.title("Log")
plt.imshow(numpy.log(ascent))
plt.axis("off")

plt.subplot(224)
plt.title("Log Masked")
plt.imshow(numpy.log(masked_array))
plt.axis('off')

plt.show()

输出结果：

[[83 83 83 ... 117 -- 117]
 [-- 82 83 ... -- -- --]
 [-- 81 -- ... -- -- 117]
 ...
 [-- -- 178 ... -- 59 --]
 [178 178 178 ... -- -- 57]
 [-- 178 -- ... 57 -- 58]]

1.创建一个掩码
为了得到一个掩码式数组，必须规定一个掩码。下面将生成一个随机掩码，这个掩码的取值非0即1。

random_mask = numpy.random.randint(0, 2, size = ascent.shape)

2.创建一个掩码式数组

masked_array = numpy.ma.array(ascent, mask = random_mask)

给NumPy数组附加了一个随机掩码，这样，与该掩码相对应的数据就会被忽略不计。在numpy.ma子程序包为处理掩码式数组提供了除此之外的各种所需函数。

忽略负值和极值
当希望忽略负值，如对数组的值取对数时，掩码式数组将会非常有用；此外，剔除异常数据时，也会用到掩码式数组。
下面以美国职业棒球大联盟选手的薪金数据为例，来说明这些技术的应用方法。文件还是从百度网盘下载。

import numpy as np
from datetime import date
import sys
import matplotlib.pyplot as plt

salary = np.loadtxt("C:/Users/Administrator/Desktop/MLB2008.csv", delimiter = ',', usecols = (1,),
                    skiprows = 1, unpack = True)
triples = np.arange(0, len(salary), 3)
print("Triples", triples[:10], '...')

signs = np.ones(len(salary))
print("Signs", signs[:10], "...")

signs[triples] = -1
print("Signs", signs[:10], '...')

ma_log = np.ma.log(salary * signs)
print("Masked logs", ma_log[:10], '...')

dev = salary.std()
avg = salary.mean()
inside = np.ma.masked_outside(salary, avg - dev, avg + dev)
print("Inside", inside[:10], '...')

plt.subplot(311)
plt.title("Original")
plt.plot(salary)

plt.subplot(312)
plt.title("Log Masked")
plt.plot(np.exp(ma_log))

plt.subplot(313)
plt.title("Not Extreme")
plt.plot(inside)

plt.tight_layout()    #设置默认的间距
plt.show()

输出结果

Triples [ 0  3  6  9 12 15 18 21 24 27] ...
Signs [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.] ...
Signs [-1.  1.  1. -1.  1.  1. -1.  1.  1. -1.] ...
Masked logs [-- 14.970818190308929 15.830413578506539 -- 13.458835614025542
 15.319587954740548 -- 15.648092021712584 13.864300722133706 --] ...
Inside [3750000.0 3175000.0 7500000.0 3000000.0 700000.0 4500000.0 3000000.0
 6250000.0 1050000.0 4600000.0] ...

1.对负数取对数
可以对含有负数的数组取对数。首先创建一个数组，存放可以被3整除的数字。
然后生成一个元素值全为1且大小与薪金数据数组相等的数组。
借助与第二章NumPy数组中学到的技巧，可以将下标是3的背书的数组元素的值取反。
最终就可以对这个数组取对数了。
2.忽略极值
此处规定：所谓异常值，就是在平均值一个标准差以下或者在平均值一个标准差以上的那些数值。所以上述代码的规则基于此。
numpy.ma子程序包中的函数可以屏蔽数组中被视为无效的元素，如无法应用与log()和aqrt()函数的负值元素，被屏蔽的值类似于关系数据库和程序设计中的NULL值，对被屏蔽的值进行计算时，给它的都是一个屏蔽后的值。

我的理解是这里先给这个数据隔三个就变成负值，就是为了显示掩码处理不正常数据的能力，同时排除定义的离散极值，强行处理数据。

3.7小结

本章学习了多种NumPy和Scipy子库，回顾了线性代数、统计学、连续和离散分布、掩码式数组和随机数等方面的内容。