NumPy - 语法基础 Pt.1

发表于 更新于 分类于

这篇随笔主要介绍 NumPy 的数据类型和函数使用，包括 NumPy 数组的创建、索引和运算，常用的一元函数和二元函数，统计计算，线性代数计算，数组比较，随机数组的生成以及 NumPy 数组的读取与写出

1
import numpy as np

Why Numpy ?

基于 NumPy 比纯 Python 处理的速度更快, 占用的内存更少

1
2
3
4
my_arr = np.arange(1000000)
my_list = list(range(1000000))
%time my_arr2 = my_arr ** 2
%time my_list2 = [x ** 2 for x in my_list]
Wall time: 2.99 ms
Wall time: 339 ms

ndarray 的创建及属性

ndarray 是一种多维数组对象

1
2
data = np.random.randn(2,3)  # 随机生成一个2x3的服从正态分布的随机矩阵
data, data * 10, data + data # 所有元素都x10，所有元素各自相加
(array([[ 0.61755716,  0.27939505, -0.13490957],
        [ 0.8987287 , -0.50354707,  0.92604458]]),
 array([[ 6.17557158,  2.79395053, -1.34909571],
        [ 8.987287  , -5.03547071,  9.26044575]]),
 array([[ 1.23511432,  0.55879011, -0.26981914],
        [ 1.7974574 , -1.00709414,  1.85208915]]))

每个 ndarray 数组都有一个 shape 和一个 dtype 属性

shape : 表示各维度大小的元组
dtype : 用于说明数组数据类型的对象
ndim : 用于说明数组的维数

1
data.shape, data.dtype, data.ndim
((2, 3), dtype('float64'), 2)

np.array(object), np.asarray(object)

1
2
3
4
5
data1 = [6, .5, 8]
data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]
arr1 = np.array(data1)
arr2 = np.array(data2)
(arr1, arr1.ndim, arr1.shape), (arr2, arr2.ndim, arr2.shape)
((array([6. , 0.5, 8. ]), 1, (3,)),
 (array([[1, 2, 3, 4],
         [5, 6, 7, 8]]), 2, (2, 4)))

np.array(object), np.asarray(object) 的区别

数据源非 ndarray 时: 两者都开辟新的内存复制数据
数据源为 ndarray 时: array 占用新内存就行复制, asarray 不进行复制直接引用源内存

1
2
3
4
5
data = [1,2,3]
arr1 = np.array(data)
arr2 = np.asarray(data)
data[1] = 4
arr1, arr2
(array([1, 2, 3]), array([1, 2, 3]))
1
2
3
4
5
data = np.zeros(3)
arr1 = np.array(data)
arr2 = np.asarray(data)
data[1] = 999
data, arr1, arr2
(array([  0., 999.,   0.]), array([0., 0., 0.]), array([  0., 999.,   0.]))

np.ones(shape), np.zeros(shape), np.empty(shape), np.full(shape, fill_value)

np.empty: 给变量分配一个没有任何值的数组空间，可以定义这个空间的shape

1
2
3
4
5
6
shape = (3, 3)
arr0 = np.zeros(shape = shape)
arr1 = np.ones(shape = shape)
arre = np.empty(shape = shape)
arrf = np.full(shape = shape, fill_value= 999)
arr0, arr1, arre, arrf
(array([[0., 0., 0.],
        [0., 0., 0.],
        [0., 0., 0.]]),
 array([[1., 1., 1.],
        [1., 1., 1.],
        [1., 1., 1.]]),
 array([[0.00000000e+000, 0.00000000e+000, 0.00000000e+000],
        [0.00000000e+000, 0.00000000e+000, 6.58095440e-321],
        [6.23058028e-307, 1.69115935e-306, 1.89142822e-307]]),
 array([[999, 999, 999],
        [999, 999, 999],
        [999, 999, 999]]))

np.ones_like(arr), np.zeros_like(arr), np.empty_like(arr), np.full_like(arr, fill_value)

