NumPy基础：通用函数-快速的元素级数组函数

通用函数

• 一元ufunc
  • abs、fabs：计算整数、浮点数或复数的绝对值。对于非复数值，可以使用更快的fabs
  • sqrt：计算各元素的平方根。相当于arr**0.5
  • square：计算各元素的平方。相当于arr**2
  • exp：计算各元素的指数
  • log、log10、log2、log1p：分别对自然对数（底数为e）、底数为10,2的log，log(1+x)
  • sign：计算各元素的正负号，1（正数）、0（零）、-1（复数）
  • ceil：计算各元素的ceiling值，即向上取整
  • floor：计算各元素的floor值，即向下取整
  • rint：将各元素四舍五入到最接近的整数
  • modf：将数组的小数和整数部分以两个独立数组返回
  • isnan：返回一个表示“哪个值是NaN”的布尔型数组
  • isfinte、isinf：分别返回一个表示“哪个元素是有穷的（非inf，非NaN）”或“哪些元素是无穷的”的布尔型数组
  • cos、cosh、sin、sinh、tan、tanh：普通型和双曲型三角函数
  • arccos、arccosh、arcsin、arcsinh、arctan、arctanh：反三角函数
  • logical_not：计算个元素not x 的真值。相当于-arr
• 二元ufunc
  • add：将数组中对应的元素想加
  • subtract：从第一个数组中减去第二个数组中的元素
  • multiply：数组元素相乘
  • divide、floor_divide：除法或下圆整除法（丢弃余数）
  • power：对于第一个数组中的元素A，根据第二个数组中的元素B，计算A的B次方
  • maximum、fmax：元素级最大值计算。fmax忽略NaN
  • minimum、fmin：元素级最小值计算。fmin忽略NaN
  • mod：元素级求模计算（除法的余数）
  • copysign：将第二个数组中的值的符号复制给第一个数组中的值
  • greater、greater_equal、less、less_equal、equal、not_equal：元素级比较运算，最终产生布尔型数组。相当于>、>=、<、<=、==、！=
  • logical_and、logical_or、logical_xor：元素级的真值逻辑运算。相当于运算符&、|、^

import numpy as np

# abs、fabs:计算整数、浮点数或复数的绝对值。对于非复数值，可以使用更快的fabs
arr_abs = np.array([1,2,-3,4,-5.98])
print(np.abs(arr_abs)) # [1.   2.   3.   4.   5.98]
print(np.fabs(arr_abs)) # [1.   2.   3.   4.   5.98]

# sqrt:计算各元素的平方根。相当于arr**0.5
arr_sqrt = np.array([1,4,9,16,25])
print(np.sqrt(arr_sqrt)) # [1. 2. 3. 4. 5.]

# square:计算各元素的平方。相当于arr**2
arr_square = np.array([1,2,3,4,5])
print(np.square(arr_square)) # [ 1  4  9 16 25]

# sign：计算各元素的正负号，1（正数）、0（零）、-1（复数）
arr_sign = np.array([-2,-1,0,1,2])
print(np.sign(arr_sign)) # [-1 -1  0  1  1]

# ceil:计算各元素的ceiling值，即向上取整
arr_ceil = np.array([1.2,2.5,3.6,4.1,5.9])
print(np.ceil(arr_ceil)) # [2. 3. 4. 5. 6.]

# floor:计算各元素的floor值，即向下取整
arr_floor = np.array([1.2,2.5,3.6,4.1,5.9])
print(np.floor(arr_floor)) # [1. 2. 3. 4. 5.]

# rint:将各元素四舍五入到最接近的整数
arr_rint = np.array([1.2,2.5,2.51,3.6,4.1,5.9])
print(np.rint(arr_rint)) # [1. 2. 3. 4. 4. 6.]

# modf：将数组的小数和整数部分以两个独立数组返回
arr_modf = np.array([1.2,2.5,2.51])
print(np.modf(arr_modf)) # (array([0.2 , 0.5 , 0.51]), array([1., 2., 2.]))

# isnan：返回一个表示“哪个值是NaN”的布尔型数组
arr_isnan = np.array([1,2,3,4,5])
print(np.isnan(arr_isnan)) # [False False False False False]

利用数组进行数据处理

import numpy as np
import matplotlib.pyplot as plt


# 用数组表达式代替循环的做法，通常被称为矢量化
points = np.arange(-5,5,0.01) # 1000个间隔相等的点
xs,ys = np.meshgrid(points,points)

z = np.sqrt(xs**2+ys**2)
plt.imshow(z)
plt.colorbar()
plt.title("Image plot of $sqrt{x^2+y^2}$ for a grid of values")
plt.show()

 

将条件逻辑表述为数组运算

import numpy as np

# numpy.where函数是 x if condition else y的矢量化版本。
from numpy.matlib import randn

xarr = np.array([1.1,1.2,1.3,1.4,1.5])
yarr = np.array([2.1,2.2,2.3,2.4,2.5])
cond = np.array([True,False,True,True,False])

# 当cond为True时，选择xarr，否则选择yarr
result = []
for x,y,c in zip(xarr,yarr,cond):
    if c:
        result.append(x)
    else:
        result.append(y)
print(result) # [1.1, 2.2, 1.3, 1.4, 2.5]

result = [(x if c else y) for x,y,c in zip(xarr,yarr,cond)]
print(result) # [1.1, 2.2, 1.3, 1.4, 2.5]

