【numpy】❤万字numpy总结❤

朱雀 2022-08-28 05:40 184阅读 0赞

### 目录 ###

*  Numpy
 *   *  1. ndarray
     *  2. 数据类型
     *   *  2.1 标量数据类型
         *  2.2 dtype
         *  2.3 唯一定义字符代码
     *  3. 数组属性
     *   *  3.1 ndarray.shape
         *  3.2 ndarray.reshape
         *  3.3 ndarray.ndim
         *  3.4 ndarray.itemsize
         *  3.5 ndarray.flags
     *  4. 数组创建
     *   *  4.1 numpy.empty
         *  4.2 numpy.zeros
         *  4.3 numpy.ones
         *  4.4 numpy.asarray
         *  4.5 numpy.frombuffer
         *  4.6 numpy.fromiter
         *  4.7 numpy.arange
         *  4.8 numpy.linspace
         *  4.9 numpy.logspace
     *  5. 切片和索引
     *   *  5.1 slice
         *  5.2 冒号分隔
         *  5.3 ...
         *  5.4 整数索引
         *  5.5 布尔索引
     *  6. 广播
     *   *  6.1 广播应满足的规则
         *  6.2 应满足的条件（任意之一）
     *  7. 迭代
     *   *  7.1 numpy.nditer
         *  7.2 转置
         *  7.3 修改数组的值
         *  7.4 外部循环
         *  7.5 广播迭代
     *  8. 数组操作
     *   *  8.1 修改形状
         *   *  8.1.1 numpy.reshape
             *  8.1.2 numpy.ndarray.flat
             *  8.1.3 numpy.ndarray.flatten
             *  8.1.4 numpy.ravel
         *  8.2 翻转
         *   *  8.2.1 numpy.transpose
             *  8.2.2 numpy.ndarray.T
             *  8.2.3 numpy.rollaxis
             *  8.2.4 numpy.swapaxes
         *  8.3 修改维度
         *   *  8.3.1 numpy.broadcast
             *  8.3.2 numpy.broadcast\_to
             *  8.3.3 numpy.expand\_dims
             *  8.3.4 numpy.squeeze
         *  8.4 数组连接
         *   *  8.4.1 numpy.concatenate
             *  8.4.2 numpy.stack
             *  8.4.3 numpy.hstack
             *  8.4.4 numpy.vstack
         *  8.5 数组分割
         *   *  8.5.1 numpy.split
             *  8.5.2 numpy.hsplit
             *  8.5.3 numpy.vsplit
         *  8.6 添加、删除元素
         *   *  8.6.1 numpy.resize
             *  8.6.2 numpy.append
             *  8.6.3 numpy.insert
             *  8.6.4 numpy.delete
             *  8.6.5 numpy.unique
         *  8.7 位操作
         *   *  8.7.1 numpy.bitwise\_and
             *  8.7.2 numpy.bitwise\_or
             *  8.7.3 numpy.invert
             *  8.7.4 numpy.binary\_repr
             *  8.7.5 numpy.left\_shift
             *  8.7.6 numpy.right\_shift
         *  8.8 字符串函数
         *   *  8.8.1 numpy.char.add
             *  8.8.2 numpy.char.multiply
             *  8.8.3 numpy.char.center
             *  8.8.4 numpy.char.capitalize
             *  8.8.5 numpy.char.title
             *  8.8.6 numpy.char.lower
             *  8.8.7 numpy.char.upper
             *  8.8.8 numpy.char.split
             *  8.8.9 numpy.char.splitlines
             *  8.8.10 numpy.char.strip
             *  8.8.11 numpy.char.join
             *  8.8.12 numpy.char.replace
             *  8.8.13 numpy.char.decode
             *  8.8.14 numpy.char.encode
         *  8.9 算术函数
         *   *  8.9.1 三角函数
             *   *  8.9.1.1 numpy.sin
                 *  8.9.1.2 numpy.cos
                 *  8.9.1.3 numpy.tan
                 *  8.9.1.4 numpy.arcsin
                 *  8.9.1.5 numpy.arccos
                 *  8.9.1.6 numpy.arctan
                 *  8.9.1.7 numpy.degrees
             *  8.9.2 舍入函数
             *   *  8.9.2.1 numpy.around
                 *  8.9.2.2 numpy.floor
                 *  8.9.2.3 numpy.ceil
         *  8.10 算术运算
         *   *  8.10.1 numpy.add
             *  8.10.2 numpy.subtract
             *  8.10.3 numpy.multiply
             *  8.10.4 numpy.divide
             *  8.10.5 numpy.reciprocal
             *  8.10.6 numpy.power
             *  8.10.7 numpy.mod
             *  8.10.8 numpy.real
             *  8.10.9 numpy.imag
             *  8.10.10 numpy.conj
             *  8.10.11 numpy.angle
         *  8.11 统计函数
         *   *  8.11.1 numpy.amin
             *  8.11.2 numpy.amax
             *  8.11.3 numpy.ptp
             *  8.11.4 numpy.percentile
             *  8.11.5 numpy.median
             *  8.11.6 numpy.mean
             *  8.11.7 numpy.average
             *  8.11.8 numpy.std
             *  8.11.9 方差
         *  8.12 排序、搜索和计数函数
         *   *  8.12.1 numpy.sort
             *  8.12.2 numpy.argsort
             *  8.12.3 numpy.lexsort
             *  8.12.4 numpy.argmax
             *  8.12.5 numpy.argmin
             *  8.12.6 numpy.nonzero
             *  8.12.7 numpy.where
             *  8.12.8 numpy.extract
         *  8.13 字节交换
         *   *  8.13.1 numpy.ndarray.byteswap
         *  8.14 副本和视图
         *   *  8.14.1 副本
             *  8.14.2 视图
             *  8.14.3 无复制
             *  8.14.4 浅拷贝ndarray.view
             *  8.14.5 深拷贝ndarray.copy
     *  9. 矩阵
     *   *  9.1 numpy.matlib.empty
         *  9.2 numpy.matlib.zeros
         *  9.3 numpy.matlib.ones
         *  9.4 numpy.matlib.eye
         *  9.5 numpy.matlib.identity
         *  9.6 numpy.matlib.rand
     *  10. 线性代数
     *   *  10.1 numpy.dot
         *  10.2 numpy.vdot
         *  10.3 numpy.inner
         *  10.4 numpy.matmul
         *  10.5 numpy.linalg.det
         *  10.6 numpy.linalg.solve
         *  10.7 numpy.linalg.inv
     *  11. IO
     *   *  11.1 numpy.save
         *  11.2 numpy.savetxt

