@[TOC] (目录)

Numpy

Numpy官网：https://numpy.org/devdocs/index.html

Numpy的主要对象是同构多维数组。它是一个元素表（通常是数字），所有类型都相同，由非负整数元组索引。在 NumPy 中，维度称为轴。

Numpy的数组类称为ndarray，其属性：

ndarray.ndim ：数组的轴数

ndarray.shape ：数组形状

ndarray.size ：数组元素总数

ndarray.dtype ：数组中元素类型

ndarray.itemsize ：数组每个元素的大小

ndarray.flags ：对象的内存信息

ndarray.real ：元素的实部

ndarray.imag ：元素的虚部

ndarray.data ：数组每个实际元素的缓冲器

ndarray.T ：转置数组

ndarray.flat ：一维迭代器

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

Numpy切片及索引

ndarray切片方式和列表相同。且**包含省略号…切片**，如果在行位置使用省略号，它将返回包含行中元素的ndarray

>>> a=np.array([[1,2,3],[4,5,6],[7,8,9]])                  #创建一个（3，3）的数组
>>> print(a)
[[1 2 3][4 5 6][7 8 9]]
>>> print(a[...,1])                    #第2列元素
[2 5 8]
>>> print(a[1,...])                    #第2行元素
[4 5 6]
>>> print(a[...,1:])               #第2列及以后的元素
[[2 3][5 6][8 9]]
>>> print(a[1:,...])               #第2行及以后的元素
[[4 5 6][7 8 9]]

ndarray高级索引：使用多个列表相同位置的数字表示坐标（从0开始）

>>> x = np.array([[1,  2],  [3,  4],  [5,  6]])
>>> y = x[[0,1,2],  [0,1,0]]                  #表示（0，0）（1，1）（2，0）位置的元素
>>> print (y)
[1 4 5]

布尔索引

>>> x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])
>>> print (x)
[[ 0  1  2][ 3  4  5][ 6  7  8][ 9 10 11]]
>>> print (x[x >  6])                           #大于6的元素
[ 7  8  9 10 11]

花式索引

>>> x=np.arange(32).reshape((8,4))             #由0～31创建一个（8，4）的数组
>>> print(x)
[[ 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]]
>>> print (x[[4,2,1,7]])
[[16 17 18 19][ 8  9 10 11][ 4  5  6  7][28 29 30 31]]
>>> print (x[[-4,-2,-1,-7]])
[[16 17 18 19][24 25 26 27][28 29 30 31][ 4  5  6  7]]

NumPy 广播(Broadcast)

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式

Numpy 可以转换这些形状不同的数组，使它们都具有相同的大小，然后再对它们进行运算。

>>> a = np.array([1,2,3,4])
>>> b = np.array([10,20,30,40])
>>> a*b
array([ 10,  40,  90, 160])>>> a=np.array([[0,0,0],[10,10,10]])
>>> b=np.array([9,9,9])
>>> a+b
array([[ 9,  9,  9],[19, 19, 19]])

numpy.amin(a,axis=None,out=None,keepdims=,initial=,where=) 返回数组的最小值或沿轴的最大值

a:输入数组

axis:沿其操作的一个或多个轴。默认情况下，使用扁平化输入

out:用于放置结果的替代输出数组。必须与预期输出具有相同的形状

keepdims:如果将其设置为 True，则减少的轴将作为尺寸为 1 的维度保留在结果中

initial:输出元素的最大值

where:要比较最小值的元素

>>> a = np.arange(4).reshape((2,2))
>>> print(a)
[[0 1][2 3]]
>>> np.amax(a)
3
>>> np.amax(a, axis=0)
array([2, 3])
>>> np.amax(a, axis=1)
array([1, 3])
>>> np.amax(a, where=[False, True], initial=-1, axis=0)
array([-1,  3])

numpy.amin(a,axis=None,out=None,keepdims=,initial=,where=) 返回数组的最小值或沿轴的最小值

a:输入数组

axis:沿其操作的一个或多个轴。默认情况下，使用扁平化输入

out:用于放置结果的替代输出数组。必须与预期输出具有相同的形状

keepdims:如果将其设置为 True，则减少的轴将作为尺寸为 1 的维度保留在结果中

initial:输出元素的最大值

where:要比较最小值的元素

>>> a = np.arange(4).reshape((2,2))
>>> print(a)
[[0 1][2 3]]
>>> np.amin(a)
0
>>> np.amin(a, axis=0)
array([0, 1])
>>> np.amin(a, axis=1)
array([0, 2])
>>> np.amin(a, where=[False, True], initial=10, axis=0)
array([10,  1])

numpy.arange([start,]stop,[step,]dtype=None,like=None) 创建给定间隔区间的numpy数组，类似arange函数

start:起点，默认起始值为0，可选

stop:终点（不包括）

step:步长

dtype:数据类型，如果未给出则从输入推断类型

like:允许创建不是numpy数组的数组引用对象

>>> x = np.arange(5)
>>> print(x)
[0 1 2 3 4]
>>> y = np.arange(5,20,3,float)
>>> print(y)
[ 5.  8. 11. 14. 17.]

numpy.argsort(a,axis=-1,kind=None,order=None) 返回对数组进行排序的索引

a:要排序的数组

axis:排序的轴。默认值为 -1，扁平数组。

kind:排序方式，默认为’quicksort’（快速排序）

order:如果数组包含字段，则是要排序的字段

>>> x = np.array([[0, 3,1], [2, 3,3]])
>>> np.argsort(x)
array([[0, 2, 1],[0, 1, 2]])
>>> np.argsort(x, axis=0)
array([[0, 0, 0],[1, 1, 1]])
>>> np.argsort(x, axis=1)
array([[0, 2, 1],[0, 1, 2]])

numpy.argmax(a,axis=None,out=None,keepdims=) 返回沿轴的最大值的索引

a:输入数组

axis:指定的轴，默认为扁平数组

out:如果提供，结果将被插入到这个数组中。它应该具有合适的形状和 dtype

keepdims:如果将其设置为 True，则减少的轴将作为尺寸为 1 的维度保留在结果中

>>> x=np.arange(12).reshape(4,3)
>>> print(x)
[[ 0  1  2][ 3  4  5][ 6  7  8][ 9 10 11]]
>>> np.argmax(x)
11
>>> np.argmax(x,axis=1)
array([2, 2, 2, 2])

numpy.argmin(a,axis=None,out=None,keepdims=) 返回延轴最小值的索引

a:输入数组

axis:指定的轴，默认为扁平数组

out:如果提供，结果将被插入到这个数组中。它应该具有合适的形状和 dtype

keepdims:如果将其设置为 True，则减少的轴将作为尺寸为 1 的维度保留在结果中

>>> x=np.arange(12).reshape(4,3)
>>> print(x)
[[ 0  1  2][ 3  4  5][ 6  7  8][ 9 10 11]]
>>> np.argmin(x)
0
>>> np.argmin(x,axis=1)
array([0, 0, 0, 0])

numpy.array(object,dyte=None,copy=True,order=None,subok=False,ndmin=0) 将其他数列转化为数组

numpy.asarray(object,dtype=None,order=None) 输入转换为数组

numpy.asanyarray(object,dtyoe=None,order=None,like=None) 输入转换为 ndarray，但通过 ndarray 子类传递

numpy.asmatrix(object,dtype=None) 输入转化为矩阵

numpy.asfarray(object,dtype=<class ‘numpy.double’>) 输入转换为浮点类型的数组。

object:数组或嵌套数列

dtype:数组的所需数据类型，可选

copy:对象是否可被复制，可选

order:创建数组样式，C为行方向，F为列方向，A为任意方向（默认）

subok:默认返回一个积类类型一致的数组

ndmin:指定生成数组的最小维度

>>> x =  [1,2,3]
>>> a = np.asarray(x)
>>> print (a)
[1 2 3]
>>> b = np.asarray(x,dtype=float)
>>> print(b)
[1. 2. 3.]

numpy.append(arr,values,axis=None) 将值附加到数组的末尾

arr:要添加的数组

values:添加到arr中的数组，形状和类型要相同

axis:插入obj所指定的轴。如果axis为None，则obj应用于扁平化数组

>> np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]])
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0)
array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])

numpy.array_split(ary,indices_or_sections,axis=0) 指定数组拆分为多个子数组

ary:将被拆分的数组

