Numper基础（二）

原创于 2024-07-30 16:34:10 发布 · 717 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#numpy

Python基础专栏收录该内容

17 篇文章

订阅专栏

Numper基础（二）

一、本科目标

掌握ndarray的广播操作
掌握Numpy的各种函数及使用

二、数组得到添加与删除

函数	元素及描述
resize	返回指定形状的新数组
append	将值添加到数组末尾
insert	沿指定轴将值插入到指定下标之前
delete	删掉某个轴的子数组，并返回删除后的新数组
unique	查找数组内的唯一元素

import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
print("第一个数组：")
print(a)
print('第一个数组的形状：')
print(a.shape)
b = np.resize(a, (3, 2))
print('第二个数组：')
print(b)
print('第二个数组的形状：')
print(b.shape)
# 要注意a的第一行在b中重复出现，因为尺寸变大了
print('修改后第二个数组的大小：')
b = np.resize(a,(3, 3))
print(b)
'''
第一个数组：
[[1 2 3]
 [4 5 6]]
第一个数组的形状：
(2, 3)
第二个数组：
[[1 2]
 [3 4]
 [5 6]]
第二个数组的形状：
(3, 2)
修改后第二个数组的大小：
[[1 2 3]
 [4 5 6]
 [1 2 3]]
'''

a = np.array([[1, 2, 3], [4, 5, 6]])
print('第一个数组：')
print(a)
print('向数组添加元素：')
print(np.append(a, [7, 8, 9]))
print('沿轴0添加元素：')
print(np.append(a, [[7, 8, 9]], axis = 0))
print('沿轴1添加元素：')
print(np.append(a, [[5, 5, 5], [7, 8, 9]], axis = 1))
'''
第一个数组：
[[1 2 3]
 [4 5 6]]
向数组添加元素：
[1 2 3 4 5 6 7 8 9]
沿轴0添加元素：
[[1 2 3]
 [4 5 6]
 [7 8 9]]
沿轴1添加元素：
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]
'''

a = np.array([[1, 2], [3, 4], [5, 6]])
print('第一个数组：')
print(a)
print('未传递Axis参数，在删除之前输入数组会被展开')
print(np.insert(a, 3, [11, 12]))
print('沿轴0广播：')
print(np.insert(a, 1, [11], axis = 0))
print('沿轴1广播：')
print(np.insert(a, 1, 11, axis = 1))
'''
第一个数组：
[[1 2]
 [3 4]
 [5 6]]
未传递Axis参数，在删除之前输入数组会被展开
[ 1  2  3 11 12  4  5  6]
沿轴0广播：
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]
沿轴1广播：
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]
'''

a = np.arange(12).reshape(3, 4)
print('第一个数组：')
print(a)
print('未传递Axis参数，再删除之前输入数组会被展开：')
print(np.delete(a, 5))
print('删除第二列：')
print(np.delete(a, 1, axis = 1))
print('包含从数组中删除的替代值的切片：')
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(np.delete(a, np.s_[::2]))
'''
第一个数组：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
未传递Axis参数，再删除之前输入数组会被展开：
[ 0  1  2  3  4  6  7  8  9 10 11]
删除第二列：
[[ 0  2  3]
 [ 4  6  7]
 [ 8 10 11]]
包含从数组中删除的替代值的切片：
[ 2  4  6  8 10]
'''

a = np.array([5, 2 ,6, 2, 7, 5, 6, 8, 2, 9])
print('第一个数组：')
print(a)
print('第一个数组的去重值：')
u = np.unique(a)
print(u)
print('去重数组的正向索引：')
u,indices = np.unique(a, return_index = True)# 返回新数组中的元素在旧数组出现的索引值
print(indices)
print('去重数组的反向索引：')
u,indices = np.unique(a,return_inverse = True)# 返回新数组中的元素在新数组出现的索引值
print(indices)
print('使用反向索引重构原数组：')
print(u[indices])
print('返回去重元素的重复数量：')
u,indices = np.unique(a, return_counts = True)
print(indices)
'''
第一个数组：
[5 2 6 2 7 5 6 8 2 9]
第一个数组的去重值：
[2 5 6 7 8 9]
去重数组的正向索引：
[1 0 2 4 7 9]
去重数组的反向索引：
[1 0 2 0 3 1 2 4 0 5]
使用反向索引重构原数组：
[5 2 6 2 7 5 6 8 2 9]
返回去重元素的重复数量：
[3 2 2 1 1 1]
'''

