Numpy入门学习之(三) 数组、矩阵基本操作

# 1.numpy的引用

import numpy as np

# 2.矩阵的属性

# 格式：注意是np.array([[,],...[,]]) 两头的中括号不要缺失
#在python中array是一维的
array = np.array([[1,2,3,4],
                  [5,6,7,8],
                  [9,10,11,12]])
print('The dimension of array is:',array.ndim) #二维数组维数(width*height)
#python中用numpy.array([1,2,3])创建的"矩阵"被认为是一维的，即不当成1*dim这样的形式
print('The shape of array:',array.shape)
print('The size (total number of elements) of array is ',array.size)#所有元素个数

# 3. 创建数组array 或者是矩阵matrix

a = np.array([2,3,4])
print(a) #[2 3 4]注意这里没有用逗号分割，这是np.array()的特性，我们另建立列表
# a = [1,2,3],输出的是[1,2,3]使用逗号分割的
# 创建array时可以定义元素的type,到底是int型的还是float型的
a = np.array([2,3,4],dtype = np.int64) #注意这里是dtype,而且赋值必须是np.int
print(a)
print(a.dtype) # float32

# 定义2维的array,例如定义矩阵
# 多在外面加一层列表
a = np.array([ [2,23,4],
               [2,3,4]]) #np.array()默认是dtype=int型的
print(a)
print(a.dtype)

# 5. 生成全0矩阵,注意这里的维度用小括号来概括,注意里面有个小括号

a = np.zeros((3,4)) #np.zeros默认是默认是float64型
print(a)
print(a.dtype)


a = np.zeros((3,4),dtype=np.int) #np.zeros默认是默认是float64型
print(a)
print(a.dtype)
print("----------------------------")
# 生成全部为1的矩阵,注意里面也是用小括号来概括,默认是float型
a = np.ones((3,4))
print(a)
print(a.dtype)


a = np.ones((3,4),dtype = np.int)
print(a)
print(a.dtype)
print(a.shape)
print("----------------------------")


# 生成空矩阵,注意里面也是用小括号来概括,其实是存储接近于0的矩阵,默认也是float64
a = np.empty((3,4))
print(a)
print(a.dtype)

# 6.生成有序的矩阵,可以定义起点,终点(取不到)和步长

a = np.arange(10,20,2)
print(a)
print("----------------------------")
# 可以重新修改尺寸(元素个数不变)
a = np.arange(12)#.reshape(3,4) np.arange(start,end,step)中end是取不到的
b = a.reshape(3,4)
print(b)
print(b.shape)

# 7. 还可以生成线段,start point, end point(linspace中终点是可以取到的), 总共有多少段

# 总是确保最后end点被取到
# linspace函数通过指定开始值、终值和元素个数来创建一维数组，
# 可以通过endpoint关键字指定是否包括终值，缺省设置是包括终值:
a = np.linspace(1,10,6) #.reshape(2,3)这里6是近似均分后总共里面有几个元素在里面，各个元素之间近似均分
# 同时注意必须在创建时用reshape?
a = a.reshape(3,2)#里边双重小括号
print(a)
print(a.shape)
print("----------------------------")

# 8. 矩阵的基本运算

a = np.array([10,20,30,40])
b = np.arange(4) #[0,1,2,3]
c = a-b #矩阵里面对应相减
d = a*b #元素对应乘积相当于matlab中的 .* 点乘
e = b**3#矩阵幂运算
element_wise_product = a*b
inner = np.dot(a.transpose(),b)#矩阵A的转置
print(a,b)
print(c)
print('两矩阵点积如下:')
print(d)
print('-----------')
print(element_wise_product)
print('inner = aT * b =',inner)
print('python里面没有power运算符^,取而代之的是** ',e) #不要把**误以为就是乘方而应该理解为幂次

# 9. 使用数学库

a = np.array([10,20,30,40])
c = 10*np.sin(a)
d = 10%np.tan(a)
print(c)
print('10*tan(a)=',d)

# 10. 判断array中哪些元素是大于(小于或等于)某个数的时候

# 用bool列表引用矩阵中的元素
b = np.arange(4)
print(b)
print(b<3)
print(a[b<3]) #类似于matlab中的调用是将列表中每个元素都与3比较,得到的结果用bool型表示
#==============================================================================
# 输出如下
# [0 1 2 3]
# [ True  True  True False]
# [10 20 30]
#==============================================================================
print(b==3)
print(a[b==3])

# 11.矩阵的运算

a = np.array([[1,1],
              [0,1]])
b = np.arange(4).reshape(2,2)
print(a)
print(b)
#==============================================================================
# c = np.dot(a,b) #正规的矩阵相乘sigma(row*col)
# print(c)
# d = a*b #
# print(d)
#==============================================================================

