【Python 科学计算学习笔记】第七章 NumPy数值计算基础

导入 Numpy 库

import numpy as np        # 导入 numpy 库并起别名为 np

np.array 创建 ndarray 数组

arr = np.array(列表, dtype=None)        # dtype 接收数据类型

import numpy as np

arr1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
print(arr1)
'''
[[1 2 3 4]
[5 6 7 8]]
'''

ndarray 数组属性

ndarray 数组存储单一数据类型，若存放不同的数据类型则会进行自动对齐

ndim：数组维数

shape：形状元组，二维：(行数, 列数)，一维：(长度,)

例如：

size：数据个数，行数×列数

dtype：数据类型，ndarray 整个数组类型必须相同

itemsize：每个元素的字节大小

import numpy as np

arr1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
print(arr1)
'''
[[1 2 3 4]
[5 6 7 8]]
'''

# 查看维数
print(arr1.ndim) # 访问属性而非调用函数，不需要加括号
'''
2
'''

# 查看形状
print(arr1.shape)
'''
(2, 4)
'''

1. 修改 shape 属性重新设置形状

arr.shape = (行数, 列数)        # 设置属性（该方法未来将弃用，可能会触发 DeprecationWarning 的警告）

2. arr.reshape 方法重新修改形状

arr2 = arr.reshape(行列元组)        # 返回形状改变后的视图，可对原数组数据域操作

arr3 = arr.reshape(-1, 1)        # -1 表示自动按元素不变展开成对应形状，自动推算该维度大小

# 示例：

import numpy as np

arr1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
print(arr1)
'''
[[1 2 3 4]
[5 6 7 8]]
'''

print(arr1.shape)
'''
(2, 4) # 2行4列
'''

arr1.shape = 4, 2 # 改变形状属性为4行2列，不写括号会自动生成元组
print(arr1)
print(arr1.shape)
'''
[[1, 2]
[3, 4]
[5, 6]
[7, 8]]
(4, 2)
'''

arr2 = arr1.reshape((1, 8)) # 用reshape方法改变形状为1行8列，返回给arr2，注意有返回值
print(arr2)
print(arr2.shape)
'''
[[1, 2, 3, 4, 5, 6, 7, 8]]
(1, 8)
'''

其它方法创建不同 ndarray 数组

1. np.arange 创建

arr = np.arange(起, 止, 步长)

在左闭右开的[起, 止)范围内按步长取，返回一维数组

import numpy as np

arr1 = np.arange(4, 8, 2)
print(arr1)
'''
[4, 6] # [4, 8)内按步长2取，8为开区间取不到
'''

2. np.linspace, np.logspace 创建等差等比数组

注意为双侧闭区间

arr = np.linspace(起, 止, 个数)        # 在[起, 止]上自动取等差元素，取够个数

arr = np.logspace(幂次起, 幂次止, 个数, base=10.0)        # 在[base^起, base^止]上自动取等比元素，取够个数。base 为底数的值，默认为 10.0

import numpy as np

arr1 = np.linspace(1, 15, 8) # 在[1, 15]取8个元素的等差数组
print(arr1)
'''
[ 1. 3. 5. 7. 9. 11. 13. 15.]
'''

arr2 = np.logspace(1, 5, 10) # 在[10^1, 10^5]取10个元素的等比数组
print(arr2)
'''
[1.00000000e+01 2.78255940e+01 7.74263683e+01 2.15443469e+02 5.99484250e+02 1.66810054e+03 4.64158883e+03 1.29154967e+04 3.59381366e+04 1.00000000e+05]
'''

3. np.eye 创建单位阵

arr = np.eye(方阵长度)

例如：np.eye(2) 为

[[1, 0]

 [0, 1]]

4. np.diag 创建对角阵

arr = np.diag(可迭代对象)        # 把可迭代对象中元素放在对角上，其余置零

例如：arr1 = np.diag([1, 3, 5]) 为

[[1, 0, 0]

 [0, 3, 0]

 [0, 0, 5]]

5. np.zeros, np.ones 创建全 0 全 1 数组

arr = np.zeros(形状元组)

arr = np.ones(形状元组)

例如 arr1 = np.ones((2, 3))        # 创建2行3列，元素全为1的数组

6. np.full 创建全为某数字的数组

arr = np.full(形状元组, 填充数)

