【Python】Python-Numpy教程

Numpy的使用

读txt数据：

· genfromtxt

import numpy as np

print(help(np.genfromtxt))
#data = np.genfromtxt("txtname",delimiter = ',',dtype = str)

创建矩阵

#一维
array1 = np.array([1,2,3,4])
print(array1)
print(array1.shape)
#元素的数据类型
## np.array中的数据类型必须是完全相同的，否则自动转化
array1.dtype

[1 2 3 4]
(4,)
dtype('int32')

#二维
## 几维就几层中括号
array2 = np.array([[1.0,2,3],[1,3,4],[13,32,23]])
print(array2)
print(array2.shape)
# shape打印维度
array2.dtype

[[ 1.  2.  3.]
 [ 1.  3.  4.]
 [13. 32. 23.]]
(3, 3
dtype('float64')

索引取array元素

d1 = array2[1,1]
print(d1)
d2 = array1[1]
print(d2)
d3 = array2[0:2,0:3]
print(d3)

3.0
2
[[1. 2. 3.]
 [1. 3. 4.]]

## 不用for，直接==来判断array中的每一个元素
#array2 == 1.0
### 返回的布尔值做索引
index = (array2[:,2] == 23.0) ## 注意这里，必须指定哪一列中找，即维度必须是1
## 这个功能是，找array中第2列是否有23.0，并把23.0所在的行找出来，用的就是bool值做索引的功能
print(index)
print(index.dtype)
print(array2[index,:])

[False False  True]
bool
[[13. 32. 23.]]

index2 = (array2 >=0) & (array2 <=10)
print(index2)
array2[index2] = 50
print(array2)

[[False False False]
 [False False False]
 [False False False]]
[[50. 50. 50.]
 [50. 50. 50.]
 [13. 32. 23.]]

类型转换

#### astype
data = np.array(["1","1","23"])
print(data)
print(data.dtype)
data2 = data.astype(int)
print(data2.dtype)
print(data2)
data3 = data.astype(float)
print(data3)
print(data3.dtype)

['1' '1' '23']
<U2
int32
[ 1  1 23]
[ 1.  1. 23.]
float64

矩阵操作 min max mean

### axis = 0表示对每一列进行操作 axis = 1表示对每一行进行操作---important
data =  np.array([[1,2,3],[4,5,6],[10,3,100]])
print(data.min())
print(data.max(axis = 1))
print(data.max())
print(data.sum())
print(data.mean())
print(data.sum(axis = 0))

1
[  3   6 100]
100
134
14.88888888888889
[ 15  10 109]

np.arange(int)函数

## ndim：返回矩阵的维度，一维/二维/三维...
data = np.arange(15)
print(data)
data = data.reshape((3,5))
print(data.ndim)

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

一些属性

### ndim:维度
### size:个数
### shape:具体维度(如m*n的)
### dtype.name:元素类型名
print(data.size)
print(data.dtype)
print(data.dtype.name)
print(data.shape)

15
int32
int32
(3, 5)

矩阵初始化

### 0矩阵
data = np.zeros((3,4),dtype = np.int32)
print(data)

[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]

### 1矩阵
data = np.ones((2,3,4),dtype = np.int32)
print(data)

[[[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]

 [[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]]

### 随机矩阵 random模块的random/randn()
### 注意生成二维的，randn不需要()内再套()；而random需要
data = np.random.randn(3,4)
print(data)

[[ 0.60265787  0.2971228  -1.02996186 -0.0770739 ]
 [ 0.56146227  2.02195675 -0.95355635  0.94009896]
 [-1.20817689 -2.25813361  1.53286479 -1.67023459]]

arange用法

### np.arange(start,end,pad)；从start到end 步长为pad
data = np.arange(0,10*np.pi,np.pi)
print(data)
print(np.pi)

[ 0.          3.14159265  6.28318531  9.42477796 12.56637061 15.70796327
 18.84955592 21.99114858 25.13274123 28.27433388]
3.141592653589793

linspace函数

### np.linspace(start,end,num)；从start到end的num个数，等距取数
data = np.linspace(0,np.pi,100)
print(data)
print(np.sin(data))

[0.         0.03173326 0.06346652 0.09519978 0.12693304 0.1586663
 0.19039955 0.22213281 0.25386607 0.28559933 0.31733259 0.34906585
 0.38079911 0.41253237 0.44426563 0.47599889 0.50773215 0.53946541
 0.57119866 0.60293192 0.63466518 0.66639844 0.6981317  0.72986496
 0.76159822 0.79333148 0.82506474 0.856798   0.88853126 0.92026451
 0.95199777 0.98373103 1.01546429 1.04719755 1.07893081 1.11066407
 1.14239733 1.17413059 1.20586385 1.23759711 1.26933037 1.30106362
 1.33279688 1.36453014 1.3962634  1.42799666 1.45972992 1.49146318
 1.52319644 1.5549297  1.58666296 1.61839622 1.65012947 1.68186273
 1.71359599 1.74532925 1.77706251 1.80879577 1.84052903 1.87226229
 1.90399555 1.93572881 1.96746207 1.99919533 2.03092858 2.06266184
 2.0943951  2.12612836 2.15786162 2.18959488 2.22132814 2.2530614
 2.28479466 2.31652792 2.34826118 2.37999443 2.41172769 2.44346095
 2.47519421 2.50692747 2.53866073 2.57039399 2.60212725 2.63386051
 2.66559377 2.69732703 2.72906028 2.76079354 2.7925268  2.82426006
 2.85599332 2.88772658 2.91945984 2.9511931  2.98292636 3.01465962
 3.04639288 3.07812614 3.10985939 3.14159265]
[0.00000000e+00 3.17279335e-02 6.34239197e-02 9.50560433e-02
 1.26592454e-01 1.58001396e-01 1.89251244e-01 2.20310533e-01
 2.51147987e-01 2.81732557e-01 3.12033446e-01 3.42020143e-01
 3.71662456e-01 4.00930535e-01 4.29794912e-01 4.58226522e-01
 4.86196736e-01 5.13677392e-01 5.40640817e-01 5.67059864e-01
 5.92907929e-01 6.18158986e-01 6.42787610e-01 6.66769001e-01
 6.90079011e-01 7.12694171e-01 7.34591709e-01 7.55749574e-01
 7.76146464e-01 7.95761841e-01 8.14575952e-01 8.32569855e-01
 8.49725430e-01 8.66025404e-01 8.81453363e-01 8.95993774e-01
 9.09631995e-01 9.22354294e-01 9.34147860e-01 9.45000819e-01
 9.54902241e-01 9.63842159e-01 9.71811568e-01 9.78802446e-01
 9.84807753e-01 9.89821442e-01 9.93838464e-01 9.96854776e-01
 9.98867339e-01 9.99874128e-01 9.99874128e-01 9.98867339e-01
 9.96854776e-01 9.93838464e-01 9.89821442e-01 9.84807753e-01
 9.78802446e-01 9.71811568e-01 9.63842159e-01 9.54902241e-01
 9.45000819e-01 9.34147860e-01 9.22354294e-01 9.09631995e-01
 8.95993774e-01 8.81453363e-01 8.66025404e-01 8.49725430e-01
 8.32569855e-01 8.14575952e-01 7.95761841e-01 7.76146464e-01
 7.55749574e-01 7.34591709e-01 7.12694171e-01 6.90079011e-01
 6.66769001e-01 6.42787610e-01 6.18158986e-01 5.92907929e-01
 5.67059864e-01 5.40640817e-01 5.13677392e-01 4.86196736e-01
 4.58226522e-01 4.29794912e-01 4.00930535e-01 3.71662456e-01
 3.42020143e-01 3.12033446e-01 2.81732557e-01 2.51147987e-01
 2.20310533e-01 1.89251244e-01 1.58001396e-01 1.26592454e-01
 9.50560433e-02 6.34239197e-02 3.17279335e-02 1.22464680e-16]

矩阵的运算

### 两个矩阵直接+-*/是对应元素进行运算
### **n的意思是n次方
data1 = np.array([10,20,30,40])
data2 = np.arange(4)
print(data1+data2)
print(data1*data2)
print(data2**2)
## 维度不同呢？有广播机制,如下
print(data1-1)

[10 21 32 43]
[  0  20  60 120]
[0 1 4 9]
[ 9 19 29 39]

矩阵的乘法：*乘法与dot内积

A = np.array([[1,1],[1,1]])
B = np.array([[3,4],[5,6]])
C= A*B
print(C)
D = A.dot(B)
E = np.dot(A,B)
print(D)
print(E)
### E.T 转置
print(E.T)

[[3 4]
 [5 6]]
[[ 8 10]
 [ 8 10]]
[[ 8 10]
 [ 8 10]]
[[ 8  8]
 [10 10]]

矩阵的其他操作

### 取整操作
np.ceil(A) ##向上取整
np.floor(B) ##向下取整
np.round(B) ##四舍五入

array([[3, 4],
       [5, 6]])

维度变换操作

## 一维--》二维
## reshape(m,n),m行n列操作
## 第二维可以用-1代替
A = np.array([1,2,3,4,5,6])
print(A.reshape(2,-1))
## 二维--》一维 flatten操作
## ravel()：直接展成一行
B = A.reshape(2,-1)
print(B.ravel())

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

多个矩阵的连接（横向h，纵向v）以及矩阵的分割操作

### 连接 np.hstack((a,b))与np.vstack((a,b))
##### 注意有两层括号
A = np.floor(np.random.random((3,4))*10)
B = np.floor(np.random.random((3,4))*10)
print(A)
print(B)
print(np.hstack((A,B)))
print(np.vstack((A,B)))

[[2. 2. 1. 3.]
 [7. 8. 8. 0.]
 [2. 0. 2. 6.]]
[[2. 8. 3. 1.]
 [0. 8. 9. 7.]
 [3. 3. 3. 9.]]
[[2. 2. 1. 3. 2. 8. 3. 1.]
 [7. 8. 8. 0. 0. 8. 9. 7.]
 [2. 0. 2. 6. 3. 3. 3. 9.]]
[[2. 2. 1. 3.]
 [7. 8. 8. 0.]
 [2. 0. 2. 6.]
 [2. 8. 3. 1.]
 [0. 8. 9. 7.]
 [3. 3. 3. 9.]]

### 分割矩阵
#### 横着切分（横着切对应于hstack,即行不变，把原矩阵切割成指定列数组成小矩阵）
#### stack需要两层括号，而split只需要一层括号
##### hsplit(A,3):把A横着切成3块
##### hsplit(A,(n1,n2,n3..n4))：第二个参数是元组，是刀口的位置
A = np.floor(10*np.random.random((2,12)))
B,C,E = np.hsplit(A,3)
print(A)
print(B)
print(np.hsplit(A,(3,4)))

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

### 纵向切分
A = A.T
print(A)
print(help(np.vsplit))
print(np.vsplit(A,4))
print(np.vsplit(A,(2,4)))

[[3. 6.]
 [1. 5.]
 [5. 2.]
 [3. 3.]
 [0. 8.]
 [7. 8.]
 [6. 2.]
 [3. 4.]
 [3. 0.]
 [1. 8.]
 [4. 9.]
 [0. 3.]]

复制操作-复制的三种方式

### A=B : A和B相当于指针，指向同一段地址区域，AB完全一样，并且改变A，B也改变，shape亦如此
A = np.array([1,2,3,4])
B =A
print(id(A))
print(id(B))
print(A is B)

1896998399632
1896998399632
True

### 方法二 A.view():浅复制AB不是一个东西了，shape改变不影响，但AB仍然指向同一区域
B = A.view()
print(A is B)
print(id(A))
print(id(B))

False
1896998398112
1896998399072

### 方法三：深复制 A.copy（）AB完全不同了，另开辟区域
B = A.copy()
print(A is B)
B[1] = 1234
print(A)
print(B)

False
[1 2 3 4]
[   1 1234    3    4]

np.argmax(A,axis = 1/0)操作

### np.argmax(A,axis = 1/0)操作：寻找某一行axis = 1/列axis=0的最大值所在的索引数
A = np.floor(np.random.random((3,4))*10)

ind = np.argmax(A,axis = 0)
print(A)
print(ind)
# 找出最大值
print(A[ind,range(A.shape[1])])
print(A[1,0:4])

[[1. 9. 4. 8.]
 [8. 8. 5. 5.]
 [4. 7. 8. 1.]]
[1 0 2 0]
[8. 9. 8. 8.]
[8. 8. 5. 5.]

np.tile(a,(3.5))扩展函数

#### np.tile(a,(3.5))扩展函数。把a扩展3*5次，横向3纵向5
A = np.arange(10,40,5)
print(A)
B = np.tile(A,(2,3))
print(B)

[10 15 20 25 30 35]
[[10 15 20 25 30 35 10 15 20 25 30 35 10 15 20 25 30 35]
 [10 15 20 25 30 35 10 15 20 25 30 35 10 15 20 25 30 35]]

排序操作sort 升序

A = np.array([[1,2,3,4],[1,5,3,2],[4,2,1,10]])
print(A)
A.sort(axis = 1)
print(A)

#### argsort()，返回排序的索引
B = np.array([[1,2,3,4],[1,5,3,2],[4,2,1,10]])
t = B.argsort(axis = 1)
print(t)
print(B[:,t])

[[ 1  2  3  4]
 [ 1  5  3  2]
 [ 4  2  1 10]]
[[ 1  2  3  4]
 [ 1  2  3  5]
 [ 1  2  4 10]]
[[0 1 2 3]
 [0 3 2 1]
 [2 1 0 3]]
[[[ 1  2  3  4]
  [ 1  4  3  2]
  [ 3  2  1  4]]

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

 [[ 4  2  1 10]
  [ 4 10  1  2]
  [ 1  2  4 10]]]