三、字符串函数

函数	描述
add()	对两个数组的逐个字符串元素进行连接
multiply()	返回按元素多重连接后的字符串
center()	居中字符串
capitalize()	将字符串第一个字母转换为大写
title()	将字符串的每个单词的第一个字母转换为大写
lower()/upper()	数组元素转换为小/大写
split()	指定分隔符（默认是空格）对字符串进行分割，并返回数组列表
strip()	移除元素开头或者结尾处的特定字符
replace()	使用新字符串替换字符串中的所有子字符串
decode()	数组元素依次调用str.decode
encode()	数组元素依次调用str.encode

print(np.char.add(['hello'], ['xyz']))
print(np.char.add(['hello', 'hi'], ['abc', 'xyz']))
print(np.char.center('Baidu', 20, fillchar = '*'))
print(np.char.capitalize('baidu'))
print(np.char.title('i like baidu'))
print(np.char.lower(['BAIDU', 'GOOGLE']))
print(np.char.lower('BAIDU'))
print(np.char.upper(['baidu', 'google']))
print(np.char.upper('baidu'))
'''
['helloxyz']
['helloabc' 'hixyz']
*******Baidu********
Baidu
I Like Baidu
['baidu' 'google']
baidu
['BAIDU' 'GOOGLE']
BAIDU
'''

print(np.char.split('i like baidu?'))
print(np.char.split('www.baidu.com', sep = '.' ))
print(np.char.splitlines('i\nlike baidu?'))
print(np.char.splitlines('i\rlike baidu?'))
print(np.char.strip('ashok abaidua', 'a'))
print(np.char.strip(['abaidua', 'admin', 'java'], 'a'))
print(np.char.join(':', 'baidu'))
print(np.char.join([':', '-'], ['baidu', 'google']))

print(np.char.replace('i like baidu', 'oo', 'cc'))
print(np.char.encode('baidu', 'cp500'))
print(np.char.decode(np.char.encode('baidu', 'cp500'), 'cp500'))
'''
['i', 'like', 'baidu?']
['www', 'baidu', 'com']
['i', 'like baidu?']
['i', 'like baidu?']
shok abaidu
['baidu' 'dmin' 'jav']
b:a:i:d:u
['b:a:i:d:u' 'g-o-o-g-l-e']
i like baidu
np.bytes_(b'\x82\x81\x89\x84\xa4')
baidu
'''

# 练习
print(np.char.add(['越努力', '充满'], ['越幸运', '正能量']))
print('努力学习' * 3)
print(np.char.center('我要努力', 20, '*'))
print(np.char.capitalize('numpy'))
print(np.char.title('i learn python and numpy.'))
a = np.char.upper('i hard work everyday.')
print(a, np.char.lower(a))
print(np.char.split(['www.baidu.com', 'www.python.org'], '.'))
# 原始字符串列表
str_list = ["admin", "java", "aheada"]
# 使用列表推导式去除每个字符串开头和结尾的字符 'a'
# 这里使用 str.lstrip('a') 去除开头的 'a'，str.rstrip('a') 去除结尾的 'a'
cleaned_str_list = [s.lstrip('a').rstrip('a') for s in str_list]
# 将处理后的字符串列表转换为 NumPy 数组
cleaned_str_array = np.array(cleaned_str_list)
print(cleaned_str_array)
print(np.char.replace(['这个', '那个'], '个', '些'))
print(np.char.encode(['努力', '学习']), np.char.decode([b'\xe5\x8a\xaa\xe5\x8a\x9b', b'\xe5\xad\xa6\xe4\xb9\xa0']))
'''
['越努力越幸运' '充满正能量']
努力学习努力学习努力学习
********我要努力********
Numpy
I Learn Python And Numpy.
I HARD WORK EVERYDAY. i hard work everyday.
[list(['www', 'baidu', 'com']) list(['www', 'python', 'org'])]
['dmin' 'jav' 'head']
['这些' '那些']
[b'\xe5\x8a\xaa\xe5\x8a\x9b' b'\xe5\xad\xa6\xe4\xb9\xa0'] ['努力' '学习']
'''

