KLucenの启示录

经典的三大神器#

1. NumPy：支持常见的数组和矩阵操作，通过ndarray类实现了对多维数组的封装，提供了操作这些数组的方法和函数。由于 NumPy 内置了并行运算功能，当使用多核 CPU 时，NumPy 会自动做并行计算。
2. Pandas：pandas 的核心是其特有的数据结构DataFrame和Series，这使得 pandas 可以处理包含不同类型数据的表格和时间序列，这一点是 NumPy 的ndarray做不到的。使用 pandas，可以轻松顺利的加载各种形式的数据，然后对数据进行切片、切块、重塑、清洗、聚合、呈现等操作。
3. Matplotlib：matplotlib 是一个包含各种绘图模块的库，能够根据我们提供的数据创建高质量的图表。此外，matplotlib 还提供了 pylab 模块，这个模块包含了很多像 MATLAB 一样的绘图组件。

其他相关库#

1. SciPy：完善了 NumPy 的功能，封装了大量科学计算的算法，包括线性代数、统计检验、稀疏矩阵、信号和图像处理、最优化问题、快速傅里叶变换等。
2. Polars：一个高性能的数据分析库，旨在提供比 pandas 更快的数据操作。它支持大规模数据处理，并能够利用多核 CPU 来加速计算，在处理大规模数据集时可以用来替代 pandas。
3. Seaborn：seaborn 是基于 matplotlib 的图形可视化工具，直接使用 matplotlib 虽然可以定制出漂亮的统计图表，但是总体来说还不够简单方便，seaborn 相当于是对 matplotlib 做了封装，让用户能够以更简洁有效的方式做出各种有吸引力的统计图表。
4. Scikit-learn：scikit-learn 最初是 SciPy 的一部分，提供了大量机器学习可能用到的工具，包括数据预处理、监督学习（分类、回归）、无监督学习（聚类）、模式选择、交叉检验等。
5. Statsmodels：包含了经典统计学和计量经济学算法的库，帮助帮助用户完成数据探索、回归分析、假设检验等任务。
6. PySpark：Apache Spark（大数据处理引擎）的 Python 版本，用于大规模数据处理和分布式计算，能够在分布式环境中高效地进行数据清洗、转化和分析。
7. Tensorflow：TensorFlow 是一个开源的深度学习框架，由 Google 开发，主要面向深度学习任务，常用于构建和训练机器学习模型（尤其是复杂的神经网络模型）。
8. Keras：Keras 是一个高层次的神经网络 API，主要用于构建和训练深度学习模型。Keras 适合深度学习初学者和研究人员，因为它让构建和训练神经网络变得更加简单。
9. PyTorch：PyTorch 是一个开源的深度学习框架，由 Facebook 开发，广泛用于研究和生产环境。PyTorch 是深度学习研究中的热门框架，在计算机视觉、自然语言处理等领域得到了广泛应用。
10. NLTK / SpaCy：自然语言处理（NLP）库。

conda命令#

对于非新手用户，如果希望使用 conda 工具来管理依赖项或者创建项目的虚拟环境，可以在终端或命令行提示符中使用 conda 命令。Windows 用户可以在“开始菜单”中找到“Anaconda3”，然后点击“Anaconda Prompt”或“Anaconda PowerShell”来启动支持 conda 的命令行提示符。新手用户如果想创建新的虚拟环境或管理三方库（依赖项），建议直接使用“Anaconda-Navigator”中的“Environments”，通过可视化的方式对虚拟环境和依赖项进行管理。

1. 版本和帮助信息。

   • 查看版本：conda -V或conda --version
   • 获取帮助：conda -h或conda --help
   • 相关信息：conda list

2. 虚拟环境相关。

   • 显示所有虚拟环境：conda env list
   • 创建虚拟环境：conda create --name venv
   • 指定 Python 版本创建虚拟环境：conda create --name venv python=3.7
   • 指定 Python 版本创建虚拟环境并安装指定依赖项：conda create --name venv python=3.7 numpy pandas
   • 通过克隆现有虚拟环境的方式创建虚拟环境：conda create --name venv2 --clone venv
   • 分享虚拟环境并重定向到指定的文件中：conda env export > environment.yml
   • 通过分享的虚拟环境文件创建虚拟环境：conda env create -f environment.yml
   • 激活虚拟环境：conda activate venv
   • 退出虚拟环境：conda deactivate
   • 删除虚拟环境：conda remove --name venv --all

   说明：上面的命令中，venv和venv2是虚拟环境文件夹的名字，可以将其替换为自己喜欢的名字，但是强烈建议使用英文且不要有特殊字符。

3. 包（三方库或工具）管理。

   • 查看已经安装的包：conda list
   • 搜索指定的包：conda search matplotlib
   • 安装指定的包：conda install matplotlib
   • 更新指定的包：conda update matplotlib
   • 移除指定的包：conda remove matplotlib

   说明：在搜索、安装和更新软件包时，默认会连接到官方网站进行操作，如果觉得速度不给力，可以将默认的官方网站替换为国内的镜像网站，推荐使用清华大学的开源镜像网站。将默认源更换为国内镜像的命令是：conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/和conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main。如果需要换回默认源，可以使用命令conda config --remove-key channels。