例如： arr1 = np.full((3, 5), 10)        # 创建3行5列，元素全为10的数组

7. np.empty 创建无元素数组

arr = np.empty(形状元组)        # 创建一个只有形状和内存空间的数组，没有元素(并不是NaN，也不是None(None是空对象)，而是没有元素)

np.random 模块生成随机数

1. np.random.random 生成 [0, 1) 区间随机数

np.random.random(形状元组)

import numpy as np

arr1 = np.random.random((3, 5)) # 生成[0, 1)上形状(3, 5)的二维数组
print(arr1)
''' # 可能的结果
[[0.72241872 0.05191684 0.40531159 0.74432949 0.01136899]
[0.16624032 0.88802688 0.52944135 0.90554355 0.43231004]
[0.29966686 0.8928324 0.85837009 0.58124955 0.3120506 ]]
'''

2. np.random.randint 生成给定区间的随机数

注意为左闭右开

arr = np.random.randint(起, 止, 形状元组)

在[起, 止)上生成满足形状(个数也满足形状)的随机数，左闭右开

形状元组若填一个整数则生成一维数组

import numpy as np

arr1 = np.random.randint(60, 100, 5)
print(arr1)
''' # 可能的结果
[76 63 67 90 84]
'''

arr2 = np.random.randint(60, 100, (3, 5))
print(arr2)
''' # 可能的结果
[[76 63 67 90 84]
[68 76 60 99 73]
[63 62 93 75 61]]
'''

3. np.random.normal 生成满足给定均值标准差的正态分布随机数

np.random.normal(均值, 标准差, 形状元组)

import numpy as np

arr1 = np.random.normal(50, 10, (3, 5)) # 生成均值50标准差10的形状(3, 5)的二维数组
print(arr1)
''' # 可能的结果
[[55.22294696 40.73133942 40.50766366 53.89317643 41.00411682]
[53.38658111 44.27465742 47.91602419 55.82222184 46.12437048]
[47.85292016 59.80853312 54.17160536 69.00520601 48.43717651]]
'''

4. np.random.randn 生成标准正态分布随机数

np.random.randn(行数, 列数)        # 不支持用形状元组

import numpy as np

arr1 = np.random.randn(5) # 生成标准正态分布长为5的一维数组
print(arr1)
''' # 可能的结果
[0.18182937 -0.48504797 0.20776869 0.03804606 1.06731209]
'''

arr2 = np.random.randn(3, 5) # 生成标准正态分布形状(3, 5)的二维数组
print(arr2)
''' # 可能的结果
[[ 0.18182937 -0.48504797 0.20776869 0.03804606 1.06731209]
[ 0.4592454 1.75033465 -0.59179004 0.72959588 1.89763036]
[ 0.55296752 -0.41325672 0.26019246 1.72186134 0.67639804]]
'''

5. np.random.rand 生成 [0, 1) 区间均匀分布随机数

np.random.rand(行数, 列数)        # 不支持用形状元组

import numpy as np

arr1 = np.random.rand(5) # 生成[0, 1)区间均匀分布长为5的一维数组
print(arr1)
''' # 可能的结果
[0.15304507 0.67005302 0.99173792 0.85848758 0.65548366]
'''

arr2 = np.random.rand(3, 5) # 生成[0, 1)区间均匀分布形状(3, 5)的二维数组
print(arr2)
''' # 可能的结果
[[0.73587354 0.06377779 0.40092621 0.63988903 0.5373042 ]
[0.96478498 0.22248589 0.58515204 0.57633366 0.85818383]
[0.07905201 0.69725932 0.69660247 0.1244136 0.46537725]]
'''

索引访问数组(产生视图)：切片索引、整数索引

对数组切片会产生视图，能够通过切片直接处理原数据域上的数据

整数索引访问也产生视图

整数索引会降维，使用一次降一次，切片索引不降维

1. 一维数组整数索引、切片索引

import numpy as np

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

# ==================== 切片索引 ====================
print(arr1[2:7])
'''
[2 3 4 5 6]
'''

print(arr1[:5])
'''
[0 1 2 3 4]
'''

print(arr1[::2])
'''
[0 2 4 6 8]
'''

print(arr1[-3:])
'''
[7 8 9]
'''

print(arr1[1:7:3])
'''
[1 4]
'''

