numpy基础教程—数组（向量）的属性和方法

来源：互联网发布：mac 上的游戏编辑：程序博客网时间：2024/05/30 04:29

本教程适合于numpy基础入门，更多详尽内容请阅读官网http://www.numpy.org/，此篇为numpy基础学习教程系列之数组（向量）的属性和方法篇，本篇篇幅较长，为同时也是numpy的核心基础篇，其中包含数组的属性和各种基本的操作方法，后续还会推出python与机器学习、人工智能的其它方面的教程，欢迎广大圈友一起交流学习，并指出其中的错误。

注意：以下np为import numpy as np中的np标识符

1. numpy数组的简介

numpy中的ndarray是一个多维数组对象，该对象由两部分组成：

◆实际的数据

◆描述这些数据的元数据

注意：与python中一样，numpy中的数组也是从下标0开始的，数组中元素的类型用专门的对象表示。

2. numpy数组的基本操作

获取数组元素的类型

>>> a = np.arange(9)
>>> a.dtype
dtype('int32')

获取数组的维度

>>> a = np.arange(10)
>>> a.shape
(10L,)

创建一个数组（np.array()创建多维数组，np.arange()创建以为数组）

>>> m = np.array([np.arange(3),np.arange(4)])
>>> m
array([array([0,1,2]),array(0,1,2,3)],dtype=object)
>>> m.shape
(2L,)

注意：array函数可以根据给定的对象生成数组，给定的对象是类数组，如python的list等。

选取数组中的元素

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

| [0,1] | [0,1] |

| [1,0] | [1,1] |

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

注意：对于数组a，只需要用a[m,n]选取各数组元素，其中m,n为下标。

A = np.ones((2,3))：创建一个元素为1的数组，参数为一个元组，表示行数和列数

B = np.zeros((2,3))：创建一个元素为0的数组，参数为一个元组，表示行数和列数

在Numpy中，许多函数的参数中，可以指定数据类型，此参数为可选。

>>>np.arange(7,dtype='int16')

array([0,1,2,3,4,5,6],dtype=int16)

复数不能转换为整数，这样会触发TypeError错误；复数也不能转换为浮点数，浮点可以转换为复数。

>>> np.complex(2.3)
(2.3+0j)

3. 一维数组的切片与索引

>>> a =np.arange(10)

>>> a[2:7:2]

array([2, 4, 6])

注意：索引格式为->起点索引：终点索引：步长

>>> a[::-1]

array([9, 8, 7, 6, 5, 4, 3,2, 1, 0])

>>> a[:1:-1]

array([9, 8, 7, 6, 5, 4, 3,2])

注意：负数颠倒数组（元素和索引）

4. 多维数组的索引与切片

reshape函数：作用是改变数组的“形状”，也就是改变数组的维度，其参数为一个元组，分别指定数组在每个维度上的大小。

>>> b =np.arange(24).reshape(2,3,4)

(2L, 3L, 4L)

>>> b

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

注意：如果reshape的维度参数为-1，则新创建的数组视图会根据原数组的长度和另外的维度来创建新数组视图

>>>arr =np.arange(16).reshape((4,4))

>>>arr

array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11],

[12, 13, 14, 15]])

>>>arr.reshape(-1)

array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15])

>>>arr.reshape(-1,1)

array([[ 0],

[ 1],

[ 2],

[ 3],

[ 4],

[ 5],

[ 6],

[ 7],

[ 8],

[ 9],

[10],

[11],

[12],

[13],

[14],

[15]])

>>>arr.reshape(-1,2)

array([[ 0, 1],

[ 2, 3],

[ 4, 5],

[ 6, 7],

[ 8, 9],

[10, 11],

[12, 13],

[14, 15]])

>>> b[:,:,2]

array([[ 2, 6, 10],

[14, 18, 22]])

注意：第一个逗号之前表示第一维，第二个逗号之前表示第二维等以此类推。冒号:表示该维度上所有。

>>>b[0,...]

array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]])

注意：…表示多个冒号

>>> b[::-1]

array([[[12, 13, 14, 15],

[16, 17, 18, 19],

[20, 21, 22, 23]],

[[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]]])

注意：如果在多维数组中执行翻转一维数组的命令，将在最前面的维度上翻转元素的顺序。

5. 改变数组的维度

>>> b

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.ravel()

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.flatten()

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

注意：flatten函数与ravel函数的功能一致，不过flatten函数会请求分配内存来保存结果，而ravel函数只是返回数组的一个视图。

除了用reshape函数设置数组的维度，还可以用一个整数元组来设置数组的维度。此操作方法直接改变数组。

