数据分析学习笔记(三)--numpy:内置函数(通用函数、数学与统计方法、集合)

通用函数

通用函数(ufunc)是一种对ndarray中对数据执行元素级运算的函数

# 例子数组
a = np.array([-1,2.1,0.2,2.6,9.1])  # [-1.   2.1  0.2  2.6  9.1]
b = np.arange(1,len(a)+1)           # [1 2 3 4 5]
  • 一元函数
函数 说明 例子 结果
abs、fabs 计算整数、浮点数和复数对绝对值,对于非复数值,可以使用更快对fabs np.abs(a) [1. 2.1 0.2 2.6 9.1]
sqrt 计算各元素的平方根,相当于 arr**0.5 np.sqrt(b)
square 计算各元素的平方,相当于 arr**2 np.square(b) [ 1 4 9 16 25 36 49 64 81]
exp 计算各元素的指数 e(x)
log、log10、log2、log1p 分别为自然对数(底数为e)、底数为10的log、底数为2的log、log(1+x)
sign 计算各元素的符号 ,1(正数)、0(零)、-1(负数) np.sign(a) [-1. 1. 1. 1. 1.]
ceil 向上取整 np.ceil(a) [-1. 3. 1. 3. 10.]
floor 向下取整 np.floor(a) [-1. 2. 0. 2. 9.]
rint 四舍五入,保留dtype np.rint(a) [-1. 2. 0. 3. 9.]
modf 将元素的小数和整数部分以两个独立的数组形式返回 np.modf(a) (array([-0. , 0.1, 0.2, 0.6, 0.1]), array([-1., 2., 0., 2., 9.]))
nonzero 将所有非零元素的行与列坐标分割开,重构成两个分别关于行和列的矩阵 np.nonzero(a) (array([0, 1, 2, 3, 4]),)
clip 切除元素 np.clip(a, 0, 5) 等同于 a.clip(0,5) [0. 2.1 0.2 2.6 5. ]
isnan 返回一个布尔数组,True位置的元素为NaN值
isfinite、isinf 返回一个布尔数组,True位置的元素为有穷的或者是无穷的
cos、conh、sin、sinh、tan、tanh 普通型和双曲型三角函数
arccos、arccosh、arcsin、arcsinh、arctan、arctanh 反三角函数
logical_not 计算各元素not x的真值,相当于 -arr
  • 二元函数
函数 说明 例子 结果
add 相加 np.add(a,b) 等同于 a+b [ 0. 4.1 3.2 6.6 14.1]
subtract 第一个数组减第二个数组 np.subtract(a,b) 等同于 a-b [-2. 0.1 -2.8 -1.4 4.1]
multiply 相乘 np.multiply(a,b) 等同于 a*b [-1. 4.2 0.6 10.4 45.5]
divide、floor_divide 除法或做完除法后向下取整 np.divide(a,b) 等同于 a/b;np.floor_divide(a,b) 等同于 np.floor(a/b)
power pow(a,b),a的b次方 np.power(a,b)
maximum、fmax 元素中最大值,fmax会忽略NaN np.maximum(a,b) 、np.fmax(a,b)
minimum、fmin 元素中最小值,fmin会忽略NaN
mod 求模 np.mod(a,b)
copysign 将第二个数组中的值的符号复制给第一个数组中的值 np.copysign(b,a) [-1. 2. 3. 4. 5.]
greater、greater_equal、less、less_equal、equal、not_equal >、>=、<、<=、=、!=
logical_and、logical_or、logical_xor 元素级的真值逻辑运算,相当于中缀运算符&、|、^

数学与统计方法

函数 说明 例子 结果
sum 对数组中全部或者某轴方向的元素求和 np.sum(a) 或 a.sum() 13.0
mean 算术平均数,零长度的数组的mean为NaN np.mean(a) 或 a.mean() 2.6
average 加权平均,权重相同时,也可看作时算术平均 np.average(a) 2.6
median 中位数,一组有序数列的中间数,偶数时,取平均 np.median(a) 2.1
std、var 分别求标准差和方差,自由度可调(默认为n) a.std()、a.var() 3.4991427521608776、12.244
min、max 最小值和最大值
argmin、argmax 分别为最小元素和最大元素的索引 a.argmin()、a.argmax() 0、 4
diff diff(a, n=1, axis=-1),后一个与前一个的差值,参数n表示进行n轮运算,多维数组中,可通过axis控制方向 np.diff(a) [ 3.1 -1.9 2.4 6.5]
cumsum 所有元素和累计和(数组) a.cumsum() [-1. 1.1 1.3 3.9 13. ]
cumprod 所有元素的累计积(数组) np.cumprod() [-1. -2.1 -0.42 -1.092 -9.9372]

