Numpy有关的函数

Numpy学习笔记010

十二、通用函数

import numpy as np

1. 一元函数

a = np.random.uniform(-10,10,size=(3,5))   # -10到10平均分布
a

array([[-3.37006314,  0.29726367,  9.02841508, -7.54948716, -0.81302544],
       [ 3.7255945 , -6.20299337, -5.32965017, -4.31364539,  1.56689175],
       [ 4.59815536, -6.71518921, -8.52824725, -9.80688088, -8.29007315]])

1.1 绝对值函数np.abs()

np.abs(a)  #求绝对值

array([[3.37006314, 0.29726367, 9.02841508, 7.54948716, 0.81302544],
       [3.7255945 , 6.20299337, 5.32965017, 4.31364539, 1.56689175],
       [4.59815536, 6.71518921, 8.52824725, 9.80688088, 8.29007315]])

1.2 平方根函数np.sqrt()

np.sqrt(a)  #负数不可开根号，为NAN

array([[       nan, 0.54521892, 3.00473212,        nan,        nan],
       [1.93017991,        nan,        nan,        nan, 1.25175547],
       [2.14433098,        nan,        nan,        nan,        nan]])

1.3 平方函数np.square(()

np.square(a) #求平方

array([[1.13573256e+01, 8.83656891e-02, 8.15122789e+01, 5.69947564e+01,
        6.61010364e-01],
       [1.38800544e+01, 3.84771267e+01, 2.84051709e+01, 1.86075366e+01,
        2.45514975e+00],
       [2.11430327e+01, 4.50937661e+01, 7.27310011e+01, 9.61749127e+01,
        6.87253129e+01]])

1.4 指数函数np.exp()

np.exp(a) #求指数

array([[3.43874659e-02, 1.34617020e+00, 8.33663623e+03, 5.26380008e-04,
        4.43514209e-01],
       [4.14958946e+01, 2.02336489e-03, 4.84576491e-03, 1.33846682e-02,
        4.79173111e+00],
       [9.93009724e+01, 1.21235660e-03, 1.97801363e-04, 5.50713532e-05,
        2.50996100e-04]])

1.5 对数np.log，np.log10，np.log2，np.log1p

np.log(a) #求对数,负数无对数，为NAN

array([[        nan, -1.21313576,  2.20037684,         nan,         nan],
       [ 1.31522644,         nan,         nan,         nan,  0.44909388],
       [ 1.52565522,         nan,         nan,         nan,         nan]])

1.6 np.sign()标签化函数

np.sign(a)
#将数组中的值标签化，大于0的变成1，等于0的变成0，小于0的变成-1

array([[-1.,  1.,  1., -1., -1.],
       [ 1., -1., -1., -1.,  1.],
       [ 1., -1., -1., -1., -1.]])

1.7 np.ceil() 向上取整

np.ceil(a)  #向上取整

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

1.8 np.floor() 向下取整

np.floor(a)  #向下取整

array([[ -4.,   0.,   9.,  -8.,  -1.],
       [  3.,  -7.,  -6.,  -5.,   1.],
       [  4.,  -7.,  -9., -10.,  -9.]])

1.9 np.rint() 返回四舍五入后的值

np.round()和np.rint()效果一样

np.rint(a)  #返回四舍五入后的值

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

1.10 np.modf() 分隔整数和小数为两个数组

np.modf(a)  #将整数和小数分隔开来形成两个数组

(array([[-0.37006314,  0.29726367,  0.02841508, -0.54948716, -0.81302544],
        [ 0.7255945 , -0.20299337, -0.32965017, -0.31364539,  0.56689175],
        [ 0.59815536, -0.71518921, -0.52824725, -0.80688088, -0.29007315]]),
 array([[-3.,  0.,  9., -7., -0.],
        [ 3., -6., -5., -4.,  1.],
        [ 4., -6., -8., -9., -8.]]))

1.11 np.isnan() 判断是否是nan

np.isnan(a)  #判断是否是nan,是则返回True,否则返回False

array([[False, False, False, False, False],
       [False, False, False, False, False],
       [False, False, False, False, False]])

1.12 np.isinf(a) 判断是否是inf

np.isinf(a)  #判断是否是inf（正无穷大或负无穷大）,是则返回True,否则返回False

array([[False, False, False, False, False],
       [False, False, False, False, False],
       [False, False, False, False, False]])

1.13 三角函数

np.cos，np.cosh，np.sin，np.sinh，np.tan，np.tanh, np.cos(a)

np.cos(a)

array([[-0.97401395,  0.95614155, -0.92247126,  0.29981094,  0.68730399],
       [-0.83426285,  0.99678635,  0.57880393, -0.3882608 ,  0.00390457],
       [-0.11398533,  0.90812856, -0.62432381, -0.92788257, -0.42240002]])

1.14 反三角函数

np.arccos，np.arcsin，np.arctan

np.arctan(a)

array([[ 0.87472609, -1.34684779, -1.43170128, -1.34976448, -1.37477613],
       [-1.45839656,  1.03729772,  1.37706824,  1.43473611, -0.43392493],
       [ 1.4638812 ,  1.47077473,  0.38492786,  1.46820152, -1.4512148 ]])

2.二元函数

函数	描述
np.add	加法运算（即1+1=2），相当于+
np.subtract	减法运算（即3-2=1），相当于-
np.negative	负数运算（即-2），相当于加个负号
np.multiply	乘法运算（即23=6），相当于
np.divide	除法运算（即3/2=1.5），相当于/
np.floor_divide	取整运算，相当于//
np.mod	取余运算，相当于%
greater,greater_equal,less,less_equal,equal,not_equal	>,>=,<,<=,=,!=的函数表达式
logical_and	&的函数表达式
logical_or	\

b = np.random.uniform(-10,10,size=(3,5))   # -10到10平均分布
b

array([[-3.91978838, -4.5279535 ,  0.09589667, -2.69008615, -2.41365434],
       [-9.34599315, -7.20666061, -1.21676534, -8.91590423, -3.11602193],
       [-2.09416103,  3.00660588,  9.64899285, -9.85506794,  6.61143825]])

2.1 np.add()

b+1

array([[-2.91978838, -3.5279535 ,  1.09589667, -1.69008615, -1.41365434],
       [-8.34599315, -6.20666061, -0.21676534, -7.91590423, -2.11602193],
       [-1.09416103,  4.00660588, 10.64899285, -8.85506794,  7.61143825]])

np.add(b,1) # b+1

array([[-2.91978838, -3.5279535 ,  1.09589667, -1.69008615, -1.41365434],
       [-8.34599315, -6.20666061, -0.21676534, -7.91590423, -2.11602193],
       [-1.09416103,  4.00660588, 10.64899285, -8.85506794,  7.61143825]])

np.add(b,np.random.randint(0,5,size=(3,1)))

array([[-1.91978838, -2.5279535 ,  2.09589667, -0.69008615, -0.41365434],
       [-8.34599315, -6.20666061, -0.21676534, -7.91590423, -2.11602193],
       [-0.09416103,  5.00660588, 11.64899285, -7.85506794,  8.61143825]])

2.2 np.greater()

#求大于0的数
b[b>0]

array([0.09589667, 3.00660588, 9.64899285, 6.61143825])

b[np.greater(b,0)]  #求大于0的数

array([0.09589667, 3.00660588, 9.64899285, 6.61143825])

还有。。。。。。

2.3 logical_and 与运算

#与运算
b[(b>0) & (b<5)]

array([0.09589667, 3.00660588])

b[np.logical_and(b>0,b<5)]

array([0.09589667, 3.00660588])

2.4 logical_or 或运算

#或运算
b[(b<-6) | (b>10)]

array([-9.34599315, -7.20666061, -8.91590423, -9.85506794])

b[np.logical_or(b<-6,b>10)]

array([-9.34599315, -7.20666061, -8.91590423, -9.85506794])

2.5 取余np.mod

c= np.random.randint(1,10,size=(2,3))
c

array([[3, 3, 3],
       [6, 9, 4]])

np.mod(c,3) #除以3取余

array([[0, 0, 0],
       [0, 0, 1]], dtype=int32)

2.6 取整np.floor_divide

np.floor_divide(c,2) #除以2取整

array([[1, 1, 1],
       [2, 3, 1]], dtype=int32)

3.聚合函数

函数名称	NAN安全版本	描述
np.sum	np.nansum	计算元素的和
np.prod	np.nanprod	计算元素的积
np.mean	np.nanmean	计算元素的平均值
np.std	np.nanstd	计算元素的标准差
np.var	np.nanvar	计算元素的方差
np.min	np.nanmin	计算元素的最小值
np.max	np.nanmax	计算元素的最大值
np.argmin	np.nanargmin	找出最小值的索引
np.argmax	np.nanargmax	找出最大值的索引
np.median	np.nanmedian	计算元素的中位数

d = np.random.randint(1,10,size=(3,5))   
d

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

3.1 np.sum()

np.sum(d)  #计算元素的和

70

np.nansum(d)  #NAN安全版本,计算元素的和

70

3.2 np.mean()

np.mean(d)  #计算平均值

4.666666666666667

np.nanmean(d) #NAN安全版本,计算平均值

4.666666666666667

3.3 np.sun()和sum()比较

使用np.sum或者是a.sum即可实现。并且在使用的时候，可以指定具体哪个轴。同样Python中也内置了sum函数，但是Python内置的sum函数执行效率没有np.sum那么高，可以通过以下代码测试了解到：

%time sum(np.arange(1000000))

Wall time: 66.8 ms
1783293664

%time np.sum(np.arange(1000000))

Wall time: 2.97 ms
1783293664

。。。。。。

4. 布尔函数np.any() ,np.all()

f = np.arange(0,10)
f

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

#np.any 	验证任何一个元素是否为真
np.any(f)

True

#np.all 	验证所有元素是否为真
np.all(f)

False

想看下数组中是不是所有元素都为0
(f==0).all()

False

(f==0).any()

True

np.all(f==0)

False

np.any(f==0)

True

5. 排序函数

m = np.random.randint(1,10,size=(3,6))
m

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

5.1.np.sort()

#np.sort：指定轴进行排序。默认axis=1是使用数组的最后一个轴进行排序。(按行排序)
np.sort(m)

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

np.sort(m,axis=0)  #指定最外面的轴，按列排序

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

np.sort()和np.sort()区别

#np.sort()不会影响原数组,np.sort()会影响原数组
n = np.sort(m)
print(m)
print("="*20)
print(n)

[[9 2 8 2 7 1]
 [2 6 9 3 7 1]
 [1 7 4 6 6 3]]
====================
[[1 2 2 7 8 9]
 [1 2 3 6 7 9]
 [1 3 4 6 6 7]]

m.sort() #sort()会影响原数组,原数组m已变
m

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

5.2. np.argsort

返回排序后的下标值

n = np.random.randint(0,10,size=(3,5))
n

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

排序后:

np.sort(n)

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

使用npp.argsort()

#np.argsort：返回排序后的下标值。默认axis=1,也是使用最后的一个轴来进行排序（按行排序）
np.argsort(n)

rray([[2, 3, 1, 4, 0],
       [3, 2, 1, 0, 4],
       [0, 2, 1, 3, 4]], dtype=int64)

np.argsort(n,axis=0)  #返回排序后的下标值。指定使用第一个轴来进行排序（按列排序）

array([[2, 3, 1, 4, 0],
       [3, 2, 1, 0, 4],
       [0, 2, 1, 3, 4]], dtype=int64)

降序排序

#降序排序：np.sort默认会采用升序排序。如果我们想采用降序排序。那么可以采用以下方案来实现
p = np.random.randint(0,10,size=(3,5))
p

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

5.2.1 使用负号

## 1. 使用负号
-np.sort(-p)

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

5.2.2 使用sort和argsort以及take

#2. 使用sort和argsort以及take
indexs = np.argsort(-p)  #返回降序的排序下标值
indexs

array([[0, 4, 1, 2, 3],
       [1, 3, 4, 0, 2],
       [3, 2, 1, 4, 0]], dtype=int64)

np.take(p,indexs)

array([[5, 5, 2, 0, 0],
       [2, 0, 5, 5, 0],
       [0, 0, 2, 5, 5]])

5.3. 其他函数

5.3.1 np.apply_along_axis

需求: 求数组a按行求均值，并且要去掉最大值和最小值。

## 求数组a按行求均值，并且要去掉最大值和最小值。
#np.apply_along_axis：沿着某个轴执行指定的函数。
k = np.random.randint(0,100,size=(3,16))
k

array([[12, 13, 60, 46, 78, 29, 70,  1,  9, 62, 40, 68, 41,  1, 26, 29],
       [27, 91, 48, 84,  1, 78, 90, 55, 86, 90,  1, 88, 69, 36, 93, 85],
       [95, 70, 71, 38,  6, 93, 60, 68, 57,  8, 86, 14, 10, 12, 52, 54]])

定义函数:

def get_mean(x):
    y = x[np.logical_and(x!=x.max(),x!=x.min())].mean()  #去除最大最小值再求平均值（axis=1按行求平均值）
    print(y)
    return y
np.apply_along_axis(get_mean,axis=1,arr=k)

38.84615384615385
71.3076923076923
49.5
array([38.84615385, 71.30769231, 49.5       ])

使用匿名函数lambda

#使用匿名函数lambda
np.apply_along_axis(lambda x: x[np.logical_and(x!=x.max(),x!=x.min())].mean(),axis=1,arr=k) #（axis=1按行求平均值）

array([38.84615385, 71.30769231, 49.5       ])

np.apply_along_axis(lambda x: x[np.logical_and(x!=x.max(),x!=x.min())].mean(),axis=0,arr=k) #（axis=0按列求平均值）

array([27., 70., 60., 46.,  6., 78., 70., 55., 57., 62., 40., 68., 41.,
       12., 52., 54.])

5.3.2 np.linspace

#np.linspace：用来将指定区间内的值平均分成多少份
np.linspace(1,10,10)  #将1-10平均分成10份，生成一个数组

array([1.        , 1.88888889, 2.77777778, 3.66666667, 4.55555556,
       5.44444444, 6.33333333, 7.22222222, 8.11111111, 9.        ])

5.3.2

#np.unique：返回数组中的唯一值。
v = np.random.randint(1,5,size=(3,5))
v

array([[4, 3, 2, 3, 4],
       [2, 2, 4, 2, 2],
       [4, 1, 4, 1, 3]])

np.unique(v) #去重,返回出现过的元素值

array([1, 2, 3, 4])

np.unique(v,return_counts=True) #返回数组a中的唯一值，并且会返回每个唯一值出现的次数。

(array([1, 2, 3, 4]), array([2, 5, 3, 5], dtype=int64))

6.random函数

6.1.np.random.seed

#np.random.seed：
#用于指定随机数生成时所用算法开始的整数值，如果使用相同的seed()值，则每次生成的随即数都相同，如果不设置这个值，则系统根据时间来自己选择这个值，
#此时每次生成的随机数因时间差异而不同。一般没有特殊要求不用设置。以下代码：
np.random.seed(1) 
print(np.random.rand()) # 打印0.417022004702574
print(np.random.rand()) # 打印其他的值，因为随机数种子只对下一次随机数的产生会有影响。

0.417022004702574
0.7203244934421581

6.2.np.random.rand

#np.random.rand：
#生成一个值为[0,1)之间的数组，形状由参数指定，如果没有参数，那么将返回一个随机值。示例代码如下：
a1 = np.random.rand()
a2 = np.random.rand(2,1,3)  # 生成2块1行3列的二维数组（1个三维数组），值从0-1之间
a3 = np.random.rand(2,3)   #生成1块2行3列的二维数组，值从0-1
print(a1)
print("="*20)
print(a2)
print("="*20)
print(a3)

0.00011437481734488664
====================
[[[0.30233257 0.14675589 0.09233859]]

 [[0.18626021 0.34556073 0.39676747]]]
====================
[[0.53881673 0.41919451 0.6852195 ]
 [0.20445225 0.87811744 0.02738759]]

6.3.np.random.randn

#np.random.randn：
#生成均值(μ)为0，标准差（σ）为1的标准正态分布的值。示例代码如下：

c = np.random.randn(2,3) #生成一个2行3列的数组，数组中的值都满足标准正太分布
c

array([[-0.85990661,  1.77260763, -1.11036305],
       [ 0.18121427,  0.56434487, -0.56651023]])

6.4.np.random.randint

#np.random.randint：
#生成指定范围内的随机数，并且可以通过size参数指定维度。示例代码如下：

d1 = np.random.randint(10,size=(3,5)) #生成值在0-10之间，3行5列的数组
d2 = np.random.randint(1,20,size=(3,6)) #生成值在1-20之间，3行6列的数组
print(d1)
print("="*20)
print(d2)

[[9 7 6 9 1]
 [0 1 8 8 3]
 [9 8 7 3 6]]
====================
[[18  4  5 18 12 13]
 [17 14 10 19 16  1]
 [ 5 16  3  8  9 10]]

6.5.np.random.choice

#np.random.choice：
#从一个列表或者数组中，随机进行采样。或者是从指定的区间中进行采样，采样个数可以通过参数指定：

data = [4,65,6,3,5,73,23,5,6]
result1 = np.random.choice(data,size=(2,3)) #从data中随机采样，生成2行3列的数组
result2 = np.random.choice(data,3) #从data中随机采样3个数据形成一个一维数组
result3 = np.random.choice(10,3) #从0-10之间随机取3个值
print(result1)
print("="*20)
print(result2)
print("="*20)
print(result3)

[[ 5  4 65]
 [ 6  6  3]]
====================
[65  6  5]
====================
[2 6 0]

6.6.np.random.shuffle

#np.random.shuffle：
#把原来数组的元素的位置打乱,不会返回值。示例代码如下：

f1 = np.arange(10)
print(f1)
f2 = np.random.shuffle(f1) #将a的元素的位置都会进行随机更换，无返回值
print("="*20)
print(f2)  #无返回值None
print("="*20)
print(f1)  #f1顺序和原来的不一样了

[0 1 2 3 4 5 6 7 8 9]
====================
None
====================
[7 3 9 2 1 5 8 0 6 4]