>>>b.shape=(6,4)

>>> b

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

transpose函数：在多维数组或矩阵中常用

>>> b

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.transpose()

array([[ 0, 4, 8,12, 16, 20],

[ 1, 5, 9, 13, 17, 21],

[ 2, 6, 10, 14, 18, 22],

[ 3, 7, 11, 15, 19, 23]])

resize函数：resize函数和reshape函数一样直接修改数组。

>>>b.resize((2,12))

>>> b

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

6. 组合数组

>>> a =np.arange(9).reshape(3,3)

>>> a

array([[0, 1, 2],

[3, 4, 5],

[6, 7, 8]])

>>> b = 2*a

>>> b

array([[ 0, 2, 4],

[ 6, 8, 10],

[12, 14, 16]])

hstack函数：水平组合

>>>np.hstack((a,b))

array([[ 0, 1, 2, 0, 2, 4],

[ 3, 4, 5, 6, 8,10],

[ 6, 7, 8, 12, 14, 16]])

concatenate函数：可以和hstack函数实现同样的效果

>>>np.concatenate((a,b),axis=1)

array([[ 0, 1, 2, 0, 2, 4],

[ 3, 4, 5, 6, 8,10],

[ 6, 7, 8, 12, 14, 16]])

vstack函数：垂直组合

>>>np.vstack((a,b))

array([[ 0, 1, 2],

[ 3, 4, 5],

[ 6, 7, 8],

[ 0, 2, 4],

[ 6, 8, 10],

[12, 14, 16]])

同样可以用concatenate函数实现垂直组合

>>>np.concatenate((a,b),axis=0)

array([[ 0, 1, 2],

[ 3, 4, 5],

[ 6, 7, 8],

[ 0, 2, 4],

[ 6, 8, 10],

[12, 14, 16]])

dstack函数：深度组合，就是将一系列数组沿着纵轴方向进行层叠组合。

>>>np.dstack((a,b))

array([[[ 0, 0],

[ 1, 2],

[ 2, 4]],

[[ 3, 6],

[ 4, 8],

[ 5, 10]],

[[ 6, 12],

[ 7, 14],

[ 8, 16]]])

column_stack函数：列组合，对于一维数组将按列方向进行组合。

>>>oned =np.arange(2)

>>>oned

array([0, 1])

>>>twice_oned =2*oned

>>>twice_oned

array([0, 2])

>>>np.column_stack((oned,twice_oned))

array([[0, 0],

[1, 2]])

注意：对于二维数组，column_stack与hstack效果是一样的。

row_stack函数：行组合，对于两个一维数组，将直接层叠起来组合成一个二维数组。

>>> a

array([[0, 1, 2],

[3, 4, 5],

[6, 7, 8]])

>>> b

array([[ 0, 2, 4],

[ 6, 8, 10],

[12, 14, 16]])

>>>np.row_stack((a,b))

array([[ 0, 1, 2],

[ 3, 4, 5],

[ 6, 7, 8],

[ 0, 2, 4],

[ 6, 8, 10],

[12, 14, 16]])

注意：对于二维数组，row_stack与vstack效果是一样的。

7. 数组的分割

hsplit函数：水平方向分割

>>> a

array([[0, 1, 2],

[3, 4, 5],

[6, 7, 8]])

>>>np.hsplit(a,3)

[array([[0],

[3],

[6]]),

array([[1],

[4],

[7]]),

array([[2],

[5],

[8]])]

注意：split(a,3,axis=1)效果与水平分割一样

vstack函数：垂直分割

>>>np.vsplit(a,3)

[array([[0, 1, 2]]),array([[3, 4, 5]]), array([[6, 7, 8]])]

注意：split(a,3,axis=0)效果与垂直分割一样

dsplit函数：深度分割

>>> c =np.arange(27).reshape(3,3,3)

>>> c

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

[24, 25, 26]]])

>>>np.dsplit(c,3)

[array([[[ 0],

[ 3],

[ 6]],

[[ 9],

[12],

[15]],

[[18],

[21],

[24]]]), array([[[ 1],

[ 4],

[ 7]],

[[10],

[13],

[16]],

[[19],

[22],

[25]]]), array([[[ 2],

[5],

[ 8]],

[[11],

[14],

[17]],

[[20],

[23],

[26]]])]

8. 数组的其它属性

array.shape：获取数组每一维度的大小

ndim属性：数组的维度或轴的个数

>>> b

array([[ 0, 2, 4],

[ 6, 8, 10],

[12, 14, 16]])