1
2
3
4
data = [[1,2,3], [4,5,6], [7,8,9]]
arr1 = np.ones_like(data)
arrf = np.full_like(data, fill_value=999)
arr1, arrf
(array([[1, 1, 1],
        [1, 1, 1],
        [1, 1, 1]]),
 array([[999, 999, 999],
        [999, 999, 999],
        [999, 999, 999]]))

np.eye(N), np.identity(N)

1
2
3
arre = np.eye(3)
arri = np.identity(3)
arre, arri, arre == arri
(array([[1., 0., 0.],
        [0., 1., 0.],
        [0., 0., 1.]]),
 array([[1., 0., 0.],
        [0., 1., 0.],
        [0., 0., 1.]]),
 array([[ True,  True,  True],
        [ True,  True,  True],
        [ True,  True,  True]]))

np.arange(start, stop, step)

1
2
3
start, stop, step = 1, 10, 2
arrr = np.arange(start = start, stop = stop, step = step)
arrr
array([1, 3, 5, 7, 9])

np.random.randn(d0, d1, d2, ...)

1
np.random.randn(2,3,4)
array([[[ 1.86999   ,  0.0390554 , -0.50994802, -1.78571159],
        [-1.16586811, -1.80043925,  0.12937635, -0.51073928],
        [ 0.90820582,  0.16733293,  1.37816101, -1.99030047]],

       [[-0.37128402,  1.01049711,  1.16644033, -0.42575843],
        [ 1.04713973,  0.30232925,  1.05983582,  1.48025048],
        [ 0.65822568,  1.00390684,  1.51106941,  1.22224557]]])

ndarray 的数据类型

np.array(object, dtype), arr.astype(dtype)

1
2
3
arr1 = np.array([1, 2, 3], dtype=np.float64)
arr2 = np.array([1, 2, 3], dtype=np.int32)
arr1.dtype, arr2.dtype
(dtype('float64'), dtype('int32'))
1
2
3
arr = np.array([1, 2, 3, 4, 5])
float_arr = arr.astype(np.float64)
arr.dtype, float_arr.dtype
(dtype('int32'), dtype('float64'))
类型类型代码说明
int8, uint8i1, u1有符号和无符号的8位（1个字节）整型
int16, uint16i2, u2有符号和无符号的16位（2个字节）整型
int32, uint32i4, u4有符号和无符号的32位（4个字节）整型
int64, uint64i8, u8有符号和无符号的64位（8个字节）整型
float16f2半精度浮点数
float32f4 or f单精度浮点数
float64f8 or d双精度浮点数
float128f16 or g扩展精度浮点数
complex64, complex128, complex256c8, c16, c32分别用两个32位、64位和128位浮点数表示的复数
bool?存储 True 和 False 值得布尔类型
objecOPython 的对象类型
string_S固定长度的字符串类型
unicode_U固定长度的 unicode 类型

类型转换

float → int : 截断取整

1
2
arr = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])
arr, arr.astype(np.int32) #截断取整
(array([ 3.7, -1.2, -2.6,  0.5, 12.9, 10.1]), array([ 3, -1, -2,  0, 12, 10]))

string_ → float : 截取

NumPy 的字符串数据是大小固定的，使用 np.string* 类型时会发生截取

1
2
numeric_strings = np.array(['1.2555555555', '-9.6', '42'], dtype=np.string_)
numeric_strings.astype(float), numeric_strings.dtype
(array([ 1.25555556, -9.6       , 42.        ]), dtype('S12'))

ndarray 的运算

arr1+arr2, arr1-arr2, arr1arr2, arr1/arr2*

矢量化运算：大小相等的数组之间的任何算术运算都会将运算应用到元素级

1
2
arr = np.array([[1., 2., 3.], [4., 5., 6.]])
arr, arr * arr, arr - arr,  arr / arr
(array([[1., 2., 3.],
        [4., 5., 6.]]),
 array([[ 1.,  4.,  9.],
        [16., 25., 36.]]),
 array([[0., 0., 0.],
        [0., 0., 0.]]),
 array([[1., 1., 1.],
        [1., 1., 1.]]))

