数据分析之NumPy基础入门

雨点打透心脏的1/2处 2023-10-10 17:08 10阅读 0赞

**目录**

numpy的基本概念和术语

numpy 概述

numpy 相关术语

ndarray 对象

创建ndarray对象

ndarray 对象常见属性

numpy 数据类型

numpy数组的创建、操作、索引、切片等基本操作

numpy 数组创建

1、numpy.empty()

2、numpy.zeros()

3、numpy.ones()

4、numpy.zeros\_like()

5、numpy.ones\_like()

6、numpy.array()

7、numpy.asarray()

8、numpy.frombuffer()

9、numpy.fromiter()

10、numpy.arange()

11、numpy.linspace()

12、numpy.logspace()

13、np.random() 随机数组

14、正态分布

均匀分布

numpy 切片和索引

numpy 高级索引

整数数组索引

布尔索引

花式索引

一维数组

二维数组

numpy操作

numpy 操作之数组迭代

控制遍历顺序

numpy 操作之数组操作

numpy.reshape

numpy.ndarray.flat

numpy.ndarray.flatten

numpy.ravel

numpy.transpose

numpy.rollaxis

numpy.swapaxes

numpy.broadcast

numpy.broadcast\_to

numpy.expand\_dims

numpy.squeeze

numpy.concatenate

numpy.stack

numpy.hstack

numpy.vstack

numpy.split

numpy.hsplit

numpy.vsplit

numpy.resize

numpy.append

numpy.insert

numpy.delete

numpy.unique

numpy数组的运算和聚合统计，如数学运算、统计计算等操作

numpy 字符串函数

numpy.char.add()

numpy.char.multiply()

numpy.char.center()

numpy.char.capitalize()

numpy.char.title()

numpy.char.lower()

numpy.char.upper()

numpy.char.split()

numpy.char.splitlines()

numpy.char.strip()

numpy.char.join()

numpy.char.replace()

numpy.char.encode()

numpy.char.decode()

numpy 数学函数

三角函数

舍入函数

numpy.floor()

numpy.ceil()

numpy 算术函数

numpy.reciprocal()

numpy.power()

numpy.mod()

numpy 统计函数

numpy.amin() 和 numpy.amax()

numpy.ptp()

numpy.percentile()

numpy.median()

numpy.mean()

numpy.average()

标准差

方差

numpy 排序、条件筛选函数

numpy.sort()

实例

numpy.argsort()

实例

numpy.lexsort()

实例

msort、sort\_complex、partition、argpartition

numpy.argmax() 和 numpy.argmin()

实例

numpy.nonzero()

实例

numpy.where()

实例

numpy.extract()

实例

numpy高级操作，如数组的交换、副本和视图、矩阵库、线性代数等操作

NumPy 字节交换

numpy.ndarray.byteswap()

NumPy 副本和视图

副本或深拷贝

NumPy 矩阵库(Matrix)

转置矩阵

matlib.empty()

numpy.matlib.zeros()

numpy.matlib.ones()

numpy.matlib.eye()

numpy.matlib.identity()

numpy.matlib.rand()

NumPy 线性代数

numpy.dot()

numpy.vdot()

numpy.inner()

numpy.matmul

numpy.linalg.det()

numpy.linalg.solve()

numpy.linalg.inv()

--------------------

## numpy的基本概念和术语 ##

### numpy 概述 ###

NumPy 是 Python 语言的一个第三方库，其支持大量高维度[数组][Link 1]与[矩阵运算][Link 2]。此外，NumPy 也针对数组运算提供大量的数学函数。机器学习涉及到大量对数组的变换和运算，NumPy 就成了必不可少的工具之一。

### numpy 相关术语 ###

#### ndarray 对象 ####

NumPy 定义了一个 n 维数组对象，简称 ndarray 对象，它是一个一系列相同类型元素组成的数组集合。数组中的每个元素都占有大小相同的内存块，您可以使用索引或切片的方式获取数组中的每个元素。

ndarray 对象采用了数组的索引机制，将数组中的每个元素映射到内存块上，并且按照一定的布局对内存块进行排列，常用的布局方式有两种，即**按行**或者**按列**。

#### 创建ndarray对象 ####

通过 NumPy 的内置函数 array() 可以创建 ndarray 对象，其语法格式如下：

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

参数说明：

<table> 
 <tbody> 
  <tr> 
   <th>序号</th> 
   <th>参数</th> 
   <th>描述说明</th> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>object</td> 
   <td>表示一个数组序列。</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>dtype</td> 
   <td>可选参数，通过它可以更改数组的数据类型。</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>copy</td> 
   <td>可选参数，表示数组能否被复制，默认是 True。</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>order</td> 
   <td>以哪种内存布局创建数组，有 3 个可选值，分别是&nbsp;C(行序列)/F(列序列)/A(默认)。</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>ndim</td> 
   <td>用于指定数组的维度。</td> 
  </tr> 
 </tbody> 
</table>

#### ndarray 对象常见属性 ####

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ndarray.ndim</td> 
   <td>秩，即轴的数量或维度的数量</td> 
  </tr> 
  <tr> 
   <td>ndarray.shape</td> 
   <td>数组的维度，对于矩阵，n 行 m 列</td> 
  </tr> 
  <tr> 
   <td>ndarray.size</td> 
   <td>数组元素的总个数，相当于 .shape 中 n*m 的值</td> 
  </tr> 
  <tr> 
   <td>ndarray.dtype</td> 
   <td>ndarray 对象的元素类型</td> 
  </tr> 
  <tr> 
   <td>ndarray.itemsize</td> 
   <td>ndarray 对象中每个元素的大小，以字节为单位</td> 
  </tr> 
  <tr> 
   <td>ndarray.flags</td> 
   <td>ndarray 对象的内存信息</td> 
  </tr> 
  <tr> 
   <td>ndarray.real</td> 
   <td>ndarray元素的实部</td> 
  </tr> 
  <tr> 
   <td>ndarray.imag</td> 
   <td>ndarray 元素的虚部</td> 
  </tr> 
  <tr> 
   <td>ndarray.data</td> 
   <td>包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。</td> 
  </tr> 
 </tbody> 
</table>

**快速入门：**

1、创建一维数组

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-1.py
    [1 3 5 7 9]
    <class 'numpy.ndarray'>

2、创建多维数组

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-1.py
    [[ 1  3  5  7  9]
     [ 2  4  6  8 10]]
    <class 'numpy.ndarray'>

3、查看/设置 ndarray 维度数

import numpy as np
    
    # 解决汉字乱码
    from pylab import mpl
    mpl.rcParams['font.sans-serif'] = ['STZhongsong']    # 指定默认字体：解决plot不能显示中文问题
    mpl.rcParams['axes.unicode_minus'] = False   
    
    # 创建一维数组
    # a = np.array([1, 3, 5, 7, 9])
    
    # 创建多维数组
    a = np.array([[1, 3, 5, 7, 9], [2, 4, 6, 8, 10]])
    
    # 输出nummpy.narray 对象
    print(a)
    
    # 输出对象类型
    print(type(a))
    
    # 输出ndarray 维度数
    print(a.ndim)
    
    # 重新设置ndarray 维度数
    a = np.array([[1, 3, 5, 7, 9], [2, 4, 6, 8, 10]], ndmin=3)
    
    # 重新输出 ndarray 维度数 
    print(a.ndim)

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-1.py
    [[ 1  3  5  7  9]
     [ 2  4  6  8 10]]
    <class 'numpy.ndarray'>
    2
    3

4、ndarray 设置数据类型

# 创建ndarray 对象，并且指定dtype 属性
    b = np.array([1, 3, 5, 7, 9], dtype="complex")
    
    print(b)

[1.+0.j 3.+0.j 5.+0.j 7.+0.j 9.+0.j]

5、ndarray 数组调整维度

数组的形状指的是多维数组的行数和列数。Numpy 模块提供 reshape() 函数可以改变多维数组行数和列数，从而达到数组变维的目的。因此数组变维即对数组形状的重塑。如图1所示：

![58c1a088ce6c17a14cfc406daee67fcc.jpeg][]

图1：reshape函数数组变维

# ndarray 对象 通过reshape()函数 调整维度
    c = np.array([[1, 2], [3, 4], [5, 6]])
    print(c)
    
    print(c.reshape(2, 3))

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

6、 ndarray

#### numpy 数据类型 ####

NumPy 作为 Python 的扩展包，它提供了比 Python 更加丰富的数据类型，如表 1 所示：