indices_or_sections:如果indices_or_sections是一个整数N，数组将被沿轴线分割成N个相等的数组。和numpy.split()不同，不会报错。如果indices_or_sections是一个排序的整数的一维数组，这些条目表示数组沿轴线被分割的位置。

axis:分割的轴，默认为0

>>> x = np.arange(8.0)
>>> np.array_split(x, 3)
[array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7.])]
>>> x = np.arange(9)
>>> np.array_split(x, 4)
[array([0, 1, 2]), array([3, 4]), array([5, 6]), array([7, 8])]
>>> np.array_split(x, [1,1,3,4])
[array([0]), array([], dtype=int64), array([1, 2]), array([3]), array([4, 5, 6, 7, 8])]

numpy.asscalar(a) 将大小为1的数组转化为等效标量

a:大小为 1 的输入数组

>>> np.asscalar(np.array([24]))
<stdin>:1: DeprecationWarning: np.asscalar(a) is deprecated since NumPy v1.16, use a.item() instead
24

numpy.average(a,axis=Noen,weights=None,returned=False) 计算沿指定轴的加权平均值

a:输入数组

axis:沿其平均 a 的一个或多个轴。默认情况下，axis=None 将平均输入数组的所有元素

weights:与a中的值相关的权重

returned:默认值为假。如果为 True，则返回元组 (average, sum_of_weights)，否则仅返回平均值

>>> a = np.arange(1, 5)
>>> np.average(a)
2.5
>>> np.average(np.arange(1, 11), weights=np.arange(10, 0, -1))
4.0
>>> a = np.arange(6).reshape((3,2))
>>> np.average(a, axis=1, weights=[1./4, 3./4])
array([0.75, 2.75, 4.75])

numpy.block(arrays) 将列表块组装一个 nd 数组

arrays:输入列表

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.block([a, b, 10])
array([ 1,  2,  3,  4,  5,  6, 10])
>>> np.block([[a], [b]])
array([[1, 2, 3],[4, 5, 6]])

numpy.broadast() 生成模拟广播对象

>>> x = np.array([[1], [2], [3]])
>>> y = np.array([4, 5, 6])
>>> b = np.broadcast(x, y)
>>> out = np.empty(b.shape)
>>> out.flat = [u+v for (u,v) in b]
>>> print(out)
[[5. 6. 7.][6. 7. 8.][7. 8. 9.]]
>>> print(x+y)
[[5 6 7][6 7 8][7 8 9]]

numpy.broadcast_arrays(*args,subok=False) 相互广播任意数量的数组

*args:要广播的数组

subok:如果为 True，则子类将被传递，False则返回的数组将被强制为基类数组（默认）。

>>> x = np.array([[1,2,3]])
>>> y = np.array([[4],[5]])
>>> np.broadcast_arrays(x, y)
[array([[1, 2, 3],[1, 2, 3]]), array([[4, 4, 4],[5, 5, 5]])]

numpy.broadcast_to(array, shape,subok=False) 将数组广播为新形状

array:要被广播的数组

shape:广播为的形状

subok:如果为 True，则子类将被传递，False则返回的数组将被强制为基类数组（默认）。

>> x = np.array([1, 2, 3])
>>> np.broadcast_to(x, (3, 3))
array([[1, 2, 3],[1, 2, 3],[1, 2, 3]])

numpy.column_stack(tup) 将一维数组作为列堆叠到二维数组中。

tup:要堆叠的数组。它们都必须具有相同的第一维。

>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.column_stack((a,b))
array([[1, 2],[2, 3],[3, 4]])

==numpy.concatenate((a1,a2…),axis=0,out=None,dtype=None,casting=“same_kind”)==拼接数组

a1,a2…:除了与轴对应的维度（默认为第一个）外，数组必须具有相同的形状

axis:阵列将沿其连接的轴。如果axis为None，数组在使用前会被展平。默认值为 0。

out:如果提供，则为放置结果的目的地。形状必须正确，与未指定 out 参数时连接将返回的形状相匹配。

dtype:如果提供，目标数组设置为此数据类型。不能与 out 一起提供

casting:控制可能发生的数据类型转换。默认为“same_kind”

>>> a = np.array([[1, 2], [3, 4]])
>>> b = np.array([[5, 6]])
>>> np.concatenate((a, b))
array([[1, 2],[3, 4],[5, 6]])

numpy.copy(a,order=‘K’,subok=Fales) 返回给定对象的数组副本

a:要拷贝的数组

order:K表示尽可能的于a的布局相匹配

subok:默认Fales，如果为 True，则子类将被传递，否则返回的数组将被强制为基类数组

>> x = np.array([1, 2, 3])
>>> y = x
>>> z = np.copy(x)
>>> x[0] = 10                         #改变x的一个数，y跟着改变，但z不变
>>> y==x
array([ True,  True,  True])
>>> z==x
array([False,  True,  True])

numpy.copyto(dst,src,casting=‘same_kind’,where=True) 将数值从一个数组复制到另一个数组，必要时进行广播

dst:将值复制到其中的数组

src:用于复制数值的数组

casting:控制复制时可能发生的数据类型转换。选项：{‘no’,‘equiv’,‘safe’,‘same_kind’,‘unsafe’}

{

no:数据类型不会被替换

equiv:允许字节顺序被替换

safe:允许保留数值的转换

same_kind:允许安全类型转换或类型转换，例如 float64 到 float32

unsafe:可以进行任何数据转换

}

where:一个布尔数组，它被广播以匹配 dst 的维度，并选择要从 src 复制到 dst 的元素，只要它包含值 True。

>>> x=np.arange(1,6,dtype=float)
>>> print(x)
[1. 2. 3. 4. 5.]
>>> y=np.arange(9,14,dtype=float)
print(y)
np.copyto(x,y)
print(x)
print(y)
>>> print(y)
[ 9. 10. 11. 12. 13.]
>>> np.copyto(x,y)
>>> print(x)
[ 9. 10. 11. 12. 13.]
>>> print(y)
[ 9. 10. 11. 12. 13.]

numpy.delete(arr,obj,axis=None) 返回一个新的数组，其中的子数组沿删除的轴。

arr:输入数组

obj:指示要沿指定轴删除的子数组的索引

axis:删除 obj所指定的轴。如果axis为None，则obj应用于扁平化数组

>>> arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
>>> print(arr)
[[ 1  2  3  4][ 5  6  7  8][ 9 10 11 12]]
>>> np.delete(arr, 1)
array([ 1,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])
>>> np.delete(arr, 1,0)
array([[ 1,  2,  3,  4],[ 9, 10, 11, 12]])
>>> np.delete(arr, [1,3,5])
array([ 1,  3,  5,  7,  8,  9, 10, 11, 12])

numpy.dot(a,b,out=None) 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和,对于二维数组，计算的是两个数组的矩阵乘积,对于多维数组公式：**dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])**

a:ndarray 数组

b:ndarray 数组

out:ndarray, 可选，用来保存dot()的计算结果

>>> a = np.array([[1,2],[3,4]])
>>> b = np.array([[11,12],[13,14]])
>>> print(np.dot(a,b))
[[37 40][85 92]]

numpy.dsplit(ary,indices_or_sections) 沿第 3 轴（深度）将数组拆分为多个子数组

ary:将被拆分的数组

indices_or_sections:数字或数组

>>> x = np.arange(16.0).reshape(2, 2, 4)
>>> print(x)
[[[ 0.  1.  2.  3.][ 4.  5.  6.  7.]][[ 8.  9. 10. 11.][12. 13. 14. 15.]]]
>>> np.dsplit(x, 2)
[array([[[ 0.,  1.],[ 4.,  5.]],[[ 8.,  9.],[12., 13.]]]),array([[[ 2.,  3.],[ 6.,  7.]],[[10., 11.],[14., 15.]]])]
>>> np.dsplit(x, np.array([3, 6]))
[array([[[ 0.,  1.,  2.],[ 4.,  5.,  6.]],[[ 8.,  9., 10.],[12., 13., 14.]]]), array([[[ 3.],[ 7.]],[[11.],[15.]]]),array([], shape=(2, 2, 0), dtype=float64)]

numpy.dstack(tup) 按顺序深度堆叠数组（沿第三轴）

tup:输入ndarrays 序列，除了第三个轴外，阵列必须具有相同的形状。一维或二维数组必须具有相同的形状。