安装和启动#

如果已经安装了 Anaconda，可以按照上面所说的方式在“Anaconda-Navigator”中直接启动 Notebook 或 JupyterLab。按照官方的说法，JupyterLab 是下一代的 Notebook，提供了更友好的界面和更强大的功能，我们也推荐大家使用 JupyterLab。Windows 用户也可以在开始菜单中打开“Anaconda Prompt”或“Anaconda PowerShell”，由于已经激活了 Anaconda 默认的虚拟环境，只需要输入jupyter lab命令来启动JupyterLab。macOS 系统在安装 Anaconda以后，每次打开终端时会自动激活 Anaconda 默认的虚拟环境，也是通过输入jupyter lab命令就可以启动JupyterLab。

对于安装了 Python 环境但是没有安装 Anaconda 的用户，可以用 Python 的包管理工具pip来安装 JupyterLab，安装成功后在终端或命令行提示符中执行jupyter lab命令来启动 JupyterLab，如下所示。

安装 JupyterLab：

1
pip install jupyterlab

安装 Python 数据分析三大神器：

1
pip install numpy pandas matplotlib

启动 JupyterLab：

1
jupyter lab

JupyterLab 是基于网页的用于交互计算的应用程序，可以用于代码开发、文档撰写、代码运行和结果展示。简单的说，你可以在网页中直接编写代码和运行代码，代码的运行结果也会直接在代码块下方进行展示。如在编写代码的过程中需要编写说明文档，可在同一个页面中使用 Markdown 格式进行编写，而且可以直接看到渲染后的效果。此外，Notebook 的设计初衷是提供一个能够支持多种编程语言的工作环境，目前它能够支持超过40种编程语言，包括 Python、R、Julia、Scala 等。

首先，我们可以创建一个用于书写 Python 代码的 Notebook，如下图所示。

接下来，我们就可以编写代码、撰写文档和运行程序啦，如下图所示。

使用技巧#

如果使用 Python 做工程化的项目开发，PyCharm 肯定是最好的选择，它提供了一个集成开发环境应该具有的所有功能，尤其是智能提示、代码补全、自动纠错这类功能会让开发人员感到非常舒服。如果使用 Python 做数据科学相关的工作，JupyterLab 并不比 PyCharm 逊色，在数据和图表展示方面 JupyterLab 更加优秀。为此，JetBrains 公司还专门开发了一个对标 JupyterLab 的新工具 DataSpell，有兴趣的读者可以自行了解。下面我们为大家介绍一些 JupyterLab 的使用技巧，希望能够帮助大家提升工作效率。

1. 自动补全。在使用 JupyterLab 编写代码时，按Tab键会获得代码提示和补全功能。

2. 获得帮助。如果希望了解一个对象（如变量、类、函数等）的相关信息或使用方式，可以在对象后面使用?并运行代码， 窗口下方会显示出对应的信息，帮助我们了解该对象，如下所示。

   

3. 搜索命名。如果只记得一个类或一个函数名字的一部分，可以使用通配符*并配合?进行搜索，如下所示。

   

4. 调用命令。可以在 JupyterLab 中使用!后面跟系统命令的方式来执行系统命令。

5. 魔法指令。JupyterLab 中有很多非常有趣且有用的魔法指令，例如可以使用%timeit测试语句的执行时间，可以使用%pwd查看当前工作目录等。如果想查看所有的魔法指令，可以使用%lsmagic，如果了解魔法指令的用法，可以使用%magic来查看，如下图所示。

   

   常用的魔法指令有：

   魔法指令	功能说明
   %pwd	查看当前工作目录
   %ls	列出当前或指定文件夹下的内容
   %cat	查看指定文件的内容
   %hist	查看输入历史
   %matplotlib inline	设置在页面中嵌入matplotlib输出的统计图表
   %config Inlinebackend.figure_format='svg'	设置统计图表使用SVG格式（矢量图）
   %run	运行指定的程序
   %load	加载指定的文件到单元格中
   %quickref	显示IPython的快速参考
   %timeit	多次运行代码并统计代码执行时间
   %prun	用cProfile.run运行代码并显示分析器的输出
   %who / %whos	显示命名空间中的变量
   %xdel	删除一个对象并清理所有对它的引用