# Numpy #

## 1. ndarray ##

NumPy 中定义的最重要的对象是称为 `ndarray` 的 n 维数组类型。 它描述相同类型的元素集合。 可以使用基于零的索引访问集合中的项目

`ndarray`中的每个元素在内存中使用相同大小的块。 `ndarray`中的每个元素是数据类型对象的对象（称为 `dtype`）

从`ndarray`对象提取的任何元素（通过切片）由一个数组标量类型的 Python 对象表示

基本的`ndarray`是使用 NumPy 中的数组函数创建的，它从任何暴露数组接口的对象，或从返回数组的任何方法创建一个ndarray：

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

以上构造器接受以下参数：

<table> 
 <thead> 
  <tr> 
   <th>参数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>object</td> 
   <td>任何暴露数组接口方法的对象都会返回一个数组或任何（嵌套）序列</td> 
  </tr> 
  <tr> 
   <td>dtype</td> 
   <td>数组的所需数据类型，可选</td> 
  </tr> 
  <tr> 
   <td>copy</td> 
   <td>对象是否被复制，可选，默认为<code>true</code></td> 
  </tr> 
  <tr> 
   <td>order</td> 
   <td><code>C</code>（按行）、<code>F</code>（按列）或<code>A</code>（任意，默认）</td> 
  </tr> 
  <tr> 
   <td>subok</td> 
   <td>默认情况下，返回的数组被强制为基类数组。 如果为<code>true</code>，则返回子类</td> 
  </tr> 
  <tr> 
   <td>ndmin</td> 
   <td>指定返回数组的最小维数</td> 
  </tr> 
 </tbody> 
</table>

## 2. 数据类型 ##

### 2.1 标量数据类型 ###

numpy中定义的标量数据类型如下：

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>bool_</code></td> 
   <td align="left">存储为一个字节的布尔值（真或假）</td> 
  </tr> 
  <tr> 
   <td><code>int_</code></td> 
   <td align="left">默认整数，相当于 C 的<code>long</code>，通常为<code>int32</code>或<code>int64</code></td> 
  </tr> 
  <tr> 
   <td><code>intc</code></td> 
   <td align="left">相当于 C 的<code>int</code>，通常为<code>int32</code>或<code>int64</code></td> 
  </tr> 
  <tr> 
   <td><code>intp</code></td> 
   <td align="left">用于索引的整数，相当于 C 的<code>size_t</code>，通常为<code>int32</code>或<code>int64</code></td> 
  </tr> 
  <tr> 
   <td><code>int8</code></td> 
   <td align="left">字节（-128 ~ 127）</td> 
  </tr> 
  <tr> 
   <td><code>int16</code></td> 
   <td align="left">16 位整数（-32768 ~ 32767）</td> 
  </tr> 
  <tr> 
   <td><code>int32</code></td> 
   <td align="left">32 位整数（-2147483648 ~ 2147483647）</td> 
  </tr> 
  <tr> 
   <td><code>int64</code></td> 
   <td align="left">64 位整数（-9223372036854775808 ~ 9223372036854775807）</td> 
  </tr> 
  <tr> 
   <td><code>uint8</code></td> 
   <td align="left">8 位无符号整数（0 ~ 255）</td> 
  </tr> 
  <tr> 
   <td><code>uint16</code></td> 
   <td align="left">16 位无符号整数（0 ~ 65535）</td> 
  </tr> 
  <tr> 
   <td><code>uint32</code></td> 
   <td align="left">32 位无符号整数（0 ~ 4294967295）</td> 
  </tr> 
  <tr> 
   <td><code>uint64</code></td> 
   <td align="left">64 位无符号整数（0 ~ 18446744073709551615）</td> 
  </tr> 
  <tr> 
   <td><code>float_</code></td> 
   <td align="left"><code>float64</code>的简写</td> 
  </tr> 
  <tr> 
   <td><code>float16</code></td> 
   <td align="left">半精度浮点：符号位，5 位指数，10 位尾数</td> 
  </tr> 
  <tr> 
   <td><code>float32</code></td> 
   <td align="left">单精度浮点：符号位，8 位指数，23 位尾数</td> 
  </tr> 
  <tr> 
   <td><code>float64</code></td> 
   <td align="left">双精度浮点：符号位，11 位指数，52 位尾数</td> 
  </tr> 
  <tr> 
   <td><code>complex_</code></td> 
   <td align="left"><code>complex128</code>的简写</td> 
  </tr> 
  <tr> 
   <td><code>complex64</code></td> 
   <td align="left">复数，由两个 32 位浮点表示（实部和虚部）</td> 
  </tr> 
  <tr> 
   <td><code>complex128</code></td> 
   <td align="left">复数，由两个 64 位浮点表示（实部和虚部）</td> 
  </tr> 
 </tbody> 
