人工智能之Numpy与Pandas培训文档
创建时间:2018-09-09  访问量:2940  4  0

人工智能之Numpy与Pandas培训文档

ndarray数组中的方法

ndarray中有很多方法以某种形式操作数组的,通常是返回一个结果数组,这些方法已经在下面做了简要说明,您还可以通过每个方法的docstring属性查看方法的更完整的描述。

下面的方法在numpy中都有对应的numpy函数:all,any, argmax, argmin, argpartition, argsort, choose, clip, compress, copy, cumprod, cumsum, diagonal, imag, max, mean, min, nonzero, partition, prod, ptp, put, ravel, real, repeat, reshape, round, searchsorted, sort, squeeze, std, sum, swapaxes, take, trace, transpose, var

大家如果感觉这篇讲的有点多,可以跳过,因为这节讲的都是ndarray中的方法的用法,如果以后用到,可以回来查询参考。

大家如果想了解更详细的信息,可以打开函数链接参考官方文档。本节内容就是来自己官方文档哦,在对官方文档消化的基础上撰写的。

 

数组的转换

ndarray.item(*args)

这个方法是以Python标量的形式返回数组中的元素。

args参数可以是None、整型和整型元组,None(这种情况只支持只有1个元素的ndarray,就以标量的形式返回这个元素)、整型(这种参数是将多维数组拉平成一维数组,然后将对应位置元素返回)、整型元组(返回对应位置的元素)。

数组拉平前面已经介绍过,使用ndarray的flat属性返回拉平后数组的迭代器,或者使用ndarray.flatten([order])方法直接返回拉平后的ndarray。

示例:

>>> x = np.random.randint(9, size=(3, 3)) # 生成3行3列的ndarray
>>> x
array([[3, 1, 7],
       [2, 8, 3],
       [8, 5, 3]])
>>> x.item(3) # 将二维数据拉成一维的再返回第4个元素
2
>>> x.item(7)
5
>>> x.item((0, 1)) # 返回第1行第2列的元素
1
>>> x.item((2, 2))
3

ndarray.tolist()

以Python列表的形式(可能是嵌套的)返回ndarray。这个比较简单:

>>> a = np.array([1, 2])
>>> a.tolist()
[1, 2]
>>> a = np.array([[1, 2], [3, 4]])
>>> list(a)
[array([1, 2]), array([3, 4])]
>>> a.tolist()
[[1, 2], [3, 4]]

ndarray.itemset(*args)

这个方法是将一个标量插入到ndarray数组中对应的位置,即设置ndarray对应的元素,这个标量的类型会被转换成ndarray的dtype类型,前提是这两个类型兼容,否则报错。args参数元素位置选择参考ndarray.item(*args)。

示例:

>>> x = np.random.randint(9, size=(3, 3))
>>> x
array([[3, 1, 7],
       [2, 8, 3],
       [8, 5, 3]])
>>> x.itemset(4, 0) # 将数组拉平后,将索引为4的元素设置为0,这样中间那个8就变成0了
>>> x.itemset((2, 2), 9) # 将数组第3行第3列的元素设置成9
>>> x
array([[3, 1, 7],
       [2, 0, 3],
       [8, 5, 9]])

ndarray.tostring([order])、ndarray.tobytes([order])

构造包含数组中原始数据字节的Python字节串并返回。order参数有两种选择一个'C'(按行排序),一个'F'(按列排序)。返回原始字节数据。

示例:

>>> x = np.array([[0, 1], [2, 3]])
>>> x.tobytes()
b'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
>>> x.tobytes('C') == x.tobytes() # 此行说明黙认是按行('C')排序的
True
>>> x.tobytes('F')
b'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'
>>> x.tostring()
'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
>>> x.tostring('C')
'\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00'
>>> x.tostring('F')
'\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00'

ndarray.tofile(fid[, sep, format])

将ndarray以文本或二进制(黙认)的形式存入文件,fid:文件file对象或文件路径字符串,sep指定元素分隔符(针出文本文件输出),如果设为""(空字符串,黙认),就是以二进制方式写入文件,这相当于file.written(x.tobytes()),format:文本文件输出的格式字符串。数组中的每个条目首先通过将其转换为最接近的Python类型,然后使用“format”% item格式化文本。