<table> 
 <tbody> 
  <tr> 
   <th>序号</th> 
   <th>数据类型</th> 
   <th>语言描述</th> 
  </tr> 
  <tr> 
   <td>1</td> 
   <td>bool_</td> 
   <td>布尔型数据类型（True 或者 False）</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>int_</td> 
   <td>默认整数类型，类似于 C 语言中的 long，取值为 int32 或 int64</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>intc</td> 
   <td>和 C 语言的 int 类型一样，一般是 int32 或 int 64</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>intp</td> 
   <td>用于索引的整数类型（类似于 C 的 ssize_t，通常为&nbsp;int32 或 int64）</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>int8</td> 
   <td>代表与1字节相同的8位整数。值的范围是-128到127。</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>int16</td> 
   <td>代表 2 字节（16位）的整数。范围是-32768至32767。</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>int32</td> 
   <td>代表 4 字节（32位）整数。范围是-2147483648至2147483647。</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>int64</td> 
   <td>表示 8 字节（64位）整数。范围是-9223372036854775808至9223372036854775807。</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>uint8</td> 
   <td>代表1字节（8位）无符号整数。</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>uint16</td> 
   <td>2 字节（16位）无符号整数。</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>uint32</td> 
   <td>4 字节（32位）的无符号整数。</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>uint64</td> 
   <td>8 字节（64位）的无符号整数。</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>float_</td> 
   <td>float64 类型的简写。</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td>float16</td> 
   <td>半精度浮点数，包括：1 个符号位，5 个指数位，10个尾数位。</td> 
  </tr> 
  <tr> 
   <td>15</td> 
   <td>float32</td> 
   <td>单精度浮点数，包括：1 个符号位，8 个指数位，23个尾数位。</td> 
  </tr> 
  <tr> 
   <td>16</td> 
   <td>float64</td> 
   <td>双精度浮点数，包括：1 个符号位，11 个指数位，52个尾数位。</td> 
  </tr> 
  <tr> 
   <td>17</td> 
   <td>complex_</td> 
   <td>复数类型，与 complex128 类型相同。</td> 
  </tr> 
  <tr> 
   <td>18</td> 
   <td>complex64</td> 
   <td>表示实部和虚部共享 32 位的复数。</td> 
  </tr> 
  <tr> 
   <td>19</td> 
   <td>complex128</td> 
   <td>表示实部和虚部共享 64 位的复数。</td> 
  </tr> 
  <tr> 
   <td>20</td> 
   <td>str_</td> 
   <td>表示字符串类型</td> 
  </tr> 
  <tr> 
   <td>21</td> 
   <td>string_</td> 
   <td>表示字节串类型</td> 
  </tr> 
 </tbody> 
</table>

**数据类型对象**

数据类型对象（Data Type Object）又称 dtype 对象，主要用来描述数组元素的数据类型、大小以及字节顺序。同时，它也可以用来创建结构化数据。比如常见的 int64、float32 都是 dtype 对象的实例，其语法格式如下：

> np.dtype(object)

1、 创建dtype 对象

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-2.py
    int64

**2、数据类型标识符**

NumPy 中每种数据类型都有一个唯一标识的字符码，如下所示：

<table> 
 <tbody> 
  <tr> 
   <th>字符</th> 
   <th>对应类型</th> 
  </tr> 
  <tr> 
   <td>b</td> 
   <td>代表布尔型</td> 
  </tr> 
  <tr> 
   <td>i</td> 
   <td>带符号整型</td> 
  </tr> 
  <tr> 
   <td>u</td> 
   <td>无符号整型</td> 
  </tr> 
  <tr> 
   <td>f</td> 
   <td>浮点型</td> 
  </tr> 
  <tr> 
   <td>c</td> 
   <td>复数浮点型</td> 
  </tr> 
  <tr> 
   <td>m</td> 
   <td>时间间隔（timedelta）</td> 
  </tr> 
  <tr> 
   <td>M</td> 
   <td>datatime（日期时间）</td> 
  </tr> 
  <tr> 
   <td>O</td> 
   <td>Python对象</td> 
  </tr> 
  <tr> 
   <td>S,a</td> 
   <td>字节串（S）与字符串（a）</td> 
  </tr> 
  <tr> 
   <td>U</td> 
   <td>Unicode</td> 
  </tr> 
  <tr> 
   <td>V</td> 
   <td>原始数据（void）</td> 
  </tr> 
 </tbody> 
</table>

1、创建自定义数据标识对象，并应用于ndarray 对象的dtype 属性。

import numpy as np
    
    # 解决汉字乱码
    from pylab import mpl
    mpl.rcParams['font.sans-serif'] = ['STZhongsong']    # 指定默认字体：解决plot不能显示中文问题
    mpl.rcParams['axes.unicode_minus'] = False   
    
    
    # 创建一个数据类型对象,指定名称、数据类型
    b = np.dtype([("score", "i1")])
    
    print(b)
    
    # 创建一个ndarray 对象，并指定dtype 对象类型为b
    a  = np.array([1, 3, 5, 7, 9], dtype=b)
    # 输出ndarray 对象
    print(a)
    
    # 输出ndarray 对象的dtype 属性
    print(a.dtype)
    
    # 输出ndarray 对象 score 属性
    print(a["score"])

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-2.py
    [('score', 'i1')]
    [(1,) (3,) (5,) (7,) (9,)]
    [('score', 'i1')]
    [1 3 5 7 9]

2、定义结构化数据，结构化数据使用字段的形式来描述某个对象的特征。以下示例描述一位普通员工的姓名、年龄、工资、家庭住址的特征，该结构化数据其包含以下字段：

*  str 字段：name
 *  int 字段：age
 *  float 字段：salary
 *  str 字段: address

# 定义一个结构化的数据类型对象
    employ = np.dtype([("name", "S20"),("age", "i1"),("salary", "f2"),("address", "U20")])
    
    print(employ)
    
    #将其应用于ndarray对象
    b = np.array([('zzg', 32, 16357.50, "横岗街道"),('zzx', 28, 13856.80, "西乡街道")], dtype = employ) 
    
    print(b)
    # 输出ndarray 对象 name 属性
    print(b["name"])
    # 输出ndarray 对象 age 属性
    print(b["age"])
    # 输出ndarray 对象 salary 属性
    print(b["salary"])
    # 输出ndarray 对象 address 属性
    print(b["address"])

PS E:\py_workspace\conda-demo>
                                 > & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-2.py
    [('score', 'i1')]
    [(1,) (3,) (5,) (7,) (9,)]
    [('score', 'i1')]
    [1 3 5 7 9]
    [('name', 'S20'), ('age', 'i1'), ('salary', '<f2'), ('address', '<U20')]
    [(b'zzg', 32, 16360., '横岗街道') (b'zzx', 28, 13856., '西乡街道')]
    [b'zzg' b'zzx']
    [32 28]
    [16360. 13856.]
    ['横岗街道' '西乡街道']

##    numpy数组的创建、操作、索引、切片等基本操作 ##

### numpy 数组创建 ###

#### 1、numpy.empty() ####

numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组：

numpy.empty(shape, dtype = float, order = 'C')

参数说明：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>shape</td> 
   <td>数组形状</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>数据类型，可选</td> 
  </tr> 
  <tr> 
   <td>order</td> 
   <td>有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。</td> 
  </tr> 
 </tbody> 
</table>

import numpy as np
    
    # 解决汉字乱码
    from pylab import mpl
    mpl.rcParams['font.sans-serif'] = ['STZhongsong']    # 指定默认字体：解决plot不能显示中文问题
    mpl.rcParams['axes.unicode_minus'] = False   
    
    a = np.empty([3, 2], dtype=int)
    
    print(a)

#### 2、numpy.zeros() ####

创建指定大小的数组，数组元素以 0 来填充：

numpy.zeros(shape, dtype = float, order = 'C')

参数说明：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>shape</td> 
   <td>数组形状</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>数据类型，可选</td> 
  </tr> 
  <tr> 
   <td>order</td> 
   <td>'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组</td> 
  </tr> 
 </tbody> 
</table>

#### 3、numpy.ones() ####

创建指定形状的数组，数组元素以 1 来填充：

numpy.ones(shape, dtype = None, order = 'C')

参数说明：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>shape</td> 
   <td>数组形状</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>数据类型，可选</td> 
  </tr> 
  <tr> 
   <td>order</td> 
   <td>'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组</td> 
  </tr> 
 </tbody> 
</table>

#### 4、numpy.zeros\_like() ####

numpy.zeros\_like 用于创建一个与给定数组具有相同形状的数组，数组元素以 0 来填充。

numpy.zeros 和 numpy.zeros\_like 都是用于创建一个指定形状的数组，其中所有元素都是 0。

它们之间的区别在于：numpy.zeros 可以直接指定要创建的数组的形状，而 numpy.zeros\_like 则是创建一个与给定数组具有相同形状的数组。

numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)

参数说明：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>a</td> 
   <td>给定要创建相同形状的数组</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>创建的数组的数据类型</td> 
  </tr> 
  <tr> 
   <td>order</td> 
   <td>数组在内存中的存储顺序，可选值为 'C'（按行优先）或 'F'（按列优先），默认为 'K'（保留输入数组的存储顺序）</td> 
  </tr> 
  <tr> 
   <td>subok</td> 
   <td>是否允许返回子类，如果为 True，则返回一个子类对象，否则返回一个与 a 数组具有相同数据类型和存储顺序的数组</td> 
  </tr> 
  <tr> 
   <td>shape</td> 
   <td>创建的数组的形状，如果不指定，则默认为 a 数组的形状。</td> 
  </tr> 
 </tbody> 
</table>

import numpy as np
    
    # 解决汉字乱码
    from pylab import mpl
    mpl.rcParams['font.sans-serif'] = ['STZhongsong']    # 指定默认字体：解决plot不能显示中文问题
    mpl.rcParams['axes.unicode_minus'] = False   
    
    # 创建一个 3x3 的二维数组
    arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
     
    # 创建一个与 arr 形状相同的，所有元素都为 0 的数组
    zeros_arr = np.zeros_like(arr)
    print(zeros_arr)

#### 5、numpy.ones\_like() ####

numpy.ones\_like 用于创建一个与给定数组具有相同形状的数组，数组元素以 1 来填充。

numpy.ones 和 numpy.ones\_like 都是用于创建一个指定形状的数组，其中所有元素都是 1。

