python-numpy库 学习笔记三 ndarray数组的索引和切片和数组的运算

数组的索引和切片和数组的运算

数组的索引和切片

索引：获取数组中特定位置元素的过程
切片：获取数组元素子集的过程

• 一维数组的索引和切片

import numpy as np
a=np.array(range(1,20,2))
print(a)   #一维数组
[ 1  3  5  7  9 11 13 15 17 19]
#一维数组的索引，
#一维数组的编号，从左向右（0 1 2*****），从右向左（-1 -2 -3 ****）
print(a[2])
5
print(a[-2])
17
#一维数组的切片
print(a[1:6:2])  #1起始位置，6终止位置，2步长 步长默认为1
[ 3  7 11]
print(a[-1:-6:-2])
[19 15 11]
print(a[-6:-1:])
[ 9 11 13 15 17]

• 多维数组的索引

import numpy as np
a=np.array(range(24)).reshape(2,3,4,)
print(a)   #多维数组
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
#多维数组的索引，多维数组的排序方式和一维相同，从0开始
print(a[0, 1, 1])   #每个维度一个索引值，逗号分隔，
5
print(a[1, 2, 3])
23
print(a[-1, 2, 3])
23

• 多维数组的切片

import numpy as np
a=np.array(range(24)).reshape(2,3,4,)
print(a)   #多维数组
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]

 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]
#多维数组的切片
#每个维度之间使用逗号分隔，选取一个维度用：，一个维度内同一维切片
print(a[1, 1, :])   #切去第二个矩阵的第二行
[16 17 18 19]
print(a[:, :, 2])   #切去两个矩阵的第三列
[[ 2  6 10]
 [14 18 22]]
print(a[:, :, :2])  #切去两个矩阵的前两列
[[[ 0  1]
  [ 4  5]
  [ 8  9]]

 [[12 13]
  [16 17]
  [20 21]]]

数组的运算

数组与标量之间的运算

数组与标量之间的运算作用于数组的每一个元素

import numpy as np
a=np.array(range(24)).reshape(2,3,4,)
print(a)   #原始数组
pm=a.mean()
print(pm)   #计算数组的平均值，数组内所有元素之和除以元素个数
11.5
#数组与标量之间的运算，标量作用于数组的每一个元素
b=a-pm
print(b)
[[[-11.5 -10.5  -9.5  -8.5]
  [ -7.5  -6.5  -5.5  -4.5]
  [ -3.5  -2.5  -1.5  -0.5]]

 [[  0.5   1.5   2.5   3.5]
  [  4.5   5.5   6.5   7.5]
  [  8.5   9.5  10.5  11.5]]]
print(a-a/pm)
[[[ 0.          0.91304348  1.82608696  2.73913043]
  [ 3.65217391  4.56521739  5.47826087  6.39130435]
  [ 7.30434783  8.2173913   9.13043478 10.04347826]]

 [[10.95652174 11.86956522 12.7826087  13.69565217]
  [14.60869565 15.52173913 16.43478261 17.34782609]
  [18.26086957 19.17391304 20.08695652 21.        ]]]

numpy一元函数

对ndarray中的数据执行元素级运算的函数

• np.abs(x) np.fabs(x) 计算数组各元素的绝对值

import numpy as np
a=0.25*(np.array(range(12)).reshape(3,4)-6)
print(a)   #原始数组
[[-1.5  -1.25 -1.   -0.75]
 [-0.5  -0.25  0.    0.25]
 [ 0.5   0.75  1.    1.25]]
print(np.abs(a))  #计算数组各元素的绝对值
[[1.5  1.25 1.   0.75]
 [0.5  0.25 0.   0.25]
 [0.5  0.75 1.   1.25]]
import numpy as np
a=0.25*(np.array(range(12)).reshape(3,4)-6)
print(a)   #原始数组
# [[-1.5  -1.25 -1.   -0.75]
#  [-0.5  -0.25  0.    0.25]
#  [ 0.5   0.75  1.    1.25]]
print(np.fabs(a))  #计算数组各元素的绝对值
[[1.5  1.25 1.   0.75]
 [0.5  0.25 0.   0.25]
 [0.5  0.75 1.   1.25]]

• np.sqrt(x) 计算数组各元素的平方根