>>> x
array([[0, 1],
       [2, 3]])
>>> x.tofile('x.txt',',','%.2f')

文本输出内容如下:

0.00,1.00,2.00,3.00

使用了Python中的%格式化方式将元素格式化成保留两位小数的字符串。

ndarray.dump(file)

将数组以pickle格式存储在file文件中,file为文件路径字符串。

ndarray.dumps()

返回数组的pickle格式字符串。

注:

pickle是Python文件存储的一种数据格式,不明白可以参考Python文件存储这部分内容。

这两个方法解释比较直观,这里就不举代码示例了,大家可以自己尝试下,不明白的,评论区见!,下面有些方法没有例举代码的同理。

ndarray.astype(dtype[, order, casting, …])

这个方法前面已经用过了,就是数组元素的类型转换,简单使用如下:

>>> x = np.array([1, 2, 2.5])
>>> x
array([ 1. ,  2. ,  2.5])
>>>
>>> x.astype(int) # 将x是元素dtype类型转成int
array([1, 2, 2])

ndarray.byteswap([inplace])

这个方法用来交换数组元素的字节

>>> A = np.array([1, 256, 8755], dtype=np.int16)
>>> map(hex, A) # map是python中映射函数,这里是将A的元素转成16进制输出
['0x1', '0x100', '0x2233']
>>> A.byteswap(inplace=True)
array([  256,     1, 13090], dtype=int16)
>>> map(hex, A)
['0x100', '0x1', '0x3322']

上面代码是不是还没看懂啥意思?

A的dtype类型是int16,也就是16位整体,占4个字节,我们将4个字节的16进制写全,实际上A的存储的二进制形式是这样子的:['0x0001','0x0100','0x2233'],交换字节后变成了这样子的:['0x0100','0x0001','0x3322'],对比下:

['0x0001','0x0100','0x2233']

['0x0100','0x0001','0x3322']

是不是高8位和低8位交换位置了?对的,就是这样。那inplace=True是干嘛的?inpplace是True,返回的是原数组的视图,如果是False(黙认)则返回的是原数组的副本,视图和副本知道有啥区别了吧,前面说过了啊~

ndarray.copy([order])

这个方法前面说过。它返回的是数组的副本,也就是原数组的一份copy。

ndarray.view([dtype, type])

这个方法其实返回一个与原数组一样的数组视图,如果不指定参数,那么这两个数组数据一模一样,连类型也一样,还共享同一个底层数组,改了一个,另一个也改了。

这个方法与copy方法的不同就是copy方法返回的是副本,view方法返回的是视图。简单,不罗嗦了!

ndarray.getfield(dtype[, offset])

虽然不常用,我也说一下,表明我好学的决心。这个方法就是以一个给定的类型返回数组的视图,明白了,举个例子:

>>> x = np.diag([1.+1.j]*2) # 这个numpy函数是生成一个对角矩阵,给定参数列表是在这个矩阵的对角线上
>>> x
array([[1.+1.j, 0.+0.j],
       [0.+0.j, 1.+1.j]])
>>> x[1, 1] = 2 + 4.j # 将第2行第2列改成2 + 4.j
>>> x
array([[ 1.+1.j,  0.+0.j],
       [ 0.+0.j,  2.+4.j]])
>>> x.getfield(np.float64) # 以给定元素类型为np.float64返回视图,所以虚部没有了
array([[ 1.,  0.],
       [ 0.,  2.]])
>>> x.getfield(np.float64, offset=8) # 偏移8个字节得到虚部,为什么?下面解释
array([[ 1.,  0.],
   [ 0.,  4.]])

numpy复数黙认的类型是np.complex128,在内存中连续存储,实部占64位8个字节,虚部占8个节,向右偏移8个字节是不是指针正好指向了虚部起始字节的内存地址?

ndarray.setflags([write, align, uic])