它们之间的区别在于：numpy.ones 可以直接指定要创建的数组的形状，而 numpy.ones\_like 则是创建一个与给定数组具有相同形状的数组。

numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)

参数说明：

#### 6、numpy.array() ####

通过 NumPy 的内置函数 array() 可以创建 ndarray 对象，其语法格式如下：

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

参数说明：

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-4.py
    ['a' 'b' 'c' 'd' 'e']
    [[1 2 3]
     [4 5 6]]

#### 7、numpy.asarray() ####

numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个。

>     numpy.asarray(a, dtype = None, order = None)

参数说明：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>a</td> 
   <td>任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>数据类型，可选</td> 
  </tr> 
  <tr> 
   <td>order</td> 
   <td>可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。</td> 
  </tr> 
 </tbody> 
</table>

# 基于列表 创建一维数组 
    c = [1, 3, 5, 7, 9]
    d = np.asarray(c)
    print(d)

[1 3 5 7 9]

基于元组，创建一维数组

# 基于元组 创建一维数组
    e = ("a", "b", "c", "d", "e")
    f =  np.asarray(e)
    print(f)

['a' 'b' 'c' 'd' 'e']

#### 8、numpy.frombuffer() ####

numpy.frombuffer 用于实现动态数组。

numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。

numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)

温馨提示：buffer 是字符串的时候，Python3 默认 str 是 Unicode 类型，所以要转成 bytestring 在原 str 前加上 b。

参数说明：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>buffer</td> 
   <td>可以是任意对象，会以流的形式读入。</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>返回数组的数据类型，可选</td> 
  </tr> 
  <tr> 
   <td>count</td> 
   <td>读取的数据数量，默认为-1，读取所有数据。</td> 
  </tr> 
  <tr> 
   <td>offset</td> 
   <td>读取的起始位置，默认为0。</td> 
  </tr> 
 </tbody> 
</table>

# 基于字符串,创建一维数组
    str = b"Hello World Python3!"
    g = np.frombuffer(str, dtype =  'S1')
    print(g)

[b'H' b'e' b'l' b'l' b'o' b' ' b'W' b'o' b'r' b'l' b'd' b' ' b'P' b'y'
     b't' b'h' b'o' b'n' b'3' b'!']

基于字符串创建多维数组

# 基于字符串,创建一维数组
    str = b"Hello World Python3!"
    g = np.frombuffer(str, dtype =  'S1')
    print(g)
    # 一位数组转换为多维数组
    h = g.reshape(4, 5)
    print(h)

[[b'H' b'e' b'l' b'l' b'o']
     [b' ' b'W' b'o' b'r' b'l']
     [b'd' b' ' b'P' b'y' b't']
     [b'h' b'o' b'n' b'3' b'!']]

#### 9、numpy.fromiter() ####

numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组。

numpy.fromiter(iterable, dtype, count=-1)

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>iterable</td> 
   <td>可迭代对象</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>返回数组的数据类型</td> 
  </tr> 
  <tr> 
   <td>count</td> 
   <td>读取的数据数量，默认为-1，读取所有数据</td> 
  </tr> 
 </tbody> 
</table>

# 使用rang 函数 创建列表对象
    i = range(1, 11)
    print(i)
    # 使用iter 函数 
    j = iter(i)
    print(j)
    
    # 使用迭代器创建 ndarray 
    k = np.fromiter(j, dtype=float)
    print(k)