注:
上述例子是一维数组,如果是二维数组调用方法类似,不过可以使用参数 axis 指定方向,1为横向,0为竖向

arr = np.arange(24).reshape(4,6)
'''
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
 '''
# 求和
arr.sum()           # 276   总和
arr.sum(axis=0)     #  [36 40 44 48 52 56]
# 算术平均数
arr.mean()          # 11.5      总数的算术平均数
arr.mean(axis=1)    # [ 2.5  8.5 14.5 20.5] 竖向的算术平均数

关于加权平均数 : average函数

arr = np.arange(10).reshape(2,5)
'''
[[0 1 2 3 4]
 [5 6 7 8 9]]
 '''
arr.mean()          # 4.5 算术平均数 
np.average(arr)     # 4.5 可看作是算术平均数
np.average(arr, axis=1) # [2. 7.],给出了方向
np.average(arr, weights=np.arange(arr1.size).reshape(2,5))  # 传入了权重 6.333333333333333

集合

# 例子数组
s0 = np.array([1,2,3,2,1,4,5,2])    # [1 2 3 2 1 4 5 2]
s1 = np.arange(0,30,2)  # [ 0  2  4  6  8 10 12 14 16 18 20 22 24 26 28]
s2 = np.arange(0,30,3)  # [ 0  3  6  9 12 15 18 21 24 27]
函数 说明 例子 结果
unique(x) 计算x中唯一元素,并返回有序的结果 np.unique(s0) [1 2 3 4 5]
intersect1d(x,y) 交集,并返回有序结果 np.intersect1d(s1,s2) [ 0 6 12 18 24]
union1d(x,y) 并集,并返回有序结果 np.union1d(s1,s2) [ 0 2 3 4 6 8 9 10 12 14 15 16 18 20 21 22 24 26 27 28]
setdiff1d(x,y) 集合差,即元素在x中且不再y中 np.setdiff1d(s1,s2) [ 2 4 8 10 14 16 20 22 26 28]
setxor1d(x,y) 集合对称差,只存在x和y中的元素集合 np.setxor1d(s1,s2) [ 2 3 4 8 9 10 14 15 16 20 21 22 26 27 28]
in1d(x,y) 得到一个”x的元素是否包含于y”的布尔行数组 np.in1d(s2,s1) [ True False True False True False True False True False]

注:数组1和数组2的元素数量及shape都可以不同
上述例子中的s1和s2虽然都是一维的,但是数量并不相同;为了验证集合操作无关shape,我们将s1和s2的shape做一下改变

s1 = s1.reshape(3,5)
'''
[[ 0  2  4  6  8]
 [10 12 14 16 18]
 [20 22 24 26 28]]
 '''
s2 = s2.reshape(2,5)
'''
[[ 0  3  6  9 12]
 [15 18 21 24 27]]
 '''
np.intersect1d(s1,s2)   # [15 18 21 24 27]]
np.union1d(s1,s2)       # [ 0  2  3  4  6  8  9 10 12 14 15 16 18 20 21 22 24 26 27 28]
np.setdiff1d(s2,s1)     # [ 3  9 15 21 27]

补充(where、sort、any、all)

  • where

    where函数是一个三目运算符,where(condition, x, y),
    完成类似下面的工作

ifcondition):
  x
else:
  y

例子1:有xarr和yarr两个数组,需要根据condition选择数据

xarr = np.array(np.arange(1.1, 1.6, 0.1))
yarr = np.array(np.arange(2.1, 2.6, 0.1))
cond = np.array([True, False, True, True, False])

在python语法中:

result = [x if c else y for x, y, c in zip(xarr, yarr, cond)]
输出:
[1.1, 2.2, 1.3000000000000003, 1.4000000000000004, 2.5000000000000004]
非常不方便,而且出现了数据异常问题

在numpy中使用where函数:

result = np.where(cond, xarr, yarr)
输出:
[1.1 2.2 1.3 1.4 2.5]