前面说过ndarray有个flags属性,这个就用来设置它的,我也不知道干什么用,这么高深的东西,我不理解,大牛们可以发表自己的看法!我只是个菜鸟。

ndarray.fill(value)

这个方法好用好理解,就是用一个标量来填充数组中的所有元素,不举例了,自己操作下。

 

ndarray形状的操作方法

针对方法reshape,resize和transpose,指定单个元组的参数可以被N个整数替换,这个可以被解释成N维元组,如前面讲到的reshape((2,3))也可以写成reshape(2,3)。

ndarray.reshape(shape[, order])

这个方法前几节讲得挺多的,就是改变数组的形状。

ndarray.resize(new_shape[, refcheck])

这个方法与reshape类似,也能改变数组的形状,它们的区别是reshape只能改变形状,不能改变长度,resize既可以改变形状也可以改变长度,如:

>>> a = np.array([[0, 1], [2, 3]], order='C')
>>> a.resize((2, 1)) # 将数组改成2行1列,元素变少了,这是可行的,reshape肯定报错
>>> a
array([[0],
       [1]])
>>> a = np.array([[0, 1], [2, 3]], order='F') 
>>> a.resize((2, 1)) # 缩减数组长度与内存排序也有关系的
>>> a
array([[0],
       [2]])

元素缩减的方式可以这么想,先将数组按内存排序拉平成一维数组,再截取前N个有效位元素后,再进行reshape。

长度可以缩减,可不可以扩充呢?

>>> b = np.array([[0, 1], [2, 3]])
>>> b.resize(2, 3) # 这个参数并不是以元组形式指定的
>>> b # 我们发现可以扩充,且扩充的元素用0填充
array([[0, 1, 2],
       [3, 0, 0]])

如果这个数组被其它对象引用了,resize还能改变它的长度吗?

>>> c = a
>>> a.resize((1, 1))
Traceback (most recent call last):
...
ValueError: cannot resize an array that has been referenced ...

事实证明:不可以!除非,将refcheck参数设为False

>>> a.resize((1, 1), refcheck=False) # refcheck设为False,表示不检查引用
>>> a
array([[0]])
>>> c
array([[0]])

ndarray.transpose(*axes)

这个方法返回数组(矩阵)的转置(行列轴对换位置),与T属性一样,返回的是视图。

ndarray.swapaxes(axis1, axis2)

这个方法与numpy.swapaxes(ndarray,axis1,axis2)函数一样,都是交换两个轴,当这与ndarray.transpose数组的转置有什么区别呢?

>>> a
array([[0, 1, 2],
       [3, 0, 0]])
>>> a
array([[0, 1, 2],
       [3, 0, 0]])
>>> a.transpose()
array([[0, 3],
       [1, 0],
       [2, 0]])
>>> a.swapaxes(0,1)
array([[0, 3],
       [1, 0],
       [2, 0]])
>>> a.swapaxes(1,0)
array([[0, 3],
       [1, 0],
       [2, 0]])

从上面的例子看,数组的转置就是交换轴0和轴1。这是针对二维数据,要是三维数组呢?

>>> x = np.arange(32).reshape(4,4,2)
>>> x
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, 27],
        [28, 29],
        [30, 31]]])
>>> x.transpose() # 转置只是交换轴0和轴2
array([[[ 0,  8, 16, 24],
        [ 2, 10, 18, 26],
        [ 4, 12, 20, 28],
        [ 6, 14, 22, 30]],

       [[ 1,  9, 17, 25],
        [ 3, 11, 19, 27],
        [ 5, 13, 21, 29],
        [ 7, 15, 23, 31]]])
>>> x.swapaxes(0,1) # 可以对换轴0和轴1
array([[[ 0,  1],
        [ 8,  9],
        [16, 17],
        [24, 25]],

       [[ 2,  3],
        [10, 11],
        [18, 19],
        [26, 27]],

       [[ 4,  5],
        [12, 13],
        [20, 21],
        [28, 29]],

       [[ 6,  7],
        [14, 15],
        [22, 23],
        [30, 31]]])
