【numpy】❤万字numpy总结❤

目录

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

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

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

2. 数据类型 2.1 标量数据类型

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

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

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参数，它可以接受下列值：

参数	描述
c_index	可以跟踪 C 顺序的索引
f_index	可以跟踪 Fortran 顺序的索引
multi-index	每次迭代可以跟踪一种索引类型
external_loop	给出的值是具有多个值的一维数组，而不是零维数组

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('str1rstr2')

>>> [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()数接受附加的可选参数，例如页首，页尾和分隔符