numpy基础

numpy创建初始数组

全0数组

import numpy as np
ndarray = np.zeros(shape=(2,3),dtype=float)
print(ndarray)

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

全1数组

import numpy as np
ndarray = np.ones(shape=(2,3),dtype=float)
print(ndarray)

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

全为自定义数组

import numpy as np
ndarray = np.full(shape=(2, 3), fill_value=6, dtype=float)
print(ndarray)

[[6. 6. 6.]
 [6. 6. 6.]]

范围数组

整数步长

import numpy as np
ndarray = np.arange(0, 10, step=2)
print(ndarray)

[0 2 4 6 8]

小数步长

import numpy as np
ndarray = np.arange(0, 5, step=0.5)
print(ndarray)

[0.  0.5  1.  1.5  2.  2.5  3.  3.5  4.  4.5]

等长分割范围

#[0,10]之间等长截出5个数值
import numpy as np
ndarray = np.linspace(0, 10, num=5)
print(ndarray)

[ 0.   2.5    5.   7.5    10. ]

随机初始化

设置随机数种子

import numpy as np
np.random.seed(123)

随机整数

[0,10)前闭后开

import numpy as np
ndarray = np.random.randint(0,10)
print(ndarray)

3

随机整数组

import numpy as np
ndarray = np.random.randint(0, 10, size=(2, 3))
print(ndarray)

[[1 0 8]
 [5 4 0]]

随机浮点数组

import numpy as np
#0-1之间均匀分布
ndarray = np.random.random(size=(2, 3))
print(ndarray)

[[0.47937583 0.77300627 0.35627445]
 [0.91318964 0.47318392 0.71168946]]

#0-1之间均匀分布
import numpy as np
#均值10 方差100
ndarray = np.random.normal(loc=10,scale=100, size=(2, 3))
print(ndarray)

[[  27.17192526   23.01253531  -88.26385275]
 [-301.95644965 -103.88142461  -13.40509226]]

numpy操作

查看数组维度

import numpy as np
ndarray = np.arange(10)
print(ndarray)
print(ndarray.ndim)

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

查看数组shape

import numpy as np
ndarray = np.arange(10)
print(ndarray)
print(ndarray.shape)

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

查看数组size

import numpy as np
ndarray = np.arange(10)
print(ndarray)
print(ndarray.size)

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

切片

带步长

import numpy as np
ndarray = np.arange(10)
print(ndarray)
print(ndarray[0:10:2])

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

逆序切

import numpy as np
ndarray = np.arange(10)
print(ndarray)
print(ndarray[0:10:-1])

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

二维切片

import numpy as np
ndarray = np.random.randint(0,10,(5,5))
print(ndarray)
print(ndarray[:2,:3])

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

切片副本

import numpy as np
ndarray = np.random.randint(0,10,(5,5))
print(ndarray)
sub1=ndarray[:2,:3]
sub2=ndarray[:2,:3].copy()
ndarray[0]=1000
print("sub1:")
print(sub1)
print("sub2:")
print(sub2)

[[9 8 5 9 1]
 [3 8 7 3 2]
 [4 3 3 3 6]
 [7 7 9 8 1]
 [8 2 0 4 4]]
sub1:
[[1000 1000 1000]
 [   3    8    7]]
sub2:
[[9 8 5]
 [3 8 7]]

reshape

完全指定shape

import numpy as np
ndarray = np.random.randint(0, 10, (2, 5))
print(ndarray)
print(ndarray.reshape(5, 2))

[[8 2 6 2 1]
 [0 2 0 5 5]]
[[8 2]
 [6 2]
 [1 0]
 [2 0]
 [5 5]]

指定部分shape

import numpy as np
ndarray = np.random.randint(0, 10, (2, 5))
print(ndarray)
print(ndarray.reshape(5,-1))

[[8 2 6 2 1]
 [0 2 0 5 5]]
[[8 2]
 [6 2]
 [1 0]
 [2 0]
 [5 5]]

合并

concatenate

