1.numpy库
1、特点：
（1）Numpy是数据科学计算的基础模块，用于数值计算
（2）基于数组运算，效率高
（3）拥有许多高级函数，可以对数据进行高效处理
（4）可以进行线性代数相关运算
2.基础用法：矩阵和数组运算
导入
from numpy import *;#导入numpy的库函数
import numpy as np; #这个方式使用numpy的函数时，需要以np.开头。
说明
mat()函数和array()函数的区别：Numpy函数库中存在两种不同的数据类型：矩阵matrix和数组array，都可以用于处理行列表示的数字元素，但类型不同，其中Numpy函数库中的matrix与MATLAB中matrices等价。
mat() 函数与array()函数生成矩阵所需的数据格式有区别，mat()函数中数据可以为字符串以分号（;）分割或者为列表形式以逗号（，）分割，而array()函数中数据只能以逗号（，）分割。
其次，两者的类型不同，用mat()函数转换为矩阵后才能进行一些线性代数的操作。
arr2 = np.linspace(1, 10, 11, dtype=int, endpoint=False)#endpoint=False,表示不取最右边的值
print(arr2)#[1 1 2 3 4 5 5 6 7 8 9] 11个数且不包括10
#dtype=int,如果不设置数据类型，默认float会是一个等差数列
arr3 = np.linspace(1, 10, 10, dtype=int)
print(arr3)#[ 1 2 3 4 5 6 7 8 9 10]10个数且包括10
arr4 = np.array([5, 6, 7])+1#[6 7 8]
arr5 = list(arr4)#[6, 7, 8]
arr6 = []
for i in [5, 6, 7]:
i = i+1
arr6.append(i)#[6, 7, 8]
print(arr4, arr5, arr6)
#对于arr4运算和arr6运算，当数据量较大时，数组处理速度是明显优于循环的
array.copy()
视图上修改，原数据也会发生变化
arr = [1, 2, 3, 4, 5]
arr_change = arr
arr_change[1:3] = [7, 9]
print(arr_change,arr)#[1, 7, 9, 4, 5] [1, 7, 9, 4, 5]
#视图上修改，原数据也会发生变化
arr1 = [1, 2, 3, 4, 5]
arr_change1 = arr.copy()
arr_change1[1:3] = [7, 9]
print(arr_change1, arr1)#[1, 7, 9, 4, 5] [1, 2, 3, 4, 5]
矩阵创建
由一维或者二维数组创建矩阵
import numpy as np
#n*n随机数组
array=np.random.rand(n,n)
#mat()函数转化为随机矩阵
matrix= np.mat（np.random.rand(n,n)）
#创建n*n的零矩阵,其中zeros函数的参数是一个tuple类型（3,3）
matrix= np.mat(np.zeros((3,3)))
#生成一个n*m的x-y之间的随机整数矩阵，其中x为下界（可选，不选时默认为0），y为上届（可选），size表示矩阵维度
matrix= np.mat(np.random.randint(x,y,size=(n,m)))
#创建n*m的未初始化二维数组
a3 = np.empty((2,3))
输出：（may vary）
array([[ 1., 2., 3.],
[ 4., 5., 6.]])
a4 = np.arange(10,30,5) # 初始值10，结束值：30（不包含），步长：5
输出：array([10, 15, 20, 25])
a5 = np.arange(0,2,0.3) # 初始值0，结束值：2（不包含），步长：0.2
输出：array([ 0. , 0.3, 0.6, 0.9, 1.2, 1.5, 1.8])
from numpy import pi
np.linspace(0, 2, 9) # 初始值0，结束值：2（包含），元素个数：9
输出：
array([ 0. , 0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ])
x = np.linspace(0, 2*pi, 9)
输出：
array([ 0. , 0.78539816, 1.57079633, 2.35619449, 3.14159265,
3.92699082, 4.71238898, 5.49778714, 6.28318531])
a = np.arange(6)
输出：
array([0, 1, 2, 3, 4, 5])
b = np.arange(12).reshape(4,3)
输出：
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11]])
c = np.arange(24).reshape(2,3,4)
输出：
array([[[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]],
[[12, 13, 14, 15],
[16, 17, 18, 19],
[20, 21, 22, 23]]])
#生成对角矩阵，dtype用于指定矩阵数据类型
matrix= np.mat(np.eye(2,2,dtype=int))
[[1 0]
[0 1]]
# 生成一个对角线为1,2,3的对角矩阵
a1 = [1,2,3]
a2 = np.mat(np.diag(a1))
[[1 0 0]
[0 2 0]
[0 0 3]]
#生成指定维数的全零数组
array= np.zeros((n,m))
注意有两个（（））
#生成指定维数的全1数组
array= np.ones((n,m))
注意有两个（（））
#生成指定行数的单位数组
array= np.eye(n)
[[1.,0.,0.,0.],
[0.,1.,0.,0.],
[0.,0.,1.,0.,],
[0.,0.,0.,1.]]
#自定义形状数组
array=np.full(shape=(2,3,4),fill_value='ai')
array([[['ai', 'ai', 'ai', 'ai'],
['ai', 'ai', 'ai', 'ai'],
['ai', 'ai', 'ai', 'ai']],
[['ai', 'ai', 'ai', 'ai'],
['ai', 'ai', 'ai', 'ai'],
['ai', 'ai', 'ai', 'ai']]], dtype='<U2')
矩阵查询与功能函数
1.类型查询：type(a)
2.维数信息：a.shape
3.查询数据类型：a.dtype.name
4.元素个数：a.size
5.每个元素所占的字节数：a.itemsize
6.维数：a.ndim
矩阵（数组）运算
1.一元操作
1）求和
b = np.arange(12).reshape(3,4)
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
b.sum()
# 按列求和
b.sum(axis=0)
array([12, 15, 18, 21])
# 按行求和
b.sum(axis=1)
array([ 6, 22, 38])
# 按列进行元素累加
b.cumsum(axis=0)
array([[ 0, 1, 2, 3],
[ 4, 6, 8, 10],
[12, 15, 18, 21]])
# 按行进行元素累加
b.cumsum(axis=1)
array([[ 0, 1, 3, 6],
[ 4, 9, 15, 22],
[ 8, 17, 27, 38]])
2）平方/开方/指数：
a = np.arange(4)
array([0, 1, 2, 3])
b = a**2
array([0, 1, 4, 9])
c = np.exp(a)#以e为底的指数
array（[ 1. 2.71828183 7.3890561 20.08553692]
）
d = np.sqrt(B)
array（[0. 1. 1.41421356 1.73205081]
）
2.与单个数值的乘法：
c = 10*np.sin(a)
array([ 0. , 8.41470985, 9.09297427, 1.41120008])
3.对应元素点乘：
A = np.array([[1,1],[0,1]])
B = np.array([[2,0],[3,4]])
C = A * B
array([[2, 0],
[0, 4]])
4.矩阵乘法：
D = A.dot(B)
E = np.dot(A,B)
array([[5, 4],
[3, 4]])
5.矩阵加法（对应元素相加）
B = np.arange(3)
C = np.array([2.,-1.,4.])
d=np.add(B,C)
6.解方程
3x+2y+z=38
2x+3y+z=34
x+2y+3z=26
A = np.array([[3,2,1],[2,3,1],[1,2,3]])
b = np.array([[38],[34],[26]])
X = np.linalg.solve(A,b)
[[8.66666667]
[4.66666667]
[2.66666667]]
7.矩阵转置
data = np.array([[1,2,3,4],[4,8,5,2]])
A = data.T
print(A)
[[1 4]
[2 8]
[3 5]
[4 2]]
data = np.arange(24).reshape(2,3,4)
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
A = data.transpose(1,0,2)#维度1和维度2互换
print(A)
[[[ 0 1 2 3]
[12 13 14 15]]
[[ 4 5 6 7]
[16 17 18 19]]
[[ 8 9 10 11]
[20 21 22 23]]]
8.矩阵求逆
import numpy as np
a = np.array([[1, 2], [3, 4]]) # 初始化一个非奇异矩阵(数组)
print(np.linalg.inv(a)) # 对应于MATLAB中 inv() 函数
# 矩阵对象可以通过 .I 更方便的求逆
A = np.matrix(a)
print(A.I)
import numpy as np
# 定义一个奇异阵 A
A = np.zeros((4, 4))
A[0, -1] = 1
A[-1, 0] = -1
A = np.matrix(A)
print(A)
# print(A.I) 将报错，矩阵 A 为奇异矩阵，不可逆
print(np.linalg.pinv(a)) # 求矩阵 A 的伪逆（广义逆矩阵），对应于MATLAB中 pinv() 函数
9.运算过程中的类型转换
操作不同类型的多维数组时，结果自动转换为精度更高类型的数组，即upcasting。
a = np.ones((2,3),dtype=int) # int32
b = np.random.random((2,3)) # float64
b += a # 正确
a += b # 错误
a = np.ones(3,dtype=np.int32)
b = np.linspace(0,pi,3)
c = a + b
d = np.exp(c*1j)
输出：
array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,
-0.54030231-0.84147098j])
d.dtype.name
输出：
'complex128'
索引与切片
1.元素索引
a = np.arange(10)**3
[ 0 1 8 27 64 125 216 343 512 729]
1）一维数组
b = a[2]
8
c = a[2:5]#含左不含右
[ 8 27 64]
d = a[::-1] # 逆序输出
[729 512 343 216 125 64 27 8 1 0]
s[i:j] 表示获取s[i]到s[j-1]
s[:-1]去掉最后一个字符
s[:-n]去掉最后n个字符
s[-2:]取最后两个字符
s[i:j:k]这种格式呢，i,j与上面的一样，但k表示步长，默认为1，i<=x<j
s[::-1]是从最后一个元素到第一个元素复制一遍（反向）
2）二维数组
X[:,0]取所有行的第0个数据,第二维下标位0的所有数据，第0列（从0开始）
X[:,1] 取所有行的第1个数据
X[:,1:]第一维全部取，即所有行，列上从第一列开始取，不要第0列
X[1,:]是取第1维中下标为1的元素的所有数据，第1行（从0开始）
X[:2,1:]第一维取下标2之前的，即第2行之前（0，1两行），列上从第一列开始取，不要第0列
3)三维数组
U[1,1,2]表示第一维取1，第二维取1，第三维取2
U[:,1,2]表示第一维全取，第二维取1，第三维取2
U[:,1:,2]表示第一维全取，第二维取1及1之后的所有值，第三维取2
def f(x,y):
return 10*x+y
b = np.fromfunction(f,(5,4),dtype=int)#函数变量值即为数组元素的索引值[0,0]-[5,4]
[[ 0 1 2 3]
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]]
b[2,3]#23
b[0:5,1]#[ 1 11 21 31 41]
b[:,1]#[ 1 11 21 31 41]
b[1:3,:]
#[[10 11 12 13]
[20 21 22 23]]
b[-1]#[40 41 42 43]
c = np.array([[[0,1,2],[10,11,12]],[[100,101,102],[110,111,112]]])
[[[ 0 1 2]
[ 10 11 12]]
[[100 101 102]
[110 111 112]]]
for row in c:
print(row)
[[ 0 1 2]
[10 11 12]]
[[100 101 102]
[110 111 112]]
for element in c.flat:
print(element)
0
1
2
10
11
12
100
101
102
110
111
112
a = 10*np.random.random((3,4))
b = np.floor(a)#地板函数，，向下取整
c = np.floor(10*np.random.random((3, 4)))
print(a, b, c)
a
[[1.03625015 1.04368512 7.93929063 9.79902952]
[9.90112806 7.48968783 4.05067491 8.64484196]
[0.38680636 1.4837849 4.12188677 1.92987458]]
b
[[1. 1. 7. 9.]
[9. 7. 4. 8.]
[0. 1. 4. 1.]]
c
[[8. 0. 9. 9.]
[3. 0. 9. 0.]
[5. 2. 5. 3.]]
2.多维数组与一维数组之间的转换
1)ravel():如果没有必要，不会产生源数据的副本
a = np.arange(12).reshape(3,4)
b = a.ravel()#横向展平
c = a.ravel(order = 'F')#纵向展平
a
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
b
[ 0 1 2 3 4 5 6 7 8 9 10 11]
c
[ 0 4 8 1 5 9 2 6 10 3 7 11]
2)flatten():返回源数据的副本
c
[ 0 1 2 3 4 5 6 7 8 9 10 11]
3)squeeze():只能对维数为1的维度降维
a = np.arange(3).reshape(3,1)
d = a.squeeze()
a
[[0]
[1]
[2]]
d
[0 1 2]
比较：
a = np.arange(12).reshape(3,4)
a.ravel()[1] = 100
a
[[ 0 100 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
a.flatten()[1] = 100
a
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
4）resize():改变数组的尺寸大小，可以改变数据
有返回值：
import numpy as np
X=np.array([[1,2,3,4],
[5,6,7,8],
[9,10,11,12]])
X_new=np.resize(X,(3,3)) # do not change the original X
print("X:\n",X) #original X
print("X_new:\n",X_new) # new X
>>
X:
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
X_new:
[[1 2 3]
[4 5 6]
[7 8 9]]
无返回值：
import numpy as np
X=np.array([[1,2,3,4],
[5,6,7,8],
[9,10,11,12]])
X_2=X.resize((3,3)) #change the original X ,and do not return a value
print("X:\n",X) # change the original X
print("X_2:\n",X_2) # return None
X:
[[1 2 3]
[4 5 6]
[7 8 9]]
X_2:
None
5）reshape():给数组一个新的形状而**不改变其原数据**
import numpy as np
X=np.array([1,2,3,4,5,6,7,8])
X_2=X.reshape((2,4)) #retuen a 2*4 2-dim array
X_3=X.reshape((2,2,2)) # retuen a 2*2*2 3-dim array
print("X:\n",X)
print("X_2:\n",X_2)
print("X_3:\n",X_3)
>>
X:
[1 2 3 4 5 6 7 8]
X_2:
[[1 2 3 4]
[5 6 7 8]]
X_3:
[[[1 2]
[3 4]]
[[5 6]
[7 8]]]
#将多维数组变换为一维数组
X_4 = X.reshape(-1)
X_4:
[1 2 3 4 5 6 7 8]
3.组合不同的多维数组
a = np.floor(10*np.random.random((2,2)))#floor地板函数，向下取整
b = np.floor(10*np.random.random((2,2)))
c = np.vstack((a,b))
d = np.hstack((a,b))
a
[[0. 3.]
[0. 3.]]
b
[[4. 7.]
[2. 5.]]
c
[[0. 3.]
[0. 3.]
[4. 7.]
[2. 5.]]
d
[[0. 3. 4. 7.]
[0. 3. 2. 5.]]
from numpy import newaxis
np.column_stack((a,b))
输出：
array([[ 5., 2., 0., 2.],
[ 6., 2., 4., 1.]])
a = np.array([4.,2.])
b = np.array([2.,8.])
a[:,newaxis]
输出：
array([[ 4.],
[ 2.]])
b[:,newaxis]
输出：
array([[ 2.],
[ 8.]])
np.column_stack((a[:,newaxis],b[:,newaxis]))
输出：
array([[ 4., 2.],
[ 2., 8.]])
np.vstack((a[:,newaxis],b[:,newaxis]))
输出：
array([[ 4.],
[ 2.],
[ 2.],
[ 8.]])
np.r_[1:4,0,4]
输出：
array([1, 2, 3, 0, 4])
np.c_[np.array([[1,2,3]]),0,0,0,np.array([[4,5,6]])]
输出：
array([[1, 2, 3, 0, 0, 0, 4, 5, 6]])
函数解析说明：
1)np.stack():在某一维度上进行堆叠;axis=0 则和原来的array相同;axis=1纵轴堆叠。
arrays = [[1,2,3,4], [5,6,7,8]]
arrays=np.array(arrays)
np.stack(arrays, axis=1)
array([[1, 5],
[2, 6],
[3, 7],
[4, 8]])
2）np.hstack（）：按照列的方向堆叠， 可以是元组，列表，或者numpy数组, 就是axis=1
3）np.vstack（）：按照行的方向堆叠， tup可以是元组，列表，或者numpy数组, 理解起来与上相同
4）np.dstack（）：按照第三维方向堆叠
5）np.column_stack（）：将一维的数组堆叠为二维数组，方向为列，相当于np.hstack
6）np.row_stack（）：将一维的数组堆叠为二维数组，方向为行,相当于np,vstack
7）np.concatenate((a1,a2,a3,…), axis=0)：按照特定方向轴进行拼接，默认是第一维：
a = np.array([[[1,2,3],[4,5,6]],[[1,2,3],[4,5,6]]])
b = np.array([[[1,2,3],[4,5,6]]])
np.concatenate((a, b), axis=0)
array([[[1, 2, 3],
[4, 5, 6]],
[[1, 2, 3],
[4, 5, 6]],
[[1, 2, 3],
[4, 5, 6]]])
这里a的shape为（2，2，3），b的shape为（1，2，3），axis=0则要求a,b在其他两维的形状是一致的，如果直接在其他维度进行concatenate操作则会报错（因为axis=1时，a和b在第一维的长度不一致）
8)np.r_:按行连接两个矩阵，就是把两矩阵左右相加，要求行数相等
9)np.c_:按列连接两个矩阵，就是把两矩阵上下相加，要求列数相等
import sys
reload(sys)
sys.setdefaultencoding('utf-8')
import numpy as np
def test():
'''
numpy函数np.c_和np.r_学习使用
'''
data_list1=[4,6,12,6,0,3,7]
data_list2=[1,5,2,65,6,7,3]
data_list3=[1,5,2,65,6]
print u'np.r_ data_list1和data_list2合并'
print np.r_[data_list1,data_list2]
print u'np.r_ data_list1和data_list3合并'
print np.r_[data_list1,data_list3]
print u'np.c_ data_list1和data_list2合并'
print np.c_[data_list1,data_list2]
print u'np.c_ data_list1和data_list3合并'
print np.c_[data_list1,data_list3]
if __name__=='__main__':
test()
运行结果：
np.r_ data_list1和data_list2合并
[ 4 6 12 6 0 3 7 1 5 2 65 6 7 3]
np.r_ data_list1和data_list3合并
[ 4 6 12 6 0 3 7 1 5 2 65 6]
np.c_ data_list1和data_list2合并
[[ 4 1]
[ 6 5]
[12 2]
[ 6 65]
[ 0 6]
[ 3 7]
[ 7 3]]
np.c_ data_list1和data_list3合并
ValueError: all the input array dimensions except for the concatenation axis must match exactly
[Finished in 0.2s with exit code 1]
4.分割大型多维数组
1）hsplit():
平均分割：
import numpy as np
a = np.floor(10 * np.random.random((2, 6)))
b = np.a(harr, 3)
print(a,b)
a：
[[ 8. 5. 0. 2. 3. 8.]
[ 0. 2. 9. 5. 8. 2.]]
b：
[array([[ 8., 5.],
[ 0., 2.]]), array([[ 0., 2.],
[ 9., 5.]]), array([[ 3., 8.],
[ 8., 2.]])]
指定分割：
print(np.hsplit(a, (2, 4, 5)))
[array([[ 8., 5.],
[ 0., 2.]]), array([[ 0., 2.],
[ 9., 5.]]), array([[ 3.],
[ 8.]]), array([[ 8.],
[ 2.]])]
2)vsplit():
平均分割：
a = np.arange(16).reshape([4,4])
b = np.vsplit(a, 2)
print(a, b)
a：
array([[ 0, 1, 2, 3],
[ 4, 5, 6, 7],
[ 8, 9, 10, 11],
[12, 13, 14, 15]])
b：
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11],
[12, 13, 14, 15]])]
指定分割：
print(np.vsplit(a, (2, 3)))
[array([[0, 1, 2, 3],
[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]]), array([[12, 13, 14, 15]])]
3）array_split()：
A = np.arange(12).reshape(3, 4)
D = np.array_split(A, 3, axis=1)
print(D)
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2],
[ 6],
[10]]), array([[ 3],
[ 7],
[11]])]
将数组按横轴(axis=1)方向接近均等地拆封成3部分。虽说是均等，实际是将不均等的部分给了第一部分，让整体看起来显得接近均等拆分。
A = np.arange(24).reshape(4, 6)
D = np.array_split(A, 4, axis=1)
print(D)
[array([[ 0, 1],
[ 6, 7],
[12, 13],
[18, 19]]), array([[ 2, 3],
[ 8, 9],
[14, 15],
[20, 21]]), array([[ 4],
[10],
[16],
[22]]), array([[ 5],
[11],
[17],
[23]])]
5.多维数组的复制操作
a = np.arange(12)
输出：
array([ 0, 1, 2, ..., 9, 10, 11])
1）b = a
not copy at all
b = a
b is a # True
b.shape = 3,4
a.shape # (3L,4L)
def f(x) # Python passes mutable objects as references, so function calls make no copy.
print(id(x)) # id是python对象的唯一标识符
id(a) # 111833936L
id(b) # 111833936L
f(a) # 111833936L
2)c = a.view()
浅复制
c = a.view()
c is a # False
c.base is a # True
c.flags.owndata # False
c.shape = 2,6
a.shape # (3L,4L)
c[0,4] = 1234
print(a)
输出：
array([[ 0, 1, 2, 3],
[1234, 5, 6, 7],
[ 8, 9, 10, 11]])
s = a[:,1:3]
s[:] = 10
print(a)
输出：
array([[ 0, 10, 10, 3],
[1234, 10, 10, 7],
[ 8, 10, 10, 11]])
3）d = a.copy()
深复制
d = a.copy()
d is a # False
d.base is a # False
d[0,0] = 9999
print(a)
输出：
array([[ 0, 10, 10, 3],
[1234, 10, 10, 7],
[ 8, 10, 10, 11]])
特殊的索引技巧
1.索引非零元素：
nonzero()函数是numpy中用于得到数组array中非零元素的位置（数组索引）函数。它的返回值是一个长度为a.ndim（数组a的轴数）的元组，元组的每个元素都是一个整数数组，其值为非零元素的下标在对应轴上的值。
import numpy as np
a = [0,2,3]
b = np.nonzero(a)
>>>b
(array([1, 2], dtype=int64),)
>>> np.array(b).ndim
2
from numpy import *
b = array([[1,1,1,0,1,1],[1,1,1,0,1,0],[1,1,1,0,1,1]])
print(b)
c = nonzero(b)
print(c)
>>>[[1 1 1 0 1 1]
[1 1 1 0 1 0]
[1 1 1 0 1 1]]
(array([0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2], dtype=int64),
array([0, 1, 2, 4, 5, 0, 1, 2, 4, 0, 1, 2, 4, 5], dtype=int64))
#矩阵b中，b[0,0]，b[0,1],b[0,2],b[0,4],b[0,5]，b[1,0],b[1,1],b[1,2], b[1,4],b[2,0],b[2,1],b[2,2],b[2,4],b[2,5]元素的值非零。
当使用布尔数组直接作为下标对象护着元组下标对象中有布尔数组时，都相当于用nonzero()将布尔数组转换成一组整数数组，然后使用整数数组进行下标计算。例如对于1维布尔数组b1，nonzero(b1)所得到的是一个长度为1的元组，它表示b1[0]和b1[2]的值不为0（FALSE）。
import numpy as np
b1 = np.array([True,False,True,False])
res1 = np.nonzero(b1)
print(res1)
# (array([0, 2], dtype=int64),)
b2 = np.array([[True,False,True],[True,False,False]])
res2 = np.nonzero(b2)
print(res2)
# (array([0, 0, 1], dtype=int64),
array([0, 2, 0], dtype=int64))
对于二维数组b2，nonzero（b2）所得到的是一个长度为2的元组，它的第0个元素是数组a中值不为0的元素的第0个轴的下标，第一个元素则是第1轴的下标，因此由上述结果可知b2[0,0] , b2[0,2]和b2[1,0]的值不为0。
1）
palette = np.array([[0,0,0],[255,0,0],[0,255,0],[0,0,255],[255,255,255]])
image = np.array([[0,1,2,0],[0,3,4,0]])
palette[image]
输出：
array([[[ 0, 0, 0],
[255, 0, 0],
[ 0, 255, 0],
[ 0, 0, 0]],
[[ 0, 0, 0],
[ 0, 0, 255],
[255, 255, 255],
[ 0, 0, 0]]])
3.最大最小值索引
time = np.linspace(20, 145, 5)
输出：
array([ 20. , 51.25, 82.5 , 113.75, 145. ])
data = np.sin(np.arange(20)).reshape(5,4)
输出：
array([[ 0. , 0.84147098, 0.90929743, 0.14112001],
[-0.7568025 , -0.95892427, -0.2794155 , 0.6569866 ],
[ 0.98935825, 0.41211849, -0.54402111, -0.99999021],
[-0.53657292, 0.42016704, 0.99060736, 0.65028784],
[-0.28790332, -0.96139749, -0.75098725, 0.14987721]])
ind = data.argmax(axis=0)
输出：
array([2, 0, 3, 1], dtype=int64)
time_max = time[ind]
输出：
array([ 82.5 , 20. , 113.75, 51.25])
data_max = data[ind, xrange(data.shape[1])]
输出：
array([ 0.98935825, 0.84147098, 0.99060736, 0.6569866 ])
np.all(data_max == data.max(axis=0))
输出：
True
a = np.arange(5)
a[[1,3,4]] = 0
print(a)
输出：
array([0, 0, 2, 0, 0])
a = np.arange(5)
a[[0,0,2]] = [1,2,3]
print(a)
输出：
array([2, 1, 3, 3, 4])
a = np.arange(5)
a[[0,0,2]] += 1
print(a)
输出：
array([1, 1, 3, 3, 4])
a = np.arange(12).reshape(3,4)
b = a > 4
输出：
array([[False, False, False, False],
[False, True, True, True],
[ True, True, True, True]], dtype=bool)
a[b]
输出：
array([ 5, 6, 7, 8, 9, 10, 11])
a[b] = 0
print(a)
输出：
array([[0, 1, 2, 3],
[4, 0, 0, 0],
[0, 0, 0, 0]])
a = np.arange(12).reshape(3,4)
b1 = np.array([False,True,True])
b2 = n.array([True,False,True,False])
a[b1,:]
输出：
array([[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
a[b1]
输出：
array([[ 4, 5, 6, 7],
[ 8, 9, 10, 11]])
a[:,b2]
输出：
array([[ 0, 2],
[ 4, 6],
[ 8, 10]])
a[b1,b2]
输出：
array([ 4, 10])
1588
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