>>>b.ndim

size属性：给出数组元素的总个数

>>> b

array([[ 0, 2, 4],

[ 6, 8, 10],

[12, 14, 16]])

>>>b.size

itemsize属性：给出数组中的元素在内存中所占的字节数

>>>b.itemsize

nbytes属性：查看整个数组所占的内存数

>>>b.nbytes

注意：也可以用b.size*b.itemsize来计算整个数组所占内存的字节数。

T属性：效果和transpose函数一样

>>> b

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.T

array([[ 0, 4, 8,12, 16, 20],

[ 1, 5, 9, 13, 17, 21],

[ 2, 6, 10, 14, 18, 22],

[ 3, 7, 11, 15, 19, 23]])

注意：对于一维数组，其T属性就是原数组

复数虚部：用j表示

>>> b =np.array([1.j+1,2.j+3])

>> b

array([ 1.+1.j, 3.+2.j])

real属性：给出复数数组的实部

array([ 1.+1.j, 3.+2.j])

>>>b.real

array([ 1., 3.])

imag属性：给出复数的虚部

>>>b.imag

array([ 1., 2.])

注意：如果数组中包含复数元素，则其数据类型自动变为复数

flat属性：该属性将返回一个numpy.flatiter对象，这是获得flatiter对象的唯一方式。这个所谓的“扁平迭代器”可以让我们向遍历一维数组一样遍历多维数组。

>>> b =np.arange(12).reshape(3,4)

>>> b

array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]])

>>> f = b.flat

>>> for item in f:

print item

注意：还可以通过flatiter对象直接获取一个数组元素

>>> b

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.flat[2]

注意：flat属性是一个可以赋值的属性，对flat属性赋值将会导致整个数组的元素都会被覆盖

>>>b.flat = 8

>>> b

array([[8, 8, 8, 8],

[8, 8, 8, 8],

[8, 8, 8, 8]])

9. 数组的转换

toList：将numpy数组转换为python列表

>>> b =np.arange(12).reshape(3,4)

>>> b

array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11]])

>>>b.tolist()

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

astype函数：可以在转换数组时指定数据类型

>>> b =np.array([1.+1.j,3.+2.j])

>>> b

array([ 1.+1.j, 3.+2.j])

>>>b.astype(int)

Warning (from warningsmodule):

File "__main__", line 2

ComplexWarning: Castingcomplex values to real discards the imaginary part array([1, 3])

注意：将复数转换为整数的过程中，会丢失复数的虚部，astype也可以接受数据类型为字符串的参数。

10. 数组的修剪与压缩

clip方法返回一个修剪过的数组，也就是将所有比给定最大值还大的元素全部设为给定的最大值，而所有比给定最小值还小的元素全部设为给定的最小值。
a = np.array([1,23,65,7,98])
print a.clip(20,80)
结果：[20 23 65 20 98]

compress方法返回一个根据给定条件筛选后的数组。
a = np.array([1,23,65,7,98])
print a.compress(a>50)
结果：[65 98]

11. 计算阶乘

prod方法计算数组中所有元素的乘积
a = np.array([1,23,65,7,98])
print a.prod()
结果为：1025570

cumprod方法计算数组元素的累积乘积
a = np.array([1,23,65,7,98])
print a.cumprod()
结果为：[ 1 23 1495 10465 1025570]

12. 数组的其它方法

np.isreal(array)：判断数组元素是否为实数

np.trim_zeros(array)：去掉一维数组中开头和结尾的0元素

np.asarray(a,dtype=None,order=None)：将列表转换为数组

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)：产生一个数组，其中数组中每个元素都是10的次幂，指数均匀的分布在start到stop之间。也就是说返回的数组的对数服从start到stop之间的均匀分布。

np.eye(2)：创建一个2*2的单位矩阵

A*B表示对应的元素相乘，得到另一个新的矩阵

np.dot(A, B)：数学意义上的矩阵相乘，如果形状不匹配，则会报错，如果A和B为一维向量，则表示內积（点积）

np.version.version：numpy的版本号

np.diff(array)：求数组array相邻元素的差构成的数组（差分）。

np.log(array)：计算数组array各个元素的对数

np.sqrt(array)：计算数组array中各元素的均方根值

np.take(array, indices)：表示从数组array中按照索引indices取出相应的元素

np.argmax(array)：返回数组array中最大元素的索引值

np.nanargmax(array)：与argmax函数有相同的功能，但忽略NaN值

np.argmin(array)：返回数组array中最小元素的索引值