>>> a = np.array((1,2,3))
>>> b = np.array((2,3,4))
>>> np.dstack((a,b))
array([[[1, 2],[2, 3],[3, 4]]])
>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[2],[3],[4]])
>>> np.dstack((a,b))
array([[[1, 2]],[[2, 3]],[[3, 4]]])

numpy.dtype(object,align,copy) 转换数据类型

object:要转换为的数据类型

align:如果为True，填充字段使其列斯C的结构体

copy:复制 dtype 对象，如果为 false，则是对内置数据类型对象的引用

>>> dt = np.dtype('i4')
>>> print(dt)
int32

名称	描述
bool_	布尔型数据类型（True 或者 False）
int_	默认的整数类型（类似于 C 语言中的 long，int32 或 int64）
intc	与 C 的 int 类型一样，一般是 int32 或 int 64
intp	用于索引的整数类型（类似于 C 的 ssize_t，一般情况下仍然是 int32 或 int64）
int8	字节（-128 to 127）
int16	整数（-32768 to 32767）
int32	整数（-2147483648 to 2147483647）
int64	整数（-9223372036854775808 to 9223372036854775807）
uint8	无符号整数（0 to 255）
uint16	无符号整数（0 to 65535）
uint32	无符号整数（0 to 4294967295）
uint64	无符号整数（0 to 18446744073709551615）
float_	float64 类型的简写
float16	半精度浮点数，包括：1 个符号位，5 个指数位，10 个尾数位
float32	单精度浮点数，包括：1 个符号位，8 个指数位，23 个尾数位
float64	双精度浮点数，包括：1 个符号位，11 个指数位，52 个尾数位
complex_	complex128 类型的简写，即 128 位复数
complex64	复数，表示双 32 位浮点数（实数部分和虚数部分）
complex128	复数，表示双 64 位浮点数（实数部分和虚数部分）

numpy.empty(shape,dtype=float,order=‘C’) 创建给定形状的空数组

shape:数组形状

dtye:数据类型，可选

order:有‘C’和‘F’两个选项，分别代表行优先和列优先

>>>x=np.empty([3,2], dtype = int)
>>>print (x)
[[-4611686018427387904        8786413404964][-4611686018427387899 -4611686018427387904][-4611686018427387900 -4611686018427387904]]

numpy.empty_like(prototype,dtype=None,order=‘K’,subok=True,shape=None) 创建一个形状和类型相同的数组

prototype:其形状和数据类型定义了所创建数组的这些相同属性

dtype:覆盖结果的数据类型

order:行优先’C’和列优先’F’ 。 “K”表示尽可能匹配原型的布局

subok:如果为True，则新创建的数组将使用prototype的子类类型，否则为基类数组。默认为True

shape:覆盖结果的形状。如果order='K’并且维数没有变化，将尽量保持顺序，否则就意味着order=‘C’

>>> a = ([1,2,3], [4,5,6])
>>> np.empty_like(a)
array([[-4611686018427387904, -4611686018427387904,           4397989924],[                  10,                   11,       -1060756062457]])
>>> b = np.array([[1., 2., 3.],[4.,5.,6.]])
>>> np.empty_like(b)
array([[-2.00000000e+000, -2.00000000e+000,  2.17506512e-314],[ 2.17507593e-314,  0.00000000e+000, -2.00000000e+000]])

numpy.expand_dims(a,axis) 展开数组的形状。插入一个新轴，该轴将出现在展开的阵列形状中的轴位置。

a:数组

axis:在扩展轴中放置新轴（或轴）的位置。

>>> x = np.array([1, 2])
>>> x.shape
(2,)
>>> y = np.expand_dims(x, axis=0)
>>> print(y)
[[1 2]]
>>> y.shape
(1, 2)
>>> y = np.expand_dims(x, axis=(2, 0))
>>> print(y)
[[[1][2]]]
>>> y.shape
(1, 2, 1)

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

condition:一个数组，其非零或 True 条目指示要提取的 arr 元素

arr:与条件大小相同的输入数组

>>> arr = np.arange(12).reshape((3, 4))
>>> np.extract(np.mod(arr, 3)==0, arr)
array([0, 3, 6, 9])
>>> arr
array([[ 0,  1,  2,  3],[ 4,  5,  6,  7],[ 8,  9, 10, 11]])
>>> np.mod(arr,3)
array([[0, 1, 2, 0],[1, 2, 0, 1],[2, 0, 1, 2]])
>>> np.mod(arr,3)==0
array([[ True, False, False,  True],[False, False,  True, False],[False,  True, False, False]])

numpy.eye(N,M=None,k=0,dtype=‘float’,order=‘C’,like=None) 返回一个二维数组，对角线上为 1，其他地方为 0

N:行数

M:列数,如果没有，默认为 N。

k:对角线的索引默认为0，表示主对角线，正值表示上对角线，负值表示下对角线。

dtype:返回数组的数据类型，可选

order:行优先’C’和列优先’F’

like:允许创建不是numpy数组的数组引用对象

>>> np.eye(2, dtype=int)
array([[1, 0],[0, 1]])
>>> np.eye(3, k=1)
array([[0., 1., 0.],[0., 0., 1.],[0., 0., 0.]])

numpy.flip(m,axis=None) 沿给定轴反转数组中元素的顺序。数组的形状被保留，但元素被重新排序

m:输入数组

axis:要翻转的轴。默认情况下，axis=None，将翻转输入阵列的所有轴。如果axis为负数，则从最后一个轴算到第一个轴。如果轴是整数元组，则在元组中指定的所有轴上执行翻转

>>> A = np.arange(8).reshape((2,2,2))
>>> print(A)
[[[0 1][2 3]][[4 5][6 7]]]
>>> np.flip(A)
array([[[7, 6],[5, 4]],[[3, 2],[1, 0]]])
>>> np.flip(A, 0)
array([[[4, 5],[6, 7]],[[0, 1],[2, 3]]])
>>> np.flip(A, 1)
array([[[2, 3],[0, 1]],[[6, 7],[4, 5]]])
>>> np.flip(A, (0, 2))
array([[[5, 4],[7, 6]],[[1, 0],[3, 2]]])

numpy.fliplr(m) 沿轴 1（左/右）反转元素的顺序

m:输入数组

>>> np.flip(A, (0, 2))
array([[[5, 4],[7, 6]],[[1, 0],[3, 2]]])
>>> A = np.diag([1.,2.,3.])
>>> print(A)
[[1. 0. 0.][0. 2. 0.][0. 0. 3.]]
>>> np.fliplr(A)
array([[0., 0., 1.],[0., 2., 0.],[3., 0., 0.]])

numpy.flipud(m) 沿轴 0（向上/向下）反转元素的顺序

m:输入数组

>>> A = np.diag([1, 2, 3])
>>> print(A)
[[1 0 0][0 2 0][0 0 3]]
>>> np.flipud(A)
array([[0, 0, 3],[0, 2, 0],[1, 0, 0]])

numpy.frombuffer(buffer,dtype=float,count=-1,offset=0) 实现动态数组，接受buffer输入函数，以流动形式转化为ndarray对象

buffer:可以是任意对象，会以流动形式读入

dtype:返回数组的数据类型，可选

count:读取的数据数量，默认为-1，读取所有数据

offset:读取的起始位置，默认为0

>>>s=b'hello world'
>>>a=np.frombuffer(s,dtype='S1')
>>>print(a)
[b'h' b'e' b'l' b'l' b'o' b' ' b'w' b'o' b'r' b'l' b'd']

numpy.fromfile(file,dtype=float,count=-1,sep=’’,offset=0,like=None) 从文本或二进制文件中的数据构造一个数组

file:打开文件对象或文件名

dtype:返回数组的数据类型

count:要阅读的项目数。 -1 表示所有项目

sep:文件内容之间的分隔符。

offset:文件当前位置的偏移量（以字节为单位）。默认为 0。

like:允许创建非NumPy数组的引用对象

>>> dt = np.dtype([('time', [('min', np.int64), ('sec', np.int64)]),('temp', float)])                   #创建数组
>>> x = np.zeros((1,), dtype=dt)
>>> x['time']['min'] = 10; x['temp'] = 98.25
>>> print(x)
[((10, 0), 98.25)]
>>> x
array([((10, 0), 98.25)],dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])
>>> import tempfile
>>> fname = tempfile.mkstemp()[1]
>>> x.tofile(fname)                                    #保存数组
>>> np.fromfile(fname, dtype=dt)
array([((10, 0), 98.25)],dtype=[('time', [('min', '<i8'), ('sec', '<i8')]), ('temp', '<f8')])