6. 快捷键。JupyterLab 中的很多操作可以通过快捷键来实现，使用快捷键可以提升工作效率。JupyterLab 的快捷键可以分为命令模式下的快捷键和编辑模式下的快捷键，所谓编辑模式就是处于输入代码或撰写文档状态的模式，在编辑模式下按Esc可以回到命令模式，在命令模式下按Enter可以进入编辑模式。

   命令模式下的快捷键：

   快捷键	功能说明
   Alt + Enter	运行当前单元格并在下面插入新的单元格
   Shift + Enter	运行当前单元格并选中下方的单元格
   Ctrl + Enter	运行当前单元格
   j / k、Shift + j / Shift + k	选中下方/上方单元格、连续选中下方/上方单元格
   a / b	在下方/上方插入新的单元格
   c / x	复制单元格 / 剪切单元格
   v / Shift + v	在下方/上方粘贴单元格
   dd / z	删除单元格 / 恢复删除的单元格
   Shift + l	显示或隐藏当前/所有单元格行号
   Space / Shift + Space	向下/向上滚动页面

   编辑模式下的快捷键：

   快捷键	功能说明
   Shift + Tab	获得提示信息
   Ctrl + ]/ Ctrl + [	增加/减少缩进
   Alt + Enter	运行当前单元格并在下面插入新的单元格
   Shift + Enter	运行当前单元格并选中下方的单元格
   Ctrl + Enter	运行当前单元格
   Ctrl + Left / Right	光标移到行首/行尾
   Ctrl + Up / Down	光标移动代码开头/结尾处
   Up / Down	光标上移/下移一行或移到上/下一个单元格

   说明：对于 macOS 系统可以将Alt键替换成Option键，将Ctrl键替换成Command键。

创建数组对象#

创建ndarray对象有很多种方法，下面我们介绍一些常用的方法。

方法一：使用array函数，通过list创建数组对象

代码：

1
array1 = np.array([1, 2, 3, 4, 5])
2
array1

输出：

1
array([1, 2, 3, 4, 5])

代码：

1
array2 = np.array([[1, 2, 3], [4, 5, 6]])
2
array2

输出：

1
array([[1, 2, 3],
2
       [4, 5, 6]])

方法二：使用arange函数，指定取值范围和跨度创建数组对象

代码：

1
array3 = np.arange(0, 20, 2)
2
array3

输出：

1
array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])

方法三：使用linspace函数，用指定范围和元素个数创建数组对象，生成等差数列

代码：

1
array4 = np.linspace(-1, 1, 11)
2
array4

输出：

1
array([-1. , -0.8, -0.6, -0.4, -0.2,  0. ,  0.2,  0.4,  0.6,  0.8,  1. ])

方法四：使用logspace函数，生成等比数列

代码：

1
array5 = np.logspace(1, 10, num=10, base=2)
2
array5

注意：等比数列的起始值是 $\small{2^1}$ ，等比数列的终止值是 $\small{2^{10}}$ ，num是元素的个数，base就是底数。

输出：

1
array([   2.,    4.,    8.,   16.,   32.,   64.,  128.,  256.,  512., 1024.])

方法五：通过fromstring函数从字符串提取数据创建数组对象

代码：

1
array6 = np.fromstring('1, 2, 3, 4, 5', sep=',', dtype='i8')
2
array6

输出：

1
array([1, 2, 3, 4, 5])

方法六：通过fromiter函数从生成器（迭代器）中获取数据创建数组对象

代码：

1
def fib(how_many):
2
    a, b = 0, 1
3
    for _ in range(how_many):
4
        a, b = b, a + b
5
        yield a
6

7

8
gen = fib(20)
9
array7 = np.fromiter(gen, dtype='i8')
10
array7

输出：

1
array([   1,    1,    2,    3,    5,    8,   13,   21,   34,   55,   89,
2
        144,  233,  377,  610,  987, 1597, 2584, 4181, 6765])

方法七：使用numpy.random模块的函数生成随机数创建数组对象

产生 10 个 $\small{[0, 1)}$ 范围的随机小数，代码：

1
array8 = np.random.rand(10)
2
array8

输出：

1
array([0.45556132, 0.67871326, 0.4552213 , 0.96671509, 0.44086463,
2
       0.72650875, 0.79877188, 0.12153022, 0.24762739, 0.6669852 ])

产生 10 个 $\small{[1, 100)}$ 范围的随机整数，代码：

1
array9 = np.random.randint(1, 100, 10)
2
array9

输出：

1
array([29, 97, 87, 47, 39, 19, 71, 32, 79, 34])

产生 20 个 $\small{\mu=50}$ ， $\small{\sigma=10}$ 的正态分布随机数，代码：

1
array10 = np.random.normal(50, 10, 20)
2
array10

输出：

1
array([55.04155586, 46.43510797, 20.28371158, 62.67884053, 61.23185964,
2
       38.22682148, 53.17126151, 43.54741592, 36.11268017, 40.94086676,
3
       63.27911699, 46.92688903, 37.1593374 , 67.06525656, 67.47269463,
4
       23.37925889, 31.45312239, 48.34532466, 55.09180924, 47.95702787])

产生 $\small{[0, 1)}$ 范围的随机小数构成的 3 行 4 列的二维数组，代码：

1
array11 = np.random.rand(3, 4)
2
array11

输出：