import numpy as np
arr1 = np.random.randint(0, 10, (2, 3))
arr2 = np.random.randint(0, 10, (2, 3))
print(arr1)
print("---------------------------")
print(arr2)
print("---------------------------")
print(np.concatenate([arr1, arr2], axis=0))
print("---------------------------")
print(np.concatenate([arr1, arr2], axis=1))

[[8 4 4]
 [3 7 7]]
---------------------------
[[2 6 8]
 [6 2 6]]
---------------------------
[[8 4 4]
 [3 7 7]
 [2 6 8]
 [6 2 6]]
---------------------------
[[8 4 4 2 6 8]
 [3 7 7 6 2 6]]

vstack

import numpy as np
arr1 = np.random.randint(0, 10, (2, 3))
arr2 = np.random.randint(0, 10, 3)
print(arr1)
print("---------------------------")
print(arr2)
print("---------------------------")
print(np.vstack([arr1, arr2]))
print("---------------------------")

[[9 1 6]
 [5 3 5]]
---------------------------
[7 7 8]
---------------------------
[[9 1 6]
 [5 3 5]
 [7 7 8]]
---------------------------

hstack

import numpy as np
arr1 = np.random.randint(0, 10, (2, 3))
arr2 = np.random.randint(0, 10, 2).reshape(2,-1)
print(arr1)
print("---------------------------")
print(arr2)
print("---------------------------")
print(np.hstack([arr1, arr2]))
print("---------------------------")

[[2 0 4]
 [8 7 5]]
---------------------------
[[7]
 [4]]
---------------------------
[[2 0 4 7]
 [8 7 5 4]]
---------------------------

分割

split

一维

import numpy as np
arr = np.random.randint(0, 10, 10)
print(arr)
print("---------------------------")
print(np.split(arr, [2, 5]))
print("---------------------------")

[[2 0 4]
 [8 7 5]]
---------------------------
[[7]
 [4]]
---------------------------
[[2 0 4 7]
 [8 7 5 4]]
---------------------------

二维

import numpy as np
arr = np.random.randint(0, 10, (4,4))
print(arr)
print("---------------------------")
print(np.split(arr, [2],axis=1))
print("---------------------------")

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

numpy矩阵运算

向量数乘

import numpy as np                                              
vecter = np.random.randint(0, 10, 3)      
print(vecter)                             
print("---------------------------")      
print(3 * vecter)                         
print("---------------------------") 

[3 7 2]
---------------------------
[ 9 21  6]
---------------------------

矩阵乘法

import numpy as np                                                 
M1 = np.random.randint(0, 10, (3 , 3)) 
M2 = np.random.randint(0, 10, (3 , 3)) 
print(M1)                              
print("---------------------------")   
print(M2)                              
print("---------------------------")   
print(M1.dot(M2))                      

[[4 0 9]
 [1 2 1]
 [1 1 6]]
---------------------------
[[6 7 4]
 [9 2 4]
 [5 1 2]]
---------------------------
[[69 37 34]
 [29 12 14]
 [45 15 20]]

矩阵转置

import numpy as np                                                      
M1 = np.random.randint(0, 10, (3 , 3)) 
print(M1)                              
print("---------------------------")   
print(M1.T)                            

[[8 2 5]
 [9 4 2]
 [1 3 3]]
---------------------------
[[8 9 1]
 [2 4 3]
 [5 2 3]]

向量堆叠

import numpy as np
M1 = np.random.randint(0, 10, (3))
print(M1)
print("---------------------------")
print(np.tile(M1,(3,2)))                 

[5 4 4]
---------------------------
[[5 4 4 5 4 4]
 [5 4 4 5 4 4]
 [5 4 4 5 4 4]]

矩阵求逆

import numpy as np
M1 = np.random.randint(0, 10, (3 , 3))
print(M1)
print("---------------------------")
print(np.linalg.inv(M1))                

[[0 1 0]
 [0 1 8]
 [5 8 4]]
---------------------------
[[-1.5   -0.1    0.2  ]
 [ 1.     0.     0.   ]
 [-0.125  0.125 -0.   ]]

矩阵求伪逆