numpy.fromfunction(function, shape,dtype=‘float’,like=None) 通过在每个坐标上执行一个函数来构造一个数组。

function:回调函数

shape:数组的形状

dtype:数据类型，默认为float

like:允许创建不是numpy数组的数组引用对象

>>> def test(i):
...     return i+1
...
>>> np.fromfunction(test,(5,))
array([1., 2., 3., 4., 5.])
>>> def test2(i,j):
...     return i**j
...
>>> np.fromfunction(test2,(5,3))
array([[ 1.,  0.,  0.],[ 1.,  1.,  1.],[ 1.,  2.,  4.],[ 1.,  3.,  9.],[ 1.,  4., 16.]])

numpy.fromiter(iterable,dtype,count=-1) 从迭代对象中建立ndarray对象，返回一维数组

iterable:可迭代对象

dtype:返回数组的数据类型

count:读取的数据数量，读取所有数据

>>> list=range(5)
>>> x=np.fromiter(list,dtype=float)
>>> print(x)
[0. 1. 2. 3. 4.]

numpy.fromstring(string,dtype=float,count=-1,sep,like=None) 从字符串中创造一维数组

string:字符串

dtype:数据类型

sep:间隔

like:允许创建不是numpy数组的数组引用对象

>>> np.fromstring('1, 2', dtype=int, sep=',')
array([1, 2])

numpy.full(shape, fill_value,dtype=None,order=‘C’,like=None) 返回一个给定形状和类型的新数组，填充 fill_value

shape:新数组的形状

fill_value:填充值

dtype:数组的数据类型默认值 None 表示

order:行优先’C’和列优先’F’

like:允许创建不是numpy数组的数组引用对象

>>> np.full((2, 2), np.inf)
array([[inf, inf],[inf, inf]])
>>> np.full((2, 2), 10)
array([[10, 10],[10, 10]])
>>> np.full((2, 2), [1, 2])
array([[1, 2],[1, 2]])

numpy.full_like(prototype,fill_value,dtype=None,order=‘K’,subok=True,shape=None) 创建一个形状和类型相同的数组用fill_value填充

prototype:其形状和数据类型定义了所创建数组的这些相同属性

fill_value:填充值

dtype:覆盖结果的数据类型

order:行优先’C’和列优先’F’ 。 “K”表示尽可能匹配原型的布局

subok:如果为True，则新创建的数组将使用prototype的子类类型，否则为基类数组。默认为True

shape:覆盖结果的形状。如果order='K’并且维数没有变化，将尽量保持顺序，否则就意味着order=‘C’

>>> x = np.arange(6, dtype=int)
>>> print(x)
[0 1 2 3 4 5]
>>> np.full_like(x,99)
array([99, 99, 99, 99, 99, 99])
>>> np.full_like(x,99.99,dtype=float)
array([99.99, 99.99, 99.99, 99.99, 99.99, 99.99])

numpy.hsplit(ary,indices_or_sections) 将数组水平（按列）拆分为多个子数组。

ary:将要被拆分的数组

indices_or_sections:所要拆分的列的索引，数字或列表

>>> x = np.arange(16.0).reshape(4, 4)
>>> print(x)
[[ 0.  1.  2.  3.][ 4.  5.  6.  7.][ 8.  9. 10. 11.][12. 13. 14. 15.]]
>>> np.hsplit(x, 2)
[array([[ 0.,  1.],[ 4.,  5.],[ 8.,  9.],[12., 13.]]),array([[ 2.,  3.],[ 6.,  7.],[10., 11.],[14., 15.]])]
>>> np.hsplit(x, [2,3])
[array([[ 0.,  1.],[ 4.,  5.],[ 8.,  9.],[12., 13.]]),array([[ 2.],[ 6.],[10.],[14.]]),array([[ 3.],[ 7.],[11.],[15.]])]

numpy.hstack(tup) 水平（按列）按顺序堆叠数组

tup:输入ndarrays 序列，除了第2个轴外，阵列必须具有相同的形状。一维数组必须具有相同的长度。

>>> b = np.array((4,5,6))
>>> np.hstack((a,b))
array([1, 2, 3, 4, 5, 6])
>>> a = np.array([[1],[2],[3]])
>>> b = np.array([[4],[5],[6]])
>>> np.hstack((a,b))
array([[1, 4],[2, 5],[3, 6]])

numpy.identity(n,dtype=‘float’,like=None) 创建一个正方形，主对角线上是1。

n:输出n x n 的数组

dtype:输出的数据类型。默认为float

like:允许创建不是numpy数组的数组引用对象

>>> np.identity(3)
array([[1., 0., 0.],[0., 1., 0.],[0., 0., 1.]])

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

a:ndarray数组

b:ndarray数组

>>> a = np.array([1,2,3])
>>> b = np.array([0,1,0])
>>> np.inner(a, b)
2
>>> a = np.arange(24).reshape((2,3,4))
>>> a
array([[[ 0,  1,  2,  3],[ 4,  5,  6,  7],[ 8,  9, 10, 11]],[[12, 13, 14, 15],[16, 17, 18, 19],[20, 21, 22, 23]]])
>>> b = np.arange(4)
>>> np.inner(a, b)
array([[ 14,  38,  62],[ 86, 110, 134]])

numpy.insert(arr,obj,values,axis=None) 在给定索引之前沿给定轴插入值

arr:输入数组

obj:指定插入值之前的一个或多个索引的对象

values:要插入 arr 的值。如果 values 的类型与 arr 的类型不同，则 values 转换为 arr 的类型

axis:插入obj所指定的轴。如果axis为None，则obj应用于扁平化数组

>>> a = np.array([[1, 1], [2, 2], [3, 3]])
>>> print(a)
[[1 1][2 2][3 3]]
>>> np.insert(a, 1, 5)
array([1, 5, 1, 2, 2, 3, 3])
>>> np.insert(a, 1, 5, axis=1)
array([[1, 5, 1],[2, 5, 2],[3, 5, 3]])
>>> np.insert(a, [1], [[1],[2],[3]], axis=1)
array([[1, 1, 1],[2, 2, 2],[3, 3, 3]])

np.iscomplex(a) 判断是否为复数返回布尔值

>>> a = np.array([1,  2+6j,  5,  3.5+5j])
>>> np.iscomplex(a)
array([False,  True, False,  True])

numpy.lexsort(keys,axis=-1) 用于对多个序列进行排序。类似对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。

keys:要排序的 k 个不同的“列”

axis:要间接排序的轴。默认情况下，对最后一个轴进行排序

>>> surnames =    ('Hertz',    'Galilei', 'Hertz')
>>> first_names = ('Heinrich', 'Galileo', 'Gustav')
>>> np.lexsort((first_names, surnames))
array([1, 2, 0])
>>> a = [1,5,1,4,3,4,4]
>>> b = [9,4,0,4,0,2,1]
>>> np.lexsort((a,b))
array([2, 4, 6, 5, 3, 1, 0])

numpy.linalg.solve(a,b) 求解线性矩阵方程

a:系数矩阵

b:常数项矩阵

>>> a = np.array([[1, 2], [3, 5]])
>>> b = np.array([1, 2])
>>> np.linalg.solve(a, b)
array([-1.,  1.])

numpy.linspace(start,stop,num=50,endpoint=True,retsetp=False,dtype=None) 函数用于创建一个一维数组

start:序列的起始值

stop:序列的终止值

num:要生成的等步长的样本数量，默认为50

endpoint:该值为true时，数列中包含stop值，反之不包含，默认是True

retstep:如果为True时，数列中会显示间距

dtype:数据类型

>>> a = np.linspace(1,10,10)
>>> print(a)
[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]
>>> b = np.linspace(1,1,10)
>>> print(b)
[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
>>> c =np.linspace(1,10,10,retstep=True)
>>> print(c)
(array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]), 1.0)
>>> d =np.linspace(1,10,10).reshape([10,1])           #拓展例子
>>> print(d)
[[ 1.][ 2.][ 3.][ 4.][ 5.][ 6.][ 7.][ 8.][ 9.][10.]]

numpy.logspace(start, stop,num=50,endpoint=True,base=10.0,dtype=None) 创建等比数列

start:序列的起始值，值为base^start

stop:序列的终止值，值为base^stop

num:要生成的等步长的样本数量，默认为50

endpoint:该值为True时，数列包含stop值，默认为True