</table>

NumPy 数字类型是`dtype`（数据类型）对象的实例，每个对象具有唯一的特征。 这些类型可以是`np.bool_`，`np.float32`等

### 2.2 dtype ###

数据类型对象描述了对应于数组的固定内存块的解释，取决于以下方面：

*  数据类型（整数、浮点或者 Python 对象）
 *  数据大小
 *  字节序（小端或大端）
 *  在结构化类型的情况下，字段的名称，每个字段的数据类型，和每个字段占用的内存块部分
 *  如果数据类型是子序列，它的形状和数据类型

构造语法：

numpy.dtype(object, align, copy)

参数及其描述如下：

*  `Object`：被转换为数据类型的对象
 *  `Align`：如果为`true`，则向字段添加间隔，使其类似 C 的结构体
 *  `Copy`：生成`dtype`对象的新副本，如果为`flase`，结果是内建数据类型对象的引用

### 2.3 唯一定义字符代码 ###

*  `'b'`：布尔值
 *  `'i'`：符号整数
 *  `'u'`：无符号整数
 *  `'f'`：浮点
 *  `'c'`：复数浮点
 *  `'m'`：时间间隔
 *  `'M'`：日期时间
 *  `'O'`：Python 对象
 *  `'S', 'a'`：字节串
 *  `'U'`：Unicode
 *  `'V'`：原始数据（`void`）

## 3. 数组属性 ##

### 3.1 ndarray.shape ###

这一数组属性返回一个包含数组维度的元组，它也可以用于调整数组大小

### 3.2 ndarray.reshape ###

调整数组大小

### 3.3 ndarray.ndim ###

返回数组的维数

### 3.4 ndarray.itemsize ###

返回数组中每个元素的字节单位长度

### 3.5 ndarray.flags ###

`ndarray`对象拥有以下属性，这个函数返回了它们的当前值：

*  C\_CONTIGUOUS ©：数组位于单一的、C 风格的连续区段内
 *  F\_CONTIGUOUS (F)：数组位于单一的、Fortran 风格的连续区段内
 *  OWNDATA (O)：数组的内存从其它对象处借用
 *  WRITEABLE (W)：数据区域可写入；将它设置为`flase`会锁定数据，使其只读
 *  ALIGNED (A)：数据和任何元素会为硬件适当对齐
 *  UPDATEIFCOPY (U)：这个数组是另一数组的副本。当这个数组释放时，源数组会由这个数组中的元素更新

## 4. 数组创建 ##

### 4.1 numpy.empty ###

创建指定形状和`dtype`的未初始化数组，使用以下构造函数：

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

构造器接受以下参数：

*  shape：空数组的形状，整数或整数元组
 *  dtype：所需的输出数组类型，可选
 *  order：‘C’为按行的C风格数组，‘F’为按列的Fortran风格数组

### 4.2 numpy.zeros ###

返回特定大小，以0填充的新数组，使用以下构造函数：

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

构造器接受下列参数：

*  shape：空数组的形状，整数或整数元组
 *  type：所需的输出数组类型，可选
 *  order：‘C’为按行的C风格数组，‘F’为按列的Fortran风格数组

### 4.3 numpy.ones ###

返回特定大小，以1填充的新数组，使用以下构造函数：

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

构造器接受下列参数：

*  shape：空数组的形状，整数或整数元组
 *  type：所需的输出数组类型，可选
 *  order：‘C’为按行的C风格数组，‘F’为按列的Fortran风格数组

### 4.4 numpy.asarray ###

类似于`numpy.array`，除了它有较少的参数，使用以下构造函数：

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

构造器接受下列参数：

*  a：任意形式的输入参数，比如列表、列表的元组、元组、元组的元组、元组的列表
 *  dtype：所需的输出数组类型，可选
 *  order：‘C’为按行的C风格数组，‘F’为按列的Fortran风格数组

### 4.5 numpy.frombuffer ###