np.argwhere(array<num)：根据条件搜索符合条件的元素，返回符合条件的元素的下标。

np.searchsorted(array, [-1, 8])：为指定的插入值寻找维持数组排序的索引的位置，并返回该索引的值，该函数使用二分查找算法，计算复杂度为O(logn)

np.extract(conditions, array)：基于指定条件，从数组array中抽取元素

np.nonzero(array)：从数组array中抽取非零元素。

np.exp(array)：计算数组array每个元素的指数

np.linspace(start, end, num)：返回一个元素值在指定范围类均匀分布的数组。

array.fill(numb)：将数组array设置为指定的值

np.ones_like(array)：构造一个元素全为1，结构与array相同的数组

np.zeros_like(array)：构造一个元素全为0，结构与array相同的数组

np.intersect1d(array1,array2)：返回一个由两个数组的公共元素组成的数组

np.unique(array, return_index=True)：返回数组中不同的值，return_index默认为False，为True时，既返回值，也返回元素的索引。

np.sign(array)：可以返回数组中每个元素的正负符号，数组元素为负是返回-1，为正时返回+1，否则返回0

aa = np.arange(-5,5)
print np.sign(aa)
结果：[-1 -1 -1 -1 -1 0 1 1 1 1]

np.piecewise(array)：获取元素的正负，可以分段给定取值，使用合适的返回值和给定的条件。
aa = np.arange(-5,5)
print np.piecewise(aa,[aa>3,aa<3],[1,-1])
结果为：[-1 -1 -1 -1 -1 -1 -1 -1 0 1]

ndarray.round(decimals=0, out=None)：将数组中的元素按指定的精度进行四舍五入
>>>np.around([0.37, 1.64]) # 没有指定decimals参数，则取最近整数值。
array([ 0., 2.])
>>>np.around([0.37, 1.64], decimals=1)
array([ 0.4, 1.6])
>>>np.around([.5, 1.5, 2.5, 3.5, 4.5]) # rounds to nearest even value
array([ 0., 2., 2., 4., 4.])
>>>np.around([1,2,3,11], decimals=1) # ndarray of ints is returned
array([ 1, 2, 3, 11])
>>>np.around([1,2,3,11], decimals=-1)
array([ 0, 0, 0, 10])

add：沿着指定的轴，在连续的数组元素之间递归地调用通用函数，即可得到输入数组的规约计算结果。
a = np.arange(9)
print np.add.reduce(a)
结果：36

accumulate方法同样的可以递归地作用于输入数组，与reduce方法不同，它可以存储运算的中间结果并返回。
a = np.arange(9)
print np.add.accumulate(a)
结果：[ 0 1 3 6 10 15 21 28 36]

reduceat：输入一个数组和一个索引值列表
a = np.arange(9)
print np.add.reduceat(a,[0,5,2,7])
结果：[10 5 20 15]
过程：第一次求索引0到5的元素之和，第二次求索引5到2的元素之和，由于2比5小，所以直接返回索引值为5的元素。第三次求索引2到7的元素之和，第四次求索引7到末端的元素之和。

outer方法：返回一个数组，它的值等于输入数组的两个值之和。
print np.add.outer(np.arange(3),a)
结果：[[ 0 1 2 3 4 5 6 7 8]
[ 1 2 3 4 5 6 7 8 9]
[ 2 3 4 5 6 7 8 9 10]]

numpy.cov
函数计算协方差矩阵
a = np.array([1,23,65,7,98])
b = np.array([2,43,21,5,65])
print np.cov(a,b)
结果为：[[ 1720.2 871.05]
[ 871.05 711.2 ]]

numpy.diagonal
函数查看对角线上的元素
a = np.array([1,23,65,7,98])
b = np.array([2,43,21,5,65])
covariance = np.cov(a,b)
print covariance.diagonal()
结果为：[ 1720.2 711.2]

numpy.trace
计算矩阵的迹，即对角线上的元素之和
a = np.array([1,23,65,7,98])
b = np.array([2,43,21,5,65])
covariance = np.cov(a,b)
print covariance.trace()
结果为：2431.4

numpy.corrcoef
函数计算相关系数矩阵
a = np.array([1,23,65,7,98])
b = np.array([2,43,21,5,65])
print np.corrcoef(a,b)
结果为：[[ 1. 0.78751301]
[ 0.78751301 1. ]]

