python/numpy学习笔记2

python/numpy学习笔记2

import numpy as np

#矩阵的乘法

a=np.array([[1,1],

            [0,1]])

b=np.arange(4).reshape((2,2))

print(a)

print(b)

print(a*b)               #这里是逐个相乘

print(np.dot(a,b))            #这里是真正的矩阵运算乘法

###这里   np.dot(a,b)=a.dot(b)

[[1 1]
[0 1]]
[[0 1]
[2 3]]
[[0 1]
[0 3]]
[[2 4]
[2 3]]

#生成随机矩阵
a0=np.random.random((2,4))
print(a0)       #这里是随机生成  0~1的随机数

[[8.36024711e-01 7.32069838e-04 7.62046606e-01 2.65831515e-02]
[8.36904991e-01 5.49310795e-01 5.23210806e-01 1.04377426e-01]]

#其他方法

print(np.sum(a0))          #给矩阵所有元素求和

print(np.min(a0))           #求矩阵中的最小值

print(np.max(a0))               #求矩阵的最大值

3.639190556154472
0.0007320698378613377
0.8369049906003381

a1=np.arange(12).reshape((3,4))

print(a1)

#设置运算范围参数

print(np.sum(a1))       #所有求和为一个数据

print(np.sum(a1,axis=0))        #列求和

print(np.sum(a1,axis=1))           #行求和

print(np.max(a1,axis=0))       #求列最大值

print(np.max(a1,axis=1))       #求行最大值

[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
66
[12 15 18 21]
[ 6 22 38]
[ 8 9 10 11]
[ 3 7 11]

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

print(A)

print(np.argmin(A))         #求最小值的索引

print(np.argmax(A))         #求最大值的索引

print(A.mean())   #求矩阵的平均值

print(np.average(A))         #这个也是求平均值，但是是老版本的，不能写成A.average()

print(np.median(A))           #求中位数

print(np.cumsum(A))      #这个是求累加的值 如1 1+2 1+2+3 ---------

print(np.diff(A))       #求每两个数之间的差值（3,4）-》（3,3）

print(np.nonzero(A))     #输出非0数的位置，前一个矩阵代表行数，后一个矩阵代表列数

[[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]
0
11
7.5
7.5
7.5
[ 2 5 9 14 20 27 35 44 54 65 77 90]
[[1 1 1]
[1 1 1]
[1 1 1]]
(array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2], dtype=int64), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3], dtype=int64))

#矩阵排序

B=np.array([[2,1,3],[5,2,1]])
print(B)
print(np.sort(B))      #这里是逐行排序

[[2 1 3]
[5 2 1]]
[[1 2 3]
[1 2 5]]

C=np.arange(14,2,-2).reshape((2,3)) #最后一个参数是步长
print(C)
print(C.T)         #这是矩阵的转置
print(np.transpose(C))      #一样的
print(C.tolist())        #矩阵转列表

[[14 12 10]
[ 8 6 4]]
[[14 8]
[12 6]
[10 4]]
[[14 8]
[12 6]
[10 4]]
[[14, 12, 10], [8, 6, 4]]

#矩阵的运算

D=np.arange(14,2,-1).reshape((3,4))
print((D.T).dot(D))      #这里是矩阵和他的转置相乘

[[332 302 272 242]
[302 275 248 221]
[272 248 224 200]
[242 221 200 179]]

#矩阵的截取
print(D)
print(np.clip(D,5,9))          #矩阵中保留5和9之间的数，所有小于5的数变成5，所有大于9的数变成9
print(np.mean(D,axis=0))      #求列的平均值

[[14 13 12 11]
[10 9 8 7]
[ 6 5 4 3]]
[[9 9 9 9]
[9 9 8 7]
[6 5 5 5]]
[10. 9. 8. 7.]

#矩阵的索引同C语言中二维数组的索引，但是可以有不同的写法，如   A[1,1] = A[1][1],
E=np.arange(1,13).reshape(3,4)
print(E)
print(E[1,1])
print(E[1][1]) 
print(E[2,:])                 #     如   A[2,:]代表第三行的所有数,像列表一样
print(E[:,1])               #代表第二列的所有数
print(E[1,1:3])         #第二行的第 1~3个数

