那些接受数组作为参数,但操作的是数组中的元素的方法称为"元素级数组方法"(ufuncs)或"通用函数"(Universal Function)
一.字符串函数
#以下函数均定义在字符数组类(numpy.char)中;均返回Ndarray对象
add(<a>,<b>):将列表a,b中的元素对应相加
#只能将str元素相加
#实例:
>>> a=np.char.add(["wqw"],["dd"])
>>> print(a)
['wqwdd']
##########################################################
multiply(<a>,<n>):对数组a中的字符串执行多重连接
#即a中字符串元素ai都*n
#参数说明:
n:重复次数
#实例:
>>> a=np.char.multiply(["asds"],3)
>>> print(a)
['asdsasdsasds']
##########################################################
center(<a>,<width>,fillchar=" "):用于将数组a中元素居中,并用指定字符在左/右侧进行填充
#如果width<len(str),会截取str的前width个元素
#如果str无法居中,len(左侧填充)=len(右侧填充)+1
#参数说明:
width:返回的字符串的长度
fillchar:指定填充用的字符;长度为1的字符串
#实例:
>>> a=np.char.center("aa",8)
>>> print(a)
aa #到此结束
>>> a=np.char.center("abcd",1)
>>> print(a)
a
>>> a=np.char.center("abcd",10,fillchar="*")
>>> print(a)
***abcd***
>>> a=np.char.center("abcd",9,fillchar="*")
>>> print(a,type(a))
***abcd** <class 'numpy.ndarray'>
>>> a=np.char.center(["aa","d"],8)
>>> print(a)
[' aa ' ' d ']
##########################################################
capitalize(<a>):将数组a中元素的首字母转换为大写
#实例:
>>> a=np.char.capitalize("asdf")
>>> print(a,type(a))
Asdf <class 'numpy.ndarray'>
>>> a=np.char.capitalize(["aa","d"])
>>> print(a)
['Aa' 'D']
##########################################################
title(<a>):将数组a中元素中的每个单词的受字母转换为大写
#空格前后将被识别为2个单词
#实例:
>>> a=np.char.title("asdf ddi amyou")
>>> print(a,type(a))
Asdf Ddi Amyou <class 'numpy.ndarray'>
>>> a=np.char.title(["asdf ddi amyou","as"])
>>> print(a)
['Asdf Ddi Amyou' 'As']
##########################################################
lower(<a>):将数组a中元素的每个字母转换成小写
#实例:
>>> a=np.char.lower("AaD1~")
>>> print(a)
aad1~
>>> a=np.char.lower(["AaD","dB"])
>>> print(a)
['aad' 'db']
##########################################################
upper(<a>):将数组a中元素的每个字母转换成大写
#实例:
>>> a=np.char.upper("AaD1`")
>>> print(a)
AAD1`
>>> a=np.char.upper(["AaD1`","s1A"])
>>> print(a)
['AAD1`' 'S1A']
##########################################################
split(<a>,sep=" "):通过指定分隔符分割数组a中元素
#不返回分隔符本身
#参数说明:
sep:指定分隔符;长度不一定为1
#实例:
>>> a=np.char.split(["1ds 12","as2 2"])
>>> print(a)
[list(['1ds', '12']) list(['as2', '2'])]
>>> a=np.char.split(["1ds~|12","as2~|2"],sep="~|")
>>> print(a)
[list(['1ds', '12']) list(['as2', '2'])]
##########################################################
splitlines(<a>):以换行符作为分隔符来分割数组a中元素
#实例:
>>> a=np.char.splitlines(["as\ns d","a\n "])
>>> print(a)
[list(['as', 's d']) list(['a', ' '])]
##########################################################
strip(<a>,<char>):用于移除数组a中元素开头和结尾处的指定字符
#会递归移除首/尾的指定字符,直到遇到非指定字符(如果首/尾有连续多个指定字符,全部移除)
#参数说明:
char:要移除的字符
如果len(char)>1,构成char的各个字符是或的关系(不需要完全匹配char)
#实例:
>>> a=np.char.strip(["asdladda","aaa"],"a")
>>> print(a)
['sdladd' '']
>>> a=np.char.strip(["asdladdassss","aaadaaa"],"as")
>>> print(a)
['dladd' 'd']
##########################################################
join(<a_sep>,<a_str>):在a_str的每个元素的每2个字符间插入a_sep中的对应元素
#参数说明:
a_sep,a_str:均为1维数组
#实例:
>>> a=np.char.join(':','runoob')
>>> print(a)
r:u:n:o:o:b
>>> a=np.char.join([':','-'],['runoob','google'])
>>> print(a)
['r:u:n:o:o:b' 'g-o-o-g-l-e']
##########################################################
replace(<a>,<pre>,<now>):将数组a中元素的指定部分用指定字符串替换
#当<a>,<pre>,<now>不同型,会触发广播机制
#参数说明:
pre:要替换的子字符串;数组或字符串
now:用于替换pre的字符串;数组或字符串
#实例:
>>> a=np.char.replace(["wwwdsdsew","dqqqweww"],"ww","qq")
>>> print(a)
['qqwdsdsew' 'dqqqweqq']
>>> a=np.char.replace([["wwwdsdsew","dqqqweww"],["ssww","saw"]],"ww","qq")
>>> print(a)
[['qqwdsdsew' 'dqqqweqq']
['ssqq' 'saw']]
>>> a=np.char.replace(["wwwdsdsew","dqqqweww"],"ww",[["qq","q"],["qs","f"]])
>>> print(a)
[['qqwdsdsew' 'dqqqweq']
['qswdsdsew' 'dqqqwef']]
>>> a=np.char.replace(["wwwdsdsew","dqqqweww"],[["ww","d"],["q","w"]],[["qq","q"],["qs","f"]])
>>> print(a)
[['qqwdsdsew' 'qqqqweww']
['wwwdsdsew' 'dqqqfeff']]
##########################################################
encode(<a>,<enco>):对数组a中的元素进行编码
#参数说明:
enco:编码方式;默认为utf-8;可以使用标准Python库中的编解码器
#实例:
>>> a=np.char.encode([["121a"],["ascs"]])
>>> print(a)
[[b'121a']
[b'ascs']]
>>> a=np.char.encode([["121a"],["ascs"]],"gbk")
>>> print(a)
[[b'121a']
[b'ascs']]
>>> a=np.char.encode([["121a"],["ascs"]],"cp500")
>>> print(a)
[[b'\xf1\xf2\xf1\x81']
[b'\x81\xa2\x83\xa2']]
##########################################################
decode(<a>,<deco>):对数组a中的元素进行解码
#参数说明:
deco:解码方式;默认为utf-8;可以使用标准Python库中的编解码器
#实例:
>>> a=np.char.encode([["121a"],["ascs"]],"cp500")
>>> b=np.char.decode(a,"cp500")
>>> print(b)
[['121a']
['ascs']]
>>> b=np.char.decode(a)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<__array_function__ internals>", line 6, in decode
File "C:\Users\1234\AppData\Roaming\Python\Python37\site-packages\numpy\core\defchararray.py", line 562, in decode
_vec_string(a, object_, 'decode', _clean_args(encoding, errors)))
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xf1 in position 0: invalid continuation byte
二.数值计算函数
1.三角学函数:
#以下函数的返回值均为弧度制
np.arccos(<x>):返回x的反三角余弦值
np.arcsin(<x>):返回x的反三角正弦值
np.arctan(<x>):返回x的反三角正切值
np.cos(<x>):返回x的余弦值
np.sin(<x>):返回x的正弦值
np.tan(<x>):返回x的正切值
##########################################################
np.degrees(x):将x转换为角度制
2.舍入函数:
参见:https://blog.csdn.net/qq_32623363/article/details/97752030
np.around(<a>[,decimals=0,out=None]):返回a的四舍五入值
np.round(<a>[,decimals=0,out=None]):返回a的四舍五入值
#参数说明:
decimals:指定保留到小数点后第几位
#为0,保留到整数位;<0,保留到个位左侧的位置
#实例
>>> a=np.array([1.0,5,55,123,0.567,25.532])
>>> print(np.around(a))
[ 1. 5. 55. 123. 1. 26.]
>>> print(np.around(a,decimals=0))
[ 1. 5. 55. 123. 1. 26.]
>>> print(np.around(a,decimals=1))
[ 1. 5. 55. 123. 0.6 25.5]
>>> print(np.around(a,decimals=-1))
[ 0. 0. 60. 120. 0. 30.]
##########################################################
np.floor(<x>):返回≤x的最大整数(向下取整)
#实例:
>>> print(np.floor([1.1,2.8,3,-3.3]))
[ 1. 2. 3. -4.]
##########################################################
np.ceil(<x>):返回≥x的最小整数(向上取整)
#实例:
>>> print(np.ceil([1.1,2.8,3,-3.3]))
[ 2. 3. 3. -3.]
3.算术函数:
(1)加减乘除:
>>> a=np.arange(9,dtype=np.float_).reshape(3,3)
>>> b=np.array([10,10,10])
#以下函数分别相当于+-*/,传入的2个数组要么同型,要么符合广播规则
np.add(<a>,<b>):将a,b相加
#参数说明:
a,b指定要相加的对象;为ndarray/scalar
#实例
>>> print(np.add(a,b))
[[10. 11. 12.]
[13. 14. 15.]
[16. 17. 18.]]
##########################################################
np.subtract(<a>,<b>):将a,b相减
#实例:
>>> print(np.subtract(a,b))
[[-10. -9. -8.]
[ -7. -6. -5.]
[ -4. -3. -2.]]
##########################################################
np.multiply(<a>,<b>):将a,b相乘
#实例:
>>> print(np.multiply(a,b))
[[ 0. 10. 20.]
[30. 40. 50.]
[60. 70. 80.]]
##########################################################
np.divide(<a>,<b>):将a,b相除
#实例:
>>> print(np.divide(a,b))
[[0. 0.1 0.2]
[0.3 0.4 0.5]
[0.6 0.7 0.8]]
>>> print(np.divide(b,a))
__main__:1: RuntimeWarning: divide by zero encountered in true_divide
[[ inf 10. 5. ]
[ 3.33333333 2.5 2. ]
[ 1.66666667 1.42857143 1.25 ]]
(2)其他算术函数:
np.abs(<a>):返回a中所有元素的绝对值构成的同型数组
np.fabs(<a>):快速返回浮点数(组)a中所有元素的绝对值构成的同型数组
##########################################################
np.reciprocal(<a>):返回a中所有元素的倒数构成的同型数组
#实例:
>>> a=np.arange(9,dtype=np.float_).reshape(3,3)
>>> print(np.reciprocal(a))
__main__:1: RuntimeWarning: divide by zero encountered in reciprocal
[[ inf 1. 0.5 ]
[0.33333333 0.25 0.2 ]
[0.16666667 0.14285714 0.125 ]]
##########################################################
np.power(<a>,<b>):让a,b进行乘方运算
np.sqrt(<a>):让a做开方运算
np.squarre(<a>):让a做平方运算
np.exp(<a>):取a的以e为底的指数
np.exp2(<a>):取a的以2为底的指数
#实例:
>>> a=np.arange(9,dtype=np.float_).reshape(3,3)
>>> b=np.array([[3.1],[2.2],[3]])
>>> print(np.power(a,b))
[[ 0. 1. 8.5741877 ]
[ 11.21157846 21.11212657 34.49324154]
[216. 343. 512. ]]
##########################################################
np.mod(<a>,<b>):让a,b做取模运算
#实例:
>>> a=np.array([[3.14,2.2,11],[22.3,4,10],[5.556,11.112,3.7]])
>>> b=np.array([10,9,8])
>>> print(np.mod(a,b))
[[3.14 2.2 3. ]
[2.3 4. 2. ]
[5.556 2.112 3.7 ]]
>>> np.mod(-3,2)
1
##########################################################
np.log(<a>):取a的自然对数
np.log2(<a>):取a的底为2的对数
np.log10(<a>):取a的底为10的对数
#实例:
>>> np.log(np.array([[1,2],[3,4]]))
array([[0. , 0.69314718],
[1.09861229, 1.38629436]])
4.统计函数
(1)最大/小值:
计算a中元素沿指定轴的最大值:np.amax(<a>[,axis=None])
#相当于np.min()或<a>.min()
计算a中元素沿指定轴的最小值:np.amin(<a>[,axis=None])
#相当于np.max()或<a>.max()
#参数说明:
axis:指定返回沿哪个轴的最大/小值
为None时为数组中全部元素中的最小值
指定轴时,返回沿该轴的各数组中最大/小值构成的数组(数组形状与a在垂直于axis的平面上的投影相同)
#实例:
>>> a = np.array([[3,7,5],[8,4,3],[2,4,9]])
>>> a=np.array([[3,7,5],[8,4,3],[2,4,9]])
>>> print(np.amax(a))
9
>>> print(np.amin(a))
2
>>> print(np.amin(a,axis=0))
[2 4 3]
>>> print(np.amax(a,axis=0))
[8 7 9]
>>> b=np.array([[[3,7],[1,2]],[[6,1],[5,8]]])
>>> print(np.amax(b))
8
>>> print(np.amin(b))
1
>>> print(np.amin(b,axis=1))
[[1 2]
[5 1]]
>>> print(np.amin(b,axis=2))
[[3 1]
[1 5]]
>>> print(np.amin(b,axis=0))
[[3 1]
[1 2]]
>>> print(np.amax(b,axis=0))
[[6 7]
[5 8]]
>>> print(np.amax(b,axis=1))
[[3 7]
[6 8]]
>>> print(np.amax(b,axis=2))
[[7 2]
[6 8]]
##########################################################
获得各个位置上较小的元素:[<rmax>=]np.maximum(<x1>,<x2>[,out=None,where=True,casting="same_kind",order="K",dtype=None,subok=True,signature,extobj])
#相当于np.fmax()
获得各个位置上较大的元素:[<rmin>=]np.minimum(<x1>,<x2>[,out=None,where=True,casting="same_kind",order="K",dtype=None,subok=True,signature,extobj])
#相当于np.fmin()
#参数说明:
x1,x2:指定要进行比较的对象;为array-like/scalar
rmax,rmin:返回结果;为ndarray/scalar
#<rmax>[i]=max(<x1>[i],<x2>[i]),<rmin>[i]=min(<x1>[i],<x2>[i])
#实例:
>>> np.maximum([1,9],[3,4])
array([3, 9])
>>> np.minimum([1,9],[3,4])
array([1, 4])
##########################################################
查看最小值的索引:np.argmin(<a>[,axis=None,out=None])
查看最大值的索引:np.argmax(<a>[,axis=None,out=None])
#参数说明:
a:指定数组;为array-like
axis:指定沿哪个轴;为None(使用展开后的array)/int
#实例:
>>> a=np.array([[1,2,3],[9,-1,3],[4,5,-12]])
>>> np.argmin(a)
8
>>> np.argmin(a,axis=0)
array([0, 1, 2], dtype=int64)
>>> np.argmax(a)
3
>>> np.argmax(a,axis=0)
array([1, 2, 0], dtype=int64)
##########################################################
计算a中元素沿指定轴的最大值与最小值的差:np.ptp(<a>[,axis=None])
#相当于np.amax()-np.amin()
#实例:
>>> a=np.array([[3,7,5],[8,4,3],[2,4,9]])
>>> max,min=np.amax(a),np.amin(a)
>>> p=np.ptp(a)
>>> print("max-min:%s;p:%s"%(max-min,p))
max-min:7;p:7
>>> max,min=np.amax(a,axis=0),np.amin(a,axis=0)
>>> p=np.ptp(a,axis=0)
>>> print("max-min:%s;p:%s"%(max-min,p))
max-min:[6 3 6];p:[6 3 6]
>>> max,min=np.amax(a,axis=1),np.amin(a,axis=1)
>>> p=np.ptp(a,axis=1)
>>> print("max-min:%s;p:%s"%(max-min,p))
max-min:[4 5 7];p:[4 5 7]
(2)分位数:
计算a中沿指定维度的百分位数:np.percentile(<a>,<q>[,axis=None)
#参数说明:
q:指定百分位(小于百分位数的观察值的百分比);属于[0,100];num或array
#q为50时返回中位数
#处于q%位置的值称为第q百分位数(有q%的观测值小于该值,有(1-q%)的观测值大于该值)
#实例:
>>> a=np.array([[3,7,5],[8,4,3],[2,4,9]])
>>> print(np.percentile(a,30))
3.4
>>> print(np.percentile(a,30,axis=0))
[2.6 4. 4.2]
>>> print(np.percentile(a,30,axis=1))
[4.2 3.6 3.2]
>>> print(np.percentile(a,60))
4.8
>>> print(np.percentile(a,30,axis=0))
[2.6 4. 4.2]
>>> print(np.percentile(a,30,axis=1))
[4.2 3.6 3.2]
##########################################################
计算a中沿指定维度的中位数:np.median(<a>[,axis=None])
#实例:
>>> a=np.array([[[11,43],[33,2]],[[9.02,33.1],[333,2]]])
>>> print(np.median(a))
22.0
>>> print(np.median(a,axis=0))
[[ 10.01 38.05]
[183. 2. ]]
>>> print(np.median(a,axis=1))
[[ 22. 22.5 ]
[171.01 17.55]]
(3)平均值:
计算a中沿指定维度的算术平均值:np.mean(<a>[,axis=None])
#实例:
>>> a=np.array([[[11,43],[33,2]],[[9.02,33.1],[333,2]]])
>>> print(np.mean(a))
58.265
>>> print(np.mean(a,axis=0))
[[ 10.01 38.05]
[183. 2. ]]
>>> print(np.mean(a,axis=1))
[[ 22. 22.5 ]
[171.01 17.55]]
##########################################################
计算a中沿指定维度的加权平均值:np.average(<a>[,weights=[[1...1]...[1...1]],axis=None,returned=False])
#参数说明:
weights:指定权重;默认时相当于np.mean(),即权重均为1
axis:如果没有指定轴,数组会被展开
returned:指定是否返回权重的和
#实例:
>>> a=np.array([1,2,3,4,5,6])
>>> print(np.average(a,weights=[0.3,3,1,1.2,0.67,1]))
3.270571827057183
>>> print(np.average(a,weights=[0.3,3,1,1.2,0.67,1],returned=True))
(3.270571827057183, 7.17)
>>> print(np.average(a,weights=[0.3,3,1,1.2,0.67,1],returned=False))
3.270571827057183
>>> a=np.arange(6).reshape(3,2)
>>> wt=np.array([3,5])
>>> print(np.average(a,axis=1,weights=wt,returned=True))
(array([0.625, 2.625, 4.625]), array([8., 8., 8.]))
(4)方差与标准差:
计算a中沿指定维度的方差:np.var(<a>[,axis=None])
#即np.mean((x-np.mean(x))**2)
计算a中沿指定维度的标准差:np.std(<a>[,axis=None])
#即np.sqrt(np.mean((x-np.mean(x))**2))
#实例:
>>> a=np.array([[1,2],[3,4]])
>>> print(np.var(a))
1.25
>>> print(np.var(a,axis=0))
[1. 1.]
>>> print(np.std(a))
1.118033988749895
>>> print(np.std(a,axis=0))
[1. 1.]
(5)其他:
沿指定轴求和和:np.sum(<a>[,axis=None,dtype=None,out=None,keepdims=np._NoValue,initial=np._NoValue,where=np._NoValue])
#参数说明:
a:指定数组;为array-like
axis:指定沿哪些轴求和;为None(求所有元素的和)/int/tuple
#实例:
>>> np.sum([[[1,2,3],[1,2,3]],[[1,2,3],[1,2,3]]])
24
>>> np.sum([[[1,2,3],[1,2,3]],[[1,2,3],[1,2,3]]],axis=-1)
array([[6, 6],
[6, 6]])
>>> np.sum([[[1,2,3],[1,2,3]],[[1,2,3],[1,2,3]]],axis=0)
array([[2, 4, 6],
[2, 4, 6]])
>>> np.sum([[[1,2,3],[1,2,3]],[[1,2,3],[1,2,3]]],axis=-3)
array([[2, 4, 6],
[2, 4, 6]])
三.排序及筛选函数
1.排序算法:
2.排序函数:
np.sort(<a>[,axis=n,kind="quicksort",order=None]):对数组a进行排序,返回a的经过排序的副本
#对复数,先按实部从大到小排列,再按虚部从大到小排列
#参数说明:
axis:指定沿哪个轴排序;默认沿行排序(n只是表示沿行,显示声明时不能写axis=n)
kind:使用哪种排序算法;可为'quicksort'(默认),'mergesort','heapsort'
order:如果数组包含字段,则是要排序的字段
#实例:
>>> a=np.array([[[1,9,2],[2,4,3]],[[3,3,4],[7,6,10]]])
>>> print(np.sort(a))
[[[ 1 2 9]
[ 2 3 4]]
[[ 3 3 4]
[ 6 7 10]]]
>>> print(np.sort(a,axis=0))
[[[ 1 3 2]
[ 2 4 3]]
[[ 3 9 4]
[ 7 6 10]]]
>>> dt=np.dtype([('name','S10'),('age',int)])
>>> a=np.array([("raju",21),("anil",25),("ravi",17),("amar",27)],dtype=dt)
>>> print(a)
[(b'raju', 21) (b'anil', 25) (b'ravi', 17) (b'amar', 27)]
>>> print(np.sort(a,order='name'))
[(b'amar', 27) (b'anil', 25) (b'raju', 21) (b'ravi', 17)]
>>> print(np.sort(a,order='age'))
[(b'ravi', 17) (b'raju', 21) (b'anil', 25) (b'amar', 27)]
##########################################################
np.argsort(<a>[,axis=n,kind="quicksort",order=None]):功能同np.sort(),但返回的是新数组元素在原数组中的索引构成的数组
#参数说明:同上
#实例:
>>> dt=np.dtype([('name','S10'),('age',int)])
>>> a=np.array([("raju",21),("anil",25),("ravi",17),("amar",27)],dtype=dt)
>>> print(np.argsort(a,axis=0,kind='quicksort',order='age'))
[2 0 1 3]
##########################################################
np.lexsort((<a1>,<a2>...)[,axis=n]):用于对多个序列进行排序
#排序的顺序由最后1个序列决定(前面各数组的对应元素放在新数组的对应位置)
#对字母从"a"-->"z",对数字从0-->9
#a1,a2...要同型
#参数说明:axis同上
a1,a2...:要排序的数组
#实例:
>>> a=[1,4,2,3,4,7]
>>> b=[3,2,5,4,3,1]
>>> c=np.lexsort((a,b))
>>> print(c)
[5 1 0 4 3 2]
>>> print([str(a[i])+","+str(b[i]) for i in c])
['7,1', '4,2', '1,3', '4,3', '3,4', '2,5']
##########################################################
np.msort(<a>):沿第0个轴对数组a进行排序,返回a的经过排序的副本
#相当于np.sort(<a>,axis=0)
##########################################################
np.sort_complex(<a>):对数复数组a进行排序
#先按实部排序,再按虚部排序
#实例:
>>> a=[[1+2j,3+1j,-1+1j],[2-3j,1+1j,2j]]
>>> print(np.sort_complex(a))
[[-1.+1.j 1.+2.j 3.+1.j]
[ 0.+2.j 1.+1.j 2.-3.j]]
##########################################################
np.partition(<a>,<kth>[,axis=n,kind="quicksort",order=None]):对数组a进行分区
#先沿axis按升序对a进行排序得到数组b,再用b[kth]进行分组,>b[kth]的值放在b[kth]前,>b[kth]的放在b[kth]后,各组内的顺序没有明显规律
#1中不完整的有序化,只在kth附近有序化
#参数说明:axis,kind,order同上
kth:指定在b中的索引;数组或数
#为数组时,对kth中每个元素都按说明的步骤进行
#实例:
>>> a=np.array([[3,7,1,2,6,9,0,4,4,5],[1,4,2,6,9,3,5,2,7,10],[1,3,2,5,6,7,8,4,20,11]])
>>> b=np.partition(a,2)
>>> print(b)
[[ 0 1 2 7 6 9 3 4 4 5]
[ 1 2 2 6 9 3 5 4 7 10]
[ 1 2 3 5 6 7 8 4 20 11]]
>>> b=np.partition(a,(2,3))
>>> print(b)
[[ 0 1 2 3 6 9 7 4 4 5]
[ 1 2 2 3 9 6 5 4 7 10]
[ 1 2 3 4 6 7 8 5 20 11]]
>>> b=np.partition(a,(2,3),axis=0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<__array_function__ internals>", line 6, in partition
File "C:\Users\1234\AppData\Roaming\Python\Python37\site-packages\numpy\core\fromnumeric.py", line 746, in partition
a.partition(kth, axis=axis, kind=kind, order=order)
ValueError: kth(=3) out of bounds (3)
>>> b=np.partition(a,(2,3),axis=1)
>>> print(b)
[[ 0 1 2 3 6 9 7 4 4 5]
[ 1 2 2 3 9 6 5 4 7 10]
[ 1 2 3 4 6 7 8 5 20 11]]
##########################################################
np.argpartition(<a>,<kth>[,axis=n,kind="quicksort",order=None]):类似partition(),不过返回的是np.partition()返回值中元素在a中的索引
#实例:
>>> a=np.array([3,7,1,2,6,9,0,4,4,5])
>>> b=np.argpartition(a,5)
>>> print(b)
[6 2 3 0 8 7 9 5 1 4]
3.筛选函数:
np.argmax(<a>[,axis=None]):返回数组a中沿指定轴的最大元素的索引
np.argmin(<a>[,axis=None]):返回数组a中沿指定轴的最小元素的索引
#axis=None时,返回的索引是最大/小值在展开后数组中的索引
#参数说明:同上
#实例:
>>> a=np.array([[4,2,7,10],[2,3,1,9]])
>>> print(np.argmax(a))
3
>>> print(np.argmin(a))
6
>>> print(np.argmax(a,axis=0))
[0 1 0 0]
>>> print(np.argmax(a,axis=1))
[3 3]
>>> print(np.argmin(a,axis=0))
[1 0 1 1]
>>> print(np.argmin(a,axis=1))
[1 2]
##########################################################
b=np.nonzero(<a>):返回数组a中非零元素的索引
#b的第1,2...行分别表示在第n,n-1...维的索引,各行间按位置一一对应,共同代表某元素
#参数说明:同上
#实例:
>>> a=np.array([[30,40,0],[0,20,10],[50,0,60]])
>>> b=np.nonzero(a)
>>> print(b)
(array([0, 0, 1, 1, 2, 2], dtype=int64), array([0, 1, 1, 2, 0, 2], dtype=int64))
#返回值的第1行代表行索引,第2行代表列索引,各行间按位置一一对应
>>> print(a[b])
[30 40 20 10 50 60]
##########################################################
b=np.where(<condition>(<a>)):返回数组a中满足给定条件的元素的索引
#b的第1,2...个元素分别表示在第n,n-1...维的索引,各行间按位置一一对应,共同代表某元素
#参数说明:
condition:用于筛选元素的条件;可为表达式或函数
#实例:
>>> a=np.array([[1,4,2,6,3],[11.1,3,2,66,9.0]])
>>> b=np.where(a>3)
>>> print(b)
(array([0, 0, 1, 1, 1], dtype=int64), array([1, 3, 0, 3, 4], dtype=int64))
>>> print(a[b])
[ 4. 6. 11.1 66. 9. ]
>>> np.where(1>0)
(array([0], dtype=int64),)
##########################################################
b=np.where(<condition>[,x=None,y=None]):利用表达式组合2个数组的目的
#相当于x if <condition> else y
#参数说明:
condition:用于筛选元素的条件;可为表达式或函数
x,y:满足和不满足条件时元素来自的数组;为array-like
#不能只传入1个
#实例:
>>> np.where(1>0,[999,999,999,999,999,999],[-111,-111,-111,-1111,-111,-111])
array([999, 999, 999, 999, 999, 999])
>>> a=[1,2,3,-1,-2,-3]
>>> np.where(np.array(a)>0,[999,999,999,999,999,999],[-111,-111,-111,-1111,-111,-111])
array([ 999, 999, 999, -1111, -111, -111])
>>> np.where(np.array(a)>0)
(array([0, 1, 2], dtype=int64),)
##########################################################
np.extract(<condition>,<a>):返回数组a中满足条件的元素
#返回1个1维数组
#参数说明:
condition:用于筛选元素的条件
#实例:
>>> x=np.arange(9).reshape(3,3)
>>> c=np.mod(x,2)==0
>>> print(c)
[[ True False True]
[False True False]
[ True False True]]
>>> y=np.extract(c,x)
>>> print(y)
[0 2 4 6 8]
四.线性代数相关函数
1.内置函数:
c=np.dot(<a>,<b>[,<out>]):求数组a和数组b的点积
#对向量是内积,对矩阵是矩阵乘积
#对高维数组来说遵循c[i,j,...,k,...,m]=sum(a[i,j,...,:]*b[k,...,:,m])
#也支持不同维数组的点积计算
#参数说明:
out:用于保存计算结果;Ndarray对象
#实例:
>>> a=[1,2,3,4]
>>> b=[2,3,4,5]
>>> print(np.dot(a,b))
40
>>> a=[[1,2],[3,4]]
>>> print(np.dot(a,a))
[[ 7 10]
[15 22]]
>>> a=[[[1,2],[3,4]],[[5,6],[7,8]]]
>>> b=np.dot(a,a)
>>> print(b)
[[[[ 7 10]
[ 19 22]]
[[ 15 22]
[ 43 50]]]
[[[ 23 34]
[ 67 78]]
[[ 31 46]
[ 91 106]]]]
>>> b[0,1,1,0]
43
>>> a=np.array(a)
#此时Matrix存储在list中,而list中每个元素大小可能不同
#不能直接取某列,需要转变为标准矩阵
>>> print(sum(a[0,1,:]*a[1,:,0]))
43
######################################################################################################################
np.vdot(<v1>,<v2>):求向量v1和v2的点积
#如果第1个参数是复数,那么其共轭复数会用于计算
#参数说明:
v1,v2:向量
#如果参数是Ndarray,会被展开,再求点积
#实例:
>>> a=[1,2,3]
>>> b=[2,3,4]
>>> print(np.vdot(a,b))
20
>>> a=np.array([[1,2],[3,4]])
>>> b=np.array([[11,12],[13,14]])
>>> print(np.vdot(a,b))
130 #1*11+2*12+3*13+4*14=130
######################################################################################################################
np.inner(<a1>,<a2>):返回数组a1和a2的内积
#a1,a2均为1维数组时同np.vdot()
#对高维数组,返回a1,a2中对应的沿n号轴(行)的各向量的点积构成的数组
#a1,a2用于得到点积向量依次沿轴n-1,轴n...变化
#a2的遍历在外,a1的在内(先固定a2的向量不变,遍历a1的向量,再改变a2的向量,再次辩论a1的向量,如此循环)
#实例:
>>> a=np.array([[1,2],[3,4]])
>>> b=np.array([[11,12],[13,14]])
>>> print(np.vdot(a,b))
130
>>> print(np.inner(a,b))
[[35 41] #1*11+2*12和1*13+2*14
[81 95]] #3*11+4*12和3*13+4*14
>>> b=np.array([[[11,12],[13,14]],[[1,1],[1,1]]])
>>> a=np.array([[[1,2],[3,4]],[[1,1],[1,1]]])
>>> print(np.vdot(a,b))
134
>>> print(np.inner(a,b))
[[[[35 41] #1*11+2*12和1*13+2*14
[ 3 3]] #1*1+1*2和1*1+1*2
[[81 95] #3*11+4*12和3*13+4*14
[ 7 7]]] #1*3+1*4和1*3+1*4
[[[23 27] #11*1+12*1和13*1+14*1
[ 2 2]] #1*1+1*1和1*1+1*1
[[23 27] #11*1+12*1和13*1+14*1
[ 2 2]]]] #1*1+1*1和1*1+1*1
######################################################################################################################
np.matmul(<a1>,<a2>):返回数组a1和a2的矩阵乘积
#如果任一参数的维数>2,将其视为存在于最后2个索引的矩阵的栈,并进行相应广播
#？？？如果任一参数是1维数组,通过在其维度上附加1来将其提升为矩阵,并在乘法之后被去除
#实例:
>>> a=[[1,2],[3,4]]
>>> print(np.matmul(a,a))
[[ 7 10]
[15 22]]
>>> b=[1,2]
>>> print(np.matmul(a,b))
[ 5 11]
>>> a=[[1,2,3],[4,5,6],[7,8,9]]
>>> b=[1,2,3]
>>> print(np.matmul(a,b))
[14 32 50]
>>> b=[[[1,2,3],[4,5,6],[7,8,9]],[[0,1,0],[3,2,3],[1,4,1]]]
>>> print(np.matmul(a,b))
[[[ 30 36 42]
[ 66 81 96]
[102 126 150]]
[[ 9 17 9]
[ 21 38 21]
[ 33 59 33]]]
2.线性代数模块(linalg):
参见 Python.第三方模块.科学计算.NumPy模块.矩阵,线性代数,随机数.二 部分
五.其他函数
查看a的符号:np.sign(<a>)
#1表示为正,0表示为0,-1表示为负
#实例:
>>> np.sign([3,-2,0])
array([ 1, -1, 0])
##########################################################
修改元素的符号:np.copysign(<x1>,<x2>[,out=None,where=True,casting='same_kind',order='K',dtype=None,subok=True,signature,extobj])
#参数说明:
x1:指定要修改的数组;为array-like/scalar
x2:指定<x1>中相应元素的符号;为array-like/scalar
#实例:
>>> np.copysign([1,2,-3,0,1,-4,0,1,-1],[1,2,3,4,-1,-2,0,0,0])
array([ 1., 2., 3., 0., -1., -4., 0., 1., 1.])
##########################################################
将展开的数组中的1维索引还原为多维索引:np.unravel_index(<indices>,<shape>[,order=None,dims=None])
#参数说明:
indices:指定1维索引;为int/array-like
shape:指定原数组的形状;为int array-like
#实例:
>>> np.unravel_index(3,[1,4])
(0, 3)
>>> np.unravel_index([3,2],[1,4])
(array([0, 0], dtype=int64), array([3, 2], dtype=int64))
##########################################################
求数组中元素间的梯度:np.gradient(<f>[,<varargs>,axis=None,edge_order=1])
#对[<x1>,<x2>,<x3>],结果为[<x2>-<x1>,(<x3>-<x1>)/2,<x3>-<x2>]
#参数说明:
f:指定数组;为array-like
varargs:指定沿各维度的采样距离;为scalar/scalar list/array,默认为1
axis:指定计算沿哪些维度的梯度;为None(所有)/int/int tuple
#实例:
>>> np.gradient([1,2])
array([1., 1.])
>>> np.gradient([[1,2,5],[3,4,6],[7,8,9]])
[array([[2., 2., 1.],
[3., 3., 2.],
[4., 4., 3.]]), array([[1. , 2. , 3. ],
[1. , 1.5, 2. ],
[1. , 1. , 1. ]])]
>>> np.gradient([[1,2,5],[3,4,6],[7,8,9]],2)
[array([[1. , 1. , 0.5],
[1.5, 1.5, 1. ],
[2. , 2. , 1.5]]), array([[0.5 , 1. , 1.5 ],
[0.5 , 0.75, 1. ],
[0.5 , 0.5 , 0.5 ]])]
扫一扫
1454
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