1
array([[0.54017809, 0.46797771, 0.78291445, 0.79501326],
2
       [0.93973783, 0.21434806, 0.03592874, 0.88838892],
3
       [0.84130479, 0.3566601 , 0.99935473, 0.26353598]])

产生 $\small{[1, 100)}$ 范围的随机整数构成的三维数组，代码：

1
array12 = np.random.randint(1, 100, (3, 4, 5))
2
array12

输出：

1
array([[[94, 26, 49, 24, 43],
2
        [27, 27, 33, 98, 33],
3
        [13, 73,  6,  1, 77],
4
        [54, 32, 51, 86, 59]],
5

6
       [[62, 75, 62, 29, 87],
7
        [90, 26,  6, 79, 41],
8
        [31, 15, 32, 56, 64],
9
        [37, 84, 61, 71, 71]],
10

11
       [[45, 24, 78, 77, 41],
12
        [75, 37,  4, 74, 93],
13
        [ 1, 36, 36, 60, 43],
14
        [23, 84, 44, 89, 79]]])

方法八：创建全0、全1或指定元素的数组

使用zeros函数，代码：

1
array13 = np.zeros((3, 4))
2
array13

输出：

1
array([[0., 0., 0., 0.],
2
       [0., 0., 0., 0.],
3
       [0., 0., 0., 0.]])

使用ones函数，代码：

1
array14 = np.ones((3, 4))
2
array14

输出：

1
array([[1., 1., 1., 1.],
2
       [1., 1., 1., 1.],
3
       [1., 1., 1., 1.]])

使用full函数，代码：

1
array15 = np.full((3, 4), 10)
2
array15

输出：

1
array([[10, 10, 10, 10],
2
       [10, 10, 10, 10],
3
       [10, 10, 10, 10]])

方法九：使用eye函数创建单位矩阵

代码：

1
np.eye(4)

输出：

1
array([[1., 0., 0., 0.],
2
       [0., 1., 0., 0.],
3
       [0., 0., 1., 0.],
4
       [0., 0., 0., 1.]])

方法十：读取图片获得对应的三维数组

代码：

1
array16 = plt.imread('guido.jpg')
2
array16

输出：

1
array([[[ 36,  33,  28],
2
        [ 36,  33,  28],
3
        [ 36,  33,  28],
4
        ...,
5
        [ 32,  31,  29],
6
        [ 32,  31,  27],
7
        [ 31,  32,  26]],
8

9
       [[ 37,  34,  29],
10
        [ 38,  35,  30],
11
        [ 38,  35,  30],
12
        ...,
13
        [ 31,  30,  28],
14
        [ 31,  30,  26],
15
        [ 30,  31,  25]],
16

17
       [[ 38,  35,  30],
18
        [ 38,  35,  30],
19
        [ 38,  35,  30],
20
        ...,
21
        [ 30,  29,  27],
22
        [ 30,  29,  25],
23
        [ 29,  30,  25]],
24

25
       ...,
26

27
       [[239, 178, 123],
28
        [237, 176, 121],
29
        [235, 174, 119],
30
        ...,
31
        [ 78,  68,  56],
32
        [ 75,  67,  54],
33
        [ 73,  65,  52]],
34

35
       [[238, 177, 120],
36
        [236, 175, 118],
37
        [234, 173, 116],
38
        ...,
39
        [ 82,  70,  58],
40
        [ 78,  68,  56],
41
        [ 75,  66,  51]],
42

43
       [[238, 176, 119],
44
        [236, 175, 118],
45
        [234, 173, 116],
46
        ...,
47
        [ 84,  70,  61],
48
        [ 81,  69,  57],
49
        [ 79,  67,  53]]], dtype=uint8)

说明：上面的代码读取了当前路径下名为guido.jpg 的图片文件，计算机系统中的图片通常由若干行若干列的像素点构成，而每个像素点又是由红绿蓝三原色构成的，刚好可以用三维数组来表示。读取图片用到了matplotlib库的imread函数。

数组对象的属性#

size属性：获取数组元素个数。

代码：

1
array17 = np.arange(1, 100, 2)
2
array18 = np.random.rand(3, 4)
3
print(array16.size)
4
print(array17.size)
5
print(array18.size)

输出：

1
1125000
2
50
3
12

shape属性：获取数组的形状。

代码：

1
print(array16.shape)
2
print(array17.shape)
3
print(array18.shape)

输出：

1
(750, 500, 3)
2
(50,)
3
(3, 4)

dtype属性：获取数组元素的数据类型。

代码：

1
print(array16.dtype)
2
print(array17.dtype)
3
print(array18.dtype)

输出：

1
uint8
2
int64
3
float64

ndarray对象元素的数据类型可以参考如下所示的表格。

ndim属性：获取数组的维度。

代码：

1
print(array16.ndim)
2
print(array17.ndim)
3
print(array18.ndim)

输出：

1
3
2
1
3
2

itemsize属性：获取数组单个元素占用内存空间的字节数。

代码：