arr+num, arr-num, arrnum, arr/num, num/arr, arrnum***

数组与标量的算术运算：会将标量值传播到数组的各个元素

1
2
arr = np.array([[1., 2., 3.], [4., 5., 6.]])
arr, arr + 1, arr / 0.5, 1 / arr, arr**2
(array([[1., 2., 3.],
        [4., 5., 6.]]),
 array([[2., 3., 4.],
        [5., 6., 7.]]),
 array([[ 2.,  4.,  6.],
        [ 8., 10., 12.]]),
 array([[1.        , 0.5       , 0.33333333],
        [0.25      , 0.2       , 0.16666667]]),
 array([[ 1.,  4.,  9.],
        [16., 25., 36.]]))

arr2>arr1

布尔运算：大小相同的数组之间的比较会生成布尔值数组

1
2
3
arr1 = np.array([[1., 2., 3.], [4., 5., 6.]])
arr2 = np.array([[0., 4., 1.], [7., 2., 12.]])
arr2 > arr
array([[False,  True, False],
       [ True, False,  True]])

切片与索引

基本的切片和索引

arr[ d1, d2, ... ], arr[ d1 ][ d2 ]...

1
2
arr = np.arange(10)
arr, arr[5], arr[5:8], arr[-5:-1], arr[-5:10]
(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
 5,
 array([5, 6, 7]),
 array([5, 6, 7, 8]),
 array([5, 6, 7, 8, 9]))

切片的赋值（广播）

1
2
arr[5:8] = 12
arr 
array([ 0,  1,  2,  3,  4, 12, 12, 12,  8,  9])

基本切片的赋值 : 直接引用内存（原地操作）

1
2
3
4
5
arr = np.arange(10)
print(arr)
arr_slice = arr[5:]
arr_slice[:] = 0
print(arr)
[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 0 0 0 0 0]

如果想得到切片的副本而不是引用, 要明确进行复制操作 : arr.copy()

1
2
3
4
5
6
arr = np.arange(10)
print(arr)
arr_copy = arr[5:].copy()
arr_copy[:] = 0
print(arr)
print(arr_copy)
[0 1 2 3 4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]
[0 0 0 0 0]

对多维数组的切片

1
2
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
arr2d, arr2d[1:], arr2d[1:][1:], arr2d[1:, 1:]
(array([[ 1,  2,  3],
        [ 4,  5,  6],
        [ 7,  8,  9],
        [10, 11, 12]]),
 array([[ 4,  5,  6],
        [ 7,  8,  9],
        [10, 11, 12]]),
 array([[ 7,  8,  9],
        [10, 11, 12]]),
 array([[ 5,  6],
        [ 8,  9],
        [11, 12]]))
1
2
arr3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
arr3d, arr3d[0, :, :], arr3d[:, 0, :], arr3d[:, :, 0]
(array([[[ 1,  2,  3],
         [ 4,  5,  6]],
 
        [[ 7,  8,  9],
         [10, 11, 12]]]),
 array([[1, 2, 3],
        [4, 5, 6]]),
 array([[1, 2, 3],
        [7, 8, 9]]),
 array([[ 1,  4],
        [ 7, 10]]))

在多维数组中, 如果省略了后面的索引, 则返回一个维度低一点的数组 : arr[d1].ndim = arr.ndim - 1

1
arr3d[0], arr3d[0, :, :], arr3d[0][0], arr3d[0, 0, :]
(array([[1, 2, 3],
        [4, 5, 6]]),
 array([[1, 2, 3],
        [4, 5, 6]]),
 array([1, 2, 3]),
 array([1, 2, 3]))

高维数组切片的赋值

1
2
3
4
arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr2d)
arr2d[:2, 1:] = 0
print(arr2d)
[[1 2 3]
 [4 5 6]
 [7 8 9]]
[[1 0 0]
 [4 0 0]
 [7 8 9]]

布尔型索引

arr[ condition ]

