@[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:序列的起始值,值为basestart
stop:序列的终止值,值为basestop
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.82559402
35.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.flags
C_CONTIGUOUS : True
F_CONTIGUOUS : False
OWNDATA : False
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : False
>>> y = np.require(x, dtype=np.float32, requirements=['A', 'O', 'W', 'F'])
>>> y.flags
C_CONTIGUOUS : False
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
WRITEBACKIFCOPY : False
UPDATEIFCOPY : 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]])