# 12. ".*"与矩阵相乘

element_wise_product = a*b#点乘
matrix_multiple = np.dot(a,b)#矩阵乘
print('a,b点乘结果')
print(element_wise_product)
print('a,b矩阵相乘的结果')
print(matrix_multiple)

# 13. 另一种矩阵相乘的表达方式

c_dot_2 = a.dot(b)
print(c_dot_2)

# 14. 创建随机矩阵

print('---------------------')
a = np.random.rand(2,4)
print('a矩阵如下:')
print(a)

# 15. 对矩阵中所有元素的操作

# 求和(将矩阵看成一维数组，所有元素加和到一起)
# 求最小值
# 求最大值
sum_a = np.sum(a)
min_a = np.min(a)
max_a = np.max(a)
print('sum_a')
print(sum_a)
print('min_a')
print(min_a)
print('max_a')
print(max_a)

# 16. 对矩阵中指定维度进行操作

# 比如类似与matlab，对矩阵每一列分别求和生成一个行向量存储每一列元素的加和
print('===========')
print('a')
print(a)
sum_a_column = np.sum(a,axis = 0)#注意行是0维,列是1维,axis = 0表示是沿着0维的方向加和(即对列求和)
min_a_column = np.min(a,axis = 0)
min_a_row = np.min(a,axis = 1)
max_a_column = np.max(a,axis = 0)
max_a_row = np.max(a,axis = 1)
print('sum_a_column')
print(sum_a_column)
print('min_a_column')
print(min_a_column)
print('min_a_row')
print(min_a_row)
print('max_a_column')
print(max_a_column)
print('max_a_row')
print(max_a_row)
#应该注意的是如果不是np.sum等，就是普通的sum(A),跟matlab相似，就是默认针对每列求和

# 17. 求矩阵中平均值、最小值、最大值的索引

A= np.arange(2,14).reshape((3,4))
print(A)
print('mean vector of each column')
print(np.mean(A,axis=0)) #凡是不指定axis的都是对矩阵中所有元素(看成一个array中)求解
#指定axis就是指定沿着那个维度计算了
#如果不加axis=0则是把全体元素加和到一起再求平均了sum(A)/A.size
# 求矩阵中最小值的索引
print(A)
print('A中所有元素最大值')
print(np.argmax(A))#numpy中用argmax提取索引号,matlab中直接用bool型向量表示，或者用find函数传回索引号
print('A中每列最大值对应的行数')
print(np.argmax(A,axis = 0))#axis=0沿着行的方向计算
print('A中每行最大值对应的行数')
print(np.argmax(A,axis=1))#axis=1沿着列的方向计算
# 因为A是由np.array()创建的所以A.argmax()等价与np.argmax(A)
# A.argmax(axis=0) <==> np.argmax(A,axis=0),对每列进行计算返回每列元素索引值(行数)
# 但是推荐用np.argmax(A,axis=0)
#==============================================================================
# >>> sum(A)
# array([18, 21, 24, 27])
# >>> A
# array([[ 2,  3,  4,  5],
#        [ 6,  7,  8,  9],
#        [10, 11, 12, 13]])
# >>> np.sum(A)
# 90
#==============================================================================

# 18. 求矩阵所有元素中位数

A = np.arange(2,14).reshape((3,4))
print('矩阵所有元素的中位数为:',np.median(A))
# 19. 求矩阵每一列中位数，矩阵每一行的中位数
median_vector_column = np.median(A,axis=0)
median_vector_row = np.median(A,axis=1)
print('矩阵每一列的中位数向量')
print(median_vector_column)
print('矩阵每一行的中位数向量')
print(median_vector_row)

# 19. cumulate sum累加和累差

A = np.arange(2,14).reshape((3,4))
print(A)
print(np.cumsum(A))


print(np.diff(A))

# 20.找出矩阵中非零的数的行坐标和列坐标

print(np.nonzero(A))# 返回值是行下表[...],列下表[...]

# 21. 排序

B = np.arange(14,2,-1).reshape(3,4)  # arange(start,end,step)
print('B')
print(B)
print('B sort')
print(np.sort(B,axis=0))
# 矩阵转置有两种形式
print(B.T)
print(B.transpose())

# 22.输出二维数组的一行、一列、特定位置的元素

import numpy as np
# A为列表(1维),A[i]仅表示第(i+1)个元素
A = np.arange(3,15)
print(A)
print('A为一维列表A[3]只能表示第4个元素',A[3])
# A为2为数组,A[i]默认为二维数组A的第(i+1)行
A = np.arange(3,15).reshape(3,4)
print('A二维数组')
print(A)
print('二维数组A中的第1行',A[1])
# 循环输出二维数组A的每行
print('------------------------')
for item in A: # item默认取A的每一行
    print(item)