base:对数log的底数默认是10

dtype:ndarray数据类型

>>> a = np.logspace(1.0,  2.0, num =  10)
>>> print (a)
[ 10.          12.91549665  16.68100537  21.5443469   27.8255940235.93813664  46.41588834  59.94842503  77.42636827 100.        ]
>>> b = np.logspace(0,9,10,base=2)
>>> print (b)
[  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]

numpy.matmul(a,b) 两个数组的矩阵乘积

a: ndarray 数组

b: ndarray 数组

>>> a = [[1,0],[0,1]]
>>> b = [[4,1],[2,2]]
>>> np.matmul(a,b)
array([[4, 1],[2, 2]])

numpy.mean(a,axis=None,dtype=None,out=None,keepdims=,where=) 计算沿指定轴的算术平均值

a:输入数组

axis:计算平均值所沿的一个或多个轴。默认扁平数组

dtype:用于计算平均值的类型。对于整数输入，默认为 float64

out:用于放置结果的备用输出数组

keepdims:如果将其设置为 True，则减少的轴将作为尺寸为 1 的维度保留在结果中

where:要包含在平均值中的元素

>>> a = np.array([[1, 2], [3, 4]])
>>> np.mean(a)
2.5
>>> np.mean(a, axis=0)
array([2., 3.])
>>> np.mean(a, axis=1)
array([1.5, 3.5])

numpy.median(a,axis=None,out=None,overwrite_input=Fales,keepdims=False) 计算沿指定轴的中位数

a:输入数组

axis:计算中位数所沿的一个或多个轴。默认值是沿着数组的扁平版本计算中位数

out:用于放置结果的替代输出数组。它必须具有与预期输出相同的形状

overwrite_input:如果是True，那么允许使用输入数组a的内存进行计算.如果overwrite_input为True，而a还不是一个ndarray将报错

keepdims:如果将其设置为 True，则减少的轴将作为尺寸为 1 的维度保留在结果中

>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> np.median(a)
3.5
>>> np.median(a, axis=0)
array([6.5, 4.5, 2.5])
>>> np.median(a, axis=1)
array([7., 2.])

numpy.moveaxis(a,source,destination) 将数组的轴移动到新位置

a:其轴将要被移动的数组

source:要移动的轴的原始位置。这些必须是唯一的

destination:每个原始轴的目标位置。这些也必须是唯一的

>>> x=np.arange(12).reshape(4,3)
>>> print(x)
[[ 0  1  2][ 3  4  5][ 6  7  8][ 9 10 11]]
>>> np.moveaxis(x,0,-1)
array([[ 0,  3,  6,  9],[ 1,  4,  7, 10],[ 2,  5,  8, 11]])

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

a:输入数组

>>> x=np.arange(12).reshape(4,3)
>>> print(x)
[[ 0  1  2][ 3  4  5][ 6  7  8][ 9 10 11]]
>>> np.nonzero(x)                  #坐标
(array([0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3]), array([1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]))

numpy.ones(shape,dtype=float,order=‘C’) 创建指定的小的数组用1填充

shape:数组形状

dtype:数据类型，可选

order:行优先’C’和列优先’F’

>>> x = np.ones((5,5))
>>> print(x)
[[1. 1. 1. 1. 1.][1. 1. 1. 1. 1.][1. 1. 1. 1. 1.][1. 1. 1. 1. 1.][1. 1. 1. 1. 1.]]

numpy.ones_like(prototype,dtype=None,order=‘K’,subok=True,shape=None) 创建一个形状和类型相同的数组用1填充

prototype:其形状和数据类型定义了所创建数组的这些相同属性

dtype:覆盖结果的数据类型

order:行优先’C’和列优先’F’ 。 “K”表示尽可能匹配原型的布局

subok:如果为True，则新创建的数组将使用prototype的子类类型，否则为基类数组。默认为True

shape:覆盖结果的形状。如果order='K’并且维数没有变化，将尽量保持顺序，否则就意味着order=‘C’

>>> x = np.arange(6).reshape((2,3))
>>> print(x)
[[0 1 2][3 4 5]]
>>> np.ones_like(x)
array([[1, 1, 1],[1, 1, 1]])

numpy.percentile(a,q,axis=None,overwrite_input=Fales,interpolation=‘linear’,keepdims=False) 计算沿指定轴的数据的第 q 个百分位数

a:输入数组

q:要计算的百分位数或百分位数序列，必须介于 0 和 100 之间（包括 0 和 100）。

axis:计算百分位数的轴。默认值是沿着数组的扁平版本计算百分位数

out:用于放置结果的替代输出数组。它必须具有与预期输出相同的形状

overwrite_input:如果为 True，则允许通过中间计算修改输入数组 a，以节省内存

interpolation:指定当所需百分位数位于两个数据点 i < j 之间时使用的插值方法

keepdims:如果将其设置为 True，则减少的轴将作为尺寸为 1 的维度保留在结果中

>>> a = np.array([[10, 7, 4], [3, 2, 1]])
>>> np.percentile(a, 50)
3.5
>>> np.percentile(a, 50, axis=0)
array([6.5, 4.5, 2.5])
>>> np.percentile(a, 50, axis=1)
array([7., 2.])
>>> np.percentile(a, 50, axis=1, keepdims=True)
array([[7.],[2.]])

numpy.ptp(a,axis=None,out=None,keepdims=) 沿轴的值范围（最大值 - 最小值）

a:输入数组

axis:沿其找到峰值的轴。默认情况下，展平数组。 axis 可是负数，在这种情况下，它从最后一个轴到第一个轴计数

out:用于放置结果的替代输出数组。它必须具有与预期输出相同的形状

keepdims:如果将其设置为 True，则减少的轴将作为尺寸为 1 的维度保留在结果中

>>> x = np.array([[4, 9, 2, 10],[6, 9, 7, 12]])
>>> np.ptp(x)
10
>>> np.ptp(x, axis=0)
array([2, 0, 5, 2])
>>> np.ptp(x, axis=1)
array([8, 6])

numpy.ravel(a,order=‘C’) 创建一个扁平的数组

a:输入数组。 a 中的元素按 order 指定的顺序读取，并打包为一维数组。

order:行优先’C’和列优先’F’

>>> a = np.array([[1,2,3], [4,5,6]])
>>> np.ravel(a)
array([1, 2, 3, 4, 5, 6])
>>> np.ravel(a,'F')
array([1, 4, 2, 5, 3, 6])
>>> np.ravel(a.T)
array([1, 4, 2, 5, 3, 6])

numpy.repeat(a,repeats.axis=None) 重复数组的元素（np.tile()不同）

a:要重复的数组

repeat:每个元素的重复次数。重复广播以适应给定轴的形状。

axis:重复取值的轴。默认情况下，使用扁平化的输入数组，并返回一个扁平化的输出数组。

>>> x = np.array([[1,2],[3,4]])
>>> np.repeat(x, 2)
array([1, 1, 2, 2, 3, 3, 4, 4])
>>> np.repeat(x, 3, axis=1)
array([[1, 1, 1, 2, 2, 2],[3, 3, 3, 4, 4, 4]])
>>> np.repeat(x, [1, 2], axis=0)
array([[1, 2],[3, 4],[3, 4]])

numpy.require(a,dtype=None,requirements=None,like=None) 返回满足要求的所提供类型的 ndarray。

a:要转换为满足类型和要求的数组的对象。

dtype:所需的数据类型。如果 None （默认）保留当前的数据类型。

requirements:选项：{‘F_CONTIGUOUS’(‘F’),‘C_CONTIGUOUS’(‘C’),‘ALIGNED’(‘A’),‘WRITEABLE’(‘W’),‘OWNDATA’ (‘O’),‘ENSUREARRAY’(‘E’)}

{

‘F_CONTIGUOUS’(‘F’)：Fortran 连续数组

‘C_CONTIGUOUS’(‘C’)：c语言连续数组

‘WRITEABLE’(‘W’)：数据类型对齐的数组

‘OWNDATA’ (‘O’)：拥有自己数据的数组

‘ENSUREARRAY’(‘E’)：确保基数组，而不是子类

}

like:允许创建不是numpy数组的数组引用对象

