python库——numpy

 

import numpy as np ##引入numpy库  

a=np.array([1,2,3])
b=np.array([[1,2,3],[2,3,4],[3,4,5],[4,5,6]])
c=np.array([[1,2,3,4],[2,3,4,5]])
##使用np.array()创建一个矩阵
##a=np.array(1,2,3),b=np.array([1,2,3],[2,3,4],[3,4,5],[4,5,6]),c=np.array([1,2,3,4],[2,3,4,5])都是错误写法，小括号里面需要是一个数组而不是一列数字
print(a,b,c)

运行结果：

[1 2 3] [[1 2 3]
 [2 3 4]
 [3 4 5]
 [4 5 6]] [[1 2 3 4]
 [2 3 4 5]]

m=np.zeros((3,5))
n=np.zeros((2,3))
##使用np.zeros(（a,b）)函数创建一个元素都为零的a乘b的矩阵
print(m)
print(n)

运行结果：

[[0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]]
[[0. 0. 0.]
 [0. 0. 0.]]

m=np.ones((3,5))
n=np.ones((2,3))
##使用np.ones(（a,b）)函数创建一个元素都为一的a乘b的矩阵
print(m)
print(n)

运行结果：

[[1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1.]]
[[1. 1. 1.]
 [1. 1. 1.]]

m=np.arange(0,17,0.5)
n=np.linspace(0,15,16)
print(m)
print(n)
## np.arange(begin, end, step)中指定起始区间，终止区间和步长每经过一个步长取一个数字
##np.linspace(begin, end, num)中指定起始终止区间和需要取的数字个数，每两个相邻数字之间差的绝对值相等

运行结果：

[ 0.   0.5  1.   1.5  2.   2.5  3.   3.5  4.   4.5  5.   5.5  6.   6.5
  7.   7.5  8.   8.5  9.   9.5 10.  10.5 11.  11.5 12.  12.5 13.  13.5
 14.  14.5 15.  15.5 16.  16.5]
[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10. 11. 12. 13. 14. 15.]

m=np.arange(0,17,0.5)
n=m.reshape(2,17)
##使用Matrix.reshape(a,b)函数，将Matrix矩阵转化为(a,b)的矩阵
print(m)
print(n)
##也可以直接使用np.arange(begin, end, step).reshape(a,b)函数
x=np.arange(0,6,1).reshape(2,3)
print(x)
##注意np.arange(int a)=np.arange(0,a,1)
y=np.arange(6)
print(y)

运行结果：

[ 0.   0.5  1.   1.5  2.   2.5  3.   3.5  4.   4.5  5.   5.5  6.   6.5
  7.   7.5  8.   8.5  9.   9.5 10.  10.5 11.  11.5 12.  12.5 13.  13.5
 14.  14.5 15.  15.5 16.  16.5]
[[ 0.   0.5  1.   1.5  2.   2.5  3.   3.5  4.   4.5  5.   5.5  6.   6.5
   7.   7.5  8. ]
 [ 8.5  9.   9.5 10.  10.5 11.  11.5 12.  12.5 13.  13.5 14.  14.5 15.
  15.5 16.  16.5]]
[[0 1 2]
 [3 4 5]]
[0 1 2 3 4 5]

b=np.array([[1,2,3],[2,3,4],[3,4,5],[4,5,6]])
print(np.ndim(b))
##使用函数np.ndim(Matrix)求解矩阵的维度
print(np.shape(b))
##使用函数np.shape(Matrix)求解矩阵的形状
print(np.size(b))
##使用函数np.size(Matrix)求解矩阵的元素个数
print(b.dtype)
##使用函数Matrix.dtype求解矩阵中的元素类型
a=np.array([1,2,3])
c=np.array([0,1,2])
print(a+c)
print(a-c)
print(2*a)
##矩阵可以进行加法减法和数乘
a=np.array([[1,2,3],[2,3,2],[1,4,3]])
b=np.array([[2,3],[1,4],[2,5]])
c=np.array([2,4,6])
print(np.dot(a,b))
##用函数np.dot(Matrix a,Matrix b)实现矩阵a乘b
print(np.linalg.det(a))
##用函数np.linalg.det(Matrix a)运算a的行列式
print(np.linalg.solve(a,c))
##用函数np.linalg.solve(a,b)表示a*x=b中矩阵x的值
print(np.linalg.inv(a))
##逆矩阵可以用numpy.linalg.inv()函数来求
x1=a*c
x2=np.dot(c,a)
print(x1)
print(x2)
##从结果可以看出‘*’和np.dot(a,b)的区别

