Numpy 常用的几种命令

一、创建数组

(一) Ndarray 对象及其创建

1
2
3
# 引入Numpy库

import numpy as np

1、创建Numpy数组

1
2
3
4
5
# 一维数组（向量）
a = np.array([1,2,3,4,5,6])

# 二维数组（矩阵）
A = np.array([[1,2,3], [4,5,6]])

2、Numpy数组的属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 查看维度数量
a.ndim  # 结果为1
A.ndim  # 结果为2
 
# 查看数组形状
a.shape  # 结果为(6,)  表示1行6列
A.shape  # 结果为(2,3)  表示2行3列

# 数组中元素总个数
a.size  # 结果为6
A.size  # 结果为6
 
# 数组中元素类型
a.dtype  # 结果为dtype('int32')
A.dtype  # 结果为dtype('int32')

3、创建数组的便捷函数

ones 创建全是1.的数组

1
2
3
4
5
6
# 默认数据类型是浮点型
np.ones(4)  # 结果为array([1.,1.,1.,1.])
np.ones(4).dtype  # 结果为dtype('float64')
np.ones(4, dtype='int64')  # 结果为array([1, 1, 1, 1], dtype=int64)
np.ones(shape=(2,4))  # 创建2行4列的数组（矩阵） 'shape'可省
np.ones_like(A)  # 创建与A数组形状相同的数组

zeros 创建全为0.的数组

1
2
3
4
# 默认数据类型是浮点型
np.zeros(4)  # array([0., 0., 0., 0.])
np.zeros((2,4))  # 创建2行4列的数组（矩阵） 已省略'shape'
np.zeros_like(A)  # 创建与A数组形状相同的数组

full 创建指定数值的数组

1
2
3
np.full(8,666)  # 创建1行8列值全为666的数组 array([666, 666, 666, 666, 666, 666, 666, 666])
np.full((2,4),666)  # 创建2行4列，元素均为666
np.full(A,666)  # 创建形状与A相同，元素均为666

empty 创建数组并初始化元素值

1
2
3
np.empty(8)  # 创建1行8列的数组，不会将数组值设置为零
np.empty((2,4))  # 2行4列
np.empty_like(A)  # 与A形状相同

4、创建等差数组

arange 创建等差数组

1
2
3
4
# arange 创建等差数组(默认步长为1)
np.arange(10)  # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
np.arange(1,10,2)  # 范围[1,10,2)，区间左闭右开，步长为2，array([1, 3, 5, 7, 9])
np.arange(10).reshape(2,5)  # 改数组形状为2行5列，array([[0, 1, 2, 3, 4],[5, 6, 7, 8, 9]])

linspace 创建等差数组

1
2
3
# linspace 创建等差数组，可指定元素数量
np.linspace(0,10,5)  # 范围[0,10]，区间双闭合，元素数量为5
# array([ 0. , 2.5, 5. , 7.5, 10. ])

5、数据取整

向上&向下

1
2
3
np.ceil(X)  # 向上取整

np.floor(X)  # 向下取整

四舍五入取整

1
2
3
4
5
6
7
8
9
10
11
12
13
a = np.array([1.2347, 0.4214, 42.2374]).astype('float')
# [ 1.2347  0.4214 42.2374]

a.round(2)	# a数组中所有值均保留n位小数
# [ 1.23  0.42 42.24]

np.round(a, 2)	# a数组中所有值均保留n位小数
# [ 1.23  0.42 42.24]

np.round(X)  # 四舍五入（实际是四舍六入），注意：对浮点数的取舍遵循的是四舍六入五平分
# 在误差理论中,当整数部分是偶数,小数部分是0.5时,向下取整;
# 当整数部分是奇数,小数部分是0.5时,则向上取整
# 也就是说,当小数部分是0.5的时候,“去奇存偶”,这样得到的结果在统计学上更精确

(二) Numpy 随机数模块

1
2
X = np.arange(10)
np.random.shuffle(X)  # 打乱X的顺序，会改变原数组，无返回值

1、random 模块