>>> x = np.arange(6).reshape(2,3)
>>> x.flagsC_CONTIGUOUS : TrueF_CONTIGUOUS : FalseOWNDATA : FalseWRITEABLE : TrueALIGNED : TrueWRITEBACKIFCOPY : FalseUPDATEIFCOPY : False
>>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F'])
>>> y.flagsC_CONTIGUOUS : FalseF_CONTIGUOUS : TrueOWNDATA : TrueWRITEABLE : TrueALIGNED : TrueWRITEBACKIFCOPY : FalseUPDATEIFCOPY : False

numpy.reshape(a,newshape,order=‘C’) 在不改变数据的情况下改变数组形状

a:要重塑的数组

newshape:需要改变为的形状

order:行优先’C’和列优先’F’

>>> x=np.arange(12).reshape(4,3)
>>> print(x)
[[ 0  1  2][ 3  4  5][ 6  7  8][ 9 10 11]]
>>> np.reshape(x,(3,4))
array([[ 0,  1,  2,  3],[ 4,  5,  6,  7],[ 8,  9, 10, 11]])
>>> np.reshape(x,(3,4),order='F')
array([[ 0,  9,  7,  5],[ 3,  1, 10,  8],[ 6,  4,  2, 11]])
>>> a = np.array([[1,2,3], [4,5,6]])
>>> print(a)
[[1 2 3][4 5 6]]
>>> np.reshape(a,6)
array([1, 2, 3, 4, 5, 6])

numpy.resize(a,new_shape) 返回具有指定形状的新数组

a:准备调整的数组

new_shape:调整为的形状

>>> a=np.array([[0,1],[2,3]])
>>> print(a)
[[0 1][2 3]]
>>> np.resize(a,(2,3))
array([[0, 1, 2],[3, 0, 1]])
>>> np.resize(a,(1,4))
array([[0, 1, 2, 3]])
>>> np.resize(a,(2,4))
array([[0, 1, 2, 3],[0, 1, 2, 3]])

numpy.roll(a,shit,axis=None) 沿给定轴滚动数组元素

a:输入元组

shit:元素滚动的位数

axis:元素沿其移动的一个或多个轴。默认情况下，数组在移位之前被展平，之后恢复原始形状。

>>> x = np.arange(10)
>>> np.roll(x, 2)
array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])
>>> np.roll(x, -2)
array([2, 3, 4, 5, 6, 7, 8, 9, 0, 1])
>>> x2 = np.reshape(x, (2,5))
>>> print(x2)
[[0 1 2 3 4][5 6 7 8 9]]
>>> np.roll(x2, 1)
array([[9, 0, 1, 2, 3],[4, 5, 6, 7, 8]])
>>> np.roll(x2, 1, axis=0)
array([[5, 6, 7, 8, 9],[0, 1, 2, 3, 4]])
>>> np.roll(x2, 1, axis=1)
array([[4, 0, 1, 2, 3],[9, 5, 6, 7, 8]])

numpy.rot90(m,k=1,axes=(0,1)) 在轴指定的平面中将数组旋转 90 度。旋转方向是从第一轴到第二轴。

m:二维或更多维度的数组

k:数组旋转 90 度的次数

axes:阵列在轴定义的平面中旋转。轴必须不同。

>>> m = np.array([[1,2],[3,4]], int)
>>> print(m)
[[1 2][3 4]]
>>> np.rot90(m)
array([[2, 4],[1, 3]])
>>> np.rot90(m,2)
array([[4, 3],[2, 1]])

numpy.rollaxis(a, axis,start=0) 向后滚动指定轴直到它指定的位置

a:数组

axis:要滚动的轴。其他轴的位置相对于彼此不改变。

start:滚动到的位置，默认为0

>>> x=np.ones((3,2,3))
>>> print(x)
[[[1. 1. 1.][1. 1. 1.]][[1. 1. 1.][1. 1. 1.]][[1. 1. 1.][1. 1. 1.]]]
>> np.rollaxis(x,1)
array([[[1., 1., 1.],[1., 1., 1.],[1., 1., 1.]],[[1., 1., 1.],[1., 1., 1.],[1., 1., 1.]]])
>>> np.rollaxis(x,1,3)
array([[[1., 1.],[1., 1.],[1., 1.]],[[1., 1.],[1., 1.],[1., 1.]],[[1., 1.],[1., 1.],[1., 1.]]])

numpy.row_stack(tup) 垂直（按行）按顺序堆叠数组。

tup:输入ndarrays 序列除了第一个轴外，阵列必须具有相同的形状。一维数组必须具有相同的长度。

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.vstack((a,b))
array([[1, 2, 3],[4, 5, 6]])
>>> a = np.array([[1], [2], [3]])
>>> b = np.array([[4], [5], [6]])
>>> np.vstack((a,b))
array([[1],[2],[3],[4],[5],[6]])

numpy.save(file, arr, allow_pickle=True, fix_imports=True) 将数组保存到以 .npy 为扩展名的文件中

file:要保存的文件，扩展名为 .npy，如果文件路径末尾没有扩展名 .npy，该扩展名会被自动加上

arr:要保存的数组

allow_pickle:可选，布尔值，允许使用 Python pickles 保存对象数组，Python 中的 pickle 用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化

fix_imports: 可选，为了方便 Pyhton2 中读取 Python3 保存的数据

np.savez(file, args,kwds) 将多个数组保存到以 npz 为扩展名的文件中

file:要保存的文件，扩展名为 .npz，如果文件路径末尾没有扩展名 .npz，该扩展名会被自动加上

args:要保存的数组，可以使用关键字参数为数组起一个名字，非关键字参数传递的数组会自动起名为 arr_0, arr_1, …

kwds:要保存的数组使用关键字名称

numpy.sort(a,axis=-1,kind=None,order=None) 返回数组的排序副本

a:要排序的数组

axis:排序的轴。如果没有，则在排序之前将数组展平

kind:排序算法，默认为’quicksort’（快速排序）

order:如果数组包含字段，则是要排序的字段

>>> a = np.array([[1,4],[3,1]])
>>> np.sort(a)
array([[1, 4],[1, 3]])
>>> np.sort(a, axis=None)
array([1, 1, 3, 4])
>>> np.sort(a, axis=0)
array([[1, 1],[3, 4]])

numpy.split(ary,indices_or_sections,axis=0) 指定数组拆分为多个子数组作为 ary 的视图。

ary:将被拆分的数组

indices_or_sections:如果indices_or_sections是一个整数N，数组将被沿轴线分割成N个相等的数组。如果这种分割是不可能的，就会报错。如果indices_or_sections是一个排序的整数的一维数组，这些条目表示数组沿轴线被分割的位置。

axis:分割的轴，默认为0

>>> x = np.arange(9.0)
>>> np.split(x, 3)
[array([0., 1., 2.]), array([3., 4., 5.]), array([6., 7., 8.])]
>>> x = np.arange(8.0)
>>> np.split(x, [3, 5, 6, 10])
[array([0., 1., 2.]), array([3., 4.]), array([5.]), array([6., 7.]), array([], dtype=float64)]

numpy.squeeze(a, axis=None) 删除轴长为1的轴

a:数组

axis:轴，默认为None（所有轴），或者指定轴的位置（若不为1则报错）

>>> x = np.array([[[0], [1], [2]]])
>>> x.shape
(1, 3, 1)
>>> np.squeeze(x)
array([0, 1, 2])
>>> np.squeeze(x, axis=0)
array([[0],[1],[2]])
>>> np.squeeze(x, axis=2)
array([[0, 1, 2]])

numpy.stack(arrays,axis=0,out=None) 沿新轴连接一系列数组

arrays:具有相同形状的数组

axis:指定轴，结果数组中的轴，输入数组沿该轴堆叠

out:如果提供，则为放置结果的目的地。形状必须正确，与未指定 out 参数时连接将返回的形状相匹配。

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.stack((a, b))
array([[1, 2, 3],[4, 5, 6]])
>>> np.stack((a, b), axis=-1)
array([[1, 4],[2, 5],[3, 6]])

numpy.swapaxes(a.axis1,axis2) 交换数组的两个轴

a:数组

axis1:要交换的轴

axis2:要交换的另一个轴

>>> x=np.ones((1,2,3))
>>> print(x)
[[[1. 1. 1.][1. 1. 1.]]]
>>> np.swapaxes(x,0,1)
array([[[1., 1., 1.]],[[1., 1., 1.]]])

numpy.tile(a,reps) 构建一个数组，重复A的次数由reps决定。

a:输入要重复的数组

reps:数字或列表（表示维度）