将缓冲区解释为一维数组，暴露缓冲区接口的任何对象都用作参数来返回`ndarray`，使用以下构造函数：

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

构造器接受下列参数：

*  buffer：任何暴露缓冲区接口的对象
 *  dtype：返回数组的数据类型，默认为`float`
 *  count：需要读取的数据数量，默认为`-1`，读取所有数据
 *  offset：需要读取的起始位置，默认为`0`

### 4.6 numpy.fromiter ###

从任何可迭代对象构建一个`ndarray`对象，返回一个新的一维数组，使用以下构造函数：

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

构造器接受下列参数：

*  iterable：任何可迭代对象
 *  dtype：返回数组的数据类型，默认为`float`
 *  count：需要读取的数据数量，默认为`-1`，读取所有数据

### 4.7 numpy.arange ###

返回`ndarray`对象，包含给定范围内的等间隔值：

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

构造器接受下列参数：

*  start: 范围的起始值，默认为`0`
 *  stop: 范围的终止值（不包含）
 *  step: 两个值的间隔，默认为`1`
 *  dtype: 返回`ndarray`的数据类型，如果没有提供，则会使用输入数据的类型

### 4.8 numpy.linspace ###

类似于`arange()`函数。 在此函数中，指定了范围之间的均匀间隔数量，而不是步长：

numpy.linspace(start, stop, num, endpoint, retstep, dtype)

构造器接受下列参数：

*  start: 序列的起始值
 *  stop: 序列的终止值，如果`endpoint`为`true`，该值包含于序列中
 *  num: 要生成的等间隔样例数量，默认为`50`
 *  endpoint: 序列中是否包含`stop`值，默认为`ture`
 *  retstep: 如果为`true`，返回样例，以及连续数字之间的步长
 *  dtype: 输出`ndarray`的数据类型

### 4.9 numpy.logspace ###

返回一个`ndarray`对象，其中包含在对数刻度上均匀分布的数字。 刻度的开始和结束端点是某个底数的幂，通常为 10：

numpy.logscale(start, stop, num, endpoint, base, dtype)

构造器接受下列参数：

*  start: 起始值是`base ** start`
 *  stop: 终止值是`base ** stop`
 *  num: 范围内的数值数量，默认为`50`
 *  endpoint: 如果为`true`，终止值包含在输出数组当中
 *  base: 对数空间的底数，默认为`10`
 *  dtype: 输出数组的数据类型，如果没有提供，则取决于其它参数

## 5. 切片和索引 ##

### 5.1 slice ###

基本切片是 Python 中基本切片概念到 n 维的扩展，通过将`start`，`stop`和`step`参数提供给内置的`slice`函数来构造一个 Python `slice`对象，此`slice`对象被传递给数组来提取数组的一部分：

ndarray.slice(start, end, step)

### 5.2 冒号分隔 ###

通过将由冒号分隔的切片参数（`start:stop:step`）直接提供给`ndarray`对象，也可以获得相同的结果：

ndarray[start: end: step]

如果只输入一个参数，则将返回与索引对应的单个项目。

如果使用`a:`，则从该索引向后的所有项目将被提取。

如果使用两个参数（以`:`分隔），则对两个索引（不包括停止索引）之间的元素以默认步骤进行切片

### 5.3 … ###

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

### 5.4 整数索引 ###

这种机制有助于基于 N 维索引来获取数组中任意元素。 每个整数数组表示该维度的下标值。 当索引的元素个数就是目标`ndarray`的维度时，会变得相当直接

### 5.5 布尔索引 ###

当结果对象是布尔运算（例如比较运算符）的结果时，将使用此类型的高级索引

## 6. 广播 ##

**广播**是指 NumPy 在算术运算期间处理不同形状的数组的能力

对数组的算术运算通常在相应的元素上进行

如果两个阵列具有完全相同的形状，则这些操作被无缝执行

如果两个数组的维数不相同，则元素到元素的操作是不可能的。然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。较小的数组会**广播**到较大数组的大小，以便使它们的形状可兼容

### 6.1 广播应满足的规则 ###

*  `ndim`较小的数组会在前面追加一个长度为 1 的维度
 *  输出数组的每个维度的大小是输入数组该维度大小的最大值
 *  如果输入在每个维度中的大小与输出大小匹配，或其值正好为 1，则在计算中可它
 *  如果输入的某个维度大小为 1，则该维度中的第一个数据元素将用于该维度的所有计算

### 6.2 应满足的条件（任意之一） ###

*  数组拥有相同形状
 *  数组拥有相同的维数，每个维度拥有相同长度，或者长度为 1
 *  数组拥有极少的维度，可以在其前面追加长度为 1 的维度，使上述条件成立

## 7. 迭代 ##

### 7.1 numpy.nditer ###

numpy 包包含一个迭代器对象`numpy.nditer`。 它是一个有效的多维迭代器对象，可以用于在数组上进行迭代。 数组的每个元素可使用 Python 的标准`Iterator`接口来访问

for item in numpy.nditer(ndarray):
        ...

### 7.2 转置 ###

ndarray.T

### 7.3 修改数组的值 ###