1
2
3
4
# random生成的值均在[0,1)之间，区间左闭右开
np.random.random()  # 返回一个[0,1)之间的随机数
np.random.random(5)  # 返回一个一维数组，元素数5个，值在[0,1)之间
np.random.random((2,4))  # 返回一个2行4列的数组，值在[0,1)之间

2、rand 模块

1
2
3
4
5
# 类似random()用法，生成元素均在[0,1)之间的随机数，区间左闭右开
np.random.rand()  # 返回一个[0,1)之间的随机数
np.random.rand(5)  # 返回一个一维数组，元素数5个，值在[0,1)之间
np.random.rand(2,4)  # 区别于np.random.random((2,4))，只需一个括号！
np.random.rand(2,3,4)  # 返回一个三维数组

3、randint 获得随机整数

1
2
3
4
np.random.randint(5)  # 生成[0,5)之间的一个随机整数
np.random.randint(5,10)  # 生成[5,10)之间的一个随机整数
np.random.randint(5,10,size=8)  # 在[5,10)之间生成8个随机整数，'size='可省
np.random.randint(5,10,size=(2,4))  # 生成2行4列的数组，'size='可省

4、seed 设置随机数生成器的种子

为随机数生成器设置了一个固定的种子后，每次生成的随机序列都会是相同的！

1
2
3
# 通过设置随机数种子后，重复运行np.random.randint(5,10,(2,4))时，生成的随机数将保持不变！
np.random.seed(666)
np.random.randint(5,10,size=(2,4))   # array([[9, 7, 6, 9],[8, 8, 9, 9]])

5、randn 标准正态分布

生成标准正态分布（均值为0，标准差为1）的随机数

1
2
np.random.randn(5)  # 生成一维数组，元素数为5个，结果为标准正态分布
np.random.randn(2,4)  # 生成二维数组，2行4列，结果为标准正态分布

6、normal 高斯分布

可设置均值、方差，生成具有高斯分布的随机数

1
2
3
np.random.normal()  # 默认均值为0，标准差为1
np.random.normal(10,1000,20)  # 均值为10，标准差为1000，生成20个数（一维数组）
np.random.normal(10,1000,size=(4,6))  # 生成4行6列的二维数组

7、uniform 均匀分布

生成服从均匀分布的随机数

1
2
3
np.random.uniform()  # 默认生成[0,1)之间的一个随机数，区间左闭右开
np.random.uniform(1,5)  # 生成[1,5)之间的一个随机数
np.random.uniform(1,5,(3,4))  # 生成3行4列数组，值在[1,5)之间

二、数组的基础索引

1
2
3
4
5
6
7
8
9
import numpy as np
a = np.arange(10)  # a 为array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
A = np.arange(20).reshape(4,5)
# A为：array([
#  [ 0, 1, 2, 3, 4],
#  [ 5, 6, 7, 8, 9],
#  [10, 11, 12, 13, 14],
#  [15, 16, 17, 18, 19]
# ])

(一) 一维数组

调用方式同python切片取值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
a  # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

a[0]  # 取序号为0的值，结果为0

a[0:5]  # 取序号[0,5)范围的值，区间左闭右开，array([0, 1, 2, 3, 4])

a[:5]  # 取序号从头开始闭区间，到5结束开区间的值，array([0, 1, 2, 3, 4])

a[4:]  # 取序号从4开始闭区间，到数组末尾的值，array([4, 5, 6, 7, 8, 9])

a[-3:]  # 取序号倒数第3个开始闭区间，到数组末尾的值，array([7, 8, 9])

a[:]  # 复制一份原数组，修改此数组时不影响原数组值，array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

a[::2]  # 复制一份原数组，并调整原数组的步长为2，array([0, 2, 4, 6, 8])

a[::-1]  # 复制一份原数组，并按原数组进行倒序，array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])

(二) 二维数组

Numpy的二维数组切片得到的数组中的值改变时，原始值也会跟着变，如：

1
2
3
X = A[:2,:3]
X[0,0] = 666  # 此时A[0,0]也会变为666
A[0,0] = 222  # 此时X[0,0]也会变为222