>>> a = np.array([0, 1, 2])
>>> np.tile(a, 2)
array([0, 1, 2, 0, 1, 2])
>>> b = np.array([[1, 2], [3, 4]])
>>> np.tile(b, 2)
array([[1, 2, 1, 2],[3, 4, 3, 4]])
>>> np.tile(b, (2, 1))
array([[1, 2],[3, 4],[1, 2],[3, 4]])

numpy.transpose(a,axes=None) 反转或置换数组的轴,返回修改后的数组

a:输入数组

axes:如果指定，它必须是一个元组或列表，包含[0,1,…,N-1]的排列，其中N是a的轴数。返回数组的第i个轴将对应于输入的轴数axes[i]。如果没有指定，默认为range(a.ndim)[::-1]

>>> x = np.arange(4).reshape((2,2))
>>> print(x)
[[0 1][2 3]]
>>> np.transpose(x)
array([[0, 2],[1, 3]])

numpy.trim_zeros(filt,trim=‘fb’) 从一维数组或序列中删除前导和/或尾随0

filt:要修改的数组

trim:其中“f”表示从前面修剪，“b”表示从后面修剪。默认为‘fb’，从数组的前面和后面修剪零

>>> a = np.array((0, 0, 0, 1, 2, 3, 0, 2, 1, 0))
>>> np.trim_zeros(a)
array([1, 2, 3, 0, 2, 1])

numpy.unique(ar, return_index=False,return_inverse=False, return_counts=False,axis=None) 查找数组的唯一元素

ar:输入数组。除非指定轴，否则如果它不是一维的，它将被展平

return_index:如果为 True，返回导致唯一数组的 ar 索引（沿着指定的轴，如果提供，或在扁平数组中）

return_inverse:如果为 True，返回可用于重建 ar 的唯一数组的索引（对于指定的轴，如果提供）

return_counts:如果为 True，返回每个唯一项在 ar 中出现的次数

axis:要操作的轴。如果没有，ar将被平坦化。如果是整数，由给定轴索引的子数组将被平坦化

>>> a = np.array([[1, 1], [2, 3]])
>>> np.unique(a)
array([1, 2, 3])
>>> a = np.array([[1, 0, 0], [1, 0, 0], [2, 3, 4]])
>>> np.unique(a, axis=0)
array([[1, 0, 0],[2, 3, 4]])

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

a:ndarray数组

b:ndarray数组

>>> a = np.array([[1,2],[3,4]])
>>> b = np.array([[11,12],[13,14]])
>>> np.vdot(a,b)
130

numpy.vsplit(ary,indices_or_sections) 将数组垂直（按行）拆分为多个子数组。

ary:将要被拆分的数组

indices_or_sections:数字或列表

>>> x = np.arange(16.0).reshape(4, 4)
>>> print(x)
[[ 0.  1.  2.  3.][ 4.  5.  6.  7.][ 8.  9. 10. 11.][12. 13. 14. 15.]]
>>> np.vsplit(x, 2)
[array([[0., 1., 2., 3.],[4., 5., 6., 7.]]),array([[ 8.,  9., 10., 11.],[12., 13., 14., 15.]])]
>>> np.vsplit(x, [2,3])
[array([[0., 1., 2., 3.],[4., 5., 6., 7.]]),array([[ 8.,  9., 10., 11.]]),array([[12., 13., 14., 15.]])]

numpy.vstack(tup) 垂直（按行）按顺序堆叠数组

tup:输入ndarrays 序列，除了第一个轴外，阵列必须具有相同的形状。一维数组必须具有相同的长度。

>>> a = np.array([1, 2, 3])
>>> b = np.array([4, 5, 6])
>>> np.vstack((a,b))
array([[1, 2, 3],[4, 5, 6]])

numpy.where(condition,[x,y,]/) 函数返回输入数组中满足给定条件的x或y中元素的索引

condition:条件

x,y,:可供选择的值

>>> x = np.arange(9.).reshape(3,  3)
>>> print(x)
[[0. 1. 2.][3. 4. 5.][6. 7. 8.]]
>>> np.where(x >  3)            #坐标
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))

numpy.zeros(shape,dtype=float,order=‘C’) 创建指定的小的数组用0填充

shape:数组形状

dtype:数据类型，可选

order:行优先’C’和列优先’F’

>>>x = np.zeros((5,5))
>>>print(x)
array([[0., 0., 0., 0., 0.],[0., 0., 0., 0., 0.],[0., 0., 0., 0., 0.],[0., 0., 0., 0., 0.],[0., 0., 0., 0., 0.]])

numpy.zeros_like(prototype,dtype=None,order=‘K’,subok=True,shape=None) 创建一个形状和类型相同的数组用0填充

prototype:其形状和数据类型定义了所创建数组的这些相同属性

dtype:覆盖结果的数据类型

order:行优先’C’和列优先’F’ 。 “K”表示尽可能匹配原型的布局

subok:如果为True，则新创建的数组将使用prototype的子类类型，否则为基类数组。默认为True

shape:覆盖结果的形状。如果order='K’并且维数没有变化，将尽量保持顺序，否则就意味着order=‘C’

>>> x = np.arange(6).reshape((2,3))
>>> print(x)
[[0 1 2][3 4 5]]
>>> np.zeros_like(x)
array([[0, 0, 0],[0, 0, 0]])

python Numpy模块汇总（字母排序）备注：内容很多，用control/command（Mac系统）+ F可以在网页内关键词查找，希望你能找到想要的内容相关推荐

Python~NumPy模块一站式教程，稳稳拿捏（持续更新ing）
一.Numpy模块基础 1. 介绍 NumPy的核心是多维数组类numpy.ndarray,矩阵类numpy.matrix是多位数组类的派生类.以多位数组类为数据组织结构,Numpy提供了众多的数学 ...
python numpy模块
目录 numpy模块一维数组二维数组(用的最多的) 获取多维数组的行和列多维数组的索引高级功能多维数组的元素的替换通过函数方法创建多维数组矩阵的运算点乘和转置(了解) 点乘必须 m*n ...
【Python numpy模块】结合金融场景演示numpy模块的操作
##基本操作输入数组,对数组进行切片和索引 ##本篇文章所有操作展示均在spyder命令行窗口股票简称 2018年9月3日 2018年9月4日 2018年9月5日 2018年9月6日 2018年9 ...
python numpy 数据类型为python对象-python numPy模块与numpy里的数据类型、数据类型对象dtype...
学习链接:http://www.runoob.com/numpy/numpy-tutorial.html 简介: numPy是python语言的一个扩展库,是一个运行非常快的数学库,主要用于数组计算. ...
numpy randn 和_人生苦短，自学python——numpy模块
numpy.pandas.matplotlib.sklearn是python机器学习领域,最核心的几个模块,玩转了这几个模块也就玩转了机器学习,其中,numpy又是这几个模块中最基础的模块. 内置 ...
python字符串按首字母排序,Python按字母順序排序字符串，首先是小寫
I want to sort a given array of strings alphabetically using python, but lowercase words should appe ...
Python—numpy模块下函数介绍（一）numpy.ones、empty等
NumPy数组的维数称为秩(rank),一维数组的秩为1,二维数组的秩为2,以此类推.在NumPy中,每一个线性的数组称为是一个轴(axes),秩其实是描述轴的数量.比如说,二维数组相当于是一个一维数 ...
js实现网页的过滤打印（去掉你不想出现的内容）
首先,我们理解打印的过程,控制页面打印有很多种方法,这里我只讲最简单的一种. 打印分三步: 打印前,打印和打印后. 过滤的原理其实很简单,就是打印前将不该显示的元素全部display = no ...
python numpy.ones(shape, dtype=None, order=’C’) empty(shape[, dtype, order]) empty_like(a) 空数组全1数组
ones(shape[, dtype, order]) 依据给定形状和类型(shape[, dtype, order])返回一个新的元素全部为1的数组. def ones(shape, dtype=N ...

python Numpy模块汇总（字母排序） 备注：内容很多，用control/command（Mac系统）+ F可以在网页内关键词查找，希望你能找到想要的内容

Numpy

Numpy的数组类称为ndarray，其属性：

Numpy切片及索引

NumPy 广播(Broadcast)

numpy.amin(a,axis=None,out=None,keepdims=,initial=,where=) 返回数组的最小值或沿轴的最大值

numpy.amin(a,axis=None,out=None,keepdims=,initial=,where=) 返回数组的最小值或沿轴的最小值

numpy.arange([start,]stop,[step,]dtype=None,like=None) 创建给定间隔区间的numpy数组，类似arange函数

numpy.argsort(a,axis=-1,kind=None,order=None) 返回对数组进行排序的索引

numpy.argmax(a,axis=None,out=None,keepdims=) 返回沿轴的最大值的索引

numpy.argmin(a,axis=None,out=None,keepdims=) 返回延轴最小值的索引

numpy.array(object,dyte=None,copy=True,order=None,subok=False,ndmin=0) 将其他数列转化为数组

numpy.asarray(object,dtype=None,order=None) 输入转换为数组

numpy.asanyarray(object,dtyoe=None,order=None,like=None) 输入转换为 ndarray，但通过 ndarray 子类传递

numpy.asmatrix(object,dtype=None) 输入转化为矩阵

numpy.asfarray(object,dtype=<class ‘numpy.double’>) 输入转换为浮点类型的数组。

numpy.append(arr,values,axis=None) 将值附加到数组的末尾

numpy.array_split(ary,indices_or_sections,axis=0) 指定数组拆分为多个子数组

numpy.asscalar(a) 将大小为1的数组转化为等效标量

numpy.average(a,axis=Noen,weights=None,returned=False) 计算沿指定轴的加权平均值

numpy.block(arrays) 将列表块组装一个 nd 数组

numpy.broadast() 生成模拟广播对象

numpy.broadcast_arrays(*args,subok=False) 相互广播任意数量的数组

numpy.broadcast_to(array, shape,subok=False) 将数组广播为新形状

numpy.column_stack(tup) 将一维数组作为列堆叠到二维数组中。

==numpy.concatenate((a1,a2…),axis=0,out=None,dtype=None,casting=“same_kind”)==拼接数组

numpy.copy(a,order=‘K’,subok=Fales) 返回给定对象的数组副本

numpy.copyto(dst,src,casting=‘same_kind’,where=True) 将数值从一个数组复制到另一个数组，必要时进行广播

numpy.delete(arr,obj,axis=None) 返回一个新的数组，其中的子数组沿删除的轴。

numpy.dot(a,b,out=None) 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和,对于二维数组，计算的是两个数组的矩阵乘积,对于多维数组公式：dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])