`nditer`对象有另一个可选参数`op_flags`，其默认值为只读，但可以设置为读写或只写模式。 这将允许使用此迭代器修改数组元素

### 7.4 外部循环 ###

`nditer`类的构造器拥有`flags`参数，它可以接受下列值：

<table> 
 <thead> 
  <tr> 
   <th align="left">参数</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left"><code>c_index</code></td> 
   <td>可以跟踪 C 顺序的索引</td> 
  </tr> 
  <tr> 
   <td align="left"><code>f_index</code></td> 
   <td>可以跟踪 Fortran 顺序的索引</td> 
  </tr> 
  <tr> 
   <td align="left"><code>multi-index</code></td> 
   <td>每次迭代可以跟踪一种索引类型</td> 
  </tr> 
  <tr> 
   <td align="left"><code>external_loop</code></td> 
   <td>给出的值是具有多个值的一维数组，而不是零维数组</td> 
  </tr> 
 </tbody> 
</table>

### 7.5 广播迭代 ###

如果两个数组是**可广播的**，`nditer`组合对象能够同时迭代它们。 假设数组`a`具有维度 3X4，并且存在维度为 1X4 的另一个数组`b`，则使用以下类型的迭代器（数组`b`被广播到`a`的大小）

## 8. 数组操作 ##

### 8.1 修改形状 ###

#### 8.1.1 numpy.reshape ####

这个函数在不改变数据的条件下修改形状，它接受如下参数：

numpy.reshape(arr, newshape, order)

其中：

*  `arr`：要修改形状的数组
 *  `newshape`：整数或者整数数组，新的形状应当兼容原有形状
 *  `order`：`'C'`为 C 风格顺序，`'F'`为 F 风格顺序，`'A'`为保留原顺序

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

该函数返回数组上的一维迭代器，行为类似 Python 内建的迭代器

#### 8.1.3 numpy.ndarray.flatten ####

该函数返回折叠为一维的数组副本，函数接受下列参数：

ndarray.flatten(order)

其中：

*  `order`：`'C'` – 按行，`'F'` – 按列，`'A'` – 原顺序，`'k'` – 元素在内存中的出现顺序

#### 8.1.4 numpy.ravel ####

返回展开的一维数组，并且按需生成副本。返回的数组和输入数组拥有相同数据类型。这个函数接受两个参数:

numpy.ravel(a, order)

构造器接受下列参数：

*  `order`：`'C'` – 按行，`'F'` – 按列，`'A'` – 原顺序，`'k'` – 元素在内存中的出现顺序

### 8.2 翻转 ###

#### 8.2.1 numpy.transpose ####

翻转给定数组的维度。如果可能的话它会返回一个视图。函数接受下列参数：

numpy.transpose(arr, axes)

其中：

*  `arr`：要转置的数组
 *  `axes`：整数的列表，对应维度，通常所有维度都会翻转

#### 8.2.2 numpy.ndarray.T ####

函数属于`ndarray`类，行为类似于`numpy.transpose`，用法见7.2

#### 8.2.3 numpy.rollaxis ####

向后滚动特定的轴，直到一个特定位置。这个函数接受三个参数：

numpy.rollaxis(arr, axis, start)

其中：

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

#### 8.2.4 numpy.swapaxes ####

该函数交换数组的两个轴。对于 1.10 之前的 NumPy 版本，会返回交换后数组的试图。这个函数接受下列参数：

numpy.swapaxes(arr, axis1, axis2)

其中：

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

### 8.3 修改维度 ###

#### 8.3.1 numpy.broadcast ####

此功能模仿广播机制。 它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果

该函数使用两个数组作为输入参数

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

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

注意 - 此功能可用于 1.10.0 及以后的版本。

该函数接受以下参数:

numpy.broadcast_to(array, shape, subok)

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

通过在指定位置插入新的轴来扩展数组形状。该函数需要两个参数：

numpy.expand_dims(arr, axis)

其中：

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

#### 8.3.4 numpy.squeeze ####

从给定数组的形状中删除一维条目。 此函数需要两个参数:

numpy.squeeze(arr, axis)

其中：

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

### 8.4 数组连接 ###

#### 8.4.1 numpy.concatenate ####

数组的连接是指连接。 此函数用于沿指定轴连接相同形状的两个或多个数组。 该函数接受以下参数：

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

其中：

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

#### 8.4.2 numpy.stack ####

沿新轴连接数组序列。 此功能添加自 NumPy 版本 1.10.0。 需要提供以下参数:

numpy.stack(arrays, axis)

其中：

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

#### 8.4.3 numpy.hstack ####

`numpy.stack`函数的变体，通过堆叠来生成水平的单个数组

#### 8.4.4 numpy.vstack ####

`numpy.stack`函数的变体，通过堆叠来生成竖直的单个数组

### 8.5 数组分割 ###

#### 8.5.1 numpy.split ####

沿特定的轴将数组分割为子数组。函数接受三个参数：

numpy.split(ary, indices_or_sections, axis)

其中：

*  `ary`：被分割的输入数组
 *  `indices_or_sections`：可以是整数，表明要从输入数组创建的，等大小的子数组的数量。 如果此参数是一维数组，则其元素表明要创建新子数组的点
 *  `axis`：默认为 0