1
print(array16.itemsize)
2
print(array17.itemsize)
3
print(array18.itemsize)

输出：

1
1
2
8
3
8

nbytes属性：获取数组所有元素占用内存空间的字节数。

代码：

1
print(array16.nbytes)
2
print(array17.nbytes)
3
print(array18.nbytes)

输出：

1
1125000
2
400
3
96

数组的索引运算#

和 Python 中的列表类似，NumPy 的ndarray对象可以进行索引和切片操作，通过索引可以获取或修改数组中的元素，通过切片操作可以取出数组的一部分，我们把切片操作也称为切片索引。

1
array19 = np.arange(1, 10)
2
print(array19[0], array19[array19.size - 1])
3
print(array19[-array20.size], array19[-1])

1
1 9
2
1 9

1
array20 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
2
array20[2]

1
array([7, 8, 9])

1
print(array20[0][0])
2
print(array20[-1][-1])

1
1
2
9

1
print(array20[1][1])
2
print(array20[1, 1])

1
5
2
5

1
array20[1][1] = 10
2
array20

1
array([[ 1,  2,  3],
2
       [ 4, 10,  6],
3
       [ 7,  8,  9]])

1
array20[1] = [10, 11, 12]
2
array20

1
array([[ 1,  2,  3],
2
       [10, 11, 12],
3
       [ 7,  8,  9]])

切片索引#

切片索引是形如[开始索引:结束索引:跨度]的语法，通过指定开始索引（默认值无穷小）、结束索引（默认值无穷大）和跨度（默认值1），从数组中取出指定部分的元素并构成新的数组。因为开始索引、结束索引和步长都有默认值，所以它们都可以省略，如果不指定步长，第二个冒号也可以省略。一维数组的切片运算跟 Python 中的list类型的切片非常类似，此处不再赘述，二维数组的切片可以参考下面的代码，相信非常容易理解。

代码：

1
array20[:2, 1:]

输出：

1
array([[ 2,  3],
2
       [11, 12]])

代码：

1
array20[2, :]

输出：

1
array([7, 8, 9])

代码：

1
array20[2:, :]

输出：

1
array([[7, 8, 9]])

代码：

1
array20[:, :2]

输出：

1
array([[ 1,  2],
2
       [10, 11],
3
       [ 7,  8]])

代码：

1
array20[::2, ::2]

输出：

1
array([[1, 3],
2
       [7, 9]])

代码：

1
array20[::-2, ::-2]

输出：

1
array([[9, 7],
2
       [3, 1]])

关于数组的索引和切片运算，大家可以通过下面的两张图来增强印象，这两张图来自《利用Python进行数据分析》一书，它是 pandas 库的作者 Wes McKinney 撰写的 Python 数据分析领域的经典教科书，有兴趣的读者可以购买和阅读原书。

图1：二维数组的普通索引

图2：二维数组的切片索引

1
array19[[0, 1, 1, -1, 4, -1]]

1
array([1, 2, 2, 9, 5, 9])

1
array20[[0, 2]]

1
array([[1, 2, 3],
2
       [7, 8, 9]])

1
array20[[0, 2], [1, 2]]

1
array([2, 9])

1
array20[[0, 2], 1]

1
array([2, 8])

1
array19[[True, True, False, False, True, False, False, True, True]]

1
array([1, 2, 5, 8, 9])

1
array19 > 5

1
array([False, False, False, False, False,  True,  True,  True,  True])

1
~(array19 > 5)

1
array([ True,  True,  True,  True,  True, False, False, False, False])

1
array19[array19 > 5]

1
array([6, 7, 8, 9])

1
array19 % 2 == 0

1
array([False,  True, False,  True, False,  True, False,  True, False])

1
array19[array19 % 2 == 0]

1
array([2, 4, 6, 8])

1
(array19 > 5) & (array19 % 2 == 0)

1
array([False, False, False, False, False,  True, False,  True, False])

1
array19[(array19 > 5) & (array19 % 2 == 0)]

1
array([6, 8])

1
array19[(array19 > 5) | (array19 % 2 == 0)]

1
array([2, 4, 6, 7, 8, 9])

1
array20[array21 % 2 != 0]

1
array([1, 3, 5, 7, 9])

案例：通过数组切片处理图像#

学习基础知识总是比较枯燥且没有成就感的，所以我们还是来个案例为大家演示下上面学习的数组索引和切片操作到底有什么用。前面我们说到过，可以用三维数组来表示图像，那么通过图像对应的三维数组进行操作，就可以实现对图像的处理，如下所示。

读入图片创建三维数组对象。

1
guido_image = plt.imread('guido.jpg')
2
plt.imshow(guido_image)

对数组的0轴进行反向切片，实现图像的垂直翻转。

1
plt.imshow(guido_image[::-1])

对数组的1轴进行反向切片，实现图像的水平翻转。

1
plt.imshow(guido_image[:,::-1])

通过切片操作实现抠图，将吉多大叔的头抠出来。