使用.copy()方法将二维数组赋值给新数组，新数组变化不影响原数组，如：

1
X = A[:2,:3].copy()

以下为二维数组常见调用方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# A为:array([[ 0, 1, 2, 3, 4],
#      [ 5, 6, 7, 8, 9],
#      [10, 11, 12, 13, 14],
#      [15, 16, 17, 18, 19]])

A[0,0]  # 取第1行第1列的值，逗号前的值表行，逗号后的值表列

A[0,:]  # 取第1行所有值，array([0, 1, 2, 3, 4])

A[0]  # 同A[0,:]，取第1行所有值，array([0, 1, 2, 3, 4])

A[-1]  # 取最后一行元素，array([15, 16, 17, 18, 19])

A[:,0]  # 取第一列元素，array([ 0, 5, 10, 15])

A[:,-1]  # 取最后一列元素，array([ 4, 9, 14, 19])

A[:2,:4]  # 取前2行，前3列元素，
# array([[0, 1, 2, 3],
#   	 [5, 6, 7, 8]])

A[::-1,::-1]  # 行取倒序，列取倒序
#array([[19, 18, 17, 16, 15],
# 	    [14, 13, 12, 11, 10],
# 	    [ 9, 8, 7, 6, 5],
#  	    [ 4, 3, 2, 1, 0]])

三、数组的合并拆分

(一) 数组的合并

1
2
3
4
5
6
7
8
9
10
11
12
13
# 引入Numpy库
import numpy as np

a = np.array([6,6,6,6])  # array([6, 6, 6, 6])
X = np.arange(12).reshape(3,4)
#array([[ 0, 1,  2,  3],
#   	[ 4, 5,  6,  7],
#    	[ 8, 9, 10, 11]])

B = np.full((3,2),666)
#array([[666, 666],
#  	    [666, 666],
#   	[666, 666]])

1、垂直方向（行操作）

方法1：concatenate函数

1
2
3
4
5
A = np.concatenate((X,a.reshape(1,4)),axis=0)  # 把a添加进X，'axis'参数默认为0
# A为:array([[ 0, 1, 2, 3],
#      		[ 4, 5, 6, 7],
#      		[ 8, 9, 10, 11],
#      		[ 6, 6, 6, 6]])

方法2：vstack函数

1
2
3
4
5
np.vstack((X,a))  # 返回的是一个新的数组对象，原始数组不会被修改
# array([[ 0, 1, 2, 3],
#    [ 4, 5, 6, 7],
#    [ 8, 9, 10, 11],
#    [ 6, 6, 6, 6]])

2、水平方向（列操作）

方法1：concatenate函数

1
2
3
4
np.concatenate((X,B),axis=1)  # 'axis'参数默认为0，设为1时为列操作
#array([[ 0,  1,  2,  3, 666, 666],
#    [ 4,  5,  6,  7, 666, 666],
#    [ 8,  9, 10, 11, 666, 666]])

方法2：hstack函数

1
2
3
4
np.hstack((X,B))
#array([[ 0,  1,  2,  3, 666, 666],
#    [ 4,  5,  6,  7, 666, 666],
#    [ 8,  9, 10, 11, 666, 666]])

(二) 数组的拆分

split函数中拆分部分按 数组[ ] 来分

数组[ ] 中包含几个值，将会按照从0开始，以每个值做开区间来进行划分，具体代码如下

1、按行拆分

方法1：split函数

1
2
3
4
5
6
X1,X2 = np.split(X,[-1],axis=0)  # 按[-1]从最后一行开始拆分,分为两个区间，区间[0,-1)和区间[-1:]两部分，'axis'默认为0

# X1为:array([[0, 1, 2, 3],
#       [4, 5, 6, 7]])

# X2为:array([[ 8, 9, 10, 11]])

方法2：vsplit函数

1
2
3
4
5
6
X1,X2 = np.vsplit(X,[2])  # 按[2]从第2行开始拆分，区间[0,2)行一部分，[2:]行一部分
# X1为：array([[0, 1, 2, 3],[4, 5, 6, 7]])
# X2为：array([[ 8, 9, 10, 11]])