range(1, 11)
    <range_iterator object at 0x00000243E6F5C2F0>
    [ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

#### 10、numpy.arange() ####

numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：

numpy.arange(start, stop, step, dtype)

根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。

参数说明：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>start</code></td> 
   <td>起始值，默认为<code>0</code></td> 
  </tr> 
  <tr> 
   <td><code>stop</code></td> 
   <td>终止值（不包含）</td> 
  </tr> 
  <tr> 
   <td><code>step</code></td> 
   <td>步长，默认为<code>1</code></td> 
  </tr> 
  <tr> 
   <td><code>dtype</code></td> 
   <td>返回<code>ndarray</code>的数据类型，如果没有提供，则会使用输入数据的类型。</td> 
  </tr> 
 </tbody> 
</table>

# 简单版本:数值范围创建一维数组
    l = np.arange(5)
    print(l)
    
    # 指定数据类型版本: 数据范围创建一维数组
    m = np.arange(10, dtype=float)
    print(m)

[0 1 2 3 4]
    [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

#### 11、numpy.linspace() ####

numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

参数说明：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>start</code></td> 
   <td>序列的起始值</td> 
  </tr> 
  <tr> 
   <td><code>stop</code></td> 
   <td>序列的终止值，如果<code>endpoint</code>为<code>true</code>，该值包含于数列中</td> 
  </tr> 
  <tr> 
   <td><code>num</code></td> 
   <td>要生成的等步长的样本数量，默认为<code>50</code></td> 
  </tr> 
  <tr> 
   <td><code>endpoint</code></td> 
   <td>该值为&nbsp;<code>true</code>&nbsp;时，数列中包含<code>stop</code>值，反之不包含，默认是True。</td> 
  </tr> 
  <tr> 
   <td><code>retstep</code></td> 
   <td>如果为 True 时，生成的数组中会显示间距，反之不显示。</td> 
  </tr> 
  <tr> 
   <td><code>dtype</code></td> 
   <td><code>ndarray</code>&nbsp;的数据类型</td> 
  </tr> 
 </tbody> 
</table>

# 设置等差数列,默认数据类型为float, 调整为int
    n = np.linspace(1,10,10, dtype=int)
    
    print(n)

上述代码设置起始点为 1 ，终止点为 10，数列个数为 10。且等差数值为1 的等差数列。

[ 1  2  3  4  5  6  7  8  9 10]

设置 endpoint 设为 false，不包含终止值：

# 设置等差数列,默认数据类型为float, 调整为int,
    o = np.linspace(10, 20, 5, dtype=int, endpoint=False)
    
    print(o)

[10 12 14 16 18]

#### 12、numpy.logspace() ####

numpy.logspace 函数用于创建一个于等比数列。格式如下：

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)

base 参数意思是取对数的时候 log 的下标。

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>start</code></td> 
   <td>序列的起始值为：base ** start</td> 
  </tr> 
  <tr> 
   <td><code>stop</code></td> 
   <td>序列的终止值为：base ** stop。如果<code>endpoint</code>为<code>true</code>，该值包含于数列中</td> 
  </tr> 
  <tr> 
   <td><code>num</code></td> 
   <td>要生成的等步长的样本数量，默认为<code>50</code></td> 
  </tr> 
  <tr> 
   <td><code>endpoint</code></td> 
   <td>该值为&nbsp;<code>true</code>&nbsp;时，数列中中包含<code>stop</code>值，反之不包含，默认是True。</td> 
  </tr> 
  <tr> 
   <td><code>base</code></td> 
   <td>对数 log 的底数。</td> 
  </tr> 
  <tr> 
   <td><code>dtype</code></td> 
   <td><code>ndarray</code>&nbsp;的数据类型</td> 
  </tr> 
 </tbody> 
</table>

# 默认底数是 10
    p = np.logspace(1.0,  2.0, num =  10)  
    print (p)
    
    # 将对数的底数设置为 2 :
    q = np.logspace(0,9,10,base=2)
    print (q)

[ 10.          12.91549665  16.68100537  21.5443469   27.82559402
      35.93813664  46.41588834  59.94842503  77.42636827 100.        ]
    [  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]

#### 13、np.random() 随机数组 ####

#### 14、正态分布 ####

> 正态分布是一种概率分布。正态分布是具有两个参数μ和σ的连续型随机变量的分布，第一参数μ是服从正态分布的随机变量的均值，第二个参 数σ是此随机变量的标准差，所以正态分布记作N(μ，σ )。

![e33e7f758c104edf9aedb8b6476fd0f9.png][]

**正态分布的应用**

> 生活、生产与科学实验中很多随机变量的概率分布都可以近似地用正态分布来描述。

**正态分布特点**

> μ决定了其位置，其标准差σ决定了分布的幅度。当μ = 0,σ = 1时的正态分布是标准正态分布。

**标准差如何来？**

**方差**  
是在概率论和统计方差衡量一组数据时离散程度的度量  
![在这里插入图片描述][20210702130648654.jpg_pic_center]

*  其中M为平均值，n为数据总个数，σ 为标准差，σ ^2可以理解一个整体为方差

![998c04628f084155bb112e22b85f6bb2.png][]

*  **标准差与方差的意义**  
    可以理解成数据的一个离散程度的衡量

![3e4d6f9310804f8fa27358600cd0382f.png][]

**正态分布创建方式**

*  **np.random.randn(d0, d1, …, dn)**  
    功能：从标准正态分布中返回一个或多个样本值
 *  **np.random.normal(loc=0.0, scale=1.0, size=None)**

loc：float
    此概率分布的均值（对应着整个分布的中心centre）
    scale：float
    此概率分布的标准差（对应于分布的宽度，scale越大越矮胖，scale越小，越瘦高）
    size：int or tuple of ints
    输出的shape，默认为None，只输出一个值
    np.random.standard_normal(size=None)
    返回指定形状的标准正态分布的数组。

**举例1**：生成均值为1.75，标准差为1的正态分布数据，100000000个

x1 = np.random.normal(1.75, 1, 100000000)

返回结果：

array([2.90646763, 1.46737886, 2.21799024, ..., 1.56047411, 1.87969135, 0.9028096 ])

**举例2**：**我们可以模拟生成一组股票的涨跌幅的数据**

举例2：随机生成4支股票1周的交易日涨幅数据

4支股票，一周(5天)的涨跌幅数据，如何获取？

*  随机生成涨跌幅在某个正态分布内，比如均值0，方差1

**股票涨跌幅数据的创建**

# 创建符合正态分布的4只股票5天的涨跌幅数据
    stock_change = np.random.normal(0, 1, (4, 5))

# 1.创建画布
    plt.figure(figsize=(20, 8), dpi=100)
    
    days = ['one', 'two', ]
    # 2.绘制图像，绘制多图
    for i in range(len(stock_change)):
        plt.plot(stock_change[i], label='Stock'+str(i))
    
    # 2.1.设置x轴刻度
    days = ['第{}天'.format(i+1) for i in range(0, 4)]
    plt.xticks(range(0, 4), days)
    
    # 2.2.设置x，y轴标签
    plt.xlabel('天数')
    plt.ylabel('股价情况')
    
    # 2.3 设置图例
    plt.legend(loc=0)
    
    # 3.显示图像
    plt.show()

![6d49e8952eaf4694bf72b78a94b19b8e.png][]

#### 均匀分布 ####

![fdbc376d2a7745a2a0d2a28e6dbb5175.png][]

# 生成均匀分布的随机数 
    x2 = np.random.uniform(-1, 1, 100000000)

# 1.创建画布
    plt.figure(figsize=(20, 8), dpi=100)
    
    # 2.绘制图像
    plt.hist(x2, 1000)  # 1000组
    
    # 3. 显示图像
    plt.show()

![1aeff98608c34ab3b5f3f1eecce8d120.png][]

### numpy 切片和索引 ###

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

ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。

import numpy as np
    
    # 解决汉字乱码
    from pylab import mpl
    mpl.rcParams['font.sans-serif'] = ['STZhongsong']    # 指定默认字体：解决plot不能显示中文问题
    mpl.rcParams['axes.unicode_minus'] = False 
    
    # 基于rang 函数，创建一维数组, 并且指定数据类型为int
    a = np.array(range(1, 10), dtype= int)
    print(a)
    # 使用slice 函数定义切片对象
    b = slice(1, 9, 2)
    # ndarray 对象进行切片
    print(a[b])

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-5.py
    [1 2 3 4 5 6 7 8 9]
    [2 4 6 8]

也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作：

import numpy as np
    
    # 解决汉字乱码
    from pylab import mpl
    mpl.rcParams['font.sans-serif'] = ['STZhongsong']    # 指定默认字体：解决plot不能显示中文问题
    mpl.rcParams['axes.unicode_minus'] = False 
    
    # 基于rang 函数，创建一维数组, 并且指定数据类型为int
    a = np.array(range(1, 10), dtype= int)
    print(a)
    # 使用slice 函数定义切片对象
    b = slice(1, 9, 2)
    # ndarray 对象进行切片
    print(a[b])
    
    # 使用冒号定义
    # ndarray 对象进行切片
    print(a[1:6:2])

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-5.py
    [1 2 3 4 5 6 7 8 9]
    [2 4 6 8]
    [2 4 6]

冒号 : 的解释：如果只放置一个参数，如 \[2\]，将返回与该索引相对应的单个元素。如果为 \[2:\]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 \[2:7\]，那么则提取两个索引(不包括停止索引)之间的项。

print(a[2:])
    print(a[2:7:])

[3 4 5 6 7 8 9]
    [3 4 5 6 7]

多维数组同样适用上述索引提取方法：

# 记录列表嵌套，定义二维数组
    b = np.array([[1,2,3],[4, 5, 6],[7, 8, 9]])
    # 从某个索引处开始切割
    print('从数组索引 b[1:] 处开始切割')
    print(b[1:])

从数组索引 b[1:] 处开始切割
    [[4 5 6]
     [7 8 9]]

切片还可以包括…，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray。

### numpy 高级索引 ###

NumPy 比一般的 Python 序列提供更多的索引方式。

除了之前看到的用整数和切片的索引外，数组可以由整数数组索引、布尔索引及花式索引。

#### 整数数组索引 ####

在 numpy 中，我们可以使用整数数组索引来获取数组中指定位置的元素。整数数组索引需要传入一个数组作为索引，该数组的每个元素表示要获取的原始数组中的位置。

# 整数数组索引
    c = np.array([["a", "b", "c"], ["d", "e", "f"], ["g", "h", "i"]])
    # 定义一个整数数组索引，获取原数组中的 (0,1), (1,2), (2,1), (2, 2) 四个位置的元素("b", "f", "h", "i")
    indices = np.array([[0, 1], [1, 2], [2, 1], [2, 2]])
    # 输出多维数组维数(0, 1)
    print(c.ndim)
    # 输出相关数组对于元素
    result = c[indices[:,0], indices[:,1]]
    
    print(result)

2
    ['b' 'f' 'h' 'i']

在上面的例子中，我们定义了一个二维数组 c，它的形状为 3x3。然后我们定义了一个整数数组索引 indices，它包含了四个元素。indices 中每个元素是一个数组，表示在原数组 c 中要获取的位置。我们将这个索引数组传入到 c 中，获取了原数组中 (0,0), (1,2), (2,1) ,(2, 2)四个位置的元素。注意，numpy 返回的结果是一个一维数组。

整数数组索引也可以用于修改数组中指定位置的元素。

# 整数数组索引
    d = np.array(range(1,13))
    print(d)
    # 一维数组 调整为3*4
    e = d.reshape(3, 4)
    print(e)
    
    # 定义一个整数数组索引，获取原数组中的 (0,1), (1,2), (2,1), (2, 2) 四个位置的元素(2, 7, 10, 11)
    eIndex = np.array([[0, 1], [1, 2], [2, 1], [2, 2]])
    # 指定元素 +10
    e[eIndex[:,0], eIndex[:,1]] += 10
    
    print(e)

[ 1  2  3  4  5  6  7  8  9 10 11 12]
    [[ 1  2  3  4]
     [ 5  6  7  8]
     [ 9 10 11 12]]
    [[ 1 12  3  4]
     [ 5  6 17  8]
     [ 9 20 21 12]]

上面的代码中，我们把 a 中 (0,1), (1,2), (2,1)，(2,2) 四个位置的元素都加了 10。可以看到，a 现在的值变成了\[\[ 1 12 3 4\] \[ 5 6 17 8\] \[ 9 20 21 12\]\]。

#### 布尔索引 ####

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

# 基于rang 函数 创建一维数组
    f = np.array(range(1, 13))
    
    # 调整一维数组的维度
    g = f.reshape(3, 4)
    
    # 打印出大于 5 的元素 
    print("大于5 的元素")
    print(g[g > 5])

大于5 的元素
    [ 6  7  8  9 10 11 12]

使用了 ~（取补运算符）来过滤 NaN。

import numpy as np 
     
    a = np.array([np.nan,  1,2,np.nan,3,4,5])  
    print (a[~np.isnan(a)])

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

从数组中过滤掉非复数元素。

import numpy as np 
     
    a = np.array([1,  2+6j,  5,  3.5+5j])  
    print (a[np.iscomplex(a)])

[2.0+6.j  3.5+5.j]

#### 花式索引 ####

花式索引指的是利用整数数组进行索引。

**花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。**

对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素，如果目标是二维数组，那么就是对应下标的行。

花式索引跟切片不一样，它总是将数据复制到新数组中。

#### 一维数组 ####

一维数组只有一个轴 axis = 0，所以一维数组就在 axis = 0 这个轴上取值：

import numpy as np
    
    x = np.arange(9)
    print(x)
    # 一维数组读取指定下标对应的元素
    print("-------读取下标对应的元素-------")
    x2 = x[[0, 6]] # 使用花式索引
    print(x2)
    
    print(x2[0])
    print(x2[1])

[0 1 2 3 4 5 6 7 8]
    -------读取下标对应的元素-------
    [0 6]
    0
    6

#### 二维数组 ####

1、传入顺序索引数组

import numpy as np 
     
    x=np.arange(32).reshape((8,4))
    print(x)
    # 二维数组读取指定下标对应的行
    print("-------读取下标对应的行-------")
    print (x[[4,2,1,7]])

print (x\[\[4,2,1,7\]\]) 输出下表为 4, 2, 1, 7 对应的行，输出结果为：

[[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]
     [12 13 14 15]
     [16 17 18 19]
     [20 21 22 23]
     [24 25 26 27]
     [28 29 30 31]]
    -------读取下标对应的行-------
    [[16 17 18 19]
     [ 8  9 10 11]
     [ 4  5  6  7]
     [28 29 30 31]]

2、传入倒序索引数组

import numpy as np 
     
    x=np.arange(32).reshape((8,4))
    print (x[[-4,-2,-1,-7]])

[[16 17 18 19]
     [24 25 26 27]
     [28 29 30 31]
     [ 4  5  6  7]]

3、传入多个索引数组（要使用 np.ix\_）

np.ix\_ 函数就是输入两个数组，产生笛卡尔积的映射关系。

笛卡尔乘积是指在数学中，两个集合 X 和 Y 的笛卡尔积（Cartesian product），又称直积，表示为 X×Y，第一个对象是X的成员而第二个对象是 Y 的所有可能有序对的其中一个成员。

例如\*\* A=\{a,b\}, B=\{0,1,2\}\*\*，则：

A×B={(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)}
    B×A={(0, a), (0, b), (1, a), (1, b), (2, a), (2, b)}

import numpy as np
    
    x=np.arange(32).reshape((8,4))
    print (x[np.ix_([1,5,7,2],[0,3,1,2])])

[[ 4 7 5 6]
    [20 23 21 22]
    [28 31 29 30]
    [ 8 11 9 10]]

### numpy操作 ###

#### 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')

该上述代码:使用 arange() 函数创建一个 2X3 数组，并使用 nditer 对它进行迭代。

原始数组是：
    [[0 1 2]
     [3 4 5]]
    
    
    迭代输出元素：
    0, 1, 2, 3, 4, 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(6).reshape(2,3)
    print ('原始数组是：')
    print (a)
    print ('\n')
    print ('迭代输出元素：')
    for x in np.nditer(a, order="F"):
        print (x, end=", " )
    print ('\n')

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

#### numpy 操作之数组操作 ####

**修改数组形状**

<table> 
 <thead> 
  <tr> 
   <th>函数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>reshape</code></td> 
   <td>不改变数据的条件下修改形状</td> 
  </tr> 
  <tr> 
   <td><code>flat</code></td> 
   <td>数组元素迭代器</td> 
  </tr> 
  <tr> 
   <td><code>flatten</code></td> 
   <td>返回一份数组拷贝，对拷贝所做的修改不会影响原始数组</td> 
  </tr> 
  <tr> 
   <td><code>ravel</code></td> 
   <td>返回展开数组</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)
    
    # 修改数组形状
    b = a.reshape(4,2)
    
    print(b)