1
plt.imshow(guido_image[30:350, 90:300])

通过切片操作实现降采样。

1
plt.imshow(guido_image[::10, ::10])

获取描述统计信息#

描述统计信息主要包括数据的集中趋势、离散程度和频数分析等，其中集中趋势主要看均值和中位数，离散程度可以看极值、方差、标准差等。

1
array1 = np.random.randint(1, 100, 10)
2
array1

输出：

1
array([46, 51, 15, 42, 53, 71, 20, 62,  6, 94])

计算总和、均值和中位数。

代码：

1
print(array1.sum())
2
print(np.sum(array1))
3
print(array1.mean())
4
print(np.mean(array1))
5
print(np.median(array1))
6
print(np.quantile(array1, 0.5))

说明：上面代码中的mean、median和quantile分别是 NumPy 中计算算术平均值、中位数和分位数的函数，其中quantitle函数的第二个参数设置为0.5表示计算50%分位数，也就是中位数。

输出：

1
460
2
460
3
46.0
4
46.0
5
48.5
6
48.5

极值、全距和四分位距离。

代码：

1
print(array1.max())
2
print(np.amax(array1))
3
print(array1.min())
4
print(np.amin(array1))
5
print(np.ptp(array1))
6
print(np.ptp(array1))
7
q1, q3 = np.quantile(array1, [0.25, 0.75])
8
print(q3 - q1)

输出：

1
94
2
94
3
6
4
6
5
88
6
88
7
34.25

方差、标准差和变异系数。

代码：

1
print(array1.var())
2
print(np.var(array1))
3
print(array1.std())
4
print(np.std(array1))
5
print(array1.std() / array1.mean())

输出：

1
651.2
2
651.2
3
25.51862065237853
4
25.51862065237853
5
0.5547526228777941

绘制箱线图。

箱线图又称为盒须图，是显示一组数据分散情况的统计图，因形状如箱子而得名。 它主要用于反映原始数据分布的特征，还可以进行多组数据分布特征的比较。

代码：

1
plt.boxplot(array1, showmeans=True)
2
plt.ylim([-20, 120])
3
plt.show()

输出：

值得注意的是，对于二维或更高维的数组，在获取描述统计信息时，可以通过名为axis的参数指定均值、方差等运算是沿着哪一个轴来执行，axis参数不同，执行的结果可能是大相径庭的，如下所示。

代码：

1
array2 = np.random.randint(60, 101, (5, 3))
2
array2

输出：

1
array([[72, 64, 73],
2
       [61, 73, 61],
3
       [76, 85, 77],
4
       [97, 88, 90],
5
       [63, 93, 82]])

代码：

1
array2.mean()

输出：

1
77.0

代码：

1
array2.mean(axis=0)

输出：

1
array([73.8, 80.6, 76.6])

代码：

1
array2.mean(axis=1)

输出：

1
array([69.66666667, 65.        , 79.33333333, 91.66666667, 79.33333333])

代码：

1
array2.max(axis=0)

输出：

1
array([97, 93, 90])

代码：

1
array2.max(axis=1)

输出：

1
array([73, 73, 85, 97, 93])

再看看绘制箱线图，对于二维数组每一列都会产生一个统计图形，如下所示。

代码：

1
plt.boxplot(array2, showmeans=True)
2
plt.ylim([-20, 120])
3
plt.show()

输出：

说明：箱线图中的小圆圈用来表示离群点，也就是大于 $\small{Q_3 + 1.5 \times IQR}$ 或小于 $\small{Q_1 - 1.5 \times IQR}$ 的值。公式中的常量 1.5 可以通过绘制箱线图的boxplot函数的whis参数进行修改，常用的值是 1.5 和 3，修改为 3 通常是为了标识出极度离群点。

需要说明的是，NumPy 的数组对象并没有提供计算几何平均值、调和平均值、去尾平均值等的方法，如果有这方面的需求，可以使用名为 scipy 的三方库，它的stats模块中提供了这些函数。此外，该模块还提供了计算众数、变异系数、偏态、峰度的函数，代码如下所示。

代码：

1
from scipy import stats
2

3
print(np.mean(array1))                # 算术平均值
4
print(stats.gmean(array1))            # 几何平均值
5
print(stats.hmean(array1))            # 调和平均值
6
print(stats.tmean(array1, [10, 90]))  # 去尾平均值
7
print(stats.variation(array1))        # 变异系数
8
print(stats.skew(array1))             # 偏态系数
9
print(stats.kurtosis(array1))         # 峰度系数

输出：

1
46.0
2
36.22349548825599
3
24.497219530825497
4
45.0
5
0.5547526228777941
6
0.11644192634527782
7
-0.7106251396024126

其他相关方法概述#

1. all() / any()方法：判断数组是否所有元素都是True / 判断数组是否有为True的元素。

2. astype()方法：拷贝数组，并将数组中的元素转换为指定的类型。

3. reshape()方法：调整数组对象的形状。