np.vsplit(X,[1,2])  # 按区间划分，区间[0,1)，区间[1,2)，区间[2:]
# [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]

2、按列拆分

方法1：split函数

1
2
3
4
5
6
7
8
9
X1,X2 = np.split(X,[-1],axis=1)  # 按[-1]从最后一行开始拆分,分为两个区间，区间[0,-1)和区间[-1:]两部分

# X1为:array([[ 0, 1, 2],
#       [ 4, 5, 6],
#       [ 8, 9, 10]])

# X2为:array([[ 3],
#       	 [ 7],
#       	 [11]])

方法2：hsplit函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
X1,X2 = np.hsplit(X,[-1])  # 按[-1]从最后一行开始拆分,分为两个区间，区间[0,-1)和区间[-1:]两部分
# array([[ 0, 1, 2],
#    [ 4, 5, 6],
#    [ 8, 9, 10]])
# array([[ 3],
#    [ 7],
#    [11]])

np.hsplit(X,[1,2,-1])   # [1,2,-1]进行拆分，以列表形式返回，分为4个区间，[0,1)、[1,2)、[2,-1)、[-1:]
# [array([[0],
#     [4],
#     [8]]),
# 	array([[1],
#     [5],
#     [9]]),
# 	array([[ 2],
#     [ 6],
#     [10]]),
# 	array([[ 3],
#     [ 7],
#     [11]])]

四、Numpy矩阵运算

对比 Python 将数组乘2

1
2
A = [i for i in range(5)]  # A == [0, 1, 2, 3, 4]
y = [i*2 for i in A]  # y == [0, 2, 4, 6, 8]

举例：Numpy 将数组乘2

1
2
3
import numpy as np
A = np.arange(5)  # A == array([0, 1, 2, 3, 4])
Y = A * 2  # Y == array([0, 2, 4, 6, 8])

(一) 一元运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
X = np.arange(1,11,0.5).reshape(4,5)
# array([[ 1. , 1.5, 2. , 2.5, 3. ],
#    [ 3.5, 4. , 4.5, 5. , 5.5],
#    [ 6. , 6.5, 7. , 7.5, 8. ],
#    [ 8.5, 9. , 9.5, 10. , 10.5]])

np.abs(X)  # 绝对值

np.sqrt(X)  # 开方

np.square(X)  # 平方

np.exp(X)  # e的指数

np.log(X)  # 对数（以e为底）

np.log2(X)  # 对数（以2为底）

np.sin(X)  # 正弦
np.cos(X)  # 余弦
np.tan(X)  # 正切

(二) 二元运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
X = np.arange(1,11,0.5).reshape(4,5)
# array([[ 1. , 1.5, 2. , 2.5, 3. ],
#    [ 3.5, 4. , 4.5, 5. , 5.5],
#    [ 6. , 6.5, 7. , 7.5, 8. ],
#    [ 8.5, 9. , 9.5, 10. , 10.5]])

X + 1  # X中所有元素 +1
np.add(X,1)  # 同 X + 1

X - 1  # X中所有元素 -1

X * 2  # X中所有元素 *2

X / 2  # X中所有元素 除2，并返回浮点数结果

2 / X  # 2 除 X中所有元素 

X // 2  # X中所有元素 整除2，并丢弃小数部分，只保留整数部分

X % 2  # X中所有元素 对2取余

X ** 3  # X中所有元素 乘方操作，X所有元素扩大为3次幂

(三) 矩阵运算

1
2
3
4
5
6
7
X = np.linspace(10,40,4).reshape(2,2)
# array([[10., 20.],
#    [30., 40.]])

Y = np.linspace(1,4,4).reshape(2,2)
# array([[1., 2.],
#    [3., 4.]])

矩阵常用运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
X + Y  # 矩阵加法，位对位相加：array([[11., 22.],[33., 44.]])

X - Y  # 矩阵减法，位对位相减：array([[ 9., 18.],[27., 36.]])