>>> x.swapaxes(0,2) # 可以对换轴0和轴2
array([[[ 0,  8, 16, 24],
        [ 2, 10, 18, 26],
        [ 4, 12, 20, 28],
        [ 6, 14, 22, 30]],

       [[ 1,  9, 17, 25],
        [ 3, 11, 19, 27],
        [ 5, 13, 21, 29],
        [ 7, 15, 23, 31]]])
>>> x.swapaxes(1,2) # 也可以对换轴1和轴2
array([[[ 0,  2,  4,  6],
        [ 1,  3,  5,  7]],

       [[ 8, 10, 12, 14],
        [ 9, 11, 13, 15]],

       [[16, 18, 20, 22],
        [17, 19, 21, 23]],

       [[24, 26, 28, 30],
        [25, 27, 29, 31]]])

从上面代码注释中看到区别了吧~。

我的天啊,写的太罗嗦了,还有好多方法,真想让大家直接看官方文档算了~。

还好,不是特别多,像前面一节numpy通用函数太多,我只写了一些代表性的,这里我打算写完。numpy中的大部分函数也一样。因为numpy有很多函数与ndarray方法一样的。后面还有一些重要的计算方法,大家还是观望一下吧,不然在阅读tensorflow时可能某些地方搞不懂。

ndarray.flatten([order])

这个方法是返回一个将原数组折叠成一维数组的一个副本。前面用过的。

ndarray.ravel([order])

这个方法与flattern一样将数组拉成一组的,但返回的是视图。

ndarray.squeeze([axis])

这个方法是删除一个维度

>>> x
array([[[0],
        [1],
        [2]]])
>>> x.shape
(1L, 3L, 1L)
>>> x.squeeze(0)
array([[0],
       [1],
       [2]])
>>> x.squeeze(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: cannot select an axis to squeeze out which has size not equal to one
>>> x.squeeze(2)
array([[0, 1, 2]])

从上面代码中看到,可以删除0轴和2轴,1轴不能删,为什么?因为它的长度不为1,注意,只能删除长度为1的维度。

 

数组元素的选择与操作

对于拥有axis参数的数组方法,它黙认都是None,如果axis参数设置为None,那么此方法就会将数组当成一维数组对待,axis设置其它值时就是对这个轴的操作。

ndarray.take(indices[, axis, out, mode])

这个方法返回的是由给定索引处元素组成的数组,返回的数组与原数组类型相同,使用的是Numpy的花式索引,这个方法同numpy.take函数。下面介绍下参数,方括号中的参数都是可选的,之前没说,以后都一样,这里统一说一下。

indices:指定要选择元素的索引。

axis:选择指定轴中对应索引的元素,其它轴不变,如果为空或不指定,则相当于将数据拉平成1维数组后进行选择。

out:这个参数是指定一个ndarray,文档是说,如果提供了这个参数,结果将使用这个ndarray代替,这个ndarray应具有与indices相同的维度并且与原数组具有相同的类型。这个参数我试了一下,发现没有什么效果,哪位大神知道可以说一下,评论区见~~~

mode:有三种可能的值{‘raise’, ‘wrap’, ‘clip’},这个参数是用于当indices索引参数超出原数组索引范围时所采取的行为。raise:(黙认)直接抛出异常,warp:循环,就是如果超出了原数组索引就从这个原数组的开始索引处循环再进行依次选择(可以自己试下哦),clip:这个参数是当索引超出原数组范围时就将这个索引用于数组中最后一个元素。

>>> import numpy as np
>>> x = np.arange(12).reshape(3,4)
>>> x
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> x.take([0,3,6,8]) # 获取对应位置的元素
array([0, 3, 6, 8])
>>> x.take([0,1],axis=1) # 只针对列选择元素,行不变,也就是说第1行选择第1、2行,第2行选择第1、2列,依此类推
array([[0, 1],
       [4, 5],
       [8, 9]])

可以通过索引来改变原数组的维度,如下所示:

>>> y = np.arange(3,9)
>>> y
array([3, 4, 5, 6, 7, 8])
>>> z = y.take([[1,3],[2,4]]) # 将对应位置的元素索引值换成原数组中的元素值即可得2维数组
>>> z
array([[4, 6],
       [5, 7]])

ndarray.put(indices, values[, mode])

这个方法是设置原ndarray中元素的值,同numy.put函数。

indices:指定索引数组,也就是这个数组中的值是原数组中的索引。

values:指定值数组,也就是这个数组中的值是用于替换原数组中对应于indices位置的元素值。

mode:同take方法。

示例:

>>> a = np.arange(5)
>>> np.put(a, [0, 2], [-44, -55]) # 将数组a中的第1、3个元素设置成-44、-55
>>> a
array([-44,   1, -55,   3,   4])
>>> a = np.arange(5)
>>> np.put(a, 22, -5, mode='clip') # 22 这个索引位置超出了原数组(5个索引位置),所以将值应用于最后一个元素
>>> a
array([ 0,  1,  2,  3, -5])

ndarray.repeat(repeats[, axis])

这个方法用于重复数组中的每个元素,同numpy.repeat函数,重复会广播到axis指定轴。

>>> x
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])
>>> x.repeat(2) # 每个元素重复2次,因为axis没有指定,所以生成一维数组。所以只会广播到0轴
array([ 0,  0,  1,  1,  2,  2,  3,  3,  4,  4,  5,  5,  6,  6,  7,  7,  8,
        8,  9,  9, 10, 10, 11, 11])