4. dump()方法：保存数组到二进制文件中，可以通过 NumPy 中的load()函数从保存的文件中加载数据创建数组。

   代码：

   1
   array.dump('array1-data')
   2
   array3 = np.load('array1-data', allow_pickle=True)
   3
   array3

   输出：

   1
   array([46, 51, 15, 42, 53, 71, 20, 62,  6, 94])

5. tofile()方法：将数组对象写入文件中。

   1
   array1.tofile('array.txt', sep=',')

6. fill()方法：向数组中填充指定的元素。

7. flatten()方法：将多维数组扁平化为一维数组。

   代码：

   1
   array2.flatten()

   输出：

   1
   array([1, 2, 3, 4, 5, 6, 7, 8, 9])

8. nonzero()方法：返回非0元素的索引。

9. round()方法：对数组中的元素做四舍五入操作。

10. sort()方法：对数组进行就地排序。

    代码：

    1
    array1.sort()
    2
    array1

    输出：

    1
    array([ 6, 15, 20, 42, 46, 51, 53, 62, 71, 94])

11. swapaxes()和transpose()方法：交换数组指定的轴和转置。

    代码：

    1
    array2.swapaxes(0, 1)

    输出：

    1
    array([[1, 4, 7],
    2
           [2, 5, 8],
    3
           [3, 6, 9]])

    代码：

    1
    array2.transpose()

    输出：

    1
    array([[1, 4, 7],
    2
           [2, 5, 8],
    3
           [3, 6, 9]])