X * Y  # 不是矩阵乘法！！！注意：该乘法是位对位相乘！array([[ 10., 40.],[ 90., 160.]])

X.dot(Y)  # 矩阵乘法，前行 乘 后列 再 求和 的形式，array([[ 70., 100.],[150., 220.]])

X / Y  # 位对位除法，array([[10., 10.],[10., 10.]])

X.T  # 转置矩阵，array([[10., 30.],[20., 40.]])

np.transpose(X)  # 对二维矩阵为转置，array([[10., 30.],[20., 40.]])

np.linalg.inv(X)  # 求逆矩阵，原阵必须为方阵，array([[-0.2 , 0.1 ],[ 0.15, -0.05]])

np.linalg.det(X)  # 求矩阵行列式，必须为方阵，结果为：-200.0000000000001

np.linalg.eig(X)  # 求矩阵的特征值和特征向量，
# EigResult(eigenvalues=array([-3.72281323, 53.72281323]), 
# eigenvectors=array([[-0.82456484, -0.41597356], [ 0.56576746, -0.90937671]]))

五、Numpy统计运算

统计最值

1
2
3
4
5
6
7
8
9
10
11
import numpy as np  # 引入numpy

# 对一维数组操作
X = np.arange(5000000)
np.min(X)  # 最小值
np.max(X)  # 最大值

# 对二维数组操作
Y = X.reshape(5,-1)  # 将X转换为5行的二维数组
np.min(Y,axis=0)  # 按 列 求最小值，将每列的最小值找出并按顺序放进数组中
np.min(Y,axis=1)  # 按 行 求最小值，将每行的最小值找出并按顺序放进数组中

计算其他数值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
X = np.linspace(1,20,20).reshape(4,5)

np.sum(X)  # 求和

np.sum(X,axis=0)  # 按列求和，计算每列元素之和

np.sum(X,axis=1)  # 按行求和，计算每行元素之和

np.mean(X)  # 求均值

np.median(X)  # 求中位数

np.std(X)  # 求标准差

np.var(X)  # 求方差

np.ptp(X)  # 计算数组中最大值和最小值的差

np.percentile(X, 90)  # 百分位数，求取X数列第90%分位的数值，结果：18.1
q = np.linspace(0,100,5)  # array([ 0., 25., 50., 75., 100.])
np.percentile(X,q)  # 百分位数，按数组q中的值来返回数组X的第n个百分位数，array([1., 5.75, 10.5, 15.25, 20.])

np.cumsum(X,axis=0)  # 求累加，'axis'默认为0，第一行值不变，其后每一行的值 = 原值 + 前一行的值
np.cumsum(X,axis=1)  # 求累加，第一列值不变，其后 每一列的值 = 原值 + 前一列的值

np.diff(X,axis=0)  # 'axis'默认为0，计算每行元素之间的差
np.diff(X,axis=1)  # 计算每列元素之间的差

np.prod(X,axis=0)  # 'axis'不可省，计算每列元素之间的乘积
np.prod(X,axis=1)  # 计算每行元素的乘积

六、arg运算和排序

1、arg运算

arg主要用来提取索引值

1
2
3
4
5
6
7
8
import numpy as np
X = np.random.normal(0,1,size=1000000)  # 生成随机数组，均值为0，标准差为1，1000000个数
np.min(X)  # 找最小值
np.argmin(X)  # 找到最小值所在的位置序号
X[np.argmin(X)]  # 查看最小值

np.max(X)  # 找最大值
np.argmax(X)  # 找到最大值的位置

2、排序

先使用np.random.shuffle(X)打乱原数组的顺序，再进行排序

1
2
3
4
5
6
7
8
9
X = np.arange(10)
np.random.shuffle(X)  # 打乱X的顺序，会改变原数组，无返回值

# 排序操作
np.sort(X)  # 返回从小到大的排序，不改变原数组

X.sort()  # python自带的排序法，无返回值，会改变原数组

X[::-1]  # 将原数组改为降序

3、arg应用

1
2
3
4
X = np.arange(10)
np.random.shuffle(X)  # 打乱X的顺序，会改变原数组，无返回值

