python必学库之NumPy库

川长思鸟来 2023-10-04 16:35 41阅读 0赞

### NumPy ###

#### NumPy简介： ####

NumPy(Numerical Python) 是 Python 语言的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。

**NumPy的应用**

NumPy 通常与 SciPy（Scientific Python）和 Matplotlib（绘图库）一起使用， 这种组合广泛用于替代 MatLab，是一个强大的科学计算环境，有助于我们通过 Python 学习数据科学或者机器学习。

SciPy 是一个开源的 Python 算法库和数学工具包。

SciPy 包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。

**官网地址**

*  NumPy 官网 http://www.numpy.org/
 *  NumPy 源代码：https://github.com/numpy/numpy
 *  SciPy 官网：https://www.scipy.org/
 *  SciPy 源代码：https://github.com/scipy/scipy

#### NumPy的安装 ####

**windows下安装**

pip3 install --user numpy scipy matplotlib

–user：指定在哪个用户下安装

默认下numpy的安装使用的是国外的服务器，速度会慢，推荐使用国内的镜像进行下载，比如阿里云，清华等

pip3 install numpy scipy matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple

**ubuntu下安装**

sudo apt-get install python-numpy

如果ubuntu下有多个python版本，还可以通过指定python的版本来指定安装给哪个版本的python，比如安装在朴有天hon下

sudo apt-get install python3-numpy

**CentOS下安装**

sudo dnf install numpy

**Mac下安装**

pip3 install numpy -i https://pypi.tuna.tsinghua.edu.cn/simple

#### NumPy Ndarray 对象 ####

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。

ndarray 对象是用于存放同类型元素的多维数组。

**实例化一个NumPy Ndarray对象**

只需调用 NumPy 的 array 函数

numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

**参数说明：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA_size_16_color_FFFFFF_t_70]

#### NumPy 数组属性 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA_size_16_color_FFFFFF_t_70 1]

**ndarray.ndim**：用于返回数组的维数，等于秩

import numpy as np 
     
    a = np.arange(24)  
    print (a.ndim)             # a 现只有一个维度
    # 现在调整其大小
    b = a.reshape(2,4,3)  # b 现在拥有三个维度
    print (b.ndim)

1
    3

**ndarray.shape**： 表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数

import numpy as np  
     
    a = np.array([[1,2,3],[4,5,6]])  
    print (a.shape)

(2, 3)

调整数组大小

import numpy as np 
     
    a = np.array([[1,2,3],[4,5,6]]) 
    a.shape =  (3,2)  
    print (a)

[[1 2]
     [3 4]
     [5 6]]

**除此之外，NumPy还提供了reshape方法可以调整数组的大小**

import numpy as np 
     
    a = np.array([[1,2,3],[4,5,6]]) 
    b = a.reshape(3,2)  
    print (b)

[[1, 2] 
     [3, 4] 
     [5, 6]]

#### NumPy 创建数组 ####

ndarray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建。

1.  **numpy.empty**：用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组
    
        numpy.empty(shape, dtype = float, order = 'C')
    
    **参数说明:**
    
    <table> 
     <thead> 
      <tr> 
       <th align="left">参数</th> 
       <th align="left">描述</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="left">shape</td> 
       <td align="left">数组形状</td> 
      </tr> 
      <tr> 
       <td align="left">dtype</td> 
       <td align="left">数据类型，可选</td> 
      </tr> 
      <tr> 
       <td align="left">order</td> 
       <td align="left">有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。</td> 
      </tr> 
     </tbody> 
    </table>
    
    **举例**：创建一个空数组
    
        import numpy as np 
        x = np.empty([3,2], dtype = int) 
        print (x)
    
    **注意** − 数组元素为随机值，因为它们未初始化。
2.  **numpy.zeros**：创建指定大小的数组，数组元素以 0 来填充
    
        numpy.zeros(shape, dtype = float, order = 'C')
    
    **参数说明：**
    
    <table> 
     <thead> 
      <tr> 
       <th align="left">参数</th> 
       <th align="left">描述</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="left">shape</td> 
       <td align="left">数组形状</td> 
      </tr> 
      <tr> 
       <td align="left">dtype</td> 
       <td align="left">数据类型，可选</td> 
      </tr> 
      <tr> 
       <td align="left">order</td> 
       <td align="left">‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组</td> 
      </tr> 
     </tbody> 
    </table>
    
    **举例:**
    
        import numpy as np
         
        # 默认为浮点数
        x = np.zeros(5) 
        print(x)
         
        # 设置类型为整数
        y = np.zeros((5,), dtype = np.int) 
        print(y)
         
        # 自定义类型
        z = np.zeros((2,2), dtype = [('x', 'i4'), ('y', 'i4')])  
        print(z)
    
        [0. 0. 0. 0. 0.]
        [0 0 0 0 0]
        [[(0, 0) (0, 0)]
         [(0, 0) (0, 0)]]
3.  **numpy.ones**：创建指定形状的数组，数组元素以 1 来填充
    
        numpy.ones(shape, dtype = None, order = 'C')
    
    **参数说明：**
    
    <table> 
     <thead> 
      <tr> 
       <th align="left">参数</th> 
       <th align="left">描述</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="left">shape</td> 
       <td align="left">数组形状</td> 
      </tr> 
      <tr> 
       <td align="left">dtype</td> 
       <td align="left">数据类型，可选</td> 
      </tr> 
      <tr> 
       <td align="left">order</td> 
       <td align="left">‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组</td> 
      </tr> 
     </tbody> 
    </table>
    
    **举例：**
    
        import numpy as np
         
        # 默认为浮点数
        x = np.ones(5) 
        print(x)
         
        # 自定义类型
        x = np.ones([2,2], dtype = int)
        print(x)
    
        [1. 1. 1. 1. 1.]
        [[1 1]
         [1 1]]