>>> x.repeat(2,axis=1) # 重复每个元素2次,表明重复列的元素
array([[ 0,  0,  1,  1,  2,  2,  3,  3],
       [ 4,  4,  5,  5,  6,  6,  7,  7],
       [ 8,  8,  9,  9, 10, 10, 11, 11]])
>>> x.repeat([1,2,1],axis=0) # axis=0表明只重复行,第1行重复1次,第2行重复2次,第3行重复1次
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

ndarray.choose(choices[, out, mode])

使用一个索引数组来从一个可选数组集中(choices参数)构建一个新的数组并返回,同numpy.choose函数。这个方法有点搞,下面看个例子

示例:

>>> x = np.array([2,3,1,0],dtype=int)
>>> x
array([2, 3, 1, 0])
>>> choices = [[0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23], [30, 31, 32, 33]]
>>> choices
[[0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23], [30, 31, 32, 33]]
>>> x.choose(choices)
array([20, 31, 12,  3])
>>>

有没有看出什么出来,估计也能猜出来,就是想不出规则到底是什么样子的,那么这把这个规则用Python列表解析表示出来。

>>> x
array([2, 3, 1, 0])
>>> choices = np.array([[0, 1, 2, 3], [10, 11, 12, 13], [20, 21, 22, 23], [30, 31, 32, 33]],dtype=int)
>>> choices
array([[ 0,  1,  2,  3],
       [10, 11, 12, 13],
       [20, 21, 22, 23],
       [30, 31, 32, 33]])
>>> x.choose(choices)
array([20, 31, 12,  3])
>>> import numpy.lib.index_tricks as ndi
>>> np.array([choices[x[i]][i] for i in ndi.ndindex(x.shape)],dtype=int)
array([20, 31, 12,  3])

简单解释一下,x是一个一维数组,x中的对元素的值是选择choices数组中的行,而x中对应元素的索引值对应choices数组中的列。是不是有点绕?可能你还有一个想法,它为什么要这么选择呢?其实我也不知道。

ndarray.sort([axis, kind, order])

这个方法比较好懂,就是排序,那就排一下好了,注意,返回的是副本。

>>> a = np.array([[1,4], [3,1]])
>>> a.sort(axis=1) # 只对轴1排序,也就是只对列排序
>>> a
array([[1, 4],
       [1, 3]])
>>> a.sort(axis=0) # 只对轴0排序,也就是只对行排序,当然相对于同一列的数据来说
>>> a
array([[1, 3],
       [1, 4]])

ndarray.argsort([axis, kind, order])

这个方法也是对数组进行排序,只不过不是返回排序后数组的元素值,而是返回排序后数组元素的索引,同numpy.argsort()

