python之多维数组（二）

ndarray访问、修改

ndarray对象的内容可以通过索引或者切片来访问和修改，就像python的内置容器对象一样。 ndarray对象中的元素遵循基于零的索引。
有三种行可用的索引方法类型：
①字段访问
②基本切片
③高级索引

字段访问、基本切片

import numpy as np
arr = np.arange(10)
print(arr)   # [0 1 2 3 4 5 6 7 8 9]
arr2 = arr[2:7:2] 
print(arr2)  # [2 4 6]

arr=np.array([
        [
            [1,2,3,4],
            [2,3,4,5],
            [3,4,5,6]
        ],
        [
            [10,20,30,40],
            [20,30,40,50],
            [30,40,50,60]
        ]
    ])
 # 字段访问
print(arr[1])  #[[10 20 30 40][20 30 40 50][30 40 50 60]]
print(arr[1][1])  #[20 30 40 50]
print(arr[1][1][2])  #40

# 基本切片
# 取40 50
print(arr[1][1][2:])  # [40 50]
print(arr[1,1,2:])  # [40 50]

print(arr[1][:][0:2])  # [[10 20 30 40] [20 30 40 50]]
print(arr[1,:,0:2])    # [[10 20][20 30][30 40]]

高级索引

如果一个ndarray是非元组序列，数据类型为整数或布尔值的ndarray，或者至少一个元素为序列对象的元组，我们就能够用它来索引ndarray。高级索引始终返回数据的副本。 与此相反，切片只提供了一个视图。

• 花式索引、 整数索引
  这种机制有助于基于 N 维索引来获取数组中任意元素。 每个整数数组表示该维度的下标值。 当索引的元素个数就是目标ndarray的维度时，会变得相当直接。

import numpy as np
a = np.arange(9).reshape(3,3)
print(a)  # [[0 1 2][3 4 5][6 7 8]]
a[[0,1,2],[0,1,2]] = 9
print(a)  # [[9 1 2][3 9 5][6 7 9]]
num = a[[0,1,2],[0,1,2]]
#使用索引器 np.ix_()
num = a[np.ix_([0,1,2],[0,1])]
print(num)

arr = np.arange(18).reshape(2,3,3)
print(arr)
arr[...,[0,1,2],[0,1,2]] = 9
print(arr)
num = arr[np.ix_([0,1],[0,1,2],[0,1])]
num[:,[0]] = 99
print(num)

• 布尔索引
  当结果对象是布尔运算的结果时，将使用此类型的高级索引

arr = np.arange(12).reshape(4,3)
print(arr)
print('大于五的元素是：')
print(arr[arr>5])

names = np.array(['joe','susan','tom'])
scores = np.array([
    [98,86,88,90],
    [70,86,90,99],
    [82,88,89,86]
])
classic = np.array(['语文','数学','英语','科学'])
print('susan的成绩是:')
# print(names=='susan')
print(scores[names=='susan'])

print('susan的数学成绩:')
# print(scores[names=='susan',classic=='数学'])
print(scores[names=='susan'].reshape(-1,)[classic=='数学'])

print('joe和susan的成绩是：')

print(scores[(names=='joe')|(names=='susan')])

print('非joe和susan的成绩')
print(scores[(names!='joe')&(names!='susan')])

• 数组转置与轴对换

arr = np.arange(24).reshape(2,3,4)
print(arr.shape)
# print(np.transpose(arr))
#print(arr.transpose())
print(arr.T)

Numpy算数运算

用于执行算数运算的输入数组必须具有相同的行列或符合数组广播规则

import numpy as np
a = np.arange(9).reshape(3,3)
b = np.array([2,3,4])
print(a)
print(b)
print('***************两个数组相加***********************')
#两个数组相加
print(np.add(a,b))
print(a+b)
print('************两个数组相减**************************')
#两个数组相减
print(a-b)
print(np.subtract(a,b))
print('*************两个数组相乘*************************')
#两个数组相乘
print(a*b)
print(np.multiply(a,b))
print('************两个数组相除**************************')
print(a/b)
print(np.divide(a,b))
print('************两个数组取幂**************************')
#两个数组取幂
print(a**b)
print(np.power(a,b))
print('****************两个数组取余**********************')
#mod 两个数组取余
a = np.array([10,20,30])
b = np.array([3,5,7])
print(np.mod(a,b))
print(np.remainder(a,b))
print('**************************************')

运行结果：

 [[0 1 2]
 [3 4 5]
 [6 7 8]]
[2 3 4]
***************两个数组相加***********************
[[ 2  4  6]
 [ 5  7  9]
 [ 8 10 12]]
[[ 2  4  6]
 [ 5  7  9]
 [ 8 10 12]]
************两个数组相减**************************
[[-2 -2 -2]
 [ 1  1  1]
 [ 4  4  4]]
[[-2 -2 -2]
 [ 1  1  1]
 [ 4  4  4]]
*************两个数组相乘*************************
[[ 0  3  8]
 [ 6 12 20]
 [12 21 32]]
[[ 0  3  8]
 [ 6 12 20]
 [12 21 32]]
************两个数组相除**************************
[[0.         0.33333333 0.5       ]
 [1.5        1.33333333 1.25      ]
 [3.         2.33333333 2.        ]]
[[0.         0.33333333 0.5       ]
 [1.5        1.33333333 1.25      ]
 [3.         2.33333333 2.        ]]
************两个数组取幂**************************
[[   0    1   16]
 [   9   64  625]
 [  36  343 4096]]
[[   0    1   16]
 [   9   64  625]
 [  36  343 4096]]
****************两个数组取余**********************
[1 0 2]
[1 0 2]
**************************************

Numpy矩阵积

两个二位矩阵，满足第一个矩阵的列数与第二个矩阵的行数相同，那么就可以进行矩阵的乘法，即矩阵积

import numpy as np
arr1 = np.array([
    [110,60,220],
    [115,45,180],
    [132,67,209]
])
arr2 = np.array([
    [12.3,0.04],
    [204,2.34],
    [9.98,0.45]
])
print(arr2)
print(arr1.dot(arr2))
print('**************************************')

运行结果：

[[1.23e+01 4.00e-02]
[2.04e+02 2.34e+00]
[9.98e+00 4.50e-01]]
[[15788.6    243.8 ]
 [12390.9    190.9 ]
 [17377.42   256.11]]
**************************************

Numpy广播

术语广播是指 NumPy 在算术运算期间处理不同形状的数组的能力。
对数组的算术运算通常在相应的元素上进行，如果两个阵列具有完全相同的形状，则这些操作无缝执行

a = np.array([1,2,3,4])
b = np.array([[10,20,30,40],[1,2,3,4]])
c = a * b
print(c)

如果两个数组的维数不相同，则元素到元素的操作是不可能的。
然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。
较小的数组会广播到较大数组的大小，以便使它们的形状可兼容。
如果满足以下规则，可以进行广播：
让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐
输出数组的shape是输入数组shape的各个轴上的最大值
如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，
否则出错
当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值