4.  **从已有的数组中创建数组**
    
    **numpy.asarray**：umpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个
    
        numpy.asarray(a, dtype = None, order = None)
    
    参数说明：
    
    <table> 
     <thead> 
      <tr> 
       <th align="left">参数</th> 
       <th align="left">描述</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="left">a</td> 
       <td align="left">任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组</td> 
      </tr> 
      <tr> 
       <td align="left">dtype</td> 
       <td align="left">数据类型，可选</td> 
      </tr> 
      <tr> 
       <td align="left">order</td> 
       <td align="left">可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。</td> 
      </tr> 
     </tbody> 
    </table>
    
    **举例：**
    
    **将列表转换为列表**
    
        import numpy as np 
         
        x =  [1,2,3] 
        a = np.asarray(x)  
        print (a)
    
        [1  2  3]
    
    **将元组转换为列表**
    
        import numpy as np 
         
        x =  (1,2,3) 
        a = np.asarray(x)  
        print (a)
    
        [1  2  3]
    
    将元组列表转换为列表
    
        import numpy as np 
         
        x =  [(1,2,3),(4,5)] 
        a = np.asarray(x)  
        print (a)
    
        [(1, 2, 3) (4, 5)]
    
    **numpy.fromiter** ：方法从可迭代对象中建立 ndarray 对象，返回一维数组
    
        numpy.fromiter(iterable, dtype, count=-1)
    
    **参数：**
    
    <table> 
     <thead> 
      <tr> 
       <th align="left">参数</th> 
       <th align="left">描述</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="left">iterable</td> 
       <td align="left">可迭代对象</td> 
      </tr> 
      <tr> 
       <td align="left">dtype</td> 
       <td align="left">返回数组的数据类型</td> 
      </tr> 
      <tr> 
       <td align="left">count</td> 
       <td align="left">读取的数据数量，默认为-1，读取所有数据</td> 
      </tr> 
     </tbody> 
    </table>
    
    **举例：**
    
        import numpy as np 
         
        # 使用 range 函数创建列表对象  
        list=range(5)
        it=iter(list)
         
        # 使用迭代器创建 ndarray 
        x=np.fromiter(it, dtype=float)
        print(x)
    
        [0. 1. 2. 3. 4.]