# ==================== 整数索引 ====================
print(arr1[5]) # 整数索引，降为0维
'''
5
'''

2. 二维数组整数索引、切片索引

1. 切片索引

2. 整数索引

import numpy as np

arr2 = np.array(
[[10, 20, 30, 40],
[50, 60, 70, 80],
[90, 100, 110, 120]])

# ==================== arr[整数行号, 整数列号] ====================
print(arr2[2, 3]) # 整数索引取行列，返回行索引2列索引3的元素，降为0维
'''
120
'''

# ==================== arr[行起:行止:行步长, 列起:列止:列步长] ====================
print(arr2[0:2]) # 仅行索引，取[0, 2)行，列取全部，不会降维
'''
[[10 20 30 40]
[50 60 70 80]]
'''

print(arr2[0:1, :]) # 行取行索引[0, 1)行，列取全部，不会降维
'''
[[10 20 30 40]]
'''

print(arr2[:, 1:3])
'''
[[20 30]
[60 70]
[100 110]]
'''

print(arr2[1:, 2:])
'''
[[70 80]
[110 120]]
'''

print(arr2[:2, ::2])
'''
[[10 30]
[50 70]]
'''

# ==================== 切片索引与整数索引混合 ====================
print(arr2[0, :]) # 整数索引取行索引0行，列取全部，此时会降为1维
'''
[10 20 30 40]
'''

print(arr2[-1, -2:]) # 降1维
'''
[110 120]
'''

索引访问数组(产生拷贝)：花式索引、布尔值索引

对数组使用花式索引与布尔值索引产生拷贝，并非视图

整数索引、切片索引、花式索引、布尔值索引可以混合使用，但只要索引操作中含有花式索引或布尔值索引，就只返回拷贝而非视图

1. 花式索引

(1) arr[行号列表]

        # 选取行号列表中的行，返回不降维

(2) arr[行号列表, 列号列表]

         # arr[row_list, col_list]

        返回一个展平的一维数组。

筛选方法：

① 行列号列表长度一致，在两列表中各取第i个数，筛选元素 arr[row_list[i], col_list[i]]。 

例如 arr[[0, 1, 4], [0, 2, 3]]        # 返回 arr[0, 0], arr[1, 2], arr[4, 3] 组成的一维数组

② 行列号列表长度不一致，但其一长度为 1，则可以进行广播

例如 arr[[1, 3, 5], 2] 广播为 arr[[1, 3, 5], [2, 2, 2]]，返回 arr[1, 2], arr[3, 2], arr[5, 2] 组成的一维数组

2. 布尔值索引

(1) arr[布尔值列表, 布尔值列表]

        # arr[row_mask, col_mask]

筛选方法：先将 True 的位置转变为行列号列表，之后按花式索引的方法求

例如：

1. row_mask=[True, True, False, False, True], col_mask=[True, False, True, True]。则 arr[row_mask, col_mask] 化为 arr[[0, 1, 4], [0, 2, 3]]，返回 arr[0, 0], arr[1, 2], arr[4, 3] 组成的数组

2. row_mask=[True, True, False, False, True], col_mask=[False, False, True, False]。则 arr[row_mask, col_mask] 先化为 arr[[0, 1, 4], 2]，再广播为 arr[[0, 1, 4], [2, 2, 2]],返回 arr[0, 2], arr[1, 2], arr[4, 2] 组成的一维数组

(2) arr[条件表达式]或arr[布尔数组]

        # 条件表达式类似 arr>20，布尔数组要与 arr 同形状。返回一个展平的一维数组

# 示例：
import numpy as np

arr2 = np.array(
[[10, 20, 30, 40],
[50, 60, 70, 80],
[90, 100, 110, 120]])

# 以下两个语句等价
print(arr2[[0, 2], [0, 3]])
print(arr2[[True, False, True], [True, False, False, True]])

# ==================== arr[行号列表] ====================
print(arr2[[0, 2]])
'''
[[10 20 30 40]
[90 100 110 120]]
'''

# ==================== arr[行号列表, 列号列表] ====================
print(arr2[[0, 1, 2], [1, 3, 0]])
'''
[20 80 90]
'''

# ==================== arr[布尔值列表, 布尔值列表] ====================
print(arr2[[True, True, True], [True, True, False, True]])
''' # 化为arr2[[0, 1, 2], [0, 1, 3]]，返回arr2[0, 0], arr[1, 1], arr[2, 3]的1维数组
[10 60 120]
'''