#### 8.5.2 numpy.hsplit ####

`numpy.hsplit`是`split()`函数的特例，其中轴为 1 表示水平分割，无论输入数组的维度是什么

#### 8.5.3 numpy.vsplit ####

`numpy.vsplit`是`split()`函数的特例，其中轴为 0 表示竖直分割，无论输入数组的维度是什么

### 8.6 添加、删除元素 ###

#### 8.6.1 numpy.resize ####

返回指定大小的新数组。 如果新大小大于原始大小，则包含原始数组中的元素的重复副本。 该函数接受以下参数：

numpy.resize(arr, shape)

其中：

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

#### 8.6.2 numpy.append ####

在输入数组的末尾添加值。 附加操作不是原地的，而是分配新的数组。 此外，输入数组的维度必须匹配否则将生成`ValueError`

函数接受下列函数：

numpy.append(arr, values, axis)

其中：

*  `arr`：输入数组
 *  `values`：要向`arr`添加的值，比如和`arr`形状相同（除了要添加的轴）
 *  `axis`：沿着它完成操作的轴。如果没有提供，两个参数都会被展开

#### 8.6.3 numpy.insert ####

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

`insert()`函数接受以下参数：

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

其中：

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

#### 8.6.4 numpy.delete ####

返回从输入数组中删除指定子数组的新数组。 与`insert()`函数的情况一样，如果未提供轴参数，则输入数组将展开。 该函数接受以下参数：

numpy.delete(arr, obj, axis)

其中：

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

#### 8.6.5 numpy.unique ####

返回输入数组中的去重元素数组。 该函数能够返回一个元组，包含去重数组和相关索引的数组。 索引的性质取决于函数调用中返回参数的类型:

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

其中：

*  `arr`：输入数组，如果不是一维数组则会展开
 *  `return_index`：如果为`true`，返回输入数组中的元素下标
 *  `return_inverse`：如果为`true`，返回去重数组的下标，它可以用于重构输入数组
 *  `return_counts`：如果为`true`，返回去重数组中的元素在原数组中的出现次数

### 8.7 位操作 ###

#### 8.7.1 numpy.bitwise\_and ####

对输入数组中的整数的二进制表示的相应位执行位与运算

#### 8.7.2 numpy.bitwise\_or ####

对输入数组中的整数的二进制表示的相应位执行位或运算

#### 8.7.3 numpy.invert ####

计算输入数组中整数的位非结果。 对于有符号整数，返回补码

#### 8.7.4 numpy.binary\_repr ####

返回给定宽度中十进制数的二进制表示

#### 8.7.5 numpy.left\_shift ####

将数组元素的二进制表示中的位向左移动到指定位置，右侧附加相等数量的 0

#### 8.7.6 numpy.right\_shift ####

将数组元素的二进制表示中的位向右左移动到指定位置，左侧附加相等数量的 0

### 8.8 字符串函数 ###

#### 8.8.1 numpy.char.add ####

按元素顺序将字符串连接:

numpy.char.add(List[str], List[str])

#### 8.8.2 numpy.char.multiply ####

执行多重连接:

numpy.char.multiply(str, times)

#### 8.8.3 numpy.char.center ####

返回所需宽度的数组，以便输入字符串位于中心，并使用`fillchar`在左侧和右侧进行填充:

numpy.char.center(str, length, fillchar)

#### 8.8.4 numpy.char.capitalize ####

返回字符串的副本，其中第一个字母大写

numpy.char.capitalize(str)

#### 8.8.5 numpy.char.title ####

返回输入字符串的按元素标题转换版本，其中每个单词的首字母都大写:

numpy.char.title(str)

#### 8.8.6 numpy.char.lower ####

返回一个数组，其元素转换为小写。它对每个元素调用`str.lower`:

numpy.char.lower(List[str])

#### 8.8.7 numpy.char.upper ####

返回一个数组，其元素转换为大写。它对每个元素调用`str.upper`:

numpy.char.upper(List[str])

#### 8.8.8 numpy.char.split ####

返回输入字符串中的单词列表。 默认情况下，空格用作分隔符。 否则，指定的分隔符字符用于分割字符串:

np.char.split (str, sep=' ')

#### 8.8.9 numpy.char.splitlines ####

返回数组中元素的单词列表，以换行符分割:

np.char.splitlines('str1\rstr2')

>>> [str1, str2]

#### 8.8.10 numpy.char.strip ####

返回数组的副本，其中元素移除了开头或结尾处的特定字符:

numpy.char.strip(List[str], remove)

#### 8.8.11 numpy.char.join ####

返回一个字符串，其中单个字符由特定的分隔符连接:

numpy.char.join(List[str], List[str])

#### 8.8.12 numpy.char.replace ####

返回字符串副本，其中所有字符序列的出现位置都被另一个给定的字符序列取代:

numpy.char.replace(str, char, repalce)

#### 8.8.13 numpy.char.decode ####

在给定的字符串中使用特定编码调用`str.decode()`:

numpy.char.decode(str, decode)

#### 8.8.14 numpy.char.encode ####