#### 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)

#### 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.flatten())
    print ('\n')
    
    print ('以 F 风格顺序展开的数组：')
    print (a.flatten(order = 'F'))

#### 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 ('调用 ravel 函数之后：')
    print (a.ravel())
    print ('\n')
     
    print ('以 F 风格顺序调用 ravel 函数之后：')
    print (a.ravel(order = 'F'))

**翻转数组**

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

#### numpy.transpose ####

numpy.transpose 函数用于对换数组的维度，格式如下：

numpy.transpose(arr, axes)

参数说明:

*  `arr`：要操作的数组
 *  `axes`：整数列表，对应维度，通常所有维度都会对换。

import numpy as np
     
    a = np.arange(12).reshape(3,4)
    
    print ('对换数组：')
    print (np.transpose(a))

numpy.ndarray.T 功能类似 numpy.transpose：

import numpy as np
     
    a = np.arange(12).reshape(3,4)
    
    print ('对换数组：')
    print (a.T)

#### numpy.rollaxis ####

numpy.rollaxis 函数向后滚动特定的轴到一个特定位置，格式如下：

numpy.rollaxis(arr, axis, start)

参数说明：

*  `arr`：数组
 *  `axis`：要向后滚动的轴，其它轴的相对位置不会改变
 *  `start`：默认为零，表示完整的滚动。会滚动到特定位置。