numpy.where函数是三元表达式x if condition else y的矢量化版本，定义一个布尔数组和两个值数组。
>>>xarr=np.array([1.1,1.2,1.3,1.4,1.5])
>>>yarr=np.array([2.1,2.2,2.3,2.4,2.5])
>>>cond=np.array([True,False,True,True,False])
>>> result=[(x if c else y) for x,y,c in zip(xarr,yarr,cond)]
>>> result
[1.1000000000000001, 2.2000000000000002, 1.3, 1.3999999999999999, 2.5]
以上做法有几个问题：第一，速度不够快；第二：无法用于多维数组。若用np.where，则可以将该功能写得非常简洁。
>>>reslut=np.where(cond,xarr,yarr)
>>> result
[1.1000000000000001, 2.2000000000000002, 1.3, 1.3999999999999999, 2.5]

例：
>>>np.where([[True, False], [True, True]],
... [[1, 2], [3, 4]],
... [[9, 8], [7, 6]])
结果：array([[1, 8],
[3, 4]])

>>>x =np.arange(9.).reshape(3, 3)
>>>np.where( x >5 )
(array([2, 2, 2]), array([0, 1, 2])) # 前面一个数组为行坐标，后面一个数组为列坐标
>>>x[np.where( x >3.0 )] # Note: result is 1D.
array([ 4., 5., 6., 7., 8.])
>>>np.where(x <5, x, -1) # Note: broadcasting.
array([[ 0., 1., 2.],
[ 3., 4., -1.],
[-1., -1., -1.]])
# 一维情况
>>>aa = np.array([1,34,65,12,98])
>>>np.where(aa>50)
(array([2, 4], dtype=int64),)

numpy.delete(arr, obj, axis=None)：删除向量的某一个分量
参数：arr—输入向量
obj—表明哪一个子向量应该被移除，可以为一个整数或int向量
axis—表明删除哪个轴的子向量，若默认，则返回一个被拉平的向量
a = np.array(np.arange(12).reshape(3,4))
a
Out[301]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])

np.delete(a,1,0)
Out[302]:
array([[ 0, 1, 2, 3],
[ 8, 9, 10, 11]])

np.delete(a,1,1)
Out[303]:
array([[ 0, 2, 3],
[ 4, 6, 7],
[ 8, 10, 11]])

np.delete(a,[0,1],1)
Out[304]:
array([[ 2, 3],
[ 6, 7],
[10, 11]])

np.delete(a,np.s_[::2],1)
Out[306]:
array([[ 1, 3],
[ 5, 7],
[ 9, 11]])
注意：numpy.s_[::2]表示选取奇数

numpy.insert(arr, obj, value, axis=None)
参数：arr为目标向量
obj为目标位置
value为想要插入的值
axis为插入的维度
np.insert(a,1,[1,1,1,1],0)
Out[309]:
array([[ 0, 1, 2, 3],
[ 1, 1, 1, 1],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])

numpy.append(arr,values,axis=None)：将values插入到目标arr的最后
a
Out[312]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])

np.append(a,[[1,1,1,1]],axis=0)
Out[313]:
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[ 1, 1, 1, 1]])
注意：values跟arr应该为相同维度的向量。

numpy.select(condlist,choicelist,default=0):根据condlist条件从choicelist中返回元素。
参数：condlist-条件列表
choiclist-被选择的元素列表，其长度与condlist相同
实例：
X = np.arange(10)
condlist = [x<3,x>5]
choicelist = [x,x**2]
np.select(condlist,choicelist)
结果为：array([0,1,2,0,0,0,36,49,64,81])
condlist2 = [x>3,x<7] #以第一个条件为准，第二个条件与第一个条件有重叠的元素，重叠部分以第一个条件为准。
np.select(condlist2,choicelist)
结果为：array([0,1,4,9,4,5,6,7,8,9])

numpy.aply_along_axis(func1d,axis,arr,*args)：在指定的轴axis上对arr运用func1d
参数：func1d—该函数接受一个一维数组，运用在一维数组arr的指定轴
axis—整形数，指定arr的哪个轴，进行运算
arr—输入数组
args-func1d的另外的参数
实例1：
>>>defmy_func(a):
... """Average first and last element of a 1-D array"""
... return (a[0] + a[-1]) * 0.5
>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>>np.apply_along_axis(my_func, 0, b)
array([ 4., 5., 6.])
>>>np.apply_along_axis(my_func, 1, b)
array([ 2., 5., 8.])

实例2：
>>>defnew_func(a):
... """Divide elements of a by 2."""
... return a * 0.5
>>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])
>>>np.apply_along_axis(new_func, 0, b)
array([[ 0.5, 1. , 1.5],
[ 2. , 2.5, 3. ],
[ 3.5, 4. , 4.5]])

阅读全文

0 0