5.  **从已有的数组范围创建**
    
    **numpy.arange**
    
    numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象
    
        numpy.arange(start, stop, step, dtype)
    
    **参数：**
    
    <table> 
     <thead> 
      <tr> 
       <th align="left">参数</th> 
       <th align="left">描述</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="left"><code>start</code></td> 
       <td align="left">起始值，默认为<code>0</code></td> 
      </tr> 
      <tr> 
       <td align="left"><code>stop</code></td> 
       <td align="left">终止值（不包含）</td> 
      </tr> 
      <tr> 
       <td align="left"><code>step</code></td> 
       <td align="left">步长，默认为<code>1</code></td> 
      </tr> 
      <tr> 
       <td align="left"><code>dtype</code></td> 
       <td align="left">返回<code>ndarray</code>的数据类型，如果没有提供，则会使用输入数据的类型。</td> 
      </tr> 
     </tbody> 
    </table>
    
    **举例：**
    
    生成0-5的数组
    
        import numpy as np
         
        x = np.arange(5)  
        print (x)
    
        [0  1  2  3  4]
    
    设置返回类型为float
    
        import numpy as np
         
        # 设置了 dtype
        x = np.arange(5, dtype =  float)  
        print (x)
    
        [0.  1.  2.  3.  4.]
    
    设置了起始值、终止值及步长
    
        import numpy as np
        x = np.arange(10,20,2)  
        print (x)
    
        [10  12  14  16  18]
    
    **numpy.linspace** ：函数用于创建一个一维数组，数组是一个等差数列构成的
    
        np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
    
    **参数：**
    
    <table> 
     <thead> 
      <tr> 
       <th align="left">参数</th> 
       <th align="left">描述</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="left"><code>start</code></td> 
       <td align="left">序列的起始值</td> 
      </tr> 
      <tr> 
       <td align="left"><code>stop</code></td> 
       <td align="left">序列的终止值，如果<code>endpoint</code>为<code>true</code>，该值包含于数列中</td> 
      </tr> 
      <tr> 
       <td align="left"><code>num</code></td> 
       <td align="left">要生成的等步长的样本数量，默认为<code>50</code></td> 
      </tr> 
      <tr> 
       <td align="left"><code>endpoint</code></td> 
       <td align="left">该值为 <code>true</code> 时，数列中包含<code>stop</code>值，反之不包含，默认是True。</td> 
      </tr> 
      <tr> 
       <td align="left"><code>retstep</code></td> 
       <td align="left">如果为 True 时，生成的数组中会显示间距，反之不显示。</td> 
      </tr> 
      <tr> 
       <td align="left"><code>dtype</code></td> 
       <td align="left"><code>ndarray</code> 的数据类型</td> 
      </tr> 
     </tbody> 
    </table>
    
    **举例：**
    
    设置起始点为 1 ，终止点为 10，数列个数为 10
    
        import numpy as np
        a = np.linspace(1,10,10)
        print(a)
    
        [ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
    
    设置元素全部是1的等差数列
    
        import numpy as np
        a = np.linspace(1,1,10)
        print(a)
    
        [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
    
    **numpy.logspace**： 用于创建一个于等比数列
    
        np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
    
    **参数：**
    
    <table> 
     <thead> 
      <tr> 
       <th align="left">参数</th> 
       <th align="left">描述</th> 
      </tr> 
     </thead> 
     <tbody> 
      <tr> 
       <td align="left"><code>start</code></td> 
       <td align="left">序列的起始值为：base ** start</td> 
      </tr> 
      <tr> 
       <td align="left"><code>stop</code></td> 
       <td align="left">序列的终止值为：base ** stop。如果<code>endpoint</code>为<code>true</code>，该值包含于数列中</td> 
      </tr> 
      <tr> 
       <td align="left"><code>num</code></td> 
       <td align="left">要生成的等步长的样本数量，默认为<code>50</code></td> 
      </tr> 
      <tr> 
       <td align="left"><code>endpoint</code></td> 
       <td align="left">该值为 <code>true</code> 时，数列中中包含<code>stop</code>值，反之不包含，默认是True。</td> 
      </tr> 
      <tr> 
       <td align="left"><code>base</code></td> 
       <td align="left">对数 log 的底数。</td> 
      </tr> 
      <tr> 
       <td align="left"><code>dtype</code></td> 
       <td align="left"><code>ndarray</code> 的数据类型</td> 
      </tr> 
     </tbody> 
    </table>
    
    **举例：**
    
        import numpy as np
        a = np.logspace(0,9,10,base=2)
        print (a)
    
        [  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]

#### NumPy 切片和索引 ####

ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样

简单的举几个例子感感受一下：

import numpy as np
     
    a = np.arange(10)
    s = slice(2,7,2)   # 从索引 2 开始到索引 7 停止，间隔为2
    print (a[s])

[2  4  6]

**多维数组的索引提取**

import numpy as np
     
    a = np.array([[1,2,3],[3,4,5],[4,5,6]])
    print(a)
    # 从某个索引处开始切割
    print('从数组索引 a[1:] 处开始切割')
    print(a[1:])

[[1 2 3]
     [3 4 5]
     [4 5 6]]
    从数组索引 a[1:] 处开始切割
    [[3 4 5]
     [4 5 6]]

**通过 … 来提取**

import numpy as np
     
    a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
    print (a[...,1])   # 第2列元素
    print (a[1,...])   # 第2行元素
    print (a[...,1:])  # 第2列及剩下的所有元素

[2 4 5]
    [3 4 5]
    [[2 3]
     [4 5]
     [5 6]]

#### NumPy 高级索引 ####

**整数数组索引**

获取数组中(0,0)，(1,1)和(2,0)位置处的元素

import numpy as np 
     
    x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
    y = x[[0,1,2],  [0,1,0]]  
    print (y)

[1  4  5]

获取 4X3 数组中的四个角的元素。 行索引是 \[0,0\] 和 \[3,3\]，而列索引是 \[0,2\] 和 \[0,2\]

import numpy as np 
     
    x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
    print ('我们的数组是：' )
    print (x)
    print ('\n')
    rows = np.array([[0,0],[3,3]]) 
    cols = np.array([[0,2],[0,2]]) 
    y = x[rows,cols]  
    print  ('这个数组的四个角元素是：')
    print (y)

我们的数组是：
    [[ 0  1  2]
     [ 3  4  5]
     [ 6  7  8]
     [ 9 10 11]]
    
    这个数组的四个角元素是：
    [[ 0  2]
     [ 9 11]]

**相当于切片是：y = x\[ \[ \[ 0,0 \],\[ 0,2\] \] , \[ \[ 3,0 \],\[ 3,2\] \] \]**

**可以借助切片 : 或 … 与索引数组组合**

import numpy as np
     
    a = np.array([[1,2,3], [4,5,6],[7,8,9]])
    b = a[1:3, 1:3]
    c = a[1:3,[1,2]]
    d = a[...,1:]
    print(b)
    print(c)
    print(d)

[[5 6]
     [8 9]]
    [[5 6]
     [8 9]]
    [[2 3]
     [5 6]
     [8 9]]

**布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组**

import numpy as np 
     
    x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
    print ('我们的数组是：')
    print (x)
    print ('\n')
    # 现在我们会打印出大于 5 的元素  
    print  ('大于 5 的元素是：')
    print (x[x >  5])

我们的数组是：
    [[ 0  1  2]
     [ 3  4  5]
     [ 6  7  8]
     [ 9 10 11]]
    
    
    大于 5 的元素是：
    [ 6  7  8  9 10 11]

#### NumPy 广播(Broadcast) ####

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。

如果两个数组 a 和 b 形状相同，即满足 **a.shape == b.shape**，那么 a\*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。

import numpy as np 
     
    a = np.array([1,2,3,4]) 
    b = np.array([10,20,30,40]) 
    c = a * b 
    print (c)

[ 10  40  90 160]

**当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制**

import numpy as np 
     
    a = np.array([[ 0, 0, 0],
               [10,10,10],
               [20,20,20],
               [30,30,30]])
    b = np.array([1,2,3])
    print(a + b)

[[ 1  2  3]
     [11 12 13]
     [21 22 23]
     [31 32 33]]

#### NumPy 迭代数组 ####

NumPy 迭代器对象 **numpy.nditer** 提供了一种灵活访问一个或者多个数组元素的方式

import numpy as np
     
    a = np.arange(6).reshape(2,3)
    print ('原始数组是：')
    print (a)
    print ('\n')
    print ('迭代输出元素：')
    for x in np.nditer(a):
        print (x, end=", " )
    print ('\n')

原始数组是：
    [[0 1 2]
     [3 4 5]]
    
    
    迭代输出元素：
    0, 1, 2, 3, 4, 5,

**还可以通过设置参数来指定输出的排序方式**

import numpy as np
     
    a = np.arange(6).reshape(2,3)
    for x in np.nditer(a.T):
        print (x, end=", " )
    print ('\n')
     
    for x in np.nditer(a.T.copy(order='C')):
        print (x, end=", " )
    print ('\n')

0, 1, 2, 3, 4, 5, 
    
    0, 3, 1, 4, 2, 5,

**控制遍历顺序**

*  `for x in np.nditer(a, order='F'):`Fortran order，即是列序优先；
 *  `for x in np.nditer(a.T, order='C'):`C order，即是行序优先；

**修改数组中元素的值**

import numpy as np
     
    a = np.arange(0,60,5) 
    a = a.reshape(3,4)  
    print ('原始数组是：')
    print (a)
    print ('\n')
    for x in np.nditer(a, op_flags=['readwrite']): 
        x[...]=2*x 
    print ('修改后的数组是：')
    print (a)

原始数组是：
    [[ 0  5 10 15]
     [20 25 30 35]
     [40 45 50 55]]
    
    
    修改后的数组是：
    [[  0  10  20  30]
     [ 40  50  60  70]
     [ 80  90 100 110]]

#### NumPy的数组操作 ####

Numpy 中包含了一些函数用于处理数组，大概可分为以下几类：

*  修改数组形状
 *  翻转数组
 *  修改数组维度
 *  连接数组
 *  分割数组
 *  数组元素的添加与删除

**修改数组形状**

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>reshape</code></td> 
   <td align="left">不改变数据的条件下修改形状</td> 
  </tr> 
  <tr> 
   <td align="left"><code>flat</code></td> 
   <td align="left">数组元素迭代器</td> 
  </tr> 
  <tr> 
   <td align="left"><code>flatten</code></td> 
   <td align="left">返回一份数组拷贝，对拷贝所做的修改不会影响原始数组</td> 
  </tr> 
  <tr> 
   <td align="left"><code>ravel</code></td> 
   <td align="left">返回展开数组</td> 
  </tr> 
 </tbody> 
</table>

**numpy.reshape**

numpy.reshape 函数可以在不改变数据的条件下修改形状，格式如下： numpy.reshape(arr, newshape, order=‘C’)

*  `arr`：要修改形状的数组
 *  `newshape`：整数或者整数数组，新的形状应当兼容原有形状
 *  order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序。

**实例**

import numpy as np  
    a = np.arange(8) 
    print ('原始数组：') 
    print (a) print ('\n')  
    
    b = a.reshape(4,2) 
    print ('修改后的数组：') print (b)

输出结果如下：

原始数组：
    [0 1 2 3 4 5 6 7]
    
    修改后的数组：
    [[0 1]
     [2 3]
     [4 5]
     [6 7]]

#### numpy.ndarray.flat ####

numpy.ndarray.flat 是一个数组元素迭代器，实例如下:

**实例**

import numpy as np
     
    a = np.arange(9).reshape(3,3) 
    print ('原始数组：')
    for row in a:
        print (row)
     
    #对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
    print ('迭代后的数组：')
    for element in a.flat:
        print (element)

输出结果如下：

原始数组：
    [0 1 2]
    [3 4 5]
    [6 7 8]
    迭代后的数组：
    0
    1
    2
    3
    4
    5
    6
    7
    8

**numpy.ndarray.flatten**

numpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下：

ndarray.flatten(order='C')

参数说明：

*  order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘K’ – 元素在内存中的出现顺序。

**实例**

import numpy as np
     
    a = np.arange(8).reshape(2,4)
     
    print ('原数组：')
    print (a)
    print ('\n')
    # 默认按行
     
    print ('展开的数组：')
    print (a.flatten())
    print ('\n')
     
    print ('以 F 风格顺序展开的数组：')
    print (a.flatten(order = 'F'))

输出结果如下：

原数组：
    [[0 1 2 3]
     [4 5 6 7]]
    
    
    展开的数组：
    [0 1 2 3 4 5 6 7]
    
    
    以 F 风格顺序展开的数组：
    [0 4 1 5 2 6 3 7]

**numpy.ravel**

numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。

该函数接收两个参数：

numpy.ravel(a, order='C')

参数说明：

*  order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘K’ – 元素在内存中的出现顺序。

**实例**

import numpy as np
     
    a = np.arange(8).reshape(2,4)
     
    print ('原数组：')
    print (a)
    print ('\n')
     
    print ('调用 ravel 函数之后：')
    print (a.ravel())
    print ('\n')
     
    print ('以 F 风格顺序调用 ravel 函数之后：')
    print (a.ravel(order = 'F'))

输出结果如下：

原数组：
    [[0 1 2 3]
     [4 5 6 7]]
    
    
    调用 ravel 函数之后：
    [0 1 2 3 4 5 6 7]
    
    
    以 F 风格顺序调用 ravel 函数之后：
    [0 4 1 5 2 6 3 7]

**翻转数组**

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>transpose</code></td> 
   <td align="left">对换数组的维度</td> 
  </tr> 
  <tr> 
   <td align="left"><code>ndarray.T</code></td> 
   <td align="left">和 <code>self.transpose()</code> 相同</td> 
  </tr> 
  <tr> 
   <td align="left"><code>rollaxis</code></td> 
   <td align="left">向后滚动指定的轴</td> 
  </tr> 
  <tr> 
   <td align="left"><code>swapaxes</code></td> 
   <td align="left">对换数组的两个轴</td> 
  </tr> 
 </tbody> 
</table>

**修改数组维度**

<table> 
 <thead> 
  <tr> 
   <th align="left">维度</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>broadcast</code></td> 
   <td align="left">产生模仿广播的对象</td> 
  </tr> 
  <tr> 
   <td align="left"><code>broadcast_to</code></td> 
   <td align="left">将数组广播到新形状</td> 
  </tr> 
  <tr> 
   <td align="left"><code>expand_dims</code></td> 
   <td align="left">扩展数组的形状</td> 
  </tr> 
  <tr> 
   <td align="left"><code>squeeze</code></td> 
   <td align="left">从数组的形状中删除一维条目</td> 
  </tr> 
 </tbody> 
</table>

**连接数组**

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>concatenate</code></td> 
   <td align="left">连接沿现有轴的数组序列</td> 
  </tr> 
  <tr> 
   <td align="left"><code>stack</code></td> 
   <td align="left">沿着新的轴加入一系列数组。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>hstack</code></td> 
   <td align="left">水平堆叠序列中的数组（列方向）</td> 
  </tr> 
  <tr> 
   <td align="left"><code>vstack</code></td> 
   <td align="left">竖直堆叠序列中的数组（行方向）</td> 
  </tr> 
 </tbody> 
</table>

**分割数组**

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th align="left">数组及操作</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>split</code></td> 
   <td align="left">将一个数组分割为多个子数组</td> 
  </tr> 
  <tr> 
   <td align="left"><code>hsplit</code></td> 
   <td align="left">将一个数组水平分割为多个子数组（按列）</td> 
  </tr> 
  <tr> 
   <td align="left"><code>vsplit</code></td> 
   <td align="left">将一个数组垂直分割为多个子数组（按行）</td> 
  </tr> 
 </tbody> 
</table>

**数组元素的添加与删除**

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th align="left">元素及描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>resize</code></td> 
   <td align="left">返回指定形状的新数组</td> 
  </tr> 
  <tr> 
   <td align="left"><code>append</code></td> 
   <td align="left">将值添加到数组末尾</td> 
  </tr> 
  <tr> 
   <td align="left"><code>insert</code></td> 
   <td align="left">沿指定轴将值插入到指定下标之前</td> 
  </tr> 
  <tr> 
   <td align="left"><code>delete</code></td> 
   <td align="left">删掉某个轴的子数组，并返回删除后的新数组</td> 
  </tr> 
  <tr> 
   <td align="left"><code>unique</code></td> 
   <td align="left">查找数组内的唯一元素</td> 
  </tr> 
 </tbody> 
</table>

#### NumPy 字符串函数 ####

以下函数用于对 dtype 为 numpy.string\_ 或 numpy.unicode\_ 的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。

这些函数在字符数组类（numpy.char）中定义。

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>add()</code></td> 
   <td align="left">对两个数组的逐个字符串元素进行连接</td> 
  </tr> 
  <tr> 
   <td align="left">multiply()</td> 
   <td align="left">返回按元素多重连接后的字符串</td> 
  </tr> 
  <tr> 
   <td align="left"><code>center()</code></td> 
   <td align="left">居中字符串</td> 
  </tr> 
  <tr> 
   <td align="left"><code>capitalize()</code></td> 
   <td align="left">将字符串第一个字母转换为大写</td> 
  </tr> 
  <tr> 
   <td align="left"><code>title()</code></td> 
   <td align="left">将字符串的每个单词的第一个字母转换为大写</td> 
  </tr> 
  <tr> 
   <td align="left"><code>lower()</code></td> 
   <td align="left">数组元素转换为小写</td> 
  </tr> 
  <tr> 
   <td align="left"><code>upper()</code></td> 
   <td align="left">数组元素转换为大写</td> 
  </tr> 
  <tr> 
   <td align="left"><code>split()</code></td> 
   <td align="left">指定分隔符对字符串进行分割，并返回数组列表</td> 
  </tr> 
  <tr> 
   <td align="left"><code>splitlines()</code></td> 
   <td align="left">返回元素中的行列表，以换行符分割</td> 
  </tr> 
  <tr> 
   <td align="left"><code>strip()</code></td> 
   <td align="left">移除元素开头或者结尾处的特定字符</td> 
  </tr> 
  <tr> 
   <td align="left"><code>join()</code></td> 
   <td align="left">通过指定分隔符来连接数组中的元素</td> 
  </tr> 
  <tr> 
   <td align="left"><code>replace()</code></td> 
   <td align="left">使用新字符串替换字符串中的所有子字符串</td> 
  </tr> 
  <tr> 
   <td align="left"><code>decode()</code></td> 
   <td align="left">数组元素依次调用<code>str.decode</code></td> 
  </tr> 
  <tr> 
   <td align="left"><code>encode()</code></td> 
   <td align="left">数组元素依次调用<code>str.encode</code></td> 
  </tr> 
 </tbody> 
</table>

#### NumPy 数学函数 ####

NumPy 包含大量的各种数学运算的函数，包括三角函数，算术运算的函数，复数处理函数等。

#### 三角函数 ####

NumPy 提供了标准的三角函数：sin()、cos()、tan()。

### 实例 ###

import numpy as np
     
    a = np.array([0,30,45,60,90])
    print ('不同角度的正弦值：')
    # 通过乘 pi/180 转化为弧度  
    print (np.sin(a*np.pi/180))
    print ('\n')
    print ('数组中角度的余弦值：')
    print (np.cos(a*np.pi/180))
    print ('\n')
    print ('数组中角度的正切值：')
    print (np.tan(a*np.pi/180))

输出结果为：

不同角度的正弦值：
    [0.         0.5        0.70710678 0.8660254  1.        ]
    
    
    数组中角度的余弦值：
    [1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
     6.12323400e-17]
    
    
    数组中角度的正切值：
    [0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
     1.63312394e+16]

arcsin，arccos，和 arctan 函数返回给定角度的 sin，cos 和 tan 的反三角函数。

这些函数的结果可以通过 numpy.degrees() 函数将弧度转换为角度。

### 实例 ###

import numpy as np
     
    a = np.array([0,30,45,60,90])  
    print ('含有正弦值的数组：')
    sin = np.sin(a*np.pi/180)  
    print (sin)
    print ('\n')
    print ('计算角度的反正弦，返回值以弧度为单位：')
    inv = np.arcsin(sin)  
    print (inv)
    print ('\n')
    print ('通过转化为角度制来检查结果：')
    print (np.degrees(inv))
    print ('\n')
    print ('arccos 和 arctan 函数行为类似：')
    cos = np.cos(a*np.pi/180)  
    print (cos)
    print ('\n')
    print ('反余弦：')
    inv = np.arccos(cos)  
    print (inv)
    print ('\n')
    print ('角度制单位：')
    print (np.degrees(inv))
    print ('\n')
    print ('tan 函数：')
    tan = np.tan(a*np.pi/180)  
    print (tan)
    print ('\n')
    print ('反正切：')
    inv = np.arctan(tan)  
    print (inv)
    print ('\n')
    print ('角度制单位：')
    print (np.degrees(inv))

输出结果为：

含有正弦值的数组：
    [0.         0.5        0.70710678 0.8660254  1.        ]
    
    
    计算角度的反正弦，返回值以弧度为单位：
    [0.         0.52359878 0.78539816 1.04719755 1.57079633]
    
    
    通过转化为角度制来检查结果：
    [ 0. 30. 45. 60. 90.]
    
    
    arccos 和 arctan 函数行为类似：
    [1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01
     6.12323400e-17]
    
    
    反余弦：
    [0.         0.52359878 0.78539816 1.04719755 1.57079633]
    
    
    角度制单位：
    [ 0. 30. 45. 60. 90.]
    
    
    tan 函数：
    [0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00
     1.63312394e+16]
    
    
    反正切：
    [0.         0.52359878 0.78539816 1.04719755 1.57079633]
    
    
    角度制单位：
    [ 0. 30. 45. 60. 90.]

#### 舍入函数 ####

numpy.around() 函数返回指定数字的四舍五入值。

numpy.around(a,decimals)

参数说明：

*  a: 数组
 *  decimals: 舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置

### 实例 ###

import numpy as np
     
    a = np.array([1.0,5.55,  123,  0.567,  25.532])  
    print  ('原数组：')
    print (a)
    print ('\n')
    print ('舍入后：')
    print (np.around(a))
    print (np.around(a, decimals =  1))
    print (np.around(a, decimals =  -1))

输出结果为：

原数组：
    [  1.      5.55  123.      0.567  25.532]
    
    
    舍入后：
    [  1.   6. 123.   1.  26.]
    [  1.    5.6 123.    0.6  25.5]
    [  0.  10. 120.   0.  30.]

#### numpy.floor() ####

numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。

### 实例 ###

import numpy as np
     
    a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])
    print ('提供的数组：')
    print (a)
    print ('\n')
    print ('修改后的数组：')
    print (np.floor(a))