四、数学函数

函数	描述
add()	返回两个数组的和
subtract()	返回两个数组的差
multiply()	返回两个数组的积
divide()	返回两个数组的商
mod()或remainder()	返回两个数组的余数
reciprocal()	返回指定数组的倒数
power()	返回两个数组的幂
around()	返回指定数字的四舍五入值
floor()	返回小于或者等于指定表达式的最大整数，即向下取整
ceil()	返回大于或者等于指定表达式的最小整数，即向上取整

a = np.array([1.0, 5.55, 123, 0.567, 25.532])
print(np.around(a))
print(np.around(a, decimals = 1))
print(np.around(a, decimals = -1))
a = np.array([-1.7, 1.5, -0.2, 0.6, 10])
print(np.floor(a))
print(np.ceil(a))
a = np.arange(9, dtype = np.float64).reshape(3, 3)
print(a)
b = np.array([10, 10, 10])
print(np.add(a, b))
print((np.subtract(a, b)))
print(np.multiply(a, b))
print(np.divide(a, b))
'''
[  1.   6. 123.   1.  26.]
[  1.    5.6 123.    0.6  25.5]
[  0.  10. 120.   0.  30.]
[-2.  1. -1.  0. 10.]
[-1.  2. -0.  1. 10.]
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
[[10. 11. 12.]
 [13. 14. 15.]
 [16. 17. 18.]]
[[-10.  -9.  -8.]
 [ -7.  -6.  -5.]
 [ -4.  -3.  -2.]]
[[ 0. 10. 20.]
 [30. 40. 50.]
 [60. 70. 80.]]
[[0.  0.1 0.2]
 [0.3 0.4 0.5]
 [0.6 0.7 0.8]]
'''

a = np.array([0.25, 1.33, 1, 100])  # 返回指定数组的倒数
print(np.reciprocal(a))
a = np.array([10, 100, 1000])
print(np.power(a, 2))
b = np.array([1, 2, 3])
print(np.power(a, b))
a = np.array([10, 20, 30])
b = np.array([3, 5, 7])
print(np.mod(a, b))
print(np.remainder(a, b))
'''
[4.        0.7518797 1.        0.01     ]
[    100   10000 1000000]
[        10      10000 1000000000]
[1 0 2]
[1 0 2]
'''

# 将以下两个数组分别求和、差、积、商、模、平方
a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
b = np.array([10, 10, 10])
print('两个数组的和:')
print(np.add(a, b))
print('两个数组的差:')
print(np.subtract(a, b))
print('两个数组的积:')
print(np.multiply(a, b))
print('两个数组的商:')
print(np.divide(a, b))
print('两个数组的模:')
print(np.mod(a, b))
print('两个数组的平方:')
print(np.power(a, 2))
print(np.power(b, 2))
'''
两个数组的和:
[[11 12 13]
 [14 15 16]
 [17 18 19]]
两个数组的差:
[[-9 -8 -7]
 [-6 -5 -4]
 [-3 -2 -1]]
两个数组的积:
[[10 20 30]
 [40 50 60]
 [70 80 90]]
两个数组的商:
[[0.1 0.2 0.3]
 [0.4 0.5 0.6]
 [0.7 0.8 0.9]]
两个数组的模:
[[1 2 3]
 [4 5 6]
 [7 8 9]]
两个数组的平方:
[[ 1  4  9]
 [16 25 36]
 [49 64 81]]
[100 100 100]
'''

a = np.array([0.5, 0.2, 0.1, 0.125, 0.0625])
print(np.reciprocal(a))
print(np.floor(a))
print(np.ceil(a))
'''
[ 2.  5. 10.  8. 16.]
[0. 0. 0. 0. 0.]
[1. 1. 1. 1. 1.]
'''