例子2:将arr数组中小于0的部分重制为0,其余部分保留

arr = np.random.randn(4,4)  
输出:
[[ 0.40336609 -1.42094364 -1.1257582   0.2787659 ]
 [-0.64618146 -0.56508989  0.20527747  1.8542685 ]
 [-0.39792887  0.94738928 -0.68713023  0.60328758]
 [-0.94495984 -1.47217366  0.03280616 -0.13120201]]
arr = np.where(arr>0, arr, 0)
输出:
[[0.40336609 0.         0.         0.2787659 ]
 [0.         0.         0.20527747 1.8542685 ]
 [0.         0.94738928 0.         0.60328758]
 [0.         0.         0.03280616 0.        ]]

例子3:复杂嵌套的情况

cond1 = np.array([True, False, True, True, False])
cond2 = np.array([True, True, True, False, False])
result = []

python语法:

for i in range(len(cond1)):
    if cond1[i] and cond2[i]:
        result.append(0)
    elif cond1[i]:
        result.append(1)
    elif cond2[i]:
        result.append(2)
    else:
        result.append(3)
print(result)           # [0, 2, 0, 1, 3]

在numpy中使用where函数:

result = np.where(cond1&cond2, 0 ,
             np.where(cond1, 1,
                  np.where(cond2, 2, 3)))
list(result)     # [0, 2, 0, 1, 3]

注:where函数可以只传条件,返回条件对象的真值下标数组

arr = np.random.randn(10)
np.where(arr>0)      # (array([1, 2, 3, 6, 9]),)

如果是多维数组,返回也是数组,分别返回纬度数组索引

cond1 = np.array([True, False, True, True, False])
cond2 = np.array([True, True, True, False, False])
arr = np.array([cond1,cond2])
np.where(arr)
# (array([0, 0, 0, 1, 1, 1]), array([0, 2, 3, 0, 1, 2]))
# 即 [(0,0),(0,2),(0,3),(1,0),(1,1),(1,2)]位置
  • sort 排序
# 多维数组,可指定方向
arr = np.random.randn(20).reshape(4,5)
'''
[[-0.94603557 -0.18393318  0.11450866  0.40325255  0.45881851]
 [ 1.17704035 -0.41401001  0.75339636 -0.43745415  2.7929479 ]
 [-0.28784153 -1.48745643 -0.07142102 -0.5482369  -0.22610164]
 [ 1.35561729 -1.08766432  0.83278514 -1.32299757  0.04410116]]
 '''
np.sort(arr, axis=0)     # 竖向排序(默认为横向排序)
'''
[[-0.94603557 -1.48745643 -0.07142102 -1.32299757 -0.22610164]
 [-0.28784153 -1.08766432  0.11450866 -0.5482369   0.04410116]
 [ 1.17704035 -0.41401001  0.75339636 -0.43745415  0.45881851]
 [ 1.35561729 -0.18393318  0.83278514  0.40325255  2.7929479 ]]
 '''
 # 一维数组
arr = np.array([2,6,4,2,1,4])
arr.sort()      # 这种方式排序会直接改变「原」数组,使用np.sort()方式则将产生新的排序后的数组,而不改变原数组
print(arr)      # [2 6 4 2 1 4]

例子:我想知道一组数据的25%分位数是多少?

# 产生一组数据
arr = np.random.randn(20).reshape(4,5)
# 1.我们先将其转化为一维数组,并进行排序处理
arr = arr.flatten()
# 排序
arr.sort()
# 获取25%下标数据
value = arr[int(0.25*len(arr))] # 获取25%分位数
print(arr)
'''
[-1.8819284  -1.84223613 -1.55037549 -1.19713841 -0.91661269 -0.69222229
 -0.6796624  -0.65882803 -0.55325753 -0.34502426 -0.1197655   0.36925446
  0.5343373   0.62780224  0.74335279  0.82012463  1.00546263  1.08559715
  1.29212188  1.47629451]
  '''
print(value)    # -0.69222229
  • all、any

    all:是否都是 True , 如果都是返回 True 否则 False
    any: 是否存在 True , 如果存在 True 返回 True 否则 False

arr = np.array([True,False,True,True,False])
arr.all()    # False
arr.any()    # True

布尔型数组的统计方法

arr = np.random.randn(100)
(arr>0).sum()      # 统计正值的总数 

你可能感兴趣的:(Python,数据分析)