输出结果为：

提供的数组：
    [-1.7  1.5 -0.2  0.6 10. ]
    
    
    修改后的数组：
    [-2.  1. -1.  0. 10.]

#### numpy.ceil() ####

numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整。

### 实例 ###

import numpy as np
     
    a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  
    print  ('提供的数组：')
    print (a)
    print ('\n')
    print ('修改后的数组：')
    print (np.ceil(a))

输出结果为：

提供的数组：
    [-1.7  1.5 -0.2  0.6 10. ]
    
    
    修改后的数组：
    [-1.  2. -0.  1. 10.]

#### NumPy 算术函数 ####

**numpy.reciprocal()**

numpy.reciprocal() 函数返回参数逐元素的倒数。如 **1/4** 倒数为 **4/1**。

**函数里可以传入参数是数组**

**numpy.power()**

numpy.power() 函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。

**参数可以传入两个相等长度的数组**

import numpy as np 
     
    a = np.array([10,100,1000])  
    print ('我们的数组是；')
    print (a)
    print ('\n') 
    print ('调用 power 函数：')
    print (np.power(a,2))
    print ('\n')
    print ('第二个数组：')
    b = np.array([1,2,3])  
    print (b)
    print ('\n')
    print ('再次调用 power 函数：')
    print (np.power(a,b))