1
2
3
4
names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])
courses = np.array(['Maths', 'English', 'Physics', 'Python'])
data = np.random.randint(90, 100, (4, 7))
names, data
(array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'], dtype='<U4'),
 array([[93, 95, 94, 94, 91, 90, 92],
        [90, 96, 95, 92, 99, 99, 90],
        [97, 99, 95, 94, 99, 93, 95],
        [90, 95, 95, 90, 98, 91, 95]]))

布尔型数组

1
names == 'Bob', courses == 'Python'
(array([ True, False, False,  True, False, False, False]),
 array([False, False, False,  True]))

布尔型数组的长度必须跟被索引的轴长度一致

1
2
data[:, names == 'Bob'], data[courses == 'Python', :], \
data[courses == 'Python', names == 'Bob']
(array([[93, 94],
        [90, 92],
        [97, 94],
        [90, 90]]),
 array([[90, 95, 95, 90, 98, 91, 95]]),
 array([90, 90]))

操作符 '~'

1
data[~(courses == 'Python')]
array([[93, 95, 94, 94, 91, 90, 92],
       [90, 96, 95, 92, 99, 99, 90],
       [97, 99, 95, 94, 99, 93, 95]])

操作符 '&', '|'
> Python 关键字 'and' 和 'or' 在布尔型数组中无效, 要使用 '&' 与 '|'

1
2
mask = (courses == 'Maths') | (courses == 'Physics')
data[mask]
array([[93, 95, 94, 94, 91, 90, 92],
       [97, 99, 95, 94, 99, 93, 95]])

通过布尔型索引选取数组中的数据，将总是创建数据的副本

基本切片：引用内存；布尔索引：创建副本

1
2
3
4
5
6
7
data = np.random.randint(90, 100, (4, 7))
mask = (courses == 'Maths') | (courses == 'Physics')
print(mask)
data_mask = data[mask] 
print(data_mask)
data_mask[:] = 0
print(data)
[ True False  True False]
[[99 97 98 92 92 90 99]
 [94 94 95 94 91 94 98]]
[[99 97 98 92 92 90 99]
 [95 99 92 99 93 99 97]
 [94 94 95 94 91 94 98]
 [91 94 95 94 96 90 99]]
1
2
3
4
data_slice = data[0:2, :]
print(data_slice)
data_slice[:] = 0
print(data)
[[99 97 98 92 92 90 99]
 [95 99 92 99 93 99 97]]
[[ 0  0  0  0  0  0  0]
 [ 0  0  0  0  0  0  0]
 [94 94 95 94 91 94 98]
 [91 94 95 94 96 90 99]]

布尔型切片赋值

1
2
3
4
data = np.random.randint(90, 100, (4, 7))
print(data)
data[data < 95] = 0
print(data)
[[92 95 92 93 93 90 96]
 [90 98 99 97 91 96 95]
 [94 95 97 97 98 98 96]
 [90 97 96 97 96 93 95]]
[[ 0 95  0  0  0  0 96]
 [ 0 98 99 97  0 96 95]
 [ 0 95 97 97 98 98 96]
 [ 0 97 96 97 96  0 95]]

花式索引（Fancy Indexing）

arr[ list1, list2, ... ]

1
2
3
4
5
6
arr = np.empty((8, 4))
for i in range(8):
    for j in range(4):
        arr[i,j] = i+j
arr = arr.astype(np.int32)
arr
array([[ 0,  1,  2,  3],
       [ 1,  2,  3,  4],
       [ 2,  3,  4,  5],
       [ 3,  4,  5,  6],
       [ 4,  5,  6,  7],
       [ 5,  6,  7,  8],
       [ 6,  7,  8,  9],
       [ 7,  8,  9, 10]])

利用整数数组进行索引

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

一次传入多个索引数组 : 返回一个一维数组, 其中的元素对应各个索引元组