numpy.dsplit(ary,indices_or_sections) 沿第 3 轴（深度）将数组拆分为多个子数组

numpy.dstack(tup) 按顺序深度堆叠数组（沿第三轴）

numpy.dtype(object,align,copy) 转换数据类型

numpy.empty(shape,dtype=float,order=‘C’) 创建给定形状的空数组

numpy.empty_like(prototype,dtype=None,order=‘K’,subok=True,shape=None) 创建一个形状和类型相同的数组

numpy.expand_dims(a,axis) 展开数组的形状。 插入一个新轴，该轴将出现在展开的阵列形状中的轴位置。

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

numpy.eye(N,M=None,k=0,dtype=‘float’,order=‘C’,like=None) 返回一个二维数组，对角线上为 1，其他地方为 0

numpy.flip(m,axis=None) 沿给定轴反转数组中元素的顺序。 数组的形状被保留，但元素被重新排序

numpy.fliplr(m) 沿轴 1（左/右）反转元素的顺序

numpy.flipud(m) 沿轴 0（向上/向下）反转元素的顺序

numpy.frombuffer(buffer,dtype=float,count=-1,offset=0) 实现动态数组，接受buffer输入函数，以流动形式转化 为ndarray对象

numpy.fromfile(file,dtype=float,count=-1,sep=’’,offset=0,like=None) 从文本或二进制文件中的数据构造一个数组

numpy.fromfunction(function, shape,dtype=‘float’,like=None) 通过在每个坐标上执行一个函数来构造一个数组。

numpy.fromiter(iterable,dtype,count=-1) 从迭代对象中建立ndarray对象，返回一维数组

numpy.fromstring(string,dtype=float,count=-1,sep,like=None) 从字符串中创造一维数组

numpy.full(shape, fill_value,dtype=None,order=‘C’,like=None) 返回一个给定形状和类型的新数组，填充 fill_value

numpy.full_like(prototype,fill_value,dtype=None,order=‘K’,subok=True,shape=None) 创建一个形状和类型相同的数组用fill_value填充

numpy.hsplit(ary,indices_or_sections) 将数组水平（按列）拆分为多个子数组。

numpy.hstack(tup) 水平（按列）按顺序堆叠数组

numpy.identity(n,dtype=‘float’,like=None) 创建一个正方形，主对角线上是1。

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

numpy.insert(arr,obj,values,axis=None) 在给定索引之前沿给定轴插入值

np.iscomplex(a) 判断是否为复数返回布尔值

numpy.lexsort(keys,axis=-1) 用于对多个序列进行排序。类似对电子表格进行排序，每一列代表一个序列，排序时优先照顾靠后的列。

numpy.linalg.solve(a,b) 求解线性矩阵方程

numpy.linspace(start,stop,num=50,endpoint=True,retsetp=False,dtype=None) 函数用于创建一个一维数组

numpy.logspace(start, stop,num=50,endpoint=True,base=10.0,dtype=None) 创建等比数列

numpy.matmul(a,b) 两个数组的矩阵乘积

numpy.mean(a,axis=None,dtype=None,out=None,keepdims=,where=) 计算沿指定轴的算术平均值

numpy.median(a,axis=None,out=None,overwrite_input=Fales,keepdims=False) 计算沿指定轴的中位数

numpy.moveaxis(a,source,destination) 将数组的轴移动到新位置

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

numpy.ones(shape,dtype=float,order=‘C’) 创建指定的小的数组用1填充

numpy.ones_like(prototype,dtype=None,order=‘K’,subok=True,shape=None) 创建一个形状和类型相同的数组用1填充

numpy.percentile(a,q,axis=None,overwrite_input=Fales,interpolation=‘linear’,keepdims=False) 计算沿指定轴的数据的第 q 个百分位数

numpy.ptp(a,axis=None,out=None,keepdims=) 沿轴的值范围（最大值 - 最小值）

numpy.ravel(a,order=‘C’) 创建一个扁平的数组

numpy.repeat(a,repeats.axis=None) 重复数组的元素（np.tile()不同）

numpy.require(a,dtype=None,requirements=None,like=None) 返回满足要求的所提供类型的 ndarray。

numpy.reshape(a,newshape,order=‘C’) 在不改变数据的情况下改变数组形状

numpy.resize(a,new_shape) 返回具有指定形状的新数组

numpy.roll(a,shit,axis=None) 沿给定轴滚动数组元素

numpy.rot90(m,k=1,axes=(0,1)) 在轴指定的平面中将数组旋转 90 度。 旋转方向是从第一轴到第二轴。

numpy.rollaxis(a, axis,start=0) 向后滚动指定轴直到它指定的位置

numpy.row_stack(tup) 垂直（按行）按顺序堆叠数组。

numpy.save(file, arr, allow_pickle=True, fix_imports=True) 将数组保存到以 .npy 为扩展名的文件中

np.savez(file, args,kwds) 将多个数组保存到以 npz 为扩展名的文件中

numpy.sort(a,axis=-1,kind=None,order=None) 返回数组的排序副本

numpy.split(ary,indices_or_sections,axis=0) 指定数组拆分为多个子数组作为 ary 的视图。

python Numpy模块汇总（字母排序）备注：内容很多，用control/command（Mac系统）+ F可以在网页内关键词查找，希望你能找到想要的内容

numpy.dot(a,b,out=None) 对于两个一维的数组，计算的是这两个数组对应下标元素的乘积和,对于二维数组，计算的是两个数组的矩阵乘积,对于多维数组公式：**dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])**

numpy.expand_dims(a,axis) 展开数组的形状。插入一个新轴，该轴将出现在展开的阵列形状中的轴位置。

numpy.flip(m,axis=None) 沿给定轴反转数组中元素的顺序。数组的形状被保留，但元素被重新排序

numpy.frombuffer(buffer,dtype=float,count=-1,offset=0) 实现动态数组，接受buffer输入函数，以流动形式转化为ndarray对象

numpy.rot90(m,k=1,axes=(0,1)) 在轴指定的平面中将数组旋转 90 度。旋转方向是从第一轴到第二轴。

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

python Numpy模块汇总（字母排序）备注：内容很多，用control/command（Mac系统）+ F可以在网页内关键词查找，希望你能找到想要的内容相关推荐