输出的结果：

我们的数组是；
    [  10  100 1000]
    
    
    调用 power 函数：
    [    100   10000 1000000]
    
    
    第二个数组：
    [1 2 3]
    
    
    再次调用 power 函数：
    [        10      10000 1000000000]

**numpy.mod()**

numpy.mod() 计算输入数组中相应元素的相除后的余数。 函数 numpy.remainder() 也产生相同的结果。

**参数可以传入两个相等长度的数组**

#### NumPy 统计函数 ####

NumPy 提供了很多统计函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等。 函数说明如下：

**numpy.amin() 和 numpy.amax()**

numpy.amin() 用于计算数组中的元素沿指定轴的最小值。

numpy.amax() 用于计算数组中的元素沿指定轴的最大值。

import numpy as np 
     
    a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
    print ('我们的数组是：')
    print (a)
    print ('\n')
    print ('调用 amin() 函数：')
    print (np.amin(a,1))
    print ('\n')
    print ('再次调用 amin() 函数：')
    print (np.amin(a,0))
    print ('\n')
    print ('调用 amax() 函数：')
    print (np.amax(a))
    print ('\n')
    print ('再次调用 amax() 函数：')
    print (np.amax(a, axis =  0))

我们的数组是：
    [[3 7 5]
     [8 4 3]
     [2 4 9]]
    
    
    调用 amin() 函数：
    [3 3 2]
    
    
    再次调用 amin() 函数：
    [2 4 3]
    
    
    调用 amax() 函数：
    9
    
    
    再次调用 amax() 函数：
    [8 7 9]