import numpy as np
M1 = np.random.randint(0, 10, (2 , 3))
M2 = np.random.randint(0, 10, (3 , 3))
print(M1)
print("---------------------------")
print(np.linalg.pinv(M1))
print("---------------------------")
print(M1.dot(np.linalg.pinv(M1)))            

[[5 1 2]
 [8 5 0]]
---------------------------
[[ 0.13178295  0.02325581]
 [-0.21085271  0.1627907 ]
 [ 0.27596899 -0.13953488]]
---------------------------
[[ 1.00000000e+00 -2.22044605e-16]
 [ 2.22044605e-16  1.00000000e+00]]

聚合操作

求和

一维

import numpy as np
M1 = np.random.randint(0, 10, 10)
print(M1)
print("---------------------------")
print(np.sum(M1))        

[3 4 6 2 8 9 5 3 2 1]
---------------------------
43

二维

import numpy as np
M1 = np.random.randint(0, 10, (4,4))
print(M1)
print("---------------------------")
print(np.sum(M1,axis=0))

[[7 6 2 4]
 [6 2 7 1]
 [9 9 5 2]
 [1 8 7 8]]
---------------------------
[23 25 21 15]

求最值

import numpy as np
M1 = np.random.randint(0, 10, 10)
print(M1)
print("---------------------------")
print(np.max(M1))
print(np.min(M1))

[7 7 5 4 2 0 6 3 0 0]
---------------------------
7
0

percentile

import numpy as np
M1 = np.random.randint(0, 10, (4,4))
print(M1)
print("---------------------------")
## M1中30%的数小于该值
print(np.percentile(M1,q=30))

[[5 6 9 2]
 [2 9 8 9]
 [8 7 1 4]
 [9 4 5 8]]
---------------------------
6.5

索引操作

最值反求索引

import numpy as np
M1 = np.random.normal(3, 5, 1000)
print("---------------------------")
print(np.max(M1))
print("---------------------------")
print(M1[np.argmax(M1)])

---------------------------
16.62756113716016
---------------------------
16.62756113716016

排序及获取排序索引

import numpy as np
M1 = np.random.normal(3, 5, 5)
print("---------------------------")
print(M1)
print("---------------------------")
print(np.sort(M1))
print("---------------------------")
print(np.argsort(M1))

---------------------------
[ 0.70228933  5.40060339  4.11317961 -1.48208407  1.88973516]
---------------------------
[-1.48208407  0.70228933  1.88973516  4.11317961  5.40060339]
---------------------------
[3 0 4 2 1]

二维数组按轴方向排序

import numpy as np
M1 = np.random.randint(3, 5, (3,3))
print("---------------------------")
print(M1)
print("---------------------------")
print(np.sort(M1,axis=0))

---------------------------
[[3 4 4]
 [4 3 3]
 [4 3 3]]
---------------------------
[[3 3 3]
 [4 3 3]
 [4 4 4]]

根据索引列表取值

import numpy as np
M1 = np.random.randint(1, 10, 10)
print("---------------------------")
print(M1)
index = [2, 5, 7]
print(M1[index])

---------------------------
[8 8 4 2 6 8 3 2 2 9]
---------------------------
[4 8 2]

比较运算和根据Boolean类型列表取值

import numpy as np
M1 = np.random.randint(1, 10, 10)
print("---------------------------")
print(M1)
print("---------------------------")
index = M1 < 5
print(index)
print("---------------------------")
print(M1[index])
print("---------------------------")
print(np.sum(index))
print("---------------------------")
print(np.count_nonzero(index))

---------------------------
[7 3 2 1 2 6 3 2 8 5]
---------------------------
[False  True  True  True  True False  True  True False False]
---------------------------
[3 2 1 2 3 2]
---------------------------
6
---------------------------
6

是否存在 和 全部

import numpy as np

M1 = np.random.randint(1, 10, 10)
print("---------------------------")
## 是否存在大于10的数
print(np.any(M1>10))
print("---------------------------")
## 是否全部大于0且小于10
print(np.all((M1 < 10) & (M1 > 0)))

---------------------------
False
---------------------------
True