五、统计函数

函数	说明
amin()	计算数组中的元素沿指定轴的最小值
amax()	计算数组中的元素沿指定轴的最大值
ptp()	计算数组中元素最大值与最小值的差
percentile()	表示小于百分值的观察值的百分比
median()	计算数组中元素的中位数（中值）
mean()	返回数组中元素的算术平均值
average()	根据权重数组计算指定数组中元素的加权平均值
std()	标准差是一组数据平均值分散程度的一种度量
var()	样本方差，标准差是方差的算术平方根

a = np.array([[3, 7, 5], [8, 4, 3], [2, 4, 9]])
print(a)
print(np.amin(a, 1))
print(np.amin(a, 0))
print(np.amax(a))
print(np.amax(a, axis = 0))
'''
[[3 7 5]
 [8 4 3]
 [2 4 9]]
[3 3 2]
[2 4 3]
9
[8 7 9]
'''
a = np.array([[3, 7, 5], [8, 4, 3], [2, 4, 9]])
print(a)
# 数组元素中最大值与最小值的差
print(np.ptp(a))
print(np.ptp(a, axis = 1))
print(np.ptp(a, axis = 0))
'''
[[3 7 5]
 [8 4 3]
 [2 4 9]]
7
[4 5 7]
[6 3 6]
'''
a = np.array([[10, 7, 4], [3, 2, 1]])
# 返回数组中所有数的中位数
print(np.percentile(a, 50))
print(np.percentile(a, 50, 0))
print(np.percentile(a, 50, 1))
'''
计算并打印数组a每一行的中位数。
np.percentile是NumPy中用于计算百分位数的函数。
a: 输入的原始数组。
50: 指定要计算的百分位数，这里是50%，即中位数。
1: 沿着数组的第二个轴（行方向）计算中位数。
keepdims=True: 确保返回结果的形状在计算中位数的轴上保持维度，即使该轴上只有一个元素。
'''
print(np.percentile(a, 50, 1, keepdims=True))
'''
3.5
[6.5 4.5 2.5]
[7. 2.]
[[7.]
 [2.]]
'''

a = np.array([[30, 65, 70], [80, 95, 10], [50, 90, 60]] )
print(np.median(a))
print(np.median(a, 0))
print(np.median(a, 1))
a = np.array([[1, 2, 3], [3, 4, 5], [4, 5, 6]])
print(a)
print(np.mean(a))
print(np.mean(a, 0))
print(np.mean(a, 1))
'''
65.0
[50. 90. 60.]
[65. 80. 60.]
[[1 2 3]
 [3 4 5]
 [4 5 6]]
3.6666666666666665
[2.66666667 3.66666667 4.66666667]
[2. 4. 5.]
'''

a = np.array([1, 2, 3, 4])
print(np.average(a))
wts = np.array([4, 3, 2, 1])
print(np.average(a, weights = wts))
print(np.average([1, 2, 3, 4], weights = [4, 3, 2, 1], returned = True))
'''
2.5
2.0
(np.float64(2.0), np.float64(10.0))
'''
a = np.arange(6).reshape(3, 2)
wt = np.array([3, 5])
print(np.average(a, 1, weights = wt))
print(np.average(a, 1, weights = wt, returned = True))
print(np.std([1, 2, 3, 4]))
print(np.var([1, 2, 3, 4]))
'''
2.5
2.0
(np.float64(2.0), np.float64(10.0))
[0.625 2.625 4.625]
(array([0.625, 2.625, 4.625]), array([8., 8., 8.]))
1.118033988749895
1.25
'''