对数组中的每个元素调用`str.encode`函数。 默认编码是`utf_8`，可以使用标准 Python 库中的编解码器:

numpy.char.encode(str, encode)

### 8.9 算术函数 ###

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

##### 8.9.1.1 numpy.sin #####

##### 8.9.1.2 numpy.cos #####

##### 8.9.1.3 numpy.tan #####

##### 8.9.1.4 numpy.arcsin #####

##### 8.9.1.5 numpy.arccos #####

##### 8.9.1.6 numpy.arctan #####

##### 8.9.1.7 numpy.degrees #####

将弧度制转换为角度制

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

##### 8.9.2.1 numpy.around #####

返回四舍五入到所需精度的值。 该函数接受以下参数：

numpy.around(a,decimals)

其中：

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

##### 8.9.2.2 numpy.floor #####

返回不大于输入参数的最大整数。 即标量`x` 的下限是最大的整数`i` ，使得`i <= x`。 注意在Python中，向下取整总是从 0 舍入

##### 8.9.2.3 numpy.ceil #####

返回输入值的上限，即，标量`x`的上限是最小的整数`i` ，使得`i> = x`

### 8.10 算术运算 ###

#### 8.10.1 numpy.add ####

两数组相加，输入数组必须具有相同的形状或符合数组广播规则

#### 8.10.2 numpy.subtract ####

两数组相减，输入数组必须具有相同的形状或符合数组广播规则

#### 8.10.3 numpy.multiply ####

两数组相乘，输入数组必须具有相同的形状或符合数组广播规则

#### 8.10.4 numpy.divide ####

两数组相除，输入数组必须具有相同的形状或符合数组广播规则

#### 8.10.5 numpy.reciprocal ####

返回参数逐元素的倒数。 由于 Python 处理整数除法的方式，对于绝对值大于 1 的整数元素，结果始终为 0， 对于整数 0，则发出溢出警告

#### 8.10.6 numpy.power ####

将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂

numpy.power(a, pow)

#### 8.10.7 numpy.mod ####

返回输入数组中相应元素的除法余数。 函数`numpy.remainder()`也产生相同的结果

#### 8.10.8 numpy.real ####

返回复数类型参数的实部

#### 8.10.9 numpy.imag ####

返回复数类型参数的虚部

#### 8.10.10 numpy.conj ####

返回通过改变虚部的符号而获得的共轭复数

#### 8.10.11 numpy.angle ####

返回复数参数的角度。 函数的参数是`degree`。 如果为`true`，返回的角度以角度制来表示，否则为以弧度制来表示

### 8.11 统计函数 ###

#### 8.11.1 numpy.amin ####

从给定数组中的元素沿指定轴返回最小值

#### 8.11.2 numpy.amax ####

从给定数组中的元素沿指定轴返回最大值

#### 8.11.3 numpy.ptp ####

返回沿轴的值的范围（最大值与最小值的差）

numpy.ptp(a, axis)

其中：

*  a: 待传入数组
 *  axis: 表示沿轴调用，0表示按行，不传入默认表示全部数据

#### 8.11.4 numpy.percentile ####

百分位数是统计中使用的度量，表示小于这个值得观察值占某个百分比。接受以下参数:

numpy.percentile(a, q, axis)

其中：

*  a: 输入数组
 *  q: 要计算的百分位数，在 0 ~ 100 之间
 *  axis: 沿着它计算百分位数的轴

#### 8.11.5 numpy.median ####

**中值**定义为将数据样本的上半部分与下半部分分开的值:

numpy.median(a, axis)

其中：

*  a: 待传入数组
 *  axis: 表示沿轴调用，0表示按行，不传入默认表示全部数据

#### 8.11.6 numpy.mean ####

算术平均值是沿轴的元素的总和除以元素的数量。 `numpy.mean()`函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算:

numpy.mean(a, axis)

其中：

*  a: 待传入数组
 *  axis: 表示沿轴调用，0表示按行，不传入默认表示全部数据

#### 8.11.7 numpy.average ####

加权平均值是由每个分量乘以反映其重要性的因子得到的平均值。 `numpy.average()`函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。 该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开

numpy.average(a, weights)

其中：

*  a: 待传入数组
 *  weights: 权重数组

#### 8.11.8 numpy.std ####

标准差是与均值的偏差的平方的平均值的平方根:

numpy.std(a, axis)

其中：

*  a: 待传入数组
 *  axis: 表示沿轴调用，0表示按行，不传入默认表示全部数据

#### 8.11.9 方差 ####

方差是偏差的平方的平均值, 换句话说，标准差是方差的平方根:

numpy.var(a, axis)

其中：

*  a: 待传入数组
 *  axis: 表示沿轴调用，0表示按行，不传入默认表示全部数据

### 8.12 排序、搜索和计数函数 ###

#### 8.12.1 numpy.sort ####

返回输入数组的排序副本, 接收以下参数:

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

其中：

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

#### 8.12.2 numpy.argsort ####

对输入数组沿给定轴执行间接排序，并使用指定排序类型返回数据的索引数组。 这个索引数组用于构造排序后的数组