1
2
3
arr[[4, 3, 0, 6], [2, 1, 0, 3]]
# 最终选出的是元素 (4, 2), (3, 1), (0, 0), (6, 3)
# 无论数组是多少维的，花式索引总是一维的
array([6, 4, 0, 9])
1
arr[[4, 3, 0, 6]][:, [2, 1, 0, 3]]
array([[6, 5, 4, 7],
       [5, 4, 3, 6],
       [2, 1, 0, 3],
       [8, 7, 6, 9]])

通过花式索引选取数组中的数据，将总是创建数据的副本

基本切片 : 引用内存;
布尔索引 : 复制副本; 花式索引 : 复制副本

1
2
3
4
arr_fancy = arr[range(0,4)][:, range(0,4)]
print(arr_fancy)
arr_fancy[:] = 0
print(arr)
[[0 1 2 3]
 [1 2 3 4]
 [2 3 4 5]
 [3 4 5 6]]
[[ 0  1  2  3]
 [ 1  2  3  4]
 [ 2  3  4  5]
 [ 3  4  5  6]
 [ 4  5  6  7]
 [ 5  6  7  8]
 [ 6  7  8  9]
 [ 7  8  9 10]]

数组转置和轴对换

arr.T : 转置

1
2
arr = np.arange(15).reshape((3, 5))
arr, arr.T
(array([[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14]]),
 array([[ 0,  5, 10],
        [ 1,  6, 11],
        [ 2,  7, 12],
        [ 3,  8, 13],
        [ 4,  9, 14]]))

np.dot(arr1, arr2) : 矩阵内积

1
np.dot(arr, arr.T)  #3x5 5x3 → 3x3
array([[ 30,  80, 130],
       [ 80, 255, 430],
       [130, 430, 730]])

arr.transpose(axes) : 轴对换

axes : 轴编号序列的元组

1
2
arr = np.arange(15).reshape((3, 5))
arr, arr.transpose((0, 1)), arr.transpose((1, 0)) # 第1轴与第2轴互换位置
(array([[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14]]),
 array([[ 0,  1,  2,  3,  4],
        [ 5,  6,  7,  8,  9],
        [10, 11, 12, 13, 14]]),
 array([[ 0,  5, 10],
        [ 1,  6, 11],
        [ 2,  7, 12],
        [ 3,  8, 13],
        [ 4,  9, 14]]))