# 定义数组
arr1 = np.array([[2, 8, 6], [7, 3, 2], [1, 4, 9]])
arr2 = np.array([[10, 8, 6], [2, 2, 1]])
arr3 = np.array([[50, 60, 70], [80, 90, 90], [60, 90, 80]])
arr4 = np.array([[2, 3, 4], [4, 5, 6], [5, 6, 7]])
arr5 = np.array([1, 2, 3, 4])
arr6 = np.array([[0, 1], [2, 0], [3, 5]])
arr7 = np.array([1, 2, 3, 4, 5])
# 求取数组中的最小值，最大值，及每行每列的最小值和最大值
min_value = np.amin(arr1)
max_value = np.amax(arr1)
min_values_per_row = np.amin(arr1, axis=1)
max_values_per_row = np.amax(arr1, axis=1)
min_values_per_column = np.amin(arr1, axis=0)
max_values_per_column = np.amax(arr1, axis=0)
# 求取数组的极差，及每行每列的极差
range_value = np.ptp(arr1)
range_values_per_row = np.ptp(arr1, axis=1)
range_values_per_column = np.ptp(arr1, axis=0)
# 求数组arr2的50%分位数及每行每列的结果，要求维度不变
percentile_50_arr2 = np.percentile(arr2, 50, keepdims=True)
# 求数组arr3的中位数及每行每列的结果
median_arr3 = np.median(arr3)
median_per_row_arr3 = np.median(arr3, axis=1)
median_per_column_arr3 = np.median(arr3, axis=0)
# 求数组arr4的算术平均值及每行每列的结果
mean_arr4 = np.mean(arr4)
mean_per_row_arr4 = np.mean(arr4, axis=1)
mean_per_column_arr4 = np.mean(arr4, axis=0)
# 求数组arr5受权重数组的加权平均值并返回权重和
weights_arr5 = np.array([4, 3, 2, 1])
average_arr5 = np.average(arr5, weights=weights_arr5)
total_weights_arr5 = weights_arr5.sum()
# 求数组arr6受权重数组的每行加权平均值并返回权重和
row_weights_arr6 = np.array([2, 3])
weighted_means_per_row_arr6 = np.average(arr6, axis=1, weights=row_weights_arr6)
total_weights_arr6 = row_weights_arr6.sum()
# 求数组arr7的标准差和方差
std_dev_arr7 = np.std(arr7)
variance_arr7 = np.var(arr7)
# 打印结果
print(f"Minimum Value of arr1: {min_value}")
print(f"Maximum Value of arr1: {max_value}")
print(f"Range Value of arr1: {range_value}")
print(f"50th Percentile of arr2: {percentile_50_arr2.ravel()}")
print(f"Median of arr3: {median_arr3}")
print(f"Mean of arr4: {mean_arr4}")
print(f"Weighted Average of arr5: {average_arr5} with Total Weights {total_weights_arr5}")
print(f"Weighted Means per Row of arr6: {weighted_means_per_row_arr6} with Total Weights {total_weights_arr6}")
print(f"Standard Deviation of arr7: {std_dev_arr7}")
print(f"Variance of arr7: {variance_arr7}")
'''
Minimum Value of arr1: 1
Maximum Value of arr1: 9
Range Value of arr1: 8
50th Percentile of arr2: [4.]
Median of arr3: 80.0
Mean of arr4: 4.666666666666667
Weighted Average of arr5: 2.0 with Total Weights 10
Weighted Means per Row of arr6: [0.6 0.8 4.2] with Total Weights 5
Standard Deviation of arr7: 1.4142135623730951
Variance of arr7: 2.0
'''

六、排序、条件筛选函数

函数	说明
sort()	返回输入数组的排序副本， order指定排序字段
argsort()	返回的是数组值从小到大的索引值
lexsort()	用于对多个序列进行排序，优先最右列
argmax()	沿给定轴返回最大元素的索引
argmin()	沿给定轴返回最小元素的索引
nonzero()	返回输入数组中非零元素的索引
where()	返回输入数组中满足给定条件的元素的索引
extract()	返回满足条件的元素

a = np.array([[3, 7], [9, 1]])
print(np.sort(a))
print(np.sort(a, 0))
# 定义一个结构化数据类型，包含'name'和'age'两个字段
dt = np.dtype([('name', 'S10'), ('age', int)])
# 使用自定义数据类型创建数组a
a = np.array([('raju', 21),('anil', 25), ('ravi', 17), ('amar', 27)], dtype = dt)
print(a)
# 按照'name'字段对数组a进行排序
print(np.sort(a, order = 'name'))
'''
[[3 7]
 [1 9]]
[[3 1]
 [9 7]]
[('name', 'S10'), ('age', '<i8')]
[(b'raju', 21) (b'anil', 25) (b'ravi', 17) (b'amar', 27)]
[(b'amar', 27) (b'anil', 25) (b'raju', 21) (b'ravi', 17)]
'''