print(arr2[[False, False, True], [True, True, False, True]])
''' # 化为arr2[2, [0, 1, 3]]，广播为arr2[[2, 2, 2], [0, 1, 3]]返回arr2[2, 0], arr[2, 1], arr[2, 3]的1维数组
[90 100 120]
'''

# ==================== arr[条件表达式] ====================
print(arr2[arr2 > 70])
'''
[80 90 100 110 120]
'''

mask = (arr2 % 20 != 0) & (arr2 > 30)
print(mask)
print(arr2[mask])
'''
[[False False False False]
[ True False True False]
[ True False True False]]

'''

变换数组形态

1. arr.reshape 返回改变形状视图

arr2 = arr.reshape(形状元组)

注意当有某一维形状填入 -1 时，表示根据元素数量自动计算该维度长度

例题：

1. a = np.array([1, 2, 3, 4, 5])，b = np.array([[1, 2, 3, 4, 5]])，c = b.reshape(-1, 1)，则 a + b  的返回值为___，a + c 的返回值为___。

# 答案：
import numpy as np

a = np.array([1, 2, 3, 4, 5])
b = np.array([[1, 2, 3, 4, 5]])
c = b.reshape(-1, 1) # 或c = b.reshape((-1, 1))

print(a+b)
'''
[[2 4 6 8 10]]
'''

print(a+c)
'''
[[2 3 4 5 6]
[3 4 5 6 7]
[4 5 6 7 8]
[5 6 7 8 9]
[6 7 8 9 10]]
'''

2. arr.resize 原地操作改变形状

arr.resize(形状元组)

3. arr.ravel 返回展平视图

arr2 = arr.ravel(order='C')        # 默认 'C' 为行优先展平，'F' 为列优先

4. arr.flatten 返回展平拷贝

arr2 = arr.flatten(order='C')

连接数组

1. 横向连接

np.hstack((arr1, arr2))        # 将 arr2 连接到 arr1 右侧

2. 竖向连接

np.vstack((arr1, arr2))        # 将 arr2 连接到 arr1 下侧

ufunc 函数

1. 算数运算

加减乘除、整除、取模、幂运算：数组与数组运算，则需要形状相同，对应位置元素做运算。数组与常数运算，则对所有数组中元素都和这个常数做运算(广播为一个形状相同的数组)。

2. 比较运算

<, >, <=, >=, ==, != 进行比较运算，返回布尔数组

3. 布尔数组逻辑运算

布尔数组间使用 &, |, ^, ~ 进行按位与、按位或、按位异或、逐位取反。注意运算优先级，最好给每个操作数加上括号

np.logical_and(arr1, arr2)：逻辑与

np.logical_or(arr1, arr2)：逻辑或

np.logical_xor(arr1, arr2)：逻辑异或

np.logical_not(arr)：逻辑非

4. 常用一元函数

np.abs(x)：返回x的绝对值

np.sqrt(x)：返回x的平方根

np.exp(x)：返回e的x次幂

np.log(x)：返回x以e为底对数

np.log10(x)：返回x以10为底对数

np.ceil(x)：返回x向上(天花板)取整结果

np.floor(x)：返回x向下(地板)取整结果

np.sin(x), np.cos(x)：返回x正余弦函数值

广播机制

arr1 与 arr2 运算时：

1 维向 2 维看齐，2 维长度记为 1

同为 2 维则：

        即，若两个维度长度不同，必须有一方长度为 1 才可以广播运算

例如：

arr1 = np.array([1, 2, 3, 4, 5]), arr2 = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])，计算 arr1+arr2 的结果。

arr1 形状为(5,)，arr2 形状为(2, 5)，则将 arr1 对齐为 (1, 5)，再广播为 (2, 5)

  而 (2, 3) 和 (3, 4) 不可计算，因为第 1 维与第 2 维都不同，都需要至少一方为 1，但是不满足。

  1、2 维广播运算示例

练习题1

手工计算在Numpy中，一个长度为5的一维数组分别与另一个长度为5的一维数组，1行5列的二维数组，5行1列的二维数组做加法操作的计算结果。从而进一步理解和掌握ufunc函数的广播机制。最后，通过编程，验证所得结果的正确性。

手工计算：