1
2
arr = np.arange(24).reshape((2, 3, 4))
arr, arr.transpose((1,0,2)) # 第1轴与第2轴互换，第3轴不变
(array([[[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [ 8,  9, 10, 11]],
 
        [[12, 13, 14, 15],
         [16, 17, 18, 19],
         [20, 21, 22, 23]]]),
 array([[[ 0,  1,  2,  3],
         [12, 13, 14, 15]],
 
        [[ 4,  5,  6,  7],
         [16, 17, 18, 19]],
 
        [[ 8,  9, 10, 11],
         [20, 21, 22, 23]]]))

arr.swapaxes(axis1, axis2) : 两个轴对换

axis : 轴编号

1
2
arr = np.arange(24).reshape((2, 3, 4))
arr, arr.swapaxes(0, 1) # 第1轴与第2轴互换，第3轴不变
(array([[[ 0,  1,  2,  3],
         [ 4,  5,  6,  7],
         [ 8,  9, 10, 11]],
 
        [[12, 13, 14, 15],
         [16, 17, 18, 19],
         [20, 21, 22, 23]]]),
 array([[[ 0,  1,  2,  3],
         [12, 13, 14, 15]],
 
        [[ 4,  5,  6,  7],
         [16, 17, 18, 19]],
 
        [[ 8,  9, 10, 11],
         [20, 21, 22, 23]]]))

通用的一元函数

1
2
arr = np.arange(1,10,2)
arr
array([1, 3, 5, 7, 9])

np.sqrt(arr), np.exp(arr) : 平方根，平方

1
np.sqrt(arr), np.square(arr)
(array([1.        , 1.73205081, 2.23606798, 2.64575131, 3.        ]),
 array([ 1,  9, 25, 49, 81], dtype=int32))

np.exp(arr), np.log(arr), np.log1p(arr) : 指数，对数，log(1+x)

1
np.exp(arr), np.log(arr), np.log1p(arr)
(array([2.71828183e+00, 2.00855369e+01, 1.48413159e+02, 1.09663316e+03,
        8.10308393e+03]),
 array([0.        , 1.09861229, 1.60943791, 1.94591015, 2.19722458]),
 array([0.69314718, 1.38629436, 1.79175947, 2.07944154, 2.30258509]))

np.sign(arr) : 符号函数

1
2
arr = np.random.randn(5) * 5
arr
array([-5.72033251,  4.14975286, -1.29811492,  1.15525507,  1.39684986])
1
arr, np.sign(arr)
(array([-5.72033251,  4.14975286, -1.29811492,  1.15525507,  1.39684986]),
 array([-1.,  1., -1.,  1.,  1.]))

np.ceil(arr), np.floor(arr), np.rint(arr) : 进一取整，退一取整，四舍五入

1
arr, np.ceil(arr), np.floor(arr), np.rint(arr)
(array([-5.72033251,  4.14975286, -1.29811492,  1.15525507,  1.39684986]),
 array([-5.,  5., -1.,  2.,  2.]),
 array([-6.,  4., -2.,  1.,  1.]),
 array([-6.,  4., -1.,  1.,  1.]))

np.modf(arr) : 返回小数、整数

1
2
part, main = np.modf(arr)
arr, main, part
(array([-5.72033251,  4.14975286, -1.29811492,  1.15525507,  1.39684986]),
 array([-5.,  4., -1.,  1.,  1.]),
 array([-0.72033251,  0.14975286, -0.29811492,  0.15525507,  0.39684986]))

np.abs(arr), np.fabs(arr) : 绝对值，非复数绝对值

1
arr, np.abs(arr), np.fabs(arr)
(array([-5.72033251,  4.14975286, -1.29811492,  1.15525507,  1.39684986]),
 array([5.72033251, 4.14975286, 1.29811492, 1.15525507, 1.39684986]),
 array([5.72033251, 4.14975286, 1.29811492, 1.15525507, 1.39684986]))

np.isnan(arr) : 判断非数字

1
arr, np.isnan(arr)
(array([-5.72033251,  4.14975286, -1.29811492,  1.15525507,  1.39684986]),
 array([False, False, False, False, False]))

np.isfinite(arr), np.isinf(arr) : 判断有穷，判断无穷

1
arr, np.isfinite(arr), np.isinf(arr)
(array([-5.72033251,  4.14975286, -1.29811492,  1.15525507,  1.39684986]),
 array([ True,  True,  True,  True,  True]),
 array([False, False, False, False, False]))

np.cos(arr), np.sin(arr), np.tan(arr) : 三角函数

np.arccos(arr), np.arcsin(arr), np.arctan(arr) : 反三角函数

np.logical_not(arr) : 逻辑非 ~

1
2
arr = np.random.randint(0, 2, (5))
arr, np.logical_not(arr)
(array([0, 1, 1, 1, 0]), array([ True, False, False, False,  True]))

通用的二元函数

1
2
3
arr1 = np.random.randint(0,10,(5))
arr2 = np.random.randint(0,10,(5))
arr1, arr2
(array([6, 2, 3, 8, 4]), array([3, 9, 0, 1, 0]))

加减乘除

np.add(arr1, arr2), np.subtract(arr1, arr2)
np.multiply(arr1, arr2), np.divide(arr1, arr2)

1
2
3
arr1, arr2, \
np.add(arr1, arr2), np.subtract(arr1, arr2), \
np.multiply(arr1, arr2), np.divide(arr1, arr2)
<ipython-input-58-7d5cbea6c653>:3: RuntimeWarning: divide by zero encountered in true_divide
  np.multiply(arr1, arr2), np.divide(arr1, arr2)





(array([6, 2, 3, 8, 4]),
 array([3, 9, 0, 1, 0]),
 array([ 9, 11,  3,  9,  4]),
 array([ 3, -7,  3,  7,  4]),
 array([18, 18,  0,  8,  0]),
 array([2.        , 0.22222222,        inf, 8.        ,        inf]))

除法的取整和取余

np.floor_divide(arr1, arr2), np.mod(arr1, arr2) : 各返回除法整数、除法余数
np.divmod(arr1, arr2) : 返回除法整数和余数

1
arr1, arr2, np.floor_divide(arr1, arr2), np.mod(arr1, arr2), np.divmod(arr1, arr2)
<ipython-input-59-f630586a71d1>:1: RuntimeWarning: divide by zero encountered in floor_divide
  arr1, arr2, np.floor_divide(arr1, arr2), np.mod(arr1, arr2), np.divmod(arr1, arr2)
<ipython-input-59-f630586a71d1>:1: RuntimeWarning: divide by zero encountered in remainder
  arr1, arr2, np.floor_divide(arr1, arr2), np.mod(arr1, arr2), np.divmod(arr1, arr2)
<ipython-input-59-f630586a71d1>:1: RuntimeWarning: divide by zero encountered in divmod
  arr1, arr2, np.floor_divide(arr1, arr2), np.mod(arr1, arr2), np.divmod(arr1, arr2)





(array([6, 2, 3, 8, 4]),
 array([3, 9, 0, 1, 0]),
 array([2, 0, 0, 8, 0], dtype=int32),
 array([0, 2, 0, 0, 0], dtype=int32),
 (array([2, 0, 0, 8, 0], dtype=int32), array([0, 2, 0, 0, 0], dtype=int32)))

最大值和最小值

np.maximum(arr1, arr2), np.fmax(arr1, arr2)
np.minimum(arr1, arr2), np.fmin(arr1, arr2)

1
2
3
a = np.array([4, 2 , np.nan,3, 1])
b = np.array([2, 3, 4, 5, np.nan])
a, b, np.maximum(a, b), np.fmax(a, b)  #fmax, fmin 将忽略NaN
(array([ 4.,  2., nan,  3.,  1.]),
 array([ 2.,  3.,  4.,  5., nan]),
 array([ 4.,  3., nan,  5., nan]),
 array([4., 3., 4., 5., 1.]))

np.copysign(arr1, arr2) : copy sign of arr2 to arr1

1
2
3
a = np.random.randint(-9, 0, (5))
b = np.random.randint(0, 9, (5))
a, b, np.copysign(b, a)
(array([-5, -6, -5, -6, -5]),
 array([3, 4, 1, 2, 6]),
 array([-3., -4., -1., -2., -6.]))

np.power(arr1, arr2) : 对 ，根据 中的元素, 计算对应的 

1
arr1, arr2, np.power(arr1, arr2)
(array([6, 2, 3, 8, 4]),
 array([3, 9, 0, 1, 0]),
 array([216, 512,   1,   8,   1], dtype=int32))

比较

np.greater(arr1, arr2), np.greater_equal(arr1, arr2)
np.less(arr1, arr2), np.less_equal(arr1, arr2)
np.equal(arr1, arr2)np.not_equal(arr1, arr2)

1
arr1, arr2, np.greater_equal(arr1, arr2), np.less_equal(arr1, arr2)
(array([6, 2, 3, 8, 4]),
 array([3, 9, 0, 1, 0]),
 array([ True, False,  True,  True,  True]),
 array([False,  True, False, False, False]))

逻辑运算

np.logical_and(arr1, arr2) : 逻辑与 &
np.logical_or(arr1, arr2) : 逻辑或 |
np.logical_xor(arr1, arr2) : 逻辑异或 ^

1
2
3
4
arr1 = np.random.randint(0, 2, (5))
arr2 = np.random.randint(0, 2, (5))
arr1, arr2, \
np.logical_and(arr1, arr2), np.logical_or(arr1, arr2), np.logical_xor(arr1, arr2)
(array([0, 0, 1, 1, 0]),
 array([1, 0, 0, 1, 0]),
 array([False, False, False,  True, False]),
 array([ True, False,  True,  True, False]),
 array([ True, False,  True, False, False]))