x = np.array([3, 1, 2])
y = np.argsort(x)
print(y)
print('以排序后的顺序重构原数组：')
print(x[y])
print('使用循环重构原数组：')
for i in y:
    print(x[i], end='')
'''
[1 2 0]
以排序后的顺序重构原数组：
[1 2 3]
使用循环重构原数组：
123
'''

a = np.array([[30, 40, 70], [80, 20, 0], [50, 90, 60]])
print(np.argmax(a))
print('展开数组：')
print(a.flatten())
print('沿轴0的最大值索引：')
maxindex = np.argmax(a, 0)
print(maxindex)
print('沿轴1的最大值索引：')
maxindex = np.argmin(a, 1)
print(maxindex)
print('调用argmin()函数：')
minindex = np.argmin(a)
print(minindex)
print('展开数组中的最小值：')
print(a.flatten()[minindex])
print('沿轴0的最小值索引：')
minindex = np.argmin(a, 0)
print(minindex)
print('沿轴1的最小值索引：')
minindex = np.argmin(a, 1)
print(minindex)
'''
7
展开数组：
[30 40 70 80 20  0 50 90 60]
沿轴0的最大值索引：
[1 2 0]
沿轴1的最大值索引：
[0 2 0]
调用argmin()函数：
5
展开数组中的最小值：
0
沿轴0的最小值索引：
[0 1 1]
沿轴1的最小值索引：
[0 2 0]
'''

mn = ('raju', 'anil', 'ravi', 'amar')
dv = ('f.y.', 's.y.', 's.y.', 'f.y.')
ind = np.lexsort((mn, dv))
print(ind)
print('使用这个索引来获取排序后的数据：')
print([mn[i] + ',' + dv[i] for i in ind])
# 返回数组包含所有非零元素的行索引和列索引值。
a = np.array([[30, 40, 0], [0, 20, 10], [50, 0, 60]])
print(np.nonzero(a))
'''
[3 0 1 2]
使用这个索引来获取排序后的数据：
['amar,f.y.', 'raju,f.y.', 'anil,s.y.', 'ravi,s.y.']
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))
'''

x = np.arange(9.).reshape(3, 3)
print(x)
print('大于3的元素的索引：')
y = np.where(x > 3)
print(y)
print('使用这些索引来获取满足条件的元素：')
print(x[y])
'''
[[0. 1. 2.]
 [3. 4. 5.]
 [6. 7. 8.]]
大于3的元素的索引：
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))
使用这些索引来获取满足条件的元素：
[4. 5. 6. 7. 8.]
'''
x = np.arange(9.).reshape(3, 3)
# 定义条件，选择偶数元素
condition = np.mod(x, 2) == 0
print('按元素的条件值：')
print(condition)
print('使用条件提取元素：')
print(np.extract(condition, x))
'''
按元素的条件值：
[[ True False  True]
 [False  True False]
 [ True False  True]]
使用条件提取元素：
[0. 2. 4. 6. 8.]
'''