# 换成np.where写法
result = np.where(cond,xarr,yarr)
print(result) # [1.1 2.2 1.3 1.4 2.5]

# 生成一个随机数组
arr = randn(4,4)
print(arr)
'''
[[-1.16508783  0.18874028  1.0206809   0.76529663]
 [ 1.54512481 -1.36804933 -1.80001501 -0.88638478]
 [-2.1297874   0.28795926 -1.30068181  1.8016327 ]
 [-1.34510486  0.60960465 -0.42626585 -0.6275682 ]]
'''
# 将正值替换为2，负值替换为-2
print(np.where(arr>0,2,-2))
'''
[[-2  2  2  2]
 [ 2 -2 -2 -2]
 [-2  2 -2  2]
 [-2  2 -2 -2]]
'''
# 将正值替换为2，负值不变
print(np.where(arr>0,2,arr))
'''
[[-1.16508783  2.          2.          2.        ]
 [ 2.         -1.36804933 -1.80001501 -0.88638478]
 [-2.1297874   2.         -1.30068181  2.        ]
 [-1.34510486  2.         -0.42626585 -0.6275682 ]]
'''

# 接下来有点费脑子
'''
result = []
for i in range[n]:
    if cond1[i] and cond2[]:
        result.append(0)
    elif cond1[i]:
        result.append(1)
    elif cond2[2]:
        result.append(2)
    else:
        result.append(3)

# 可以改写成一个嵌套where
np.where(cond1 & cond2,0,
         np.where(cond1,1,
                  np.where(cond2,2,3)))
'''

数学和统计方法

• 基本数组统计方法
  • sum：对数组中全部或某轴向的元素求和。零长度的数组sum为0
  • mean：算术平均数。零长度的数组mean为NaN
  • std、var：标准差和方差，自由度可调（默认为n）
  • min、max：最大值和最小值
  • argmin、argmax：最小和最大元素的索引
  • cumsum：所有元素的累计和
  • cumpord：所有元素的累计积

import numpy as np

arr = np.array([[1,2,3,4],[4,5,6,7],[7,8,9,10]])
print(arr)
'''
[[ 1  2  3  4]
 [ 4  5  6  7]
 [ 7  8  9 10]]
'''
print(arr.mean()) # 5.5
print(np.mean(arr)) # 5.5
print(arr.mean(axis=1)) # [2.5 5.5 8.5], 2.5=(1+2+3+4)/4
print(arr.sum()) # 66
print(arr.sum(0)) #[12 15 18 21]

用于布尔数组的方法

import numpy as np
from numpy.matlib import randn

arr = randn(100)
print((arr>0).sum()) #正数的个数


bools = np.array([False,True,True,False,False])
# any检查是否存在一个或者多个True
print(bools.any()) # True
# all检查是否都是True
print(bools.all()) # False 

排序

import numpy as np

arr = np.array([4,3,6,1,2,9])
arr.sort()
print(arr) # [1 2 3 4 6 9]

arr_2d = np.array([[4,3,6,1,2,9],[4,7,4,5,6,7],[10,4,2,5,3,9]])
arr_2d.sort()
print(arr_2d)
'''
[[ 1  2  3  4  6  9]
 [ 4  4  5  6  7  7]
 [ 2  3  4  5  9 10]]

'''
# 多维数组可以在任何一个轴向上进行排序，只需要将编号传给sort即可
arr_2d2 = np.array([[5,4,3,2,1],[4,3,2,1,0],[9,8,7,6,5],[1,1,1,5,2]])
arr_2d2.sort(0)
print(arr_2d2)
'''
[[1 1 1 1 0]
 [4 3 2 2 1]
 [5 4 3 5 2]
 [9 8 7 6 5]]
'''

唯一化以及其他的集合逻辑

•  数组的集合运算
  • unique(x)：计算x中的唯一元素
  • intersect1d(x,y)：计算x和y中的公共元素
  • union1d(x,y)：计算x和y的并集
  • in1d(x,y)：得到一个表示“x元素是否包含于y”的布尔型数组
  • setdiff1d(x,y)：集合的差，x元素不在y中
  • setxor1d(x,y)：集合的对称差，即存在于一个数组中但是不同时存在于两个数组中的元素

import numpy as np

names = np.array(['Bob','Joe','Will','Bob','Will','Joe','Joe'])
print(sorted(set(names))) # 去重 ['Bob' 'Joe' 'Will']
print(np.unique(names)) # 去重 ['Bob' 'Joe' 'Will']

arr1 = np.array([1,2,3])
arr2 = np.array([2,3,4])
# unique(x)：计算x中的唯一元素
print(np.union1d(arr1,arr2)) # [1 2 3 4]
# intersect1d(x,y)：计算x和y中的公共元素
print(np.intersect1d(arr1,arr2)) # [2 3]
# in1d(x,y)：得到一个表示“x元素是否包含于y”的布尔型数组
print(np.in1d(arr1,arr2)) # [False  True  True]
# setdiff1d(x,y)：集合的差，x元素不在y中
print(np.setdiff1d(arr1,arr2)) # [1]
# setxor1d(x,y)：集合的对称差，即存在于一个数组中但是不同时存在于两个数组中的元素
print(np.setxor1d(arr1,arr2)) # [1 4]