print('------------------------')
for item in np.transpose(A): #item取A转置的每一列
    print(item)
    
# A为二维数组时,单个元素(行、列)定位
print('A[0][2]=',A[0][2])
print('A[0,2]=',A[0,2])
# 采用切片方式输出二维数组A的一行
print('A[1][:]',A[1])
print('A[1][:]',A[1][:])
print('A[1,:]',A[1,:])


# 采用切片方式输出二维数组A的一列
print('------------------------')
print('A')
print(A)
print('A[:][1]',A.T[1]) #输出一列的时候利用A转置A.T后对应的列即可
print('A[:][1]',A.T[:][1])
print('A[:,1]',A[:,1])


# 二维数组对应切片选取(矩阵的规约)
print('------------------------')
A = np.arange(3,27)
print('A为一维列表时,切片表示',A[0:3])


A = np.reshape(A,(4,-1))# -1的意思是告诉计算机自行计算为4行时每列多少个元素
print('A')
print(A)
print('A为二维数组时,第2行的前2个元素',A[1,0:2])


print('A的子块A[1:3,0:2]')
print(A[1:3,0:2])
B= A[1:3,0:2]
#==============================================================================
# 和Python的列表序列不同，
# 通过下标范围获取的新的数组是原始数组的一个视图。
# 它与原始数组共享同一块数据空间：
#==============================================================================
print('-------------------')
print('A的子块A[1:3,0:2]')
A = np.arange(3,27).reshape(4,-1)
print(A[1:3,0:2])
B= A[1:3,0:2]
print('初始B')
print(B)
B[0,0]=-1
print('修改后的B')
print('B')
print(B)
print('A')
print(A)

print('采用浅层次拷贝')
A = np.arange(3,27).reshape(4,-1)
#B= np.copy(A[1:3,0:2])
B = A[1:3,0:2].copy()
B[0,0]=-1
print('B')
print(B)
print('A')
print(A)

# 23. 矩阵的合并

# 垂直合并相当于matlab中cat(A,B,1) or A = [A;B]
A = np.array([1,1,1])
B = np.array([2,2,2])
C = np.vstack((A,B)) #注意里面多一层元组双重小括号
print('垂直合并的A与B')
print(C)
print(C.shape)
# 水平合并相当于matlab中的cat(A,B,2) or A = [A,B]
A = np.array([1,1,1])
B = np.array([2,2,2])


D = np.vstack((A,B))
print('水平合并的A与B')
print(D)
print('D.shape=',D.shape)
# np.concatenate可以设置沿着哪个维度合并
#如果这里不添加新的维度,则无法实现合并,会出现提示'IndexError: axis 1 out of bounds [0, 1)'
A = A[:,np.newaxis] # 列表没有第二维
B = B[:,np.newaxis]
E = np.concatenate((A,B,A,A),axis = 1) #注意前面是用元组(),axis=1表示沿着列方向即水平方向合并
print('E')
print(E)
print(E.shape)

# 24. 矩阵的分割

#A = np.array(12)#注意np.array后面没有reshape,只有np.arange(12).reshape(3,-1)成立
A = np.arange(12).reshape(3,-1)
print(A)
#等量分割
B = np.split(A,3,axis=0)
print('沿行方向等量分割称三块')
print(B)


B = np.split(A,2,axis=1) #(A,2,axis = 1),出错了，因为不能被整除
print('沿行列方向等量分割成2块') 
print(B)
# 进行不等量分割n.parray_split
A = np.arange(12).reshape(3,-1)
print('A')
print(A)
B = np.array_split(A,3,axis=1)
print('沿行列方向分割成3块,最后一块不等量') 
print(B)
# 与合并对应vsplit,hsplit
print(np.vsplit(A,3))#沿着垂直方向即按行分割
print(np.hsplit(A,2))

# 25.numpy的copy & deep copy .copy()就是深拷贝

#==============================================================================
# 26. fromfunction函数的第一个参数为计算每个数组元素的函数，第二个参数为数组的大小(shape)，
# 因为它支持多维数组，所以第二个参数必须是一个序列，本例中用(10,)创建一个10元素的一维数组。
#==============================================================================
#==============================================================================
# >>> def func(i):
# ...   return i%4+1
# ...
# >>> np.fromfunction(func, (10,))
# array([ 1.,  2.,  3.,  4.,  1.,  2.,  3.,  4.,  1.,  2.])
# 
# >>> def func2(i, j):
# ...     return (i+1) * (j+1)
# ...
# >>> a = np.fromfunction(func2, (9,9))
#==============================================================================