**参数：**

print (np.amin(a,1))：a：是传的数组 1：代表行，0 代表列

**numpy.ptp()**

numpy.ptp()函数计算数组中元素最大值与最小值的差（最大值 - 最小值）。

import numpy as np 
     
    a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
    print ('我们的数组是：')
    print (a)
    print ('\n')
    print ('调用 ptp() 函数：')
    print (np.ptp(a))
    print ('\n')
    print ('沿轴 1 调用 ptp() 函数：')
    print (np.ptp(a, axis =  1))
    print ('\n')
    print ('沿轴 0 调用 ptp() 函数：')
    print (np.ptp(a, axis =  0))

我们的数组是：
    [[3 7 5]
     [8 4 3]
     [2 4 9]]
    
    
    调用 ptp() 函数：
    7
    
    
    沿轴 1 调用 ptp() 函数：
    [4 5 7]
    
    
    沿轴 0 调用 ptp() 函数：
    [6 3 6]

**numpy.median()**

numpy.median() 函数用于计算数组 a 中元素的中位数（中值）

import numpy as np 
     
    a = np.array([[30,65,70],[80,95,10],[50,90,60]])  
    print ('我们的数组是：')
    print (a)
    print ('\n')
    print ('调用 median() 函数：')
    print (np.median(a))
    print ('\n')
    print ('沿轴 0 调用 median() 函数：')
    print (np.median(a, axis =  0))
    print ('\n')
    print ('沿轴 1 调用 median() 函数：')
    print (np.median(a, axis =  1))

我们的数组是：
    [[30 65 70]
     [80 95 10]
     [50 90 60]]
    
    
    调用 median() 函数：
    65.0
    
    
    沿轴 0 调用 median() 函数：
    [50. 90. 60.]
    
    
    沿轴 1 调用 median() 函数：
    [65. 80. 60.]

**numpy.mean()**

numpy.mean() 函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。

算术平均值是沿轴的元素的总和除以元素的数量。

import numpy as np 
     
    a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
    print ('我们的数组是：')
    print (a)
    print ('\n')
    print ('调用 mean() 函数：')
    print (np.mean(a))
    print ('\n')
    print ('沿轴 0 调用 mean() 函数：')
    print (np.mean(a, axis =  0))
    print ('\n')
    print ('沿轴 1 调用 mean() 函数：')
    print (np.mean(a, axis =  1))