import numpy as np
a=0.25*(np.array(range(12)).reshape(3,4))
print(a)   #原始数组
[[0.   0.25 0.5  0.75]
 [1.   1.25 1.5  1.75]
 [2.   2.25 2.5  2.75]]
print(np.sqrt(a))  #计算数组各元素的平方根
[[0.         0.5        0.70710678 0.8660254 ]
 [1.         1.11803399 1.22474487 1.32287566]
 [1.41421356 1.5        1.58113883 1.6583124 ]]

• np.square(x) 计算数组各元素的平方

import numpy as np
a=0.25*(np.array(range(12)).reshape(3,4)-6)
print(a)   #原始数组
[[-1.5  -1.25 -1.   -0.75]
 [-0.5  -0.25  0.    0.25]
 [ 0.5   0.75  1.    1.25]]
print(np.square(a))  #计算数组各元素的平方
[[2.25   1.5625 1.     0.5625]
 [0.25   0.0625 0.     0.0625]
 [0.25   0.5625 1.     1.5625]]

• np.log(x) 计算数组各元素的自然对数

import numpy as np
a=np.array(range(12)).reshape(3,4)+1
print(a)   #原始数组
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
print(np.log(a))  #计算数组各元素的自然对数
[[0.         0.69314718 1.09861229 1.38629436]
 [1.60943791 1.79175947 1.94591015 2.07944154]
 [2.19722458 2.30258509 2.39789527 2.48490665]]

• np.log10(x) 计算数组各元素以10为底的对数

import numpy as np
a=np.array(range(12)).reshape(3,4)+1
print(a)   #原始数组
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
print(np.log10(a))  #计算数组各元素以10为底的对数
[[0.         0.30103    0.47712125 0.60205999]
 [0.69897    0.77815125 0.84509804 0.90308999]
 [0.95424251 1.         1.04139269 1.07918125]]

• np.log2(x) 计算数组各元素以2为底的对数

import numpy as np
a=np.array(range(12)).reshape(3,4)+1
print(a)   #原始数组
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
print(np.log2(a))  #计算数组各元素以2为底的对数
[[0.         1.         1.5849625  2.        ]
 [2.32192809 2.5849625  2.80735492 3.        ]
 [3.169925   3.32192809 3.45943162 3.5849625 ]]

• np.ceil(x) 计算数组各元素的ceiling值，返回大于或者等于指定表达式的最小整数

import numpy as np
a=0.25*np.array(range(12)).reshape(3,4)
print(a)   #原始数组
[[0.   0.25 0.5  0.75]
 [1.   1.25 1.5  1.75]
 [2.   2.25 2.5  2.75]]
print(np.ceil(a))  #计算数组各元素的ceiling值,返回大于或者等于指定表达式的最小整数
[[0. 1. 1. 1.]
 [1. 2. 2. 2.]
 [2. 3. 3. 3.]]

• np.floor(x) 计算数组各元素的floor值，向下取整”，或者说“向下舍入”、“向零取舍”，即取不大于x的最大整数

import numpy as np
a=0.25*np.array(range(12)).reshape(3,4)
print(a)   #原始数组
[[0.   0.25 0.5  0.75]
 [1.   1.25 1.5  1.75]
 [2.   2.25 2.5  2.75]]
print(np.floor(a))  #计算数组各元素的floor值,向下取整”，或者说“向下舍入”、“向零取舍”，即取不大于x的最大整数
[[0. 0. 0. 0.]
 [1. 1. 1. 1.]
 [2. 2. 2. 2.]]

• np.rint(x) 计算数组各元素的四舍五入值

import numpy as np
a=0.6241*np.array(range(12)).reshape(3,4)
print(a)   #原始数组
[[0.     0.6241 1.2482 1.8723]
 [2.4964 3.1205 3.7446 4.3687]
 [4.9928 5.6169 6.241  6.8651]]
print(np.rint(a))  #计算数组各元素的四舍五入值
[[0. 1. 1. 2.]
 [2. 3. 4. 4.]
 [5. 6. 6. 7.]]

• np.modf(x) 将数组各元素的小数和整数部分以两个独立数组形式返回。