#### 8.12.3 numpy.lexsort ####

使用键序列执行间接排序。 键可以看作是电子表格中的一列。 该函数返回一个索引数组，使用它可以获得排序数据

注意，最后一个键恰好是 sort 的主键

#### 8.12.4 numpy.argmax ####

沿给定轴返回最大元素的索引

#### 8.12.5 numpy.argmin ####

沿给定轴返回最小元素的索引

#### 8.12.6 numpy.nonzero ####

返回输入数组中非零元素的索引

#### 8.12.7 numpy.where ####

返回输入数组中满足给定条件的元素的索引

#### 8.12.8 numpy.extract ####

返回满足任何条件的元素

### 8.13 字节交换 ###

#### 8.13.1 numpy.ndarray.byteswap ####

大端和小端之间切换

### 8.14 副本和视图 ###

#### 8.14.1 副本 ####

在执行函数时，其中一些返回输入数组的副本，而另一些返回视图。 当内容物理存储在另一个位置时，称为**副本**

#### 8.14.2 视图 ####

如果提供了相同内存内容的不同视图，我们将其称为**视图**

#### 8.14.3 无复制 ####

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

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

#### 8.14.4 浅拷贝ndarray.view ####

它是一个新的数组对象，并可查看原始数组的相同数据

与前一种情况不同，新数组的维数更改不会更改原始数据的维数

#### 8.14.5 深拷贝ndarray.copy ####

创建一个深层副本。 它是数组及其数据的完整副本，不与原始数组共享

## 9. 矩阵 ##

numpy 包含一个 Matrix库`numpy.matlib`。此模块的函数返回矩阵而不是返回`ndarray`对象

### 9.1 numpy.matlib.empty ###

返回一个新的矩阵，而不初始化元素。 该函数接受以下参数:

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

其中：

*  shape：定义新矩阵形状的整数或整数元组
 *  dtype：可选，输出的数据类型
 *  order：`C` 或者 `F`

### 9.2 numpy.matlib.zeros ###

返回以0填充的矩阵

### 9.3 numpy.matlib.ones ###

返回以1填充的矩阵

### 9.4 numpy.matlib.eye ###

返回一个对角矩阵，对角线元素为 1，其他位置为零。 该函数接受以下参数:

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

其中：

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

### 9.5 numpy.matlib.identity ###

返回给定大小的单位矩阵。单位矩阵是主对角线元素都为 1 的方阵

### 9.6 numpy.matlib.rand ###

返回给定大小的填充随机值的矩阵

## 10. 线性代数 ##

### 10.1 numpy.dot ###

返回两个数组的点积。 对于二维向量，其等效于矩阵乘法。 对于一维数组，它是向量的内积。 对于 N 维数组，它是`a`的最后一个轴上的和与`b`的倒数第二个轴的乘积

### 10.2 numpy.vdot ###

返回两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数`id`是多维数组，它会被展开

### 10.3 numpy.inner ###

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

### 10.4 numpy.matmul ###

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

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

### 10.5 numpy.linalg.det ###

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

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

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

### 10.6 numpy.linalg.solve ###

给出了矩阵形式的线性方程的解

### 10.7 numpy.linalg.inv ###

计算矩阵的逆

矩阵的逆是这样的，如果它乘以原始矩阵，则得到单位矩阵

## 11. IO ##

`ndarray`对象可以保存到磁盘文件并从磁盘文件加载。 可用的 IO 功能有：

*  `load()`和`save()`函数处理 numPy 二进制文件（带`npy`扩展名）
 *  `loadtxt()`和`savetxt()`函数处理正常的文本文件

NumPy 为`ndarray`对象引入了一个简单的文件格式。 这个`npy`文件在磁盘文件中，存储重建`ndarray`所需的数据、图形、`dtype`和其他信息，以便正确获取数组，即使该文件在具有不同架构的另一台机器上

### 11.1 numpy.save ###

文件将输入数组存储在具有`npy`扩展名的磁盘文件中

为了从`outfile.npy`重建数组，请使用`load()`函数

`save()`和`load()`函数接受一个附加的布尔参数`allow_pickles`。 Python 中的`pickle`用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化

### 11.2 numpy.savetxt ###

以简单文本文件格式存储和获取数组数据，是通过`savetxt()`和`loadtx()`函数完成的

`savetxt()`和`loadtxt()`数接受附加的可选参数，例如页首，页尾和分隔符

【numpy】❤万字numpy总结❤

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 ❤️六万字《SpringMVC框架介绍—从入门到高级》（建议收藏）❤️

相关近万字的Numpy总结——边学边练

相关 numpy总结

相关 ❤️并发编程❤️一万字线程生命周期和状态转换知识梳理

相关 ❤️六W字《计算机基础知识》（三）（建议收藏）❤️

相关 ❤️六W字《计算机基础知识》（二）（建议收藏）❤️

相关 ❤️六W字《计算机基础知识》（一）（建议收藏）❤️

相关【numpy】❤万字numpy总结❤

相关 Numpy 总结

相关面试10多家中大厂后的万字总结——❤️集合篇❤️（精心打磨，建议收藏）