# 1. 将数组 [[3,7],[9,1]] 按行和列排序
a = np.array([[3, 7], [9, 1]])
# 按行排序
row_sorted = np.sort(a, axis=1)
# 按列排序
column_sorted = np.sort(a, axis=0)
# 2. 将类型为 (name, age) 的数组 [("raju",22),("anil",26),("ravi",15),("amar",28)] 按 name 排序
dt = np.dtype([('name', 'U10'), ('age', int)])
people = np.array([("raju", 22), ("anil", 26), ("ravi", 15), ("amar", 28)], dtype=dt)
# 使用 argsort 按 'name' 字典顺序排序
sorted_people_indices = np.argsort(people['name'])
sorted_people = people[sorted_people_indices]
# 3. 将数组 [5, 3, 4] 以排序后的顺序重构原数组
values = np.array([5, 3, 4])
# 获取排序后的索引
sorted_indices = np.argsort(values)
# 使用索引重构数组
reconstructed = values[sorted_indices]
# 4. 求数组 [[40, 30, 70], [10, 20, 80], [50, 60, 90]] 的最大和最小索引
matrix = np.array([[40, 30, 70], [10, 20, 80], [50, 60, 90]])
# 获取全局最大和最小元素的索引
global_max_index = np.argmax(matrix)
global_min_index = np.argmin(matrix)
# 获取每行每列的最大和最小索引
row_max_indices = np.argmax(matrix, axis=1)
row_min_indices = np.argmin(matrix, axis=1)
col_max_indices = np.argmax(matrix, axis=0)
col_min_indices = np.argmin(matrix, axis=0)
# 5. 两个数组 ('raju', 'anil', 'ravi', 'amar') 和 ('f.y.', 's.y.', 's.y.', 'f.y.') 按第一个数组排序返回的索引
names = np.array(['raju', 'anil', 'ravi', 'amar'])
grades = np.array(['f.y.', 's.y.', 's.y.', 'f.y.'])
# 按 names 排序返回索引
sorted_indices_names = np.argsort(names)
# 6. 求数组 [[40,30,0],[0,30,20],[20,0,50]] 的非零元素的索引
non_zero_matrix = np.array([[40, 30, 0], [0, 30, 20], [20, 0, 50]])
# 获取非零元素的索引
non_zero_row_indices, non_zero_col_indices = np.nonzero(non_zero_matrix)
# 7. 求数组 [[9., 1., 2.], [3., 4., 5.], [6., 7., 8.]] 中大于 3 的元素的索引及元素
array_greater_3 = np.array([[9., 1., 2.], [3., 4., 5.], [6., 7., 8.]])
# 获取大于 3 的元素的索引
indices_greater_3 = np.where(array_greater_3 > 3)
# 8. 抽取数组 [[1., 0., 2.], [4., 3., 5.], [6., 8., 7.]] 中的偶数元素
even_array = np.array([[1., 0., 2.], [4., 3., 5.], [6., 8., 7.]])
# 获取偶数元素的索引
even_row_indices, even_col_indices = np.where(even_array % 2 == 0)
# 打印结果
print("按行排序的数组:\n", row_sorted)
print("按列排序的数组:\n", column_sorted)
print("按 'name' 排序后的数组:\n", sorted_people)
print("排序后的数组重构:\n", reconstructed)
print("全局最大元素索引:", global_max_index)
print("全局最小元素索引:", global_min_index)
print("每行最大索引:", row_max_indices)
print("每行最小索引:", row_min_indices)
print("每列最大索引:", col_max_indices)
print("每列最小索引:", col_min_indices)
print("按 names 排序后的索引:", sorted_indices_names)
print("非零元素的行索引:", non_zero_row_indices)
print("非零元素的列索引:", non_zero_col_indices)
print("大于 3 的元素的索引:", indices_greater_3)
print("偶数元素的行索引:", even_row_indices)
print("偶数元素的列索引:", even_col_indices)
'''
按行排序的数组:
 [[3 7]
 [1 9]]
按列排序的数组:
 [[3 1]
 [9 7]]
按 'name' 排序后的数组:
 [('amar', 28) ('anil', 26) ('raju', 22) ('ravi', 15)]
排序后的数组重构:
 [3 4 5]
全局最大元素索引: 8
全局最小元素索引: 3
每行最大索引: [2 2 2]
每行最小索引: [1 0 0]
每列最大索引: [2 2 2]
每列最小索引: [1 1 0]
按 names 排序后的索引: [3 1 0 2]
非零元素的行索引: [0 0 1 1 2 2]
非零元素的列索引: [0 1 1 2 0 2]
大于 3 的元素的索引: (array([0, 1, 1, 2, 2, 2]), array([0, 1, 2, 0, 1, 2]))
偶数元素的行索引: [0 0 1 2 2]
偶数元素的列索引: [1 2 0 0 1]
'''