import numpy as np 
    
    # 声明一个三维数组
    a = np.arange(24).reshape(2, 3, 4)
    
    print(a)
    
    print("\n")
    # 将轴 2 滚动到轴 0（宽度到深度）
    b = np.rollaxis(a,2,0)
    
    print(b)
    print("\n")
    # 将轴 2 滚动到轴 1（宽度到深度）
    c  = np.rollaxis(a,2,1)
    
    print(c)

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-8.py
    [[[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]
    
     [[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]]
    
    
    [[[ 0  4  8]
      [12 16 20]]
    
     [[ 1  5  9]
      [13 17 21]]
    
     [[ 2  6 10]
      [14 18 22]]
    
     [[ 3  7 11]
      [15 19 23]]]
    
    
    [[[ 0  4  8]
      [ 1  5  9]
      [ 2  6 10]
      [ 3  7 11]]
    
     [[12 16 20]
      [13 17 21]
      [14 18 22]
      [15 19 23]]]

#### numpy.swapaxes ####

numpy.swapaxes 函数用于交换数组的两个轴，格式如下

numpy.swapaxes(arr, axis1, axis2)

参数说明:

*  `arr`：输入的数组
 *  `axis1`：对应第一个轴的整数
 *  `axis2`：对应第二个轴的整数

import numpy as np 
    
    # 声明一个三维数组
    a = np.arange(24).reshape(2, 3, 4)
    
    print(a)
    print("\n")
    
    # 现在交换轴 0（深度方向）到轴 2（宽度方向）
    print ('调用 swapaxes 函数后的数组：')
    print (np.swapaxes(a, 2, 0))

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-9.py
    [[[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]
    
     [[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]]
    
    
    调用 swapaxes 函数后的数组：
    [[[ 0 12]
      [ 4 16]
      [ 8 20]]
    
     [[ 1 13]
      [ 5 17]
      [ 9 21]]
    
     [[ 2 14]
      [ 6 18]
      [10 22]]
    
     [[ 3 15]
      [ 7 19]
      [11 23]]]

**修改数组维度**

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

#### numpy.broadcast ####

numpy.broadcast 用于模仿广播的对象，它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果。

import numpy as np 
    
    a =  np.array([1, 3, 5, 7, 9])
    b = np.array([2, 4, 6, 8, 10])
    
    # a 对 b 广播
    c = np.broadcast(a, b)
    print(c)
    
    # 它拥有 iterator 属性，基于自身组件的迭代器元组
    for key, value in enumerate(c.iters):
        print(key)
        print(type(value))
        for item in value:
            print(item)
        print("\n")

#### numpy.broadcast\_to ####

numpy.broadcast\_to 函数将数组广播到新形状。它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则，该函数可能会抛出ValueError。

numpy.broadcast_to(array, shape, subok)

import numpy as np
    
    # 构建3维度数组
    a = np.arange(12).reshape(1, 12)
    
    print(a)
    print("\n")
    print ('调用 broadcast_to 函数之后：')
    print (np.broadcast_to(a,(3,12)))

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-10.py
    [[ 0  1  2  3  4  5  6  7  8  9 10 11]]
    
    
    调用 broadcast_to 函数之后：
    [[ 0  1  2  3  4  5  6  7  8  9 10 11]
     [ 0  1  2  3  4  5  6  7  8  9 10 11]
     [ 0  1  2  3  4  5  6  7  8  9 10 11]]

#### numpy.expand\_dims ####

numpy.expand\_dims 函数通过在指定位置插入新的轴来扩展数组形状，函数格式如下:

numpy.expand_dims(arr, axis)

参数说明：

*  `arr`：输入数组
 *  `axis`：新轴插入的位置

b = np.array(([1,2],[3,4]))
    
    print(b)
    print("\n")
    
    c = np.expand_dims(b, axis = 0)
    print(c)
    print("\n")

[[1 2]
     [3 4]]
    
    
    [[[1 2]
      [3 4]]]

#### numpy.squeeze ####

numpy.squeeze 函数从给定数组的形状中删除一维的条目，函数格式如下：

numpy.squeeze(arr, axis)

参数说明：

*  `arr`：输入数组
 *  `axis`：整数或整数元组，用于选择形状中一维条目的子集

b = np.array([1, 2, 3, 4])
    
    print(b)
    print("\n")
    
    c = np.squeeze(b)
    print(c)

**连接数组**

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

#### numpy.concatenate ####

numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下：

numpy.concatenate((a1, a2, ...), axis)

参数说明：

*  `a1, a2, ...`：相同类型的数组
 *  `axis`：沿着它连接数组的轴，默认为 0

d = np.array([[1, 2], [3, 4]])
    e = np.array([[5, 6], [7, 8]])
    
    f = np.concatenate((d, e), axis = 0)
    print(f)

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

#### numpy.stack ####

numpy.stack 函数用于沿新轴连接数组序列，格式如下：

numpy.stack(arrays, axis)

参数说明：

*  `arrays`相同形状的数组序列
 *  `axis`：返回数组中的轴，输入数组沿着它来堆叠

d = np.array([[1, 2], [3, 4]])
    e = np.array([[5, 6], [7, 8]])
    
    f = np.concatenate((d, e), axis = 0)
    print(f)
    
    g = np.stack((d, e), axis=0)
    print(g)

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-10.py
    [[1 2]
     [3 4]
     [5 6]
     [7 8]]
    [[[1 2]
      [3 4]]
    
     [[5 6]
      [7 8]]]

#### numpy.hstack ####

numpy.hstack 是 numpy.stack 函数的变体，它通过水平堆叠来生成数组。

#### numpy.vstack ####

numpy.vstack 是 numpy.stack 函数的变体，它通过垂直堆叠来生成数组。

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-10.py
    [[1 2]
     [5 6]
     [7 8]]
    [[[1 2]
      [3 4]]
    
     [[5 6]
      [7 8]]]
    [[1 2 5 6]
     [3 4 7 8]]
    [[1 2]
     [3 4]
     [5 6]
     [7 8]]

**分隔数组**

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

#### numpy.split ####

numpy.split 函数沿特定的轴将数组分割为子数组，格式如下：

numpy.split(ary, indices_or_sections, axis)

参数说明：

*  `ary`：被分割的数组
 *  `indices_or_sections`：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
 *  `axis`：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。

import numpy as np
    
    # 构建3维度数组
    
    
    d = np.array([[1, 2], [3, 4]])
    e = np.array([[5, 6], [7, 8]])
    
    f = np.concatenate((d, e), axis = 0)
    print(f)
    
    g = np.stack((d, e), axis=0)
    print(g)
    
    h = np.hstack((d, e))
    print(h)
    
    i = np.vstack((d, e))
    print(i)
    
    print(np.split(i, indices_or_sections = 2))

#### numpy.hsplit ####

numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-10.py
    [[1 2]
     [3 4]
     [5 6]
     [7 8]]
    [[[1 2]
      [3 4]]
    
     [[5 6]
      [7 8]]]
    [[1 2 5 6]
     [3 4 7 8]]
    [[1 2]
     [3 4]
     [5 6]
     [7 8]]
    
    
    [array([[1, 2],
           [3, 4]]), array([[5, 6],
           [7, 8]])]
    
    
    [array([[1],
           [3],
           [5],
           [7]]), array([[2],
           [4],
           [6],
           [8]])]

#### numpy.vsplit ####

numpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同。

**数据元素添加和修改**

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

#### numpy.resize ####

numpy.resize 函数返回指定大小的新数组。

如果新数组大小大于原始大小，则包含原始数组中的元素的副本。

numpy.resize(arr, shape)

参数说明：

*  `arr`：要修改大小的数组
 *  `shape`：返回数组的新形状

import numpy as np
    
    a = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
    print(a)
    print("\n")
    print(a.shape)
    print("\n")
    
    b = np.resize(a, (5, 2))
    print("\n")
    print(b)

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-11.py
    [[ 1  2  3  4  5]
     [ 6  7  8  9 10]]
    
    
    (2, 5)
    
    
    
    
    [[ 1  2]
     [ 3  4]
     [ 5  6]
     [ 7  8]
     [ 9 10]]

#### numpy.append ####

numpy.append 函数在数组的末尾添加值。 追加操作会分配整个数组，并把原来的数组复制到新数组中。 此外，输入数组的维度必须匹配否则将生成ValueError。

append 函数返回的始终是一个一维数组。

numpy.append(arr, values, axis=None)

参数说明：

*  `arr`：输入数组
 *  `values`：要向`arr`添加的值，需要和`arr`形状相同（除了要添加的轴）
 *  `axis`：默认为 None。当axis无定义时，是横向加成，返回总是为一维数组！当axis有定义的时候，分别为0和1的时候。当axis有定义的时候，分别为0和1的时候（列数要相同）。当axis为1时，数组是加在右边（行数要相同）。

import numpy as np
    
    a = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
    print(a)
    print("\n")
    print(a.shape)
    print("\n")
    
    b = np.resize(a, (5, 2))
    print("\n")
    print(b)
    
    e = np.append(b,[11, 12])
    print("\n")
    print(e)

#### numpy.insert ####

numpy.insert 函数在给定索引之前，沿给定轴在输入数组中插入值。

如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开。

numpy.insert(arr, obj, values, axis)

参数说明：

*  `arr`：输入数组
 *  `obj`：在其之前插入值的索引
 *  `values`：要插入的值
 *  `axis`：沿着它插入的轴，如果未提供，则输入数组会被展开

#### numpy.delete ####

numpy.delete 函数返回从输入数组中删除指定子数组的新数组。 与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。

Numpy.delete(arr, obj, axis)

参数说明：

*  `arr`：输入数组
 *  `obj`：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
 *  `axis`：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开

g = np.delete(b,1, axis= 1)
    print("\n")
    print(g)

[[1]
     [3]
     [5]
     [7]
     [9]]

#### numpy.unique ####

numpy.unique 函数用于去除数组中的重复元素。

numpy.unique(arr, return_index, return_inverse, return_counts)

*  `arr`：输入数组，如果不是一维数组则会展开
 *  `return_index`：如果为`true`，返回新列表元素在旧列表中的位置（下标），并以列表形式储
 *  `return_inverse`：如果为`true`，返回旧列表元素在新列表中的位置（下标），并以列表形式储
 *  `return_counts`：如果为`true`，返回去重数组中的元素在原数组中的出现次数

h = np.unique(b)
    print("\n")
    print(h)

[ 1  2  3  4  5  6  7  8  9 10]

## **numpy数组的运算和聚合统计，如数学运算、统计计算等操作** ##

### numpy 字符串函数 ###

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

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

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

#### numpy.char.add() ####

numpy.char.add() 函数依次对两个数组的元素进行字符串连接。

import numpy as np
    
    a = np.char.add(["Hello "], ["Python 3"])
    print(a)
    print("\n")

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-12.py
    ['Hello Python 3']

#### numpy.char.multiply() ####

numpy.char.multiply() 函数执行多重连接。

b = np.char.multiply(["Hello ", "SpringBoot "], 3)
    print(b)
    print("\n")

['Hello Hello Hello ' 'SpringBoot SpringBoot SpringBoot ']

#### numpy.char.center() ####

numpy.char.center() 函数用于将字符串居中，并使用指定字符在左侧和右侧进行填充。

c = np.char.center("Python 3", 20, "*")
    print(c)
    print("\n")

******Python 3******

#### numpy.char.capitalize() ####

numpy.char.capitalize() 函数将字符串的第一个字母转换为大写：

d = np.char.capitalize("python 3")
    print(d)
    print("\n")

Python 3

#### numpy.char.title() ####

numpy.char.title() 函数将字符串的每个单词的第一个字母转换为大写：

print (np.char.title('i like python3'))

#### numpy.char.lower() ####

numpy.char.lower() 函数对数组的每个元素转换为小写。它对每个元素调用 str.lower。

print (np.char.lower('PYTHON3'))

#### numpy.char.upper() ####

numpy.char.upper() 函数对数组的每个元素转换为大写。它对每个元素调用 str.upper。

print (np.char.upper('python3'))

#### numpy.char.split() ####

numpy.char.split() 通过指定分隔符对字符串进行分割，并返回数组。默认情况下，分隔符为空格。

# 分隔符为 .
    print (np.char.split ('www.csdn.com', sep = '.'))

#### numpy.char.splitlines() ####

numpy.char.splitlines() 函数以换行符作为分隔符来分割字符串，并返回数组。

# 换行符 \n
    print (np.char.splitlines('i\nlike python3'))

#### numpy.char.strip() ####

numpy.char.strip() 函数用于移除开头或结尾处的特定字符。

# 移除字符串头尾的 a 字符
    print (np.char.strip('ask me','a'))

#### numpy.char.join() ####

numpy.char.join() 函数通过指定分隔符来连接数组中的元素或字符串

print (np.char.join(':','python3'))

#### numpy.char.replace() ####

numpy.char.replace() 函数使用新字符串替换字符串中的所有子字符串。

print (np.char.replace ('i like python2', '2', '3'))

#### numpy.char.encode() ####

numpy.char.encode() 函数对数组中的每个元素调用 str.encode 函数。 默认编码是 utf-8，可以使用标准 Python 库中的编解码器。

a = np.char.encode('runoob', 'cp500') 
    print (a)

#### numpy.char.decode() ####

numpy.char.decode() 函数对编码的元素进行 str.decode() 解码。

a = np.char.encode('runoob', 'cp500') 
    print (a)
    print (np.char.decode(a,'cp500'))

### 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))

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

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

numpy.around(a,decimals)

参数说明：

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

import numpy as np
    
    # 定义一个一维数组
    a = np.array([99.123, 45.12, 10])
    
    # 对数组进行四舍五入
    b = np.around(a, 2)
    print(b)

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-13.py
    [99.12 45.12 10.  ]

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

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

c = np.array([-1.2, 1.3, -2.5, 2.5])
    # 对数组向下取整
    d = np.floor(c)
    print(d)

[-2.  1. -3.  2.]

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

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

c = np.array([-1.2, 1.3, -2.5, 2.5])
    # 对数组向下取整
    d = np.floor(c)
    print(d)
    
    # 对数组向上取整
    e = np.ceil(c)
    print(e)

[-1.  2. -2.  3.]

### numpy 算术函数 ###

NumPy 算术函数包含简单的加减乘除: **add()**，**subtract()**，**multiply()** 和 **divide()**。

温馨提示：数组必须具有相同的形状。

import  numpy  as np
    
    a = np.array([1, 2, 3, 4, 5])
    b = np.array([6, 7, 8, 9, 10])
    
    # 加法
    c = np.add(a, b)
    print(c)
    
    # 减法
    e = np.subtract(b, a)
    print(e)
    
    # 乘法
    f = np.multiply(a, b)
    print(f)
    
    # 除法
    g = np.divide(b, a)
    print(g)

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-15.py
    [ 7  9 11 13 15]
    [5 5 5 5 5]
    [ 6 14 24 36 50]
    [6.         3.5        2.66666667 2.25       2.        ]

#### numpy.reciprocal() ####

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

h = np.array([0.25])
    i = np.reciprocal(h)
    print(i)

#### numpy.power() ####

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

j = np.array([10, 100, 10000])
    print(np.power(j, 2))

[      100     10000 100000000]

#### numpy.mod() ####

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

k = np.array([30, 20, 10])
    l = np.array([6, 5, 3])
    print(np.mod(k,l))

[0 0 1]

### numpy 统计函数 ###

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

#### numpy.amin() 和 numpy.amax() ####

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

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

import numpy as np
    
    # 定义三维数组
    a = np.array([[1, 5, 21], [103, 12, 5], [209, 23, 11]])
    
    # 获取指定轴最大值
    print(np.amin(a, 1))
    # 获取指定轴最大值
    print(np.amax(a, 1))

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-16.py
    [ 1  5 11]
    [ 21 103 209]

#### numpy.ptp() ####

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

# 获取最大值与最小值之差
    print(np.ptp(a))

208

#### numpy.percentile() ####

百分位数是统计中使用的度量，表示小于这个值的观察值的百分比。 函数numpy.percentile()接受以下参数。

numpy.percentile(a, q, axis)

import numpy as np 
     
    a = np.array([[10, 7, 4], [3, 2, 1]])
    print ('我们的数组是：')
    print (a)
     
    print ('调用 percentile() 函数：')
    # 50% 的分位数，就是 a 里排序之后的中位数
    print (np.percentile(a, 50)) 
     
    # axis 为 0，在纵列上求
    print (np.percentile(a, 50, axis=0)) 
     
    # axis 为 1，在横行上求
    print (np.percentile(a, 50, axis=1)) 
     
    # 保持维度不变
    print (np.percentile(a, 50, axis=1, keepdims=True))

#### 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))

#### 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))

#### numpy.average() ####

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

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

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

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

加权平均值 = (1*4+2*3+3*2+4*1)/(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))

#### 标准差 ####

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

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

标准差公式如下：

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]))