我们的数组是：
    [[1 2 3]
     [3 4 5]
     [4 5 6]]
    
    
    调用 mean() 函数：
    3.6666666666666665
    
    
    沿轴 0 调用 mean() 函数：
    [2.66666667 3.66666667 4.66666667]
    
    
    沿轴 1 调用 mean() 函数：
    [2. 4. 5.]

**numpy.average()**

numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。

该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。

加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。

考虑数组\[1,2,3,4\]和相应的权重\[4,3,2,1\]，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。

import numpy as np 
     
    a = np.array([1,2,3,4])  
    print ('我们的数组是：')
    print (a)
    print ('\n')
    print ('调用 average() 函数：')
    print (np.average(a))
    print ('\n')
    # 不指定权重时相当于 mean 函数
    wts = np.array([4,3,2,1])  
    print ('再次调用 average() 函数：')
    print (np.average(a,weights = wts))
    print ('\n')
    # 如果 returned 参数设为 true，则返回权重的和  
    print ('权重的和：')
    print (np.average([1,2,3,  4],weights =  [4,3,2,1], returned =  True))

我们的数组是：
    [1 2 3 4]
    
    
    调用 average() 函数：
    2.5
    
    
    再次调用 average() 函数：
    2.0
    
    
    权重的和：
    (2.0, 10.0)

**也可以用于处理对维数组**

**标准差**

标准差是一组数据平均值分散程度的一种度量。

标准差是方差的算术平方根。

标准差公式如下：

std = sqrt(mean((x - x.mean())**2))

如果数组是 \[1，2，3，4\]，则其平均值为 2.5。 因此，差的平方是 \[2.25,0.25,0.25,2.25\]，并且再求其平均值的平方根除以 4，即 sqrt(5/4) ，结果为 1.1180339887498949。

import numpy as np 
     
    print (np.std([1,2,3,4]))

1.1180339887498949

**方差**

统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())\*\* 2)。

换句话说，标准差是方差的平方根。

import numpy as np
     
    print (np.var([1,2,3,4]))

1.25

#### NumPy 排序、条件刷选函数 ####

NumPy 提供了多种排序的方法。 这些排序函数实现不同的排序算法，每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性。 下表显示了三种排序算法的比较。

<table> 
 <thead> 
  <tr> 
   <th align="left">种类</th> 
   <th align="left">速度</th> 
   <th align="left">最坏情况</th> 
   <th align="left">工作空间</th> 
   <th align="left">稳定性</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>'quicksort'</code>（快速排序）</td> 
   <td align="left">1</td> 
   <td align="left"><code>O(n^2)</code></td> 
   <td align="left">0</td> 
   <td align="left">否</td> 
  </tr> 
  <tr> 
   <td align="left"><code>'mergesort'</code>（归并排序）</td> 
   <td align="left">2</td> 
   <td align="left"><code>O(n*log(n))</code></td> 
   <td align="left">~n/2</td> 
   <td align="left">是</td> 
  </tr> 
  <tr> 
   <td align="left"><code>'heapsort'</code>（堆排序）</td> 
   <td align="left">3</td> 
   <td align="left"><code>O(n*log(n))</code></td> 
   <td align="left">0</td> 
   <td align="left">否</td> 
  </tr> 
 </tbody> 
</table>

**numpy.sort()**

numpy.sort(a, axis, kind, order)

参数说明：

*  a: 要排序的数组
 *  axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis=0 按列排序，axis=1 按行排序
 *  kind: 默认为’quicksort’（快速排序）
 *  order: 如果数组包含字段，则是要排序的字段

import numpy as np  
     
    a = np.array([[3,7],[9,1]])  
    print ('我们的数组是：')
    print (a)
    print ('\n')
    print ('调用 sort() 函数：')
    print (np.sort(a))
    print ('\n')
    print ('按列排序：')
    print (np.sort(a, axis =  0))
    print ('\n')
    # 在 sort 函数中排序字段 
    dt = np.dtype([('name',  'S10'),('age',  int)]) 
    a = np.array([("raju",21),("anil",25),("ravi",  17),  ("amar",27)], dtype = dt)  
    print ('我们的数组是：')
    print (a)
    print ('\n')
    print ('按 name 排序：')
    print (np.sort(a, order =  'name'))

我们的数组是：
    [[3 7]
     [9 1]]
    
    
    调用 sort() 函数：
    [[3 7]
     [1 9]]
    
    
    按列排序：
    [[3 1]
     [9 7]]
    
    
    我们的数组是：
    [(b'raju', 21) (b'anil', 25) (b'ravi', 17) (b'amar', 27)]
    
    
    按 name 排序：
    [(b'amar', 27) (b'anil', 25) (b'raju', 21) (b'ravi', 17)]

**numpy.argsort()**

numpy.argsort() 函数返回的是数组值从小到大的索引值。

import numpy as np 
     
    x = np.array([3,  1,  2])  
    print ('我们的数组是：')
    print (x)
    print ('\n')
    print ('对 x 调用 argsort() 函数：')
    y = np.argsort(x)  
    print (y)
    print ('\n')
    print ('以排序后的顺序重构原数组：')
    print (x[y])
    print ('\n')
    print ('使用循环重构原数组：')
    for i in y:  
        print (x[i], end=" ")

我们的数组是：
    [3 1 2]
    
    
    对 x 调用 argsort() 函数：
    [1 2 0]
    
    
    以排序后的顺序重构原数组：
    [1 2 3]
    
    
    使用循环重构原数组
    
    1 2 3

**numpy.lexsort()**

numpy.lexsort() 用于对多个序列进行排序。把它想象成对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。

import numpy as np 
     
    nm =  ('raju','anil','ravi','amar') 
    dv =  ('f.y.',  's.y.',  's.y.',  'f.y.') 
    ind = np.lexsort((dv,nm))  
    print ('调用 lexsort() 函数：') 
    print (ind) 
    print ('\n') 
    print ('使用这个索引来获取排序后的数据：') 
    print ([nm[i]  +  ", "  + dv[i]  for i in ind])

调用 lexsort() 函数：
    [3 1 0 2]
    
    
    使用这个索引来获取排序后的数据：
    ['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']