[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
6
6
[ 9 10 11 12]
[ 2 6 10]
[6 7]

#使用循环遍历矩阵
print(E)
#默认的是行
for row in E:
    print(row)
for lie in E.T:        #通过转置，是得迭代他的列
    print(lie)

[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
[1 2 3 4]
[5 6 7 8]
[ 9 10 11 12]
[1 5 9]
[ 2 6 10]
[ 3 7 11]
[ 4 8 12]

print(E.flatten())      #转为一维的可以进行全部迭代
for item in E.flatten():
    print(item)
print(E.flat)
for item in E.flat:       #相当于生成迭代器
    print(item)

[ 1 2 3 4 5 6 7 8 9 10 11 12]
1
2
3
4
5
6
7
8
9
10
11
12
<numpy.flatiter object at 0x000001E8EAF083C0>
1
2
3
4
5
6
7
8
9
10
11
12

#矩阵的合并
F=np.array([1,1,1])     #一维的默认是序列，不是矩阵，shape = 3，
G=np.array([2,2,2])
#这是上下合并
print(np.vstack((F,G)))         #注意合并的矩阵要作为一个参数穿进去，就是说要有一个括号括起来
#这是左右合并
print(np.hstack((F,G)))       #就是说左右连接在一起，合并两个序列  shape = 6，

[[1 1 1]
[2 2 2]]
[1 1 1 2 2 2]

#把序列变成竖着的矩阵
print(F)
print(F.T)       #显然这样是不行的
print(F[np.newaxis,:])       #这样是行上面加一个维度
print(F[np.newaxis,:].shape)
print(F[:,np.newaxis])       #这样是列上面加一个维度
print(F[:,np.newaxis].shape)
#使用这种方法测试左右合并
print(np.hstack((F[:,np.newaxis],G[:,np.newaxis])))

[1 1 1]
[1 1 1]
[[1 1 1]]
(1, 3)
[[1]
[1]
[1]]
(3, 1)
[[1 2]
[1 2]
[1 2]]

#不过相比vstack和hstack，这里有更好的合并方法
H=np.array([1,1,1])[:,np.newaxis]
I=np.array([2,2,2])[:,np.newaxis]
print(H)
print(I)
print(np.concatenate((H,H,I)))      #默认是上下合并
print(np.concatenate((H,H,I),axis=1))      #可以进行参数修改 

[[1]
[1]
[1]]
[[2]
[2]
[2]]
[[1]
[1]
[1]
[1]
[1]
[1]
[2]
[2]
[2]]
[[1 1 2]
[1 1 2]
[1 1 2]]

#矩阵分割
J=np.arange(12).reshape(3,4)
print(J)
print(np.split(J,2,axis=1))  #第二个参数是分割成几部分，这里是实现相等分割
#实现不等分割
print(np.array_split(J,3,axis=1))
#下面有一个简化版的函数
print(np.vsplit(J,3))          #行分割
print(np.hsplit(J,2))           #列分割

[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2],
[ 6],
[10]]), array([[ 3],
[ 7],
[11]])]
[array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]

#注意numpy中的python中的矩阵赋值，不是创建新的地址，而是相当于指针直接指向同一个矩阵，
A1=np.array([0,1,2,3])
B1=A1
A1[0]=11
#        A的改变也会导致B的改变

print(B1,A1)

print(B1 is A1)

#所以如果要使用A的值而又不改变，关联A，要使用copy方法

C1=A1.copy()               #这里是深度copy

print(C1)

print(C1 is A1)       

[11 1 2 3] [11 1 2 3]
True
[11 1 2 3]
False

#运算
arr=np.arange(12).reshape((3,4))
print(arr)
print(arr*10)
print(arr/2)

[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[ 0 10 20 30]
[ 40 50 60 70]
[ 80 90 100 110]]
[[0. 0.5 1. 1.5]
[2. 2.5 3. 3.5]
[4. 4.5 5. 5.5]]