#### 方差 ####

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

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

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

### numpy 排序、条件筛选函数 ###

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

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

#### numpy.sort() ####

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\]。

#### msort、sort\_complex、partition、argpartition ####

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

复数排序：

>>> import numpy as np
    >>> np.sort_complex([5, 3, 6, 2, 1])
    array([ 1.+0.j,  2.+0.j,  3.+0.j,  5.+0.j,  6.+0.j])
    >>>
    >>> np.sort_complex([1 + 2j, 2 - 1j, 3 - 2j, 3 - 3j, 3 + 5j])
    array([ 1.+2.j,  2.-1.j,  3.-3.j,  3.-2.j,  3.+5.j])

partition() 分区排序：

>>> a = np.array([3, 4, 2, 1])
    >>> np.partition(a, 3)  # 将数组 a 中所有元素（包括重复元素）从小到大排列，3 表示的是排序数组索引为 3 的数字，比该数字小的排在该数字前面，比该数字大的排在该数字的后面
    array([2, 1, 3, 4])
    >>>
    >>> np.partition(a, (1, 3)) # 小于 1 的在前面，大于 3 的在后面，1和3之间的在中间
    array([1, 2, 3, 4])

找到数组的第 3 小（index=2）的值和第 2 大（index=-2）的值

>>> arr = np.array([46, 57, 23, 39, 1, 10, 0, 120])
    >>> arr[np.argpartition(arr, 2)[2]]
    10
    >>> arr[np.argpartition(arr, -2)[-2]]
    57

同时找到第 3 和第 4 小的值。注意这里，用 \[2,3\] 同时将第 3 和第 4 小的排序好，然后可以分别通过下标 \[2\] 和 \[3\] 取得。

>>> arr[np.argpartition(arr, [2,3])[2]]
    10
    >>> arr[np.argpartition(arr, [2,3])[3]]
    23

#### numpy.argmax() 和 numpy.argmin() ####

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

### 实例 ###

import numpy as np 
     
    a = np.array([[30,40,70],[80,20,10],[50,90,60]])  
    print  ('我们的数组是：') 
    print (a) 
    print ('\n') 
    print ('调用 argmax() 函数：') 
    print (np.argmax(a)) 
    print ('\n') 
    print ('展开数组：') 
    print (a.flatten()) 
    print ('\n') 
    print ('沿轴 0 的最大值索引：') 
    maxindex = np.argmax(a, axis =  0)  
    print (maxindex) 
    print ('\n') 
    print ('沿轴 1 的最大值索引：') 
    maxindex = np.argmax(a, axis =  1)  
    print (maxindex) 
    print ('\n') 
    print ('调用 argmin() 函数：') 
    minindex = np.argmin(a)  
    print (minindex) 
    print ('\n') 
    print ('展开数组中的最小值：') 
    print (a.flatten()[minindex]) 
    print ('\n') 
    print ('沿轴 0 的最小值索引：') 
    minindex = np.argmin(a, axis =  0)  
    print (minindex) 
    print ('\n') 
    print ('沿轴 1 的最小值索引：') 
    minindex = np.argmin(a, axis =  1)  
    print (minindex)

输出结果为：

我们的数组是：
    [[30 40 70]
     [80 20 10]
     [50 90 60]]
    
    
    调用 argmax() 函数：
    7
    
    
    展开数组：
    [30 40 70 80 20 10 50 90 60]
    
    
    沿轴 0 的最大值索引：
    [1 2 0]
    
    
    沿轴 1 的最大值索引：
    [2 0 1]
    
    
    调用 argmin() 函数：
    5
    
    
    展开数组中的最小值：
    10
    
    
    沿轴 0 的最小值索引：
    [0 1 1]
    
    
    沿轴 1 的最小值索引：
    [0 2 0]

#### numpy.nonzero() ####

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

### 实例 ###

import numpy as np 
     
    a = np.array([[30,40,0],[0,20,10],[50,0,60]])  
    print ('我们的数组是：')
    print (a)
    print ('\n')
    print ('调用 nonzero() 函数：')
    print (np.nonzero (a))

输出结果为：

我们的数组是：
    [[30 40  0]
     [ 0 20 10]
     [50  0 60]]
    
    
    调用 nonzero() 函数：
    (array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))

#### numpy.where() ####

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

### 实例 ###

import numpy as np 
     
    x = np.arange(9.).reshape(3,  3)  
    print ('我们的数组是：')
    print (x)
    print ( '大于 3 的元素的索引：')
    y = np.where(x >  3)  
    print (y)
    print ('使用这些索引来获取满足条件的元素：')
    print (x[y])

输出结果为：

我们的数组是：
    [[0. 1. 2.]
     [3. 4. 5.]
     [6. 7. 8.]]
    大于 3 的元素的索引：
    (array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))
    使用这些索引来获取满足条件的元素：
    [4. 5. 6. 7. 8.]

#### numpy.extract() ####

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

### 实例 ###

import numpy as np 
     
    x = np.arange(9.).reshape(3,  3)  
    print ('我们的数组是：')
    print (x)
    # 定义条件, 选择偶数元素
    condition = np.mod(x,2)  ==  0  
    print ('按元素的条件值：')
    print (condition)
    print ('使用条件提取元素：')
    print (np.extract(condition, x))

输出结果为：

我们的数组是：
    [[0. 1. 2.]
     [3. 4. 5.]
     [6. 7. 8.]]
    按元素的条件值：
    [[ True False  True]
     [False  True False]
     [ True False  True]]
    使用条件提取元素：
    [0. 2. 4. 6. 8.]

###    numpy高级操作，如数组的交换、副本和视图、矩阵库、线性代数等操作 ###

#### NumPy 字节交换 ####

在几乎所有的机器上，多字节对象都被存储为连续的字节序列。字节顺序，是跨越多字节的程序对象的存储规则。

*  **大端模式：**指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；这和我们的阅读习惯一致。
 *  **小端模式：**指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低。

例如在 C 语言中，一个类型为 int 的变量 x 地址为 0x100，那么其对应地址表达式&x的值为 0x100。且x的四个字节将被存储在存储器的 0x100, 0x101, 0x102, 0x103位置。

![65e4aba92603ae2ba38e8856237c935c.png][]

#### numpy.ndarray.byteswap() ####

numpy.ndarray.byteswap() 函数将 ndarray 中每个元素中的字节进行大小端转换。

b = np.array([1, 10, 100])
    
    print(b.byteswap(True))

#### NumPy 副本和视图 ####

副本是一个数据的完整的拷贝，如果我们对副本进行修改，它不会影响到原始数据，物理内存不在同一位置。

视图是数据的一个别称或引用，通过该别称或引用亦便可访问、操作原有数据，但原有数据不会产生拷贝。如果我们对视图进行修改，它会影响到原始数据，物理内存在同一位置。

**视图一般发生在：**

*  1、numpy 的切片操作返回原数据的视图。
 *  2、调用 ndarray 的 view() 函数产生一个视图。

**副本一般发生在：**

*  Python 序列的切片操作，调用deepCopy()函数。
 *  调用 ndarray 的 copy() 函数产生一个副本。

**无复制**

简单的赋值不会创建数组对象的副本。 相反，它使用原始数组的相同id()来访问它。 id()返回 Python 对象的通用标识符，类似于 C 中的指针。

此外，一个数组的任何变化都反映在另一个数组上。 例如，一个数组的形状改变也会改变另一个数组的形状。

b = np.array([1, 10, 100])
    
    print (id(b))
    
    c = b
    
    print(id(c))

2758948287184
    2758948287184

**视图或浅拷贝**

ndarray.view() 方会创建一个新的数组对象，该方法创建的新数组的维数变化不会改变原始数据的维数。

import numpy as np
    
    # 定义三维数组
    a = np.array([[1, 5, 21], [103, 12, 5], [209, 23, 11]])
    
    # 获取指定轴最大值
    print(np.amin(a, 1))
    # 获取指定轴最大值
    print(np.amax(a, 1))
    
    # 获取最大值与最小值之差
    print(np.ptp(a))
    # 指定轴
    print(np.ptp(a, 1))
    
    b = np.array([1, 10, 100])
    
    print (id(b))
    
    c = b
    
    print(id(c))
    
    # 浅拷贝/视图
    d = b.view()
    
    print(d)

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-16.py
    [ 1  5 11]
    [ 21 103 209]
    208
    [ 20  98 198]
    2267694166736
    2267694166736
    [  1  10 100]

#### 副本或深拷贝 ####

