数组运算和广播机制

[TOC]

广播机制

如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，


1、让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
2、输出数组的形状是输入数组形状的各个维度上的最大值。
3、如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
4、当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。

arr = np.array([[1, 2, 3, 2, 1, 4], [5, 6, 1, 2, 3, 1]])
print(arr*2)

#[[ 2  4  6  4  2  8]
# [10 12  2  4  6  2]]

a=np.array([1,2,3])
b=np.array([[1,2,3],[4,5,6]])

c=a+b
print(c)
#[[2 4 6]
# [5 7 9]]

#如果数组的秩不同, 将秩较小的数组进行扩展（复制已有的）， 直到两个数组的尺寸长度都一样

基础运算

size相等的数组之间的算术运算，可以直接进行加减乘除


x1=np.array([[1,2,3],[4,5,6]])
x2=np.array([[7,8,9],[1,1,2]])
print(x1+x2)
#[[ 8 10 12] 
# [ 5  6  8]]


print(x1-x2)
#[[-6 -6 -6]
# [ 3  4  4]]

print(x1*x2)
#[[ 7 16 27]
# [ 4  5 12]]

print(x1/x2)
#[[0.14285714 0.25       0.33333333] 
# [4.         5.         3.        ]]

基本属性

	方法	描述
最值	`ndarray.max(self,axis)`	沿给定轴返回最大值。
	`ndarray.min(self,axis)`	沿给定轴返回最小值。
最值索引	`ndarray.argmax(self,axis)`	返回给定轴上最大值的索引。
	`ndarray.argmin(self,axis)`	返回沿给定轴的最小值的索引。
求和	`ndarray.sum(self,axis)`	返回给定轴上数组元素的和。
求积	`ndarray.prod(self,axis)`	返回数组元素在给定轴上的乘积
极值	`ndarray.ptp(self,axis)`	沿给定轴的峰间（最大-最小）值。
限定范围	`ndarray.clip(min,max)`	返回值限制为的数组 `[min, max]`
四舍五入	`ndarray.round(decimals)`	返回每个元素四舍五入到给定的小数位数。
累和	`ndarray.cumsum(self,axis)`	返回给定轴上元素的累积和。
累积	`ndarray.cumprod(self,axis)`	返回元素沿给定轴的累积积。
对角线和	`ndarray.trace()`	沿数组的对角线返回和。
均值	`ndarray.mean(axis)`	返回沿给定轴的数组元素的平均值。
方差	`ndarray.var(axis)`	返回数组元素沿给定轴的方差。
标准差	`ndarray.std(axis)`	返回数组元素沿给定轴的标准偏差。
布尔值	`ndarray.all(axis)`	如果所有元素的计算结果都为true，则返回true。
布尔值	`ndarray.any(axis)`	如果的任何元素计算为真

x1=np.array([[1,2,3],[4,5,6]])
x2=np.array([[7,8,9],[-1,1,2]])

print(x1[0].sum())   #6   求和
print(x2[1].prod())  #-2  求积
print(x1.argmax())   #5   最大值索引
print(x2.max())      #9   最大值

print(x2.ptp())      #10  极差

#-----------------------------------------------------------------
print(x1.clip(min=2,max=5))   #将元素 限定到[min,max]之中
#[[2 2 3]
# [4 5 5]]

print(x1.cumsum())  #累加，返回数组等长的列表
#[ 1  3  6 10 15 21]
print(x1.cumsum(axis=0))  
#[[1 2 3]
# [5 7 9]]
 
print(x2.cumprod(axis=0))  #累积
#[[ 7  8  9]
# [-7  8 18]]

print(x2.trace())  #对角线和

一元函数

	方法	描述
	`np.abs/fabs(array)`	绝对值
	`np.sqrt()`	平方根
	`np.square()`	平方
	`np.negative()`	取数组中所有元素的负数
	`np.reciprocal()`	取数组中所有元素的倒数
	`np.absolute()`	取数组中所有元素的绝对值