[1 2 3 4 5]分别与

加法结果

# 代码验证：
import numpy as np

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

arr1 = np.array([2, 4, 6, 8, 10])
arr2 = np.array([[2, 4, 6, 8, 10]])
arr3 = np.array([[2], [4], [6], [8], [10]])

# 做加法结果
print('1.\\n', arr+arr1)
'''
1.
[ 3 6 9 12 15]
'''
print('2.\\n', arr+arr2)
'''
2.
[[ 3 6 9 12 15]]
'''
print('3.\\n', arr+arr3)
'''
3.
[[ 3 4 5 6 7]
[ 5 6 7 8 9]
[ 7 8 9 10 11]
[ 9 10 11 12 13]
[11 12 13 14 15]]
'''

手工计算：

线性代数运算

1. arr.T 转置

arr2 = arr.T        # 返回 arr 的转置

2. 矩阵乘法运算

arr1 为 (m, k)，arr2 为(k, n)

arr3 = arr1@arr2

arr3 = arr1.dot(arr2)

arr3 = np.dot(arr1, arr2)

则 arr3 为 (m, n)

读写 npy, npz 二进制文件

存储时可以省略拓展名，读取时不能

1. np.save 存储单个数组到 npy 文件

np.save('./data.npy', arr1, allow_pickle=True)

2. np.savez 存储多个数组到 npz 文件

np.savez('./data.npz', arr1, arr2)        # 没有 allow_pickle 参数

np.savez('./data.npz', A1=arr1, A2=arr2)        # 用类似字典的关键字参数在保存时命名

保存时若不指定名称，则默认命名为 'arr_1', 'arr_2' 等

3. np.load 读取 npy, npz 文件

f = np.load('./data.npy', allow_pickle=True)

f = np.load('./data.npz', allow_pickle=True)

4. 读取后访问数组

使用类似字典格式访问

import numpy as np

f = np.load('./data.npz', allow_pickle=True)
print(f)
'''
NpzFile './data.npz' with keys: columns, values
'''
names = f['columns']
data = f['values']
# 则names与data分别为一个数组了
# 若保存时没有起名，那么arr1 = f['arr_1'], arr2 = f['arr_2']即可

读写 csv 文本文件

1. np.savetxt 存储到 csv 文件

np.savetxt('./data.csv', arr, delimiter=',', fmt='%.18e')

delimiter：分隔符，默认以逗号分隔

fmt：存入格式

2. np.loadtxt 读取 csv 文件

arr = np.loadtxt('./data.csv', delimiter=None)        # 直接得到数组

数组统计分析

1. axis 轴向

axis=0 沿 0 轴(纵轴)，axis=1 沿 1 轴(横轴)

2. arr.sort 直接排序

arr.sort(axis=-1)

原地操作，无返回值

默认沿最后一条轴升序排序，在该轴方向上独立排序，移动的是单元素，而不是整行/列

arr.sort(axis=0)        # 沿 0 轴升序排序

arr.sort(axis=1)        # 沿 1 轴升序排序

import numpy as np

arr = np.array([[1, 3, 1], [5, 6, 8], [2, 2, 9]])
print(arr)
'''
[[1 3 1]
[5 6 8]
[2 2 9]]
'''
arr.sort(axis=0)
print(arr)
'''
[[1 2 1]
[2 3 8]
[5 6 9]]
'''

3. arr.argsort 间接排序

arr.argsort(axis=-1)

返回排序后各元素对应原数组的下标数组

import numpy as np

arr1 = np.array([1, 3, 2, 6, 4])
print(arr1)
'''
[1 3 2 6 4]
'''
print(arr1.argsort())
'''
[0 2 1 4 3] # 对应下标位置
'''

arr2 = np.array([[1, 3, 1], [5, 6, 8], [2, 2, 9]])
print(arr2)
'''
[[1 3 1]
[5 6 8]
[2 2 9]]
'''
print(arr2.argsort(axis=0))
'''
[[0 2 0] # 每一列单独排，对应每一列元素原来的行下标
[2 0 1]
[1 1 2]]
'''

4. np.unique 去重与排序

np.unique(arr, return_index=False, return_counts=False, axis=None)

return_index：返回一个与 arr2 长度相同，分别对应每个元素在原数组 arr 中第一次出现的下标的数组