>>> x = np.array([4,5,3,8,1],dtype=int)
>>> x.argsort()
array([4, 2, 0, 1, 3], dtype=int64)

返回的是一个索引数组,如上述x[4]是最大的,其次是x[2],...

ndarray.partition(kth[, axis, kind, order])

这个方法是用来对数组进行分区的,主要参数是kth,可以是一个整数,也可以是一个整数序列。按分区划分元素索引。第k个元素值放在这个分区最终排序位置的最后,将小于第k个元素的元素都放在它的前面,将大于或等于它的元素放在它的后面,分区中元素的排序是未定义的。

>>> x
array([3, 1, 4, 5, 8]) # 将第0个元素3进行分区,比3小的放在3前面其余放在3后面
>>> x.partition(0)
>>> x
array([1, 3, 4, 5, 8])

ndarray.argpartition(kth[, axis, kind, order])

此方法返回数组分区后的索引。参与上述说明。

ndarray.searchsorted(v[, side, sorter])

这个方法是先将数组排序,再将v值插入到数组中,返回插入位置的索引。

>>> np.searchsorted([1,2,3,4,5], 3) # 将3插入到2后面
2
>>> np.searchsorted([1,2,3,4,5], 3, side='right')
3
>>> np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])
array([0, 5, 1, 2]) # 将-10插入到位置0处,将10插入到位置5处,将2插入到位置1处,将3插入到位置2处

 side插入规则:

side       返回满足i的索引        
left a[i-1] < v <= a[i]
right a[i-1] <= v < a[i]

ndarray.nonzero()

此方法返回非0元素的索引。

ndarray.compress(condition[, axis, out])

此方法返回已选择的数组给定轴的切片。用于bool索引方式切片,同numpy.compress。

>>> a = np.array([[1, 2], [3, 4], [5, 6]])
>>> a
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> a.compress([0,1],axis=0) # 只选择了第2行,因为第1行条件是0,表示False所以未选,第3行无条件
array([[3, 4]])
>>> a.compress([False,True,True],axis=0) # 选择了第2、3行
array([[3, 4],
       [5, 6]])
>>> a.compress([False,True],axis=1) # 选择的是第2列
array([[2],
       [4],
       [6]])

ndarray.diagonal([offset, axis1, axis2])

此方法是返回指定对角线上的元素。

>>> a = np.array([1,2,3,4,5,6,7,8,9]).reshape(3,3)
>>> a
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
>>> a.diagonal()
array([1, 5, 9])

其它参数功能,大家可以试试,记忆犹为深刻。不明白参考:https://www.numpy.org/devdocs/reference/generated/numpy.diagonal.html#numpy.diagonal

 

数组计算的方法

其实这些方法挺重要的,因为人工智能少不了计算,大部分计算函数都会在后面学习用到。

大部分方法都有axis轴参数,有以下几种情况:

  • 如果axis为None(黙认),那么数组会被当作一维的,并在整个数组上执行操作。如果自身是0维数组或数组标量,则此行为也是默认的。(数组标量是类型/类float32、float64等的实例,而0维数组是恰好包含一个数组标量的ndarray实例。)
  • 如果axis被设置成整型数值,则会在给定的轴上进行操作(对于每一个子数组都可以根据给定axis进行创建)。

ndarray.argmax([axis, out])

此方法返回给定轴的最大元素的索引。

>>> x = np.random.randint(1,30,(3,4))
>>> x
array([[ 1, 27, 12,  8],
       [ 2, 17, 19, 18],
       [ 9, 27, 14,  5]])
>>> x.argmax(axis=0) # 同一列行与行之间的比较,返回最大者的索引
array([2, 0, 1, 1], dtype=int64)
>>> x.argmax(axis=1) # 同一行列与列之间的比较,返回最大者的索引
array([1, 2, 1], dtype=int64)

ndarray.min([axis, out, keepdims])

返回给定轴的最小元素值。

>>> x.min() # 返回所有元素中的最小值
1
>>> x.min(axis=0) # 同列,行与行比较,返回最小值
array([ 1, 17, 12,  5])
>>> x.min(axis=1) # 同行,列与列比较,返回最小值
array([1, 2, 5])