12. tolist()方法：将数组转成 Python 中的list。

    代码：

    1
    print(array2.tolist())
    2
    print(type(array2.tolist()))

    输出：

    1
    [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
    2
    <class 'list'>

数组跟标量的运算#

NumPy 的数组可以跟一个数值进行加、减、乘、除、求模、求幂等运算，对应的运算会作用到数组的每一个元素上，如下所示。

代码：

1
array1 = np.arange(1, 10)
2
print(array1 + 10)
3
print(array1 * 10)

输出：

1
[11 12 13 14 15 16 17 18 19]
2
[10 20 30 40 50 60 70 80 90]

除了上述的运算，关系运算也是没有问题的，之前讲布尔索引的时候已经遇到过了。

代码：

1
print(array1 > 5)
2
print(array1 % 2 == 0)

输出：

1
[False False False False False  True  True  True  True]
2
[False  True False  True False  True False  True False]

数组跟数组的运算#

NumPy 的数组跟数组也可以执行算术运算和关系运算，运算会作用于两个数组对应的元素上，这就要求两个数组的形状（shape属性）要相同，如下所示。

代码：

1
array2 = np.array([1, 1, 1, 2, 2, 2, 3, 3, 3])
2
print(array1 + array2)
3
print(array1 * array2)
4
print(array1 ** array2)

输出：

1
[ 2  3  4  6  7  8 10 11 12]
2
[ 1  2  3  8 10 12 21 24 27]
3
[  1   2   3  16  25  36 343 512 729]

代码：

1
print(array1 > array2)
2
print(array1 % array2 == 0)

输出：

1
[False  True  True  True  True  True  True  True  True]
2
[ True  True  True  True False  True False False  True]

通用一元函数#

NumPy 中通用一元函数的参数是一个数组对象，函数会对数组进行元素级的处理，例如：sqrt函数会对数组中的每个元素计算平方根，而log2函数会对数组中的每个元素计算以2为底的对数，代码如下所示。

代码：

1
print(np.sqrt(array1))
2
print(np.log2(array1))

输出：

1
[1.         1.41421356 1.73205081 2.         2.23606798 2.44948974
2
 2.64575131 2.82842712 3.        ]
3
[0.         1.         1.5849625  2.         2.32192809 2.5849625
4
 2.80735492 3.         3.169925  ]

表1：通用一元函数

通用二元函数#

NumPy 中通用二元函数的参数是两个数组对象，函数会对两个数组中的对应元素进行运算，例如：maximum函数会对两个数组中对应的元素找最大值，而power函数会对两个数组中对应的元素进行求幂操作，代码如下所示。

代码：

1
array3 = np.array([[4, 5, 6], [7, 8, 9]])
2
array4 = np.array([[1, 2, 3], [3, 2, 1]])
3
print(np.maximum(array3, array4))
4
print(np.power(array3, array4))

输出：

1
[[4 5 6]
2
 [7 8 9]]
3
[[  4  25 216]
4
 [343  64   9]]

表2：通用二元函数

说明：关于向量和矩阵的运算，我们在下一个章节加以说明。

广播机制#

上面数组运算的例子中，两个数组的形状（shape属性）是完全相同的，我们再来研究一下，两个形状不同的数组是否可以直接做二元运算或使用通用二元函数进行运算，请看下面的例子。

代码：

1
array5 = np.array([[0, 0, 0], [1, 1, 1], [2, 2, 2], [3, 3, 3]])
2
array6 = np.array([1, 2, 3])
3
array5 + array6

输出：

1
array([[1, 2, 3],
2
       [2, 3, 4],
3
       [3, 4, 5],
4
       [4, 5, 6]])

代码：

1
array7 = np.array([[1], [2], [3], [4]])
2
array5 + array7

输出：

1
array([[1, 1, 1],
2
       [3, 3, 3],
3
       [5, 5, 5],
4
       [7, 7, 7]])

通过上面的例子，我们发现形状不同的数组仍然有机会进行二元运算，但这不代表任意形状的数组都可以进行二元运算。简单的说，只有两个数组后缘维度相同或者后缘维度不同但其中一个数组后缘维度为1时，广播机制才会被触发。通过广播机制，NumPy 将两个原本形状不相同的数组变成形状相同，才能进行二元运算。所谓后缘维度，指的是数组形状（shape属性）从后往前看对应的部分，我们举例说明。

上图中，一个数组的形状是(4, 3)，另一个数组的形状是(3, )，从后往前看对应的部分都是3，属于后缘维度相同，可以应用广播机制，第二个数组会沿着缺失元素那个轴的方向去广播自己，最终让两个数组形状达成一致。

上图中，一个数组的形状是(3, 4, 2)，另一个数组的形状是(4, 2)，从后往前看对应的部分都是(4, 2)，属于后缘维度相同，可以应用广播机制，第二个数组会沿着缺失元素那个轴的方向去广播自己，最终让两个数组形状达成一致。

上图中，一个数组的形状是(4, 3)，另一个数组的形状是(4, 1)，这是后缘维度不相同的情况，但是第二个数组跟第一个数组不同的地方为1，第二个数组可以沿着为1 的那个轴广播自己，最终让两个数组形状达成一致。

思考：一个3行1列的二维数组和一个1行3列的二维数组能够执行加法运算吗？

向量的加法#

相同维度的向量可以相加得到一个新的向量，运算的方法是将向量的每个分量相加，如下所示。

向量的加法满足“平行四边形法则”，即两个向量 $\small{\boldsymbol{u}}$ 和 $\small{\boldsymbol{v}}$ 构成了平行四边形的两条邻边，相加的结果是平行四边形的对角线，如下图所示。

向量的数乘#

一个向量 $\small{\boldsymbol{v}}$ 可以和一个标量 $\small{k}$ 相乘，运算的方法是将向量中的每个分量与该标量相乘即可，如下所示。

我们可以用 NumPy 的数组来表示向量，向量的加法可以通过两个数组的加法来实现，向量的数乘可以通过数组和标量的乘法来实现，此处不再进行赘述。

向量的点积#

点积（dot product）是两个向量之间最为重要的运算之一，运算的方法是将两个向量对应分量的乘积求和，所以点积的结果是一个标量，其几何意义是两个向量的模乘以二者夹角的余弦如下所示。

假如我们用三维向量来表示用户对喜剧片、言情片和动作片这三类电影的偏好，我们用 1 到 5 的数字来表示喜欢的程度，其中 5 表示非常喜欢，4 表示比较喜欢，3 表示无感，2 表示比较反感，1 表示特别反感。那么，下面的向量表示用户非常喜欢喜剧片，特别反感言情片，对动作片不喜欢也不反感。

现在有两部电影上映了，一部属于言情喜剧片，一部属于喜剧动作片，我们把两部电影也通过3维向量的方式进行表示，如下所示。

如果现在我们需要向刚才的用户推荐一部电影，我们应该给他推荐哪一部呢？我们可以将代表用户的向量 $\small{\boldsymbol{u}}$ 和代表电影的向量 $\small{\boldsymbol{m_{1}}}$ 和 $\small{\boldsymbol{m_{2}}}$ 分别进行点积运算，再除以向量的模长，得到向量夹角的余弦值，余弦值越接近 1，说明向量的夹角越接近 0 度，也就是两个向量的相似度越高。很显然，我们应该向用户推荐跟他观影喜好相似度更高的电影。

大家可能会说，向量 $\small{\boldsymbol{m_{2}}}$ 代表的电影肉眼可见跟用户是更加匹配的。的确，对于一个三维向量我们凭借直觉也能够给出正确的答案，但是对于一个 $\small{n}$ 维向量，当 $\small{n}$ 的值非常大时，你还有信心凭借肉眼的观察和本能的直觉给出准确的答案吗？向量的点积可以通过dot函数来计算，而向量的模长可以通过 NumPy 的linalg模块中的norm函数来计算，代码如下所示。

1
u = np.array([5, 1, 3])
2
m1 = np.array([4, 5, 1])
3
m2 = np.array([5, 1, 5])
4
print(np.dot(u, m1) / (np.linalg.norm(u) * np.linalg.norm(m1)))  # 0.7302967433402214
5
print(np.dot(u, m2) / (np.linalg.norm(u) * np.linalg.norm(m2)))  # 0.9704311900788593

向量的叉积#

在二维空间，两个向量的叉积是这样定义的：