return_counts：返回一个与 arr2 长度相同，分别对应每个元素在原数组 arr 中出现次数的数组

axis：None 表示展平为 1 维返回一个去除重复值并且升序排序的数组 arr2，0 或 1 表示按方向返回不重复行/列在原数组中首次出现位置（整行/列作为一个单位）

import numpy as np

arr = np.array([[1, 3, 1], [5, 6, 8], [2, 5, 1]])
print(arr)
'''
[[1 3 1]
[5 6 8]
[2 5 1]]
'''
unique, indexx, countss = np.unique(arr, return_index=True, return_counts=True)
print(unique)
print(indexx)
print(countss)
'''
[1 2 3 5 6 8]
[0 6 1 3 4 5]
[3 1 1 2 1 1]
'''

arr2 = arr
u2, i2 = np.unique(arr, return_index=True, axis=0)
print(u2)
'''
[[1 3 1] # 整行整行排
[2 5 1]
[5 6 8]]
'''
print(i2)
'''
[0 2 1]
'''

例题：

1. 若有import numpy as np，则依次执行以下语句的输出结果为___。

    a = np.array([[1, 3, 5], [2, 5, 8], [1, 3, 5]])

    u, idx = np.unique(a, return_index=True, axis=0)

    print(u)

    print(idx)

# 答案
import numpy as np

a = np.array([[1, 3, 5], [2, 5, 8], [1, 3, 5]])
u, idx = np.unique(a, return_index=True, axis=0)
print(u)
'''
[[1 3 5]
[2 5 8]]
'''
print(idx)
'''
[0 1]
'''

5. arr 统计函数

axis=None 表示返回全部的聚合，会展平为 1 为之后聚合，axis=0 或 1 表示返回轴向的聚合

arr.max(axis=None)：最大值

arr.argmax(axis=None)：最大值下标

arr.min(axis=None)：最小值

arr.argmin(axis=None)：最小值下标

arr.sum(axis=None)：求和

arr.cumsum(axis=None)：

        累和，与原数组形状相同

        1维axis=None：[a0 a0+a1 a0+a1+a2 …]

        2维axis=None，展平为1维：[a00 a00+a01 a00+a01+a02 … a00+…+a10 a00+…+a11 a00+…+a12 …]

arr.prod(axis=None)：求积

arr.cumprod(axis=None)：

        累积，与原数组形状相同

        1维axis=None：[a0 a0*a1 a0*a1*a2 …]

        2维axis=None，展平为1维：[a00 a00*a01 a00*a01*a02 … a00*…*a10 a00*…*a11 a00*…*a12 …]

arr.var(axis=None)：方差

arr.std(axis=None)：标准差

练习题2

读取iris数据集中的花萼长度数据(已保存为csv格式)，求出总和、均值、标准差、方差、最小值、最大值、每种花萼的长度及其出现的次数(放在同一个元组给出列表，形如[(长度1, 次数1), (长度2, 次数2), …])。

# 本人思路，供参考
import numpy as np

arr = np.loadtxt('./iris_sepal_length.csv', delimiter=',')
print('花萼长度数组为：', arr)
print('总和：', arr.sum())
print('均值：', arr.mean())
print('标准差：', arr.std())
print('方差：', arr.var())
print('最小值：', arr.min())
print('最大值：', arr.max())
unique, countss = np.unique(arr, return_counts=True)
results = list(zip(unique, countss))
print('花萼长度及出现次数：', results)

练习题3

写出一个表达式，其功能是选取二维数组中各列上的元素之和位于一个给定区间(a, b)的那些列。然后，通过编程，验证所写表达式的正确性。

# 本人思路，供参考
import numpy as np

arr2 = np.array([[1, 3, 1, 5], [5, 6, 8, 5], [2, 2, 9, 5]])
print(arr2)
'''
[[1 3 1 5]
[5 6 8 5]
[2 2 9 5]]
'''

a, b = 10, 16
# 一维布尔数组，列和大于10小于16
col_mask = np.logical_and(arr2.sum(axis=0) > a, arr2.sum(axis=0) < b)

# 数组列和大于10小于16的列
print(arr2[:, col_mask])
'''
[[3 5]
[6 5]
[2 5]]
'''

# 合并为最终表达式arr2[:, np.logical_and(arr2.sum(axis=0) > a, arr2.sum(axis=0) < b)]