np.argsort(X)  # 按从小到大顺序先排列，而后将排列后的元素在原数组中的位置去到

3、partition分区

1
2
3
4
5
6
X = np.arange(10)
np.random.shuffle(X)  # 打乱X的顺序，会改变原数组，无返回值

np.partition(X,5)  # 5表示有序排序中第5个元素，小于5的在5左边，大于5的在5右边，不改变原数组

np.argpartition(X,5)  # 对np.partition(X,5)中数组元素取在原数组X中的位置

4、高维数组排序

1
2
3
4
5
6
X = np.random.randint(10,size=(5,5))  # 生成5行5列的数组
np.sort(X)  # 将每行中的元素进行升序排序

np.argsort(X,axis=1)  # 按行操作，将每行中元素升序排列后的序号返回

np.argsort(X,axis=1)  # 按列操作，将每列中元素升序排列（小数在上）的序号返回

七、神奇索引和布尔索引

1
2
3
4
5
6
7
8
9
10
11
12
13
import numpy as np

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

index = [2,5,8]
X[index]  # 取X[2]，X[5]，X[8]，array([2, 5, 8])

X[2:8]  # 对X切片，array([2, 3, 4, 5, 6, 7])

X[2:8:2]  # 对X切片，且步长为2，array([2, 4, 6])

index = np.array([[1,3,5],[2,4,6]])
X[index]  # 结果与index的维度一致，array([[1, 3, 5],[2, 4, 6]])

1、神奇索引

1
2
3
4
5
6
7
8
9
10
11
# 用于二维数组
X = np.arange(10)  # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
X = X.reshape(2,-1)  # X变为两行的二维数组
row = np.array([0,1,0])  # 表示行坐标
col = np.array([0,2,4])  # 表示列坐标

X[row,col]  # 取X[0][0]，X[1][2]，X[0][4]的值，array([0, 7, 4])

X[0,col]  # 取第0行中序号为col的值，array([0, 2, 4])

X[row,:2]  # 取row行中序号在[0,2)的值，array([[0, 1],[5, 6],[0, 1]])

2、布尔索引

1
2
3
4
5
X = np.arange(10)  # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
X = X.reshape(2,-1)  # X变为两行的二维数组

col = [True, False, True, False, True]  # 相当于[0,2,4]
X[0,col]  # 取第0行中序号为col的值，array([0, 2, 4])

比较用法

1
2
3
4
5
6
7
8
9
10
11
X = np.arange(10)  # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

X < 5  # array([ True, True, True, True, True, False, False, False, False, False])

X >= 2  # array([False, False, True, True, True, True, True, True, True, True])

X == 3  # array([False, False, False, True, False, False, False, False, False,False])

X != 3  # array([ True, True, True, False, True, True, True, True, True, True])

X * X == 9  # array([False, False, False, True, False, False, False, False, False, False])

比较用法应用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
X = np.arange(10)  # array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

X[X > 3]  # array([4, 5, 6, 7, 8, 9])

X[X % 2]  # array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])

np.count_nonzero(X < 5)  # 找出X<5的个数，5个

np.sum(X < 5)  # 计算X中小于5的个数，5个

np.any(X < 0)  # X中是否有小于0的数，False
np.any(X > 5)  # X中是否有大于5的数，True

np.all(X > 0)  # X中元素是否都大于0，False
np.all(X < 10)  # X中元素是否都小于10，True

X = X.reshape(2,-1)  # 将X变为2行的二维数组

np.sum(X % 2 == 0)  # 计算X中所有偶数的个数，5个

np.sum(X % 2 == 0, axis=1)  # 统计每行有几个偶数，array([3, 2])
np.sum(X % 2 == 0, axis=0)  # 统计每列有几个偶数，array([1, 1, 1, 1, 1])

np.all(X > 2, axis=0)  # 每列是否都大于2，array([False, False, False, True, True])

八、与& 或| 非~

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

np.sum((X<5) & (X>1))  # 找小于5 且 大于1 的数的个数，3个
np.sum(~(X==0))  # 除了0都是，9个