ndarray.copy() 函数创建一个副本。 对副本数据进行修改，不会影响到原始数据，它们物理内存不在同一位置。

#### NumPy 矩阵库(Matrix) ####

NumPy 中包含了一个矩阵库 numpy.matlib，该模块中的函数返回的是一个矩阵，而不是 ndarray 对象。

一个 M\*N的矩阵是一个由M行（row）N列（column）元素排列成的矩形阵列。

#### 转置矩阵 ####

NumPy 中除了可以使用 numpy.transpose 函数来对换数组的维度，还可以使用 T 属性。。

例如有个 m 行 n 列的矩阵，使用 t() 函数就能转换为 n 行 m 列的矩阵。

import numpy as np
    
    a = np.arange(12).reshape(3, 4)
    
    print(a)
    print("\n")
    
    print(a.T)

PS E:\py_workspace\conda-demo> & D:/anaconda3/envs/python310/python.exe e:/py_workspace/conda-demo/numpy-17.py
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    
    
    [[ 0  4  8]
     [ 1  5  9]
     [ 2  6 10]
     [ 3  7 11]]

#### matlib.empty() ####

matlib.empty() 函数返回一个新的矩阵，语法格式为：

numpy.matlib.empty(shape, dtype, order)

**参数说明：**

*  **shape**: 定义新矩阵形状的整数或整数元组
 *  **Dtype**: 可选，数据类型
 *  **order**: C（行序优先） 或者 F（列序优先）

import numpy as np
    import numpy.matlib 
    
    a = np.arange(12).reshape(3, 4)
    
    print(a)
    print("\n")
    
    print(a.T)
    print("\n")
    
    # 填充随机数
    print (numpy.matlib.empty((2,2)))

#### numpy.matlib.zeros() ####

numpy.matlib.zeros() 函数创建一个以 0 填充的矩阵。

# 创建填充为0，并且指定形状的矩阵
    print(numpy.matlib.zeros((3, 4)))

[[0. 0. 0. 0.]
     [0. 0. 0. 0.]
     [0. 0. 0. 0.]]

#### numpy.matlib.ones() ####

numpy.matlib.ones()函数创建一个以 1 填充的矩阵。

# 创建填充为1，并且指定形状的矩阵
    print(numpy.matlib.ones((3, 4)))

[[1. 1. 1. 1.]
     [1. 1. 1. 1.]
     [1. 1. 1. 1.]]

#### numpy.matlib.eye() ####

numpy.matlib.eye() 函数返回一个矩阵，对角线元素为

[[1. 0. 0. 0.]
     [0. 1. 0. 0.]
     [0. 0. 1. 0.]]

1，其他位置为零。

numpy.matlib.eye(n, M,k, dtype)

**参数说明：**

*  **n**: 返回矩阵的行数
 *  **M**: 返回矩阵的列数，默认为 n
 *  **k**: 对角线的索引
 *  **dtype**: 数据类型

import numpy.matlib 
    import numpy as np 
     
    print (np.matlib.eye(n =  3, M =  4, k =  0, dtype =  float))

[[1. 0. 0. 0.]
     [0. 1. 0. 0.]
     [0. 0. 1. 0.]]

#### numpy.matlib.identity() ####

numpy.matlib.identity() 函数返回给定大小的单位矩阵。

单位矩阵是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为 1，除此以外全都为 0。

import numpy.matlib 
    import numpy as np 
     
    # 大小为 5，类型位浮点型
    print (np.matlib.identity(5, dtype =  float))

[[ 1.  0.  0.  0.  0.] 
     [ 0.  1.  0.  0.  0.] 
     [ 0.  0.  1.  0.  0.] 
     [ 0.  0.  0.  1.  0.] 
     [ 0.  0.  0.  0.  1.]]

#### numpy.matlib.rand() ####

numpy.matlib.rand() 函数创建一个给定大小的矩阵，数据是随机填充的。

import numpy.matlib 
    import numpy as np 
     
    print (np.matlib.rand(3,3))

[[0.23966718 0.16147628 0.14162   ]
     [0.28379085 0.59934741 0.62985825]
     [0.99527238 0.11137883 0.41105367]]

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

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

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

#### numpy.dot() ####

numpy.dot() 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和(数学上称之为向量点积)；对于二维数组，计算的是两个数组的矩阵乘积；对于多维数组，它的通用计算公式如下，即结果数组中的每个元素都是：数组a的最后一维上的所有元素与数组b的倒数第二位上的所有元素的乘积和： dot(a, b)\[i,j,k,m\] = sum(a\[i,j,:\] \* b\[k,:,m\])。

numpy.dot(a, b, out=None)

**参数说明：**

*  **a** : ndarray 数组
 *  **b** : ndarray 数组
 *  **out** : ndarray, 可选，用来保存dot()的计算结果

import numpy.matlib
    import numpy as np
     
    a = np.array([[1,2],[3,4]])
    b = np.array([[11,12],[13,14]])
    print(np.dot(a,b))

[[37  40] 
     [85  92]]

计算式为：

[[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]]

#### numpy.vdot() ####

numpy.vdot() 函数是两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数是多维数组，它会被展开。

import numpy as np 
     
    a = np.array([[1,2],[3,4]]) 
    b = np.array([[11,12],[13,14]]) 
     
    # vdot 将数组展开计算内积
    print (np.vdot(a,b))

130

计算式为：

1*11 + 2*12 + 3*13 + 4*14 = 130

#### numpy.inner() ####

numpy.inner() 函数返回一维数组的向量内积。对于更高的维度，它返回最后一个轴上的和的乘积。

import numpy as np 
     
    print (np.inner(np.array([1,2,3]),np.array([0,1,0])))
    # 等价于 1*0+2*1+3*0

#### numpy.matmul ####

numpy.matmul 函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。

另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。

对于二维数组，它就是矩阵乘法：

import numpy.matlib 
    import numpy as np 
     
    a = [[1,0],[0,1]] 
    b = [[4,1],[2,2]] 
    print (np.matmul(a,b))

[[4  1] 
     [2  2]]

#### numpy.linalg.det() ####

numpy.linalg.det() 函数计算输入矩阵的行列式。

行列式在线性代数中是非常有用的值。 它从方阵的对角元素计算。 对于 2×2 矩阵，它是左上和右下元素的乘积与其他两个的乘积的差。

换句话说，对于矩阵\[\[a，b\]，\[c，d\]\]，行列式计算为 ad-bc。 较大的方阵被认为是 2×2 矩阵的组合。

import numpy as np
    a = np.array([[1,2], [3,4]]) 
     
    print (np.linalg.det(a))

-2.0

#### numpy.linalg.solve() ####

numpy.linalg.solve() 函数给出了矩阵形式的线性方程的解。

#### numpy.linalg.inv() ####

numpy.linalg.inv() 函数计算矩阵的乘法逆矩阵。

**逆矩阵（inverse matrix）**：设A是数域上的一个n阶矩阵，若在相同数域上存在另一个n阶矩阵B，使得： AB=BA=E ，则我们称B是A的逆矩阵，而A则被称为可逆矩阵。注：E为单位矩阵。

import numpy as np 
     
    x = np.array([[1,2],[3,4]]) 
    y = np.linalg.inv(x) 
    print (x)
    print (y)
    print (np.dot(x,y))

[[1 2]
     [3 4]]
    [[-2.   1. ]
     [ 1.5 -0.5]]
    [[1.0000000e+00 0.0000000e+00]
     [8.8817842e-16 1.0000000e+00]]

[Link 1]: https://so.csdn.net/so/search?q=%E6%95%B0%E7%BB%84&spm=1001.2101.3001.7020
[Link 2]: https://so.csdn.net/so/search?q=%E7%9F%A9%E9%98%B5%E8%BF%90%E7%AE%97&spm=1001.2101.3001.7020
[58c1a088ce6c17a14cfc406daee67fcc.jpeg]: https://img-blog.csdnimg.cn/img_convert/58c1a088ce6c17a14cfc406daee67fcc.jpeg
[e33e7f758c104edf9aedb8b6476fd0f9.png]: https://img-blog.csdnimg.cn/e33e7f758c104edf9aedb8b6476fd0f9.png
[20210702130648654.jpg_pic_center]: https://img-blog.csdnimg.cn/20210702130648654.jpg#pic_center
[998c04628f084155bb112e22b85f6bb2.png]: https://img-blog.csdnimg.cn/998c04628f084155bb112e22b85f6bb2.png
[3e4d6f9310804f8fa27358600cd0382f.png]: https://img-blog.csdnimg.cn/3e4d6f9310804f8fa27358600cd0382f.png
[6d49e8952eaf4694bf72b78a94b19b8e.png]: https://img-blog.csdnimg.cn/6d49e8952eaf4694bf72b78a94b19b8e.png
[fdbc376d2a7745a2a0d2a28e6dbb5175.png]: https://img-blog.csdnimg.cn/fdbc376d2a7745a2a0d2a28e6dbb5175.png
[1aeff98608c34ab3b5f3f1eecce8d120.png]: https://img-blog.csdnimg.cn/1aeff98608c34ab3b5f3f1eecce8d120.png
[Link 3]: https://so.csdn.net/so/search?q=%E5%B8%83%E5%B0%94%E8%BF%90%E7%AE%97&spm=1001.2101.3001.7020
[65e4aba92603ae2ba38e8856237c935c.png]: https://img-blog.csdnimg.cn/img_convert/65e4aba92603ae2ba38e8856237c935c.png