**上面传入 np.lexsort 的是一个tuple，排序时首先排 nm，顺序为：amar、anil、raju、ravi 。综上排序结果为 \[3 1 0 2\]。**

既是先将含有nm的元素进行排序，在排序其他的元素

**msort、sort\_complex、partition、argpartition**

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">msort(a)</td> 
   <td align="left">数组按第一个轴排序，返回排序后的数组副本。np.msort(a) 相等于 np.sort(a, axis=0)。</td> 
  </tr> 
  <tr> 
   <td align="left">sort_complex(a)</td> 
   <td align="left">对复数按照先实部后虚部的顺序进行排序。</td> 
  </tr> 
  <tr> 
   <td align="left">partition(a, kth[, axis, kind, order])</td> 
   <td align="left">指定一个数，对数组进行分区</td> 
  </tr> 
  <tr> 
   <td align="left">argpartition(a, kth[, axis, kind, order])</td> 
   <td align="left">可以通过关键字 kind 指定算法沿着指定轴对数组进行分区</td> 
  </tr> 
 </tbody> 
</table>

**numpy.argmax() 和 numpy.argmin()**

numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引。

**numpy.nonzero()**

numpy.nonzero() 函数返回输入数组中非零元素的索引。

**numpy.where()**

numpy.where() 函数返回输入数组中满足给定条件的元素的索引。

**numpy.extract()**

numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素。

#### NumPy 线性代数 ####

NumPy 提供了线性代数函数库 **linalg**，该库包含了线性代数所需的所有功能，可以看看下面的说明：

<table> 
 <thead> 
  <tr> 
   <th align="left">函数</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>dot</code></td> 
   <td align="left">两个数组的点积，即元素对应相乘。</td> 
  </tr> 
  <tr> 
   <td align="left"><code>vdot</code></td> 
   <td align="left">两个向量的点积</td> 
  </tr> 
  <tr> 
   <td align="left"><code>inner</code></td> 
   <td align="left">两个数组的内积</td> 
  </tr> 
  <tr> 
   <td align="left"><code>matmul</code></td> 
   <td align="left">两个数组的矩阵积</td> 
  </tr> 
  <tr> 
   <td align="left"><code>determinant</code></td> 
   <td align="left">数组的行列式</td> 
  </tr> 
  <tr> 
   <td align="left"><code>solve</code></td> 
   <td align="left">求解线性矩阵方程</td> 
  </tr> 
  <tr> 
   <td align="left"><code>inv</code></td> 
   <td align="left">计算矩阵的乘法逆矩阵</td> 
  </tr> 
 </tbody> 
</table>

#### NumPy IO ####

Numpy 可以读写磁盘上的文本数据或二进制数据。

NumPy 为 ndarray 对象引入了一个简单的文件格式：**npy**。

npy 文件用于存储重建 ndarray 所需的数据、图形、dtype 和其他信息。

常用的 IO 函数有：

*  load() 和 save() 函数是读写文件数组数据的两个主要函数，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npy 的文件中。
 *  savez() 函数用于将多个数组写入文件，默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npz 的文件中。
 *  loadtxt() 和 savetxt() 函数处理正常的文本文件(.txt 等)

**numpy.save()**

numpy.save() 函数将数组保存到以 .npy 为扩展名的文件中。

numpy.save(file, arr, allow_pickle=True, fix_imports=True)

**参数说明**：

*  **file**：要保存的文件，扩展名为 .npy，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上。
 *  **arr**: 要保存的数组
 *  **allow\_pickle**: 可选，布尔值，允许使用 Python pickles 保存对象数组，Python 中的 pickle 用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化。
 *  **fix\_imports**: 可选，为了方便 Pyhton2 中读取 Python3 保存的数据。

import numpy as np 
     
    a = np.array([1,2,3,4,5]) 
     
    # 保存到 outfile.npy 文件上
    np.save('outfile.npy',a) 
     
    # 保存到 outfile2.npy 文件上，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上
    np.save('outfile2',a)

**save()保存的文件使用load()加载**

b = np.load('outfile.npy')  
    print (b)

[1 2 3 4 5]

**np.savez**

numpy.savez() 函数将多个数组保存到以 npz 为扩展名的文件中。

numpy.savez(file, *args, **kwds)

参数说明：

*  **file**：要保存的文件，扩展名为 **.npz**，如果文件路径末尾没有扩展名 **.npz**，该扩展名会被自动加上。
 *  **args**: 要保存的数组，可以使用关键字参数为数组起一个名字，非关键字参数传递的数组会自动起名为 **arr\_0**, **arr\_1**, …　。
 *  **kwds**: 要保存的数组使用关键字名称。

import numpy as np 
     
    a = np.array([[1,2,3],[4,5,6]])
    b = np.arange(0, 1.0, 0.1)
    c = np.sin(b)
    # c 使用了关键字参数 sin_array
    np.savez("runoob.npz", a, b, sin_array = c)
    r = np.load("runoob.npz")  
    print(r.files) # 查看各个数组名称
    print(r["arr_0"]) # 数组 a
    print(r["arr_1"]) # 数组 b
    print(r["sin_array"]) # 数组 c

['sin_array', 'arr_0', 'arr_1']
    [[1 2 3]
     [4 5 6]]
    [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
    [0.         0.09983342 0.19866933 0.29552021 0.38941834 0.47942554
     0.56464247 0.64421769 0.71735609 0.78332691]

**savetxt()**

savetxt() 函数是以简单的文本文件格式存储数据，对应的使用 loadtxt() 函数来获取数据。

np.loadtxt(FILENAME, dtype=int, delimiter=' ')
    np.savetxt(FILENAME, a, fmt="%d", delimiter=",")

参数 delimiter 可以指定各种分隔符、针对特定列的转换器函数、需要跳过的行数等。

import numpy as np 
     
    a = np.array([1,2,3,4,5]) 
    np.savetxt('out.txt',a) 
    b = np.loadtxt('out.txt')  
     
    print(b)

[1. 2. 3. 4. 5.]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/39476326cee4403a88bc5586ef37dee7.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/14c8850b01924033a7ae93c7e1efff16.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NjQyOTI5MA==,size_16,color_FFFFFF,t_70