ndarray.argmin([axis, out])

根据指定的axis,返回数组中最小元素的索引。参考ndarray.argmax()方法。

ndarray.ptp([axis, out, keepdims])

这个方法也比较简单,返回给定轴中最大值与最小值的差。

>>> x
array([[ 1, 27, 12,  8],
       [ 2, 17, 19, 18],
       [ 9, 27, 14,  5]])
>>> x.ptp() # 数组中最大值与最小值相差27-1=26
26
>>> x.ptp(axis=0) # 行间最大值与最小值之差
array([ 8, 10,  7, 13])
>>> x.ptp(axis=1) # 列间最大值与最小值之差
array([26, 17, 22])

ndarray.clip([min, max, out])

这个方法是返回在[min, max]之间的值的数组。大于max就用max代替,小于min就用min代替。

>>> x
array([[ 1, 27, 12,  8],
       [ 2, 17, 19, 18],
       [ 9, 27, 14,  5]])
>>> x.clip(3,20)
array([[ 3, 20, 12,  8],
       [ 3, 17, 19, 18],
       [ 9, 20, 14,  5]])

ndarray.conj()

此方法返回所有元素的共轭复数,共轭复数就是实部相同,虚部互为相反数的复数。

>>> y
array([[ 1. +4.j, 27. -3.j, 12. +6.j,  8. -5.j],
       [ 2. -7.j, 17.+11.j, 19.-21.j, 18.+13.j],
       [ 9. +7.j, 27. +4.j, 14. -3.j,  5. +1.j]])
>>> y.conj()
array([[ 1. -4.j, 27. +3.j, 12. -6.j,  8. +5.j],
       [ 2. +7.j, 17.-11.j, 19.+21.j, 18.-13.j],
       [ 9. -7.j, 27. -4.j, 14. +3.j,  5. -1.j]])

ndarray.round([decimals, out])

此方法返回的是数组中每个元素在给定精度四舍五入后的元素组成的数组。

>>> z = np.random.random((3,4))
>>> z
array([[0.51123462, 0.83900677, 0.00640728, 0.59459365],
       [0.67633995, 0.52600691, 0.28055095, 0.90640635],
       [0.96707984, 0.81025241, 0.03787711, 0.21430548]])
>>> z.round(2) # 保留两位小数
array([[0.51, 0.84, 0.01, 0.59],
       [0.68, 0.53, 0.28, 0.91],
       [0.97, 0.81, 0.04, 0.21]])

ndarray.trace([offset, axis1, axis2, dtype, out])

此方法返回主对角线上元素的和。

>>> x
array([[ 1, 27, 12,  8],
       [ 2, 17, 19, 18],
       [ 9, 27, 14,  5]])
>>> x.trace() # 1 + 17 + 14
32
>>> x.trace(offset=1) # 27 + 19 + 5 对角线向右偏移一位
51
>>>

ndarray.sum([axis, dtype, out, keepdims])

这个方法就是用来求和的。

>>> x
array([[ 1, 27, 12,  8],
       [ 2, 17, 19, 18],
       [ 9, 27, 14,  5]])
>>> x.sum() # 全元素求和
159
>>> x.sum(axis=0) # 同列行间求和
array([12, 71, 45, 31])
>>> x.sum(axis=1) # 同行列间求和
array([48, 56, 55])
>>>

ndarray.cumsum([axis, dtype, out])

返回给定轴元素的累和的数组。

>>> x
array([[ 1, 27, 12,  8],
       [ 2, 17, 19, 18],
       [ 9, 27, 14,  5]])
>>> x.cumsum()
array([  1,  28,  40,  48,  50,  67,  86, 104, 113, 140, 154, 159])
>>> x.cumsum(axis=0) # 同列,每行元素就是原数组当前行元素与之前行元素的和
array([[ 1, 27, 12,  8],
       [ 3, 44, 31, 26],
       [12, 71, 45, 31]])
>>> x.cumsum(axis=1) # 同行,每列元素就是不前列元素与前面列元素的和
array([[ 1, 28, 40, 48],
       [ 2, 19, 38, 56],
       [ 9, 36, 50, 55]])