向上取整	`np.ceil()`	向上取整,也就是取比这个数大的整数
向下取数	`np.floor()`	向下取整,也就是取比这个数小的整数
	`np.rint()`	四舍五入
	`np.modf()`	将array中值得整数和小数分离，返回两个数组
	`np.around(a,decimals)`	返回指定数字的四舍五入值

x1=np.arange(-1,10,2)
print(x1)
#array([-1,1,3,5,7,9])

print(np.abs(x1))
#array([1,1,3,5,7,9])

print(np.sqrt(x1))
#array([nan,1 1.73205081 2.23606798 2.64575131 3. ])


print(np.exp(x1))
#[3.67879441e-01 2.71828183e+00 2.00855369e+01 1.48413159e+02 1.09663316e+03 8.10308393e+03]

print(np.log)
#[       nan 0.         1.09861229 1.60943791 1.94591015 2.19722458]

二元函数

	方法	描述
相加	`np.add(arr1,arr2)`	元素级加法
相减	`np.subtract(arr1,arr2)`	元素级减法
乘	`np.multiply(arr1,arr2)`	元素级乘法
相除	`np.divide(arr1,arr2)`	元素级除法 `array1./array2`
指数	`np.power(arr1,arr2)`	元素级指数 `array1.^array2`

最大	`np.fmax/fmin(arr1,arr2)`	元素级最大值，忽略NaN
	`np.mod(arr1,arr2)`	元素级求模
	`np.copysign(arr1,arr2)`	将第二个数组中值得符号复制给第一个数组中值

余数	`np.fmod(x1,x2)`	返回除法的元素余项
	`np.mod(x1,x2)`	取模，和 np.remainder(a,b) 结果相同
	`np.modf(x1)`	返回数组的小数和整数部分
	`np.remainder(x1,x2)`	返回除法余数

x1 = np.arange(9.0).reshape((3, 3))
x2 = np.arange(3.0)

print(np.add(x1, x2))
#array([[  0.,   2.,   4.],
#       [  3.,   5.,   7.],
#       [  6.,   8.,  10.]])

print(x1+x2)
#array([[ 0.,  2.,  4.],
#       [ 3.,  5.,  7.],
#       [ 6.,  8., 10.]])
#---------------------------------------------------


a1=array([3, 7, 8, 0, 0])
a2=array([1, 8, 6, 4, 4])
print(np.reciprocal(a1))   # 倒数后取 整 为0
#array([0, 0, 0, , ])   
print(np.negative(a1))
#array([-3, -7, -8,  0,  0])

print(np.multiply(a1, a2))
#array([ 3, 56, 48,  0,  0])

print( np.divide(a1, a2))   #相除取整
#array([3, 0, 1, 0, 0])

print(np.subtract(a1, a2))  #相减取整
#array([ 2, -1,  2, -4, -4]) 
#----------------------------------------------

print(np.modf(a1))   #返回小数和余数
#(array([ 0.,  0.,  0.,  0.,  0.]), array([ 3.,  7.,  8.,  0.,  0.]))

数值修约

	方法	描述
	`np.around(arr,decimals)`	将数组元素平均舍入到给定的小数位数
	`np.rint()`	修约到最接近的整数
	`np.fix()`	向 0 舍入到最接近的整数
	`np.floor()`	返回不大于输入参数的最大整数，向下取整
	`np.ceil()`	返回输入值的上限，向上取整
	`np.trunc()`	返回输入的截断值

a = np.array([1.0,5.55, 123, 0.567, 25.532]) 
print (np.around(a)) 
print (np.around(a, decimals = 1)) 
#[   1.    6.   123.    1.   26. ]                                             
#[   1.    5.6  123.    0.6  25.5] 

#-----------------------------------------------
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print (np.floor(a))   #[-2.  1. -1.  0. 10.]
print (np.ceil(a))    #[-1.  2. -0.  1. 10.]

四舍五入和取整

import numpy as np