运行结果：

2

(4, 3)

12
int32
[1 3 5]
[1 1 1]
[2 4 6]
[[10 26]
 [11 28]
 [12 34]]
8.000000000000002
[-0.5  2.  -0.5]
[[ 0.125  0.75  -0.625]
 [-0.5    0.     0.5  ]
 [ 0.625 -0.25  -0.125]]
[[ 2  8 18]
 [ 4 12 12]
 [ 2 16 18]]
[16 40 32]

a=np.array([[1,2,3],[2,3,2],[1,4,3]])
b=a
print(a)
print(b)
b[2,2]=100
print(a)
print(b)
##直接使用=赋值是数组的浅拷贝，浅拷贝时两个数组的存储空间一致，修改其中一个数组另一个也会发生改变

运行结果：

[[1 2 3]
 [2 3 2]
 [1 4 3]]
[[1 2 3]
 [2 3 2]
 [1 4 3]]
[[  1   2   3]
 [  2   3   2]
 [  1   4 100]]
[[  1   2   3]
 [  2   3   2]
 [  1   4 100]]

a=np.array([[1,2,3],[2,3,2],[1,4,3]])
b=a.copy()
print(a)
print(b)
b[2,2]=100
print(a)
print(b)
##使用函数a.copy()实现深拷贝，深拷贝时拷贝完成后的数组会存放在与原数组不同的存储空间里

运行结果：

[[1 2 3]
 [2 3 2]
 [1 4 3]]
[[1 2 3]
 [2 3 2]
 [1 4 3]]
[[1 2 3]
 [2 3 2]
 [1 4 3]]
[[  1   2   3]
 [  2   3   2]
 [  1   4 100]]

##索引的概念
##对于正索引值，第一个元素对应的索引值为0，第二个元素的索引值为1，依此类推，最后一个元素的索引值对应的就是列表内总元素的数量减1。
##而对于负索引值，-1代表的是元素的最后一个，然后依次递减到元素的第一位
my_list = [1,2,3,4,5]
print('列表第一个元素',my_list[0])#访问第一个元素，索引值为0
print('列表第二个元素',my_list[1],my_list[-4])#访问第二个元素，正索引值为1，负索引值为-4
print('列表最后一个元素',my_list[4],my_list[-1])#访问最后一个元素，正索引值为4，负索引值为-1

运行结果：

列表第一个元素 1
列表第二个元素 2 2
列表最后一个元素 5 5

##切片的概念
##1) [start:end]:start为起始索引位置（包含start），end为结束索引位置（不包含end）。
##2) [start:end:step]:同上一样，不同的是step，step为步长，不含step时默认为1（此时无间隔），step也可以为负值。
my_list = [1,2,3,4,5,6,7,8,9,]
print('取列表的前5项',my_list[0:4])#当0省略的时候默认为0，即为my_list[:4]
print('取列表的第2-4项',my_list[1:4])#注意4是列表的第五项，但是在这里是不包含4的，所以没有第五项
print('取列表所有项，步长为2',my_list[::2])#步长为2，也就是走2步，所以间隔为1
print('取列表的逆序',my_list[::-1])#当步长为-1的时候，也就是反向走了一遍，即为逆序

运行结果：

取列表的前5项 [1, 2, 3, 4]
取列表的第2-4项 [2, 3, 4]
取列表所有项，步长为2 [1, 3, 5, 7, 9]
取列表的逆序 [9, 8, 7, 6, 5, 4, 3, 2, 1]

##多维切片数组
y = np.arange(35).reshape(5,7)
print(y[1:5:2,::3])
##代表行上取[1:5:2]切片，列上取[::3]切片

##多位索引数组
print( y[np.array([0,2,4]), np.array([0,1,2])])
##选择0,2,4行，0,1,2列的数
print(y[np.array([0,2,4]), 1])
##选取第0,2,4行，第1列的值
print( y[np.array([0,2,4])])
##选取第0,2,4行的值

##数组与切片的组合索引数组　
print(y[np.array([0,2,4]),1:3])
##使用数组来索引第一个轴，使用切换来索引第二个轴

运行结果：

[[ 7 10 13]
 [21 24 27]]
[ 0 15 30]
[ 1 15 29]
[[ 0  1  2  3  4  5  6]
 [14 15 16 17 18 19 20]
 [28 29 30 31 32 33 34]]
[[ 1  2]
 [15 16]
 [29 30]]