看明白了吗?

ndarray.mean([axis, dtype, out, keepdims])

返回由给定轴元素的平均数组成的数组。

>>> x
array([[ 1, 27, 12,  8],
       [ 2, 17, 19, 18],
       [ 9, 27, 14,  5]])
>>> x.mean() # 所有元素的平均值
'13.25'
>>> x.mean(axis=0) # 同列,行间平均值组成的数组
array([ 4.        , 23.66666667, 15.        , 10.33333333])
>>> x.mean(axis=1) # 同行,列间平均值组成的数组
array([12.  , 14.  , 13.75])

ndarray.var([axis, dtype, out, ddof, keepdims])

根据给定轴,返回数组元素的方差。

随机变量方差的计算公式:D(X)=E{[X-E(X)]^2}=E(X^2) - [ E(X)]^2,可表述方差为随机变量X与随机变量X期望之差的平方的期望。用法与前面几个方法类似。

>>> x
array([[ 1, 27, 12,  8],
       [ 2, 17, 19, 18],
       [ 9, 27, 14,  5]])
>>> x.var()
'70.02083333333333'
>>> x.var(axis=0)
array([12.66666667, 22.22222222,  8.66666667, 30.88888889])
>>> x.var(axis=1)
array([90.5   , 48.5   , 68.6875])

ndarray.std([axis, dtype, out, ddof, keepdims])

根据给定轴,返回数组元素的标准差,计算公式为sqrt(D(x)),可表述标准差为方差的平方根。

>>> x
array([[ 1, 27, 12,  8],
       [ 2, 17, 19, 18],
       [ 9, 27, 14,  5]])
>>> x.std()
'8.367845202519781'
>>> x.std(axis=0)
array([3.55902608, 4.71404521, 2.94392029, 5.55777733])
>>> x.std(axis=1)
array([9.5131488 , 6.96419414, 8.28779223])

ndarray.prod([axis, dtype, out, keepdims])

返回数组元素在给定轴上的乘积。

>>> x
array([[ 1, 27, 12,  8],
       [ 2, 17, 19, 18],
       [ 9, 27, 14,  5]])
>>> x.prod() # 所有元素乘积
1576481536
>>> x.prod(axis=0) # 同列,行元素的积
array([   18, 12393,  3192,   720])
>>> x.prod(axis=1) # 同行,列元素的积
array([ 2592, 11628, 17010])

ndarray.cumprod([axis, dtype, out])

返回数组元素在给定轴上的累积。

>>> x
array([[ 1, 27, 12,  8],
       [ 2, 17, 19, 18],
       [ 9, 27, 14,  5]])
>>> x.cumprod(axis=0)
array([[    1,    27,    12,     8],
       [    2,   459,   228,   144],
       [   18, 12393,  3192,   720]])
>>> x.cumprod(axis=1)
array([[    1,    27,   324,  2592],
       [    2,    34,   646, 11628],
       [    9,   243,  3402, 17010]])

ndarray.all([axis, out, keepdims])

返回数组在给定轴上的BOOL值(与运算),我们用0,1数组来举例吧,在Python中也是0或空为False,非0为True。

>>> p = np.array([[1,1,0],[1,0,1],[1,0,0]])
>>> p
array([[1, 1, 0],
       [1, 0, 1],
       [1, 0, 0]])
>>> p.all()
False
>>> p.all(axis=0) # 同列,第1列都是1,所以是True,其它为False
array([ True, False, False])
>>> p.all(axis=1) # 没有哪一行都是1,所以都是False
array([False, False, False])

ndarray.any([axis, out, keepdims])

返回数组在给定轴上的BOOL值(或运算),给定轴元素只要有一个是1,结果就是True。还是用上面的数据举例。

>>> p
array([[1, 1, 0],
       [1, 0, 1],
       [1, 0, 0]])
>>> p.any()
True
>>> p.any(axis=0)
array([ True,  True,  True])
>>> p.any(axis=1)
array([ True,  True,  True])