a = np.array([1.0,5.55,  123,  0.567,  25.532])  
print (a)

print (np.around(a))
print (np.around(a, decimals =  1))
print (np.around(a, decimals =  -1))

[ 1.      5.55  123.     0.567  25.532]
[ 1.    6. 123.  1.  26.]
[ 1.     5.6 123.  0.6  25.5]
[ 0.    10. 120.  0.  30.]

numpy.floor() 返回小于或者等于指定表达式的最大整数，即向下取整。

import numpy as np

a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])
print ('提供的数组：')
print (a)
print (np.floor(a))

[-1.7 1.5 -0.2 0.6 10.]
[-2. 1. -1. 0. 10.]

numpy.ceil() 返回大于或者等于指定表达式的最小整数，即向上取整。

import numpy as np

a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  

print (a)

print (np.ceil(a))

[-1.7 1.5 -0.2 0.6 10.]
[-1. 2. -0. 1. 10.]

求和、求积、差分

	方法	描述
	`np.prod(a, axis)`	返回指定轴上的数组元素的乘积
	`np.sum(a, axis)`	返回指定轴上的数组元素的总和
	`np.nanprod(a, axis)`	返回指定轴上的数组元素的乘积, 将 NaN 视作 1
	`np.nansum(a,axis)`	返回指定轴上的数组元素的总和, 将 NaN 视作 0
	`np.cumprod(a,axis)`	返回沿给定轴的元素的累积乘积
	`np.cumsum(a,axis)`	返回沿给定轴的元素的累积总和
	`np.nancumprod(a,axis)`	返回沿给定轴的元素的累积乘积, 将 NaN 视作 1
	`np.nancumsum(a,axis)`	返回沿给定轴的元素的累积总和, 将 NaN 视作 0

	`np.diff(a,n,axis)`	计算沿指定轴的第 n 个离散差分
	`np.ediff1d(ary, to_end, to_begin)`	数组的连续元素之间的差异
	`np.gradient(f)`	返回 N 维数组的梯度
	`np.cross((a, b, axisa, axisb, axisc, axis)`	返回两个(数组）向量的叉积
	`np.trapz(y, x, dx,)`	使用复合梯形规则沿给定轴积分

import numpy as np

a = np.arange(5)
print(a)
# [[0 1 2 3 4]
#  [5 6 7 8 9]]

print(np.prod(a))  # 所有元素乘积
# 0

print(np.sum(a))  # 所有元素和
# 45

print(np.nanprod(a))  # 默认轴上所有元素乘积
# 0

print(np.nansum(a))  # 默认轴上所有元素和
# 45 

print(np.cumprod(a))  # 默认轴上元素的累积乘积。
# [0 0 0 0 0 0 0 0 0 0]
print(np.diff(a))  # 默认轴上元素差分。
# [[1 1 1 1]
#  [1 1 1 1]]

指数和对数

	`np.exp(x)`	计算输入数组中所有元素的指数
	`np.expm1(x)`	对数组中的所有元素计算 exp(x） - 1
	`np.exp2(x)`	对于输入数组中的所有 p, 计算 2 ** p
	`np.log(x)`	计算自然对数
	`np.log10(x)`	计算常用对数
	`np.log2(x)`	计算二进制对数
	`np.log1p(x)`	log(1 + x)

矩阵和向量积


	`np.dot(a,b)`	求解两个数组的点积
	`np.vdot(a,b)`	求解两个向量的点积
	`np.inner(a,b)`	求解两个数组的内积
	`np.outer(a,b)`	求解两个向量的外积
	`np.matmul(a,b)`	求解两个数组的矩阵乘积
	`np.tensordot(a,b)`	求解张量点积
	`np.kron(a,b)`	计算 `Kronecker` 乘积

numpy-4数组运算

数组运算和广播机制

广播机制

基础运算

基本属性

一元函数

二元函数

数值修约

四舍五入和取整

求和、求积、差分

指数和对数

矩阵和向量积