import numpy as np
a=0.6241*np.array(range(12)).reshape(3,4)
print(a)   #原始数组
# [[0.     0.6241 1.2482 1.8723]
#  [2.4964 3.1205 3.7446 4.3687]
#  [4.9928 5.6169 6.241  6.8651]]
print(np.modf(a))  #将数组各元素的小数和整数部分以两个独立数组形式返回。
(array([[0.    , 0.6241, 0.2482, 0.8723],
       [0.4964, 0.1205, 0.7446, 0.3687],
       [0.9928, 0.6169, 0.241 , 0.8651]]), array([[0., 0., 1., 1.],
       [2., 3., 3., 4.],
       [4., 5., 6., 6.]]))

• np.cos(x)/np.sin(x)/np.tan(x) 计算数组各元素三角函数
• np.cosh(x)/np.sinh(x)/np.tanh(x) 计算数组各元素双曲型三角函数

import numpy as np
a=0.6241*np.array(range(12)).reshape(3,4)
print(a)   #原始数组
# [[0.     0.6241 1.2482 1.8723]
#  [2.4964 3.1205 3.7446 4.3687]
#  [4.9928 5.6169 6.241  6.8651]]
print(np.cos(a))  #计算三角函数。
[[ 1.          0.81148938  0.31703002 -0.29695639]
 [-0.79898393 -0.99977756 -0.82363381 -0.33696262]
 [ 0.27675064  0.78612302  0.99911033  0.83541182]]

• np.exp(x) 计算数组各元素的指数值

import numpy as np
a=np.array(range(12)).reshape(3,4)
print(a)   #原始数组
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
print(np.exp(a))  #计算数组各元素的e的指数值
[[1.00000000e+00 2.71828183e+00 7.38905610e+00 2.00855369e+01]
 [5.45981500e+01 1.48413159e+02 4.03428793e+02 1.09663316e+03]
 [2.98095799e+03 8.10308393e+03 2.20264658e+04 5.98741417e+04]]

• np.sign(x) 计算数组各元素的符号值，1（+），0，-1（-）

import numpy as np
a=np.array(range(12)).reshape(3,4)-6
print(a)   #原始数组
[[-6 -5 -4 -3]
 [-2 -1  0  1]
 [ 2  3  4  5]]
print(np.sign(a))  #计算数组各元素的符号值，1（+），0，-1（-）
[[-1 -1 -1 -1]
 [-1 -1  0  1]
 [ 1  1  1  1]]

numpy二元函数

• （+ - * / ** ） 两个数组各元素进行对应运算
• np.maximum(x,y)/np.fmax() 元素级的最大值
• np.minimum(x,y)/np.fmin() 元素级的最小值
• np.mod(x,y) 元素级的模运算
• np.copysign(x,y) 将数组y中个元素值的符号赋值给数组x对应元素
• ||| > < >= <= == != 算术比较产生布尔型数组

import numpy as np
a=np.array(range(12)).reshape(3,4)-3
b=0.5*np.array(range(12)).reshape(3,4)+1
print(a)   #原始数组a
[[-3 -2 -1  0]
 [ 1  2  3  4]
 [ 5  6  7  8]]
print(b)   #原始数组b
[[1.  1.5 2.  2.5]
 [3.  3.5 4.  4.5]
 [5.  5.5 6.  6.5]]
print(a*b)    #两个数组各元素进行对应运算
[[-3. -3. -2.  0.]
 [ 3.  7. 12. 18.]
 [25. 33. 42. 52.]]
print(np.fmax(a,b))    #元素级的最大值,将两个数组对应元素对比取大的组成新数组
[[1.  1.5 2.  2.5]
 [3.  3.5 4.  4.5]
 [5.  6.  7.  8. ]]
print(np.fmin(a,b))    #元素级的最大值，将两个数组对应元素对比取小的组成新数组
[[-3.  -2.  -1.   0. ]
 [ 1.   2.   3.   4. ]
 [ 5.   5.5  6.   6.5]]
print(np.mod(a,b))    #元素级的模运算 a/b
[[0.  1.  1.  0. ]
 [1.  2.  3.  4. ]
 [0.  0.5 1.  1.5]]
print(np.copysign(b,a))    #将数组a中个元素值的符号赋值给数组b对应元素
[[-1.  -1.5 -2.   2.5]
 [ 3.   3.5  4.   4.5]
 [ 5.   5.5  6.   6.5]]
print(a>b)    #算术比较产生布尔型数组
[[False False False False]
 [False False False False]
 [False  True  True  True]]