方法查询
如果不太熟悉某个函数的使用，可以用help命令来查看这个函数的用法，比如：
import numpy as np
print(help(np.ravel))
方法讲解
array
生产矩阵，array当中的元素必须是相同的结构
例子：
import numpy as np
a = np.array([1, 2, 3])
b = np.array([1, 2, 3], [4, 5, 6])
arange
生成矩阵
例子：
# 生成指定大小的矩阵
a = np.arange(15)
# 生成一个等差数列的矩阵，第一个参数是起始值，第二个参数是终值(<终值)，第三个参数是公差
b = np.arange(10, 30, 5)
print(a)
print(b)
[ 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14]
[10 15 20 25]
shape
查看矩阵结构
例子：
import numpy as np
a = np.array([1, 2, 3])
b = np.array([1, 2, 3], [4, 5, 6])
print(a.shape)
print(b.shape)
输出如下：
(3,)
(2,3)
一维矩阵直接打印出元素个数
二维矩阵打印出矩阵的行和列的个数
size
查看矩阵元素个数
例子：
a = np.arange(15).reshape(3, 5)
print(a.size)
输出如下：
15
ndim
矩阵唯度
例子：
a = np.arange(15).reshape(3, 5)
print(a.ndim)
输出如下：
2
dtype
查看矩阵内部的数据类型
例子：
import numpy as np
a = np.array([1, 2, 3])
print(a.dtype)
输出如下：
int32
astype
矩阵类型转换
例子：
a = np.array(['1', '2', '3'])
print(a)
print(a.dtype)
b = a.astype(float)
print(b)
print(b.dtype)
输出如下：
['1' '2' '3']
<U1
[1. 2. 3.]
float64
sum
求和
例子：
a = np.array([
[5, 10, 15],
[20, 25, 30],
[35, 40, 45]
])
b = a.sum(axis=1)
print(b)
c = a.sum(axis=0)
print(c)
输出如下：
[ 30 75 120]
[60 75 90]
axis = 1 时，是按行求和
axis = 0 时， 是按列求和
dot
矩阵的点乘。首先，一维矩阵不能点乘一维矩阵，一维矩阵可以点乘二维矩阵，二维矩阵不能点乘一维矩阵，二维矩阵可以点乘二维矩阵。矩阵点乘后会生成一个和A行列相同的矩阵，矩阵中第n行的第p个元素的值，就是A中第n行每一个元素与B中第p列对应位置的每一个元素相乘后的求和。
例子：
a = np.array([[2, 3]])
b = np.array([[1, 2],
[3, 4]])
c = np.array([[2, 0],
[3, 4]])
# 结果为： [[ 1*2+2*3, 1*0+2*4 ], [3*2+4*3, 3*0+4*4]]
d = np.dot(a, b)
# e和f表示的意思相同，都表示前一个数和后一个数的点乘，只是写法不同
# 结果为：[[1*2+2*3, 1*0+2*4], []]
e = np.dot(b, c)
f = b.dot(c)
print(d)
print(e)
print(f)
输出如下：
[[11 16]]
[[ 8 8]
[18 16]]
[[ 8 8]
[18 16]]
random
生成随机数矩阵
例子：
# 生成随机数矩阵，范围是-1到+1
a = np.random.random((2, 3))
print(a)
输出如下：
[[0.70269028 0.86374853 0.04578158]
[0.25137128 0.08898347 0.91946659]]
multinomial
多项分布
例子：
import numpy as np
'''
掷骰子20次，获取每个点数的出现次数
第一个参数是实验次数
第二个参数是每个可能性的分布[1/6.]*6 = [1/6, 1/6, 1/6, 1/6, 1/6, 1/6]
size参数是样本大小，这里一次样本会执行20次掷骰子。如果是2代表两组实验，每组20次掷骰子
'''
print(np.random.multinomial(200, [1/6.]*6, size=1))
输出如下：
[[3 5 5 2 2 3]]
seed
可以让每次生成的随机数一致
例子：
a = np.random.random(5)
b = np.random.random(5)
print('a=', a)
print('b=', b)
# 设置seed不加参数，相当于每次都会随机
np.random.seed()
c = np.random.random(5)
d = np.random.random(5)
print('-'*80)
print('c=', c)
print('d=', d)
# 按第一类随机数算法生成数据，即下一次生成随机数会固定
np.random.seed(1)
e = np.random.random(5)
np.random.seed(1)
f = np.random.random(5)
print('-'*80)
print('e=', e)
print('f=', f)
输出如下：
a= [0.72601271 0.215321 0.75086442 0.91489658 0.19248521]
b= [0.76752269 0.51673528 0.05068929 0.58941153 0.10504093]
--------------------------------------------------------------------------------
c= [0.75929355 0.98929559 0.98299537 0.55001877 0.07192605]
d= [0.65825984 0.18411651 0.53176325 0.92423704 0.04044016]
--------------------------------------------------------------------------------
e= [4.17022005e-01 7.20324493e-01 1.14374817e-04 3.02332573e-01
1.46755891e-01]
f= [4.17022005e-01 7.20324493e-01 1.14374817e-04 3.02332573e-01
1.46755891e-01]
normal
生成高斯分布（正态分布）密度随机数
例子：
'''
参数loc(float)：正态分布的均值，对应着这个分布的中心。loc=0说明这一个以Y轴为对称轴的正态分布，
参数scale(float)：正态分布的标准差，对应分布的宽度，scale越大，正态分布的曲线越矮胖，scale越小，曲线越高瘦。
参数size(int 或者整数元组)：输出的值赋在shape里，默认为None，只输出一个元素。
'''
a = np.random.normal(loc=0, scale=2, size=5)
b = np.random.normal(size=5)
c = np.random.normal()
print('a=', a)
print('b=', b)
print('c=', c)
输出如下：
a= [ 0.92146664 -0.31756177 -0.46058047 1.16359713 2.83604809]
b= [-0.1658345 0.92637427 -1.32726054 -1.85050108 -1.23593504]
c= -0.2765881552368154
multivariate_normal
生成多元高斯分布（正态分布）的数据，多元高斯分布可以理解为多个高斯分布在同一坐标轴上。mean：代表每个高斯分布的均值，比如二元高斯分布的均值应是两个元素的数组。
cov：代表每个高斯分布的协方差，比如二元高斯分布的协方差应是两个元素的数组，每个元素是一个大小为2的元祖。
size：代表生成的数据大小.
例子：
mean, cov = [0, 1], [(1, .5), (.5, 1)]
data = np.random.multivariate_normal(mean, cov, 10)
print(data)
输出如下：
[[-0.65489084 1.96013504]
[-0.63309745 0.13913229]
[ 1.13817248 1.13184925]
[ 1.00192568 3.14208045]
[-0.06685283 -0.16943892]
[ 0.02962607 0.66183857]
[ 0.35785569 1.59914613]
[ 0.41936836 1.95183972]
[-0.16021818 1.79921516]
[ 0.61943039 2.15558493]]
randn
返回一个或一组样本，具有标准正态分布
例子：
a = np.random.randn()
b = np.random.randn(2, 3)
print('a=', a)
print('b=',b )
输出如下：
a= -1.3446832226414807
b= [[-0.89930504 2.68421964 -0.80293859]
[ 0.03245242 -0.84803903 -0.70010662]]
exp
原始矩阵A经过exp方法后生产一个同样行列的矩阵B，矩阵B中的每个元素的值对应矩阵A中每个元素值个e相乘得到的。
例子：
a = np.arange(3)
# 结果为：[e^0, e^1, e^2]
b = np.exp(a)
print(a)
print(b)
输出如下：
[0 1 2]
[1. 2.71828183 7.3890561 ]
sqrt
开根号，原始矩阵A经过exp方法后生产一个同样行列的矩阵B，矩阵B中的每个元素是值，是矩阵A中对应元素开根号后得到的值。
例子：
a = np.arange(3)
b = np.sqrt(a)
print(a)
print(b)
输出如下：
[0 1 2]
[0. 1. 1.41421356]
floor
向下取整
例子：
a = np.floor(10*np.random.random((3, 4)))
print(a)
输出如下：
[[3. 2. 1. 9.]
[8. 0. 8. 0.]
[3. 1. 3. 9.]]
hstack和vstack
hstack矩阵横向叠加，vstack矩阵纵向叠加
例子：
a = np.floor(10*np.random.random((2, 2)))
b = np.floor(10*np.random.random((2, 2)))
c = np.hstack((a, b))
d = np.vstack((a, b))
print(a)
print(b)
print(c)
print(d)
输出如下：
[[3. 8.]
[6. 1.]]
[[4. 9.]
[8. 3.]]
[[3. 8. 4. 9.]
[6. 1. 8. 3.]]
[[3. 8.]
[6. 1.]
[4. 9.]
[8. 3.]]
linspace
生成指定元素个数的等差数列
例子：
# pi 近似 3.14
from numpy import pi
# 以第一个参数为第一个元素，第二个参数为最后一个元素，均等的生成100个元素的矩阵
a = np.linspace(0, 2*pi, 100)
print(a)
输出如下：
[0. 0.06346652 0.12693304 0.19039955 0.25386607 0.31733259
0.38079911 0.44426563 0.50773215 0.57119866 0.63466518 0.6981317
0.76159822 0.82506474 0.88853126 0.95199777 1.01546429 1.07893081
1.14239733 1.20586385 1.26933037 1.33279688 1.3962634 1.45972992
1.52319644 1.58666296 1.65012947 1.71359599 1.77706251 1.84052903
1.90399555 1.96746207 2.03092858 2.0943951 2.15786162 2.22132814
2.28479466 2.34826118 2.41172769 2.47519421 2.53866073 2.60212725
2.66559377 2.72906028 2.7925268 2.85599332 2.91945984 2.98292636
3.04639288 3.10985939 3.17332591 3.23679243 3.30025895 3.36372547
3.42719199 3.4906585 3.55412502 3.61759154 3.68105806 3.74452458
3.8079911 3.87145761 3.93492413 3.99839065 4.06185717 4.12532369
4.1887902 4.25225672 4.31572324 4.37918976 4.44265628 4.5061228
4.56958931 4.63305583 4.69652235 4.75998887 4.82345539 4.88692191
4.95038842 5.01385494 5.07732146 5.14078798 5.2042545 5.26772102
5.33118753 5.39465405 5.45812057 5.52158709 5.58505361 5.64852012
5.71198664 5.77545316 5.83891968 5.9023862 5.96585272 6.02931923
6.09278575 6.15625227 6.21971879 6.28318531]
ravel
矩阵扁平化
例子：
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.ravel())
输出如下：
[1, 2, 3, 4, 5, 6]
where
条件转换
例子：
import pandas as pd
file = 'data.csv'
df = pd.read_csv(file, header=None)
y = df.loc[0:100, 4].values
# 数组中的元素为Iris-setosa的都转为-1，其他的都转为1
y = np.where(y == 'Iris-setosa', -1, 1)
reshape
重定义矩阵的shape，把一维矩阵转化为二维矩阵
例子：
import numpy as np
a = np.arange(8)
print (a)
# 重定义矩阵a的shape，把一维矩阵改为4行2列的二维矩阵，第一个参数代表二维矩阵的行
b = a.reshape(4,2)
# 重定义矩阵a的shape
a.shape = (4, 2)
# 对二维矩阵来说,确定了其中一个元素,比如确定了行,列是会自动生成的,让其自动生成可以输入-1
c = a.reshape(4, -1)
a.shape = (2, -1)
print (b)
print (a)
print (c)
print (a)
输出如下：
[0 1 2 3 4 5 6 7]
[[0 1]
[2 3]
[4 5]
[6 7]]
[[0 1]
[2 3]
[4 5]
[6 7]]
[[0 1]
[2 3]
[4 5]
[6 7]]
[[0 1 2 3]
[4 5 6 7]]
zeros
创建一个初始值为0的矩阵
例子：
a = np.zeros(3)
b = np.zeros((3, 4))
print(a)
print(b)
输出如下：
[0. 0. 0.]
[[0. 0. 0. 0.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]
ones
创建一个初始值为1的矩阵
例子：
# dtype可以指定创建的矩阵类型
a = np.ones(3, dtype=np.int32)
b = np.ones((3, 4), dtype=np.int32)
print(a)
print(b)
输出如下：
[1. 1. 1.]
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
transpose与.T
transpose和.T的功能大致相同，都是转置数组
例子：
a = np.arange(12).reshape(3,4)
print (a )
print (np.transpose(a))
print(a.T)
输出如下：
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
[[ 0 4 8]
[ 1 5 9]
[ 2 6 10]
[ 3 7 11]]
hsplit和vsplit
hsplit是把矩阵横向切分成多份，vsplit是把矩阵纵向切分成多份
例子：
a = np.floor(10*np.random.random((2,12)))
# 把矩阵横向均等地切分为三份
b = np.hsplit(a, 3)
# 在指定元素后进行切分，下面的代码是横向在第三个元素后面切一刀，再横向在第四个元素后面切一刀
c = np.hsplit(a, (3, 4))
d = a.T
# 把矩阵纵向均等地切分为三份
e = np.vsplit(d, 3)
print(a)
print(b)
print(c)
print(d)
print(e)
输出如下：
[[4. 2. 1. 8. 5. 4. 8. 8. 2. 3. 8. 6.]
[5. 0. 6. 7. 4. 2. 4. 7. 0. 4. 9. 3.]]
[array([[4., 2., 1., 8.],
[5., 0., 6., 7.]]), array([[5., 4., 8., 8.],
[4., 2., 4., 7.]]), array([[2., 3., 8., 6.],
[0., 4., 9., 3.]])]
[array([[4., 2., 1.],
[5., 0., 6.]]), array([[8.],
[7.]]), array([[5., 4., 8., 8., 2., 3., 8., 6.],
[4., 2., 4., 7., 0., 4., 9., 3.]])]
[[4. 5.]
[2. 0.]
[1. 6.]
[8. 7.]
[5. 4.]
[4. 2.]
[8. 4.]
[8. 7.]
[2. 0.]
[3. 4.]
[8. 9.]
[6. 3.]]
[array([[4., 5.],
[2., 0.],
[1., 6.],
[8., 7.]]), array([[5., 4.],
[4., 2.],
[8., 4.],
[8., 7.]]), array([[2., 0.],
[3., 4.],
[8., 9.],
[6., 3.]])]
argmax
找出最大值所在的下标
例子：
# 生成一个正弦函数区间的矩阵，并把矩阵转为五行四列的二维矩阵
data = np.sin(np.arange(20)).reshape(5, 4)
# 找出最大值所在的下表， axis = 0代表按列查找， axis=1代表按行查找
ind = data.argmax(axis = 0)
# 找出指定坐标下的元素，range(data.shape[1])是分别从[0,1,2,3]列下面查找
data_max = data[ind, range(data.shape[1])]
print(data)
print(ind)
print(data_max)
输出如下：
[[ 0. 0.84147098 0.90929743 0.14112001]
[-0.7568025 -0.95892427 -0.2794155 0.6569866 ]
[ 0.98935825 0.41211849 -0.54402111 -0.99999021]
[-0.53657292 0.42016704 0.99060736 0.65028784]
[-0.28790332 -0.96139749 -0.75098725 0.14987721]]
[2 0 3 1]
[0.98935825 0.84147098 0.99060736 0.6569866 ]
tile
把矩阵复制后进行扩展
例子：
a = np.arange(0, 40, 10)
b = np.tile(a, (2, 3))
print(a)
print(b)
输出如下：
[ 0 10 20 30]
[[ 0 10 20 30 0 10 20 30 0 10 20 30]
[ 0 10 20 30 0 10 20 30 0 10 20 30]]
sort
矩阵排序
例子：
a = np.array([[4, 3, 5], [1, 2, 1]])
# 按行排序
b = np.sort(a, axis=1)
# 按列排序
c = np.sort(a, axis=0)
d = np.array([4, 3, 1, 2])
# 按元素从小到大排序，用元素对应的下标来生成对应的新矩阵
e = np.argsort(d)
# 让矩阵以指定的下标进行排序
f = d[e]
print(a)
print(b)
print(c)
print(d)
print(e)
print(f)
输入如下：
[[4 3 5]
[1 2 1]]
[[3 4 5]
[1 1 2]]
[[1 2 1]
[4 3 5]]
[4 3 1 2]
[2 3 1 0]
[1 2 3 4]
meshgrid
例子：
import numpy as np
a = array([ 0. , 0.25, 0.5 , 0.75, 1. ])
b = array([ 0. , 0.5, 1. ])
A, B = np.meshgrid(a,b)
print(A)
print(B)
输出如下：
array([[ 0. , 0.25, 0.5 , 0.75, 1. ],
[ 0. , 0.25, 0.5 , 0.75, 1. ],
[ 0. , 0.25, 0.5 , 0.75, 1. ]])
array([[ 0. , 0. , 0. , 0. , 0. ],
[ 0.5, 0.5, 0.5, 0.5, 0.5],
[ 1. , 1. , 1. , 1. , 1. ]])
meshgrid函数接收两个一维矩阵的入参a和b，会生成两个二维矩阵A和B
A的行数为b的元素个数(既b.shape)，A的每一行数据都是a，也就是说，A是一个由b.shape个a组成的二维矩阵。
B的行数为b的元素个数(既b.shape)，B的第n行数据是b的第n个元素重复a.shape次组成的一维矩阵，也就是说，B是每一行对应b的每一个元素重复a.shape次的一维矩阵组成的二维矩阵。
矩阵运算
==
判断矩阵中是否存在某个值
例子：
import numpy as np
a = np.array([5, 10, 15, 20])
b = np.array([5, 10, 15], [20, 25, 30], [35, 40, 45])
print(a == 10)
print(b == 25)
输出如下：
[False True False False]
[[False False False]
[False True False]
[False False False]]
== 会把矩阵A中的所有元素和目标值进行对比，生成一个同样的行列类型为boolean类型的矩阵B，矩阵B中每个元素的值为True或False，也就是矩阵A在该位置的值若是与目标祥等，对应矩阵B中同样位置的值为True，反之则为False。若是>、<等判断，也会返回类似的矩阵。
以上boolean类型的矩阵B还可以对矩阵A进行索引。
例子：
import numpy as np
a = np.array([[5, 10, 15], [20, 25, 30], [35, 40, 45]])
b = a == 25
print(a)
print(b)
print(a[b])
输出如下：
[[ 5 10 15]
[20 25 30]
[35 40 45]]
[[False False False]
[False True False]
[False False False]]
[25]
&
与操作
例子：
a = np.array([5, 10, 15, 20])
b = (a == 5) & (a == 10)
print(b)
输出如下：
[False False False False]
|
或操作
例子：
a = np.array([5, 10, 15, 20])
b = (a == 5) | (a == 10)
print(b)
输出如下：
[ True True False False]
+、-
数字类型的矩阵元素个数相同时，可以进行加减运算，结果是对应位置的每个元素单独加减后的结果矩阵。矩阵还可以和指定数字做加减，结果为每个元素单独和指定数字做加减。
例子：
a = np.array([5, 10, 15, 20, 25])
b = np.arange(5)
print(a)
print(b)
c = a - b
d = c - 1
print(c)
print(d)
输出如下：
[ 5 10 15 20 25]
[0 1 2 3 4]
[ 5 9 13 17 21]
[ 4 8 12 16 20]
*
数字类型的矩阵元素个数相同时，还可以进行乘法运算，结果是对应位置的每个元素单独相乘后的结果矩阵。矩阵还可以和指定数字相乘，结果为每个元素单独和指定数字相乘。
例子：
a = np.array([[1, 1],
[0, 1]])
b = np.array([[2, 0],
[3, 4]])
c = a*b
d = c*2
print(c)
print(d)
输出如下：
[[2 0]
[0 4]]
[[4 0]
[0 8]]
**
求矩阵的平方
例子：
a = np.arange(5)
b = a**2
print(a)
print(b)
输出如下：
[0 1 2 3 4]
[ 0 1 4 9 16]
替换
把矩阵中的某些元素替换成指定值
例子：
a = np.array([5, 10, 15, 20])
b = (a == 5) | (a == 10)
a[b] = 50
print(a)
输出如下：
[50 50 15 20]
拷贝问题
归纳：=是赋值操作，在内存中共用id与值，view是浅拷贝，在内存中不共用id，但是共用值，copy是深拷贝，在内存中不共用id，也不共用值。
=
赋值操作，在内存中共用id与源数据
例子：
a = np.arange(12)
b = a
print(a)
print(b)
# 改变b指向的值，a也会跟着改变
b.shape = (3, 4)
print(a is b)
print(id(a))
print(id(b))
print(a)
print(b)
输出如下：
[ 0 1 2 3 4 5 6 7 8 9 10 11]
[ 0 1 2 3 4 5 6 7 8 9 10 11]
True
2448230632384
2448230632384
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
view
浅拷贝，复制一份共享源数据的新数据
a = np.arange(12)
b = a.view()
print(a)
print(b)
b.shape = (3, 4)
# 改变b指向的值，a也会跟着改变
b[0, 3] = 999
print(a is b)
print(id(a))
print(id(b))
print(a)
print(b)
输出如下：
[ 0 1 2 3 4 5 6 7 8 9 10 11]
[ 0 1 2 3 4 5 6 7 8 9 10 11]
False
2689698089920
2689728226928
[ 0 1 2 999 4 5 6 7 8 9 10 11]
[[ 0 1 2 999]
[ 4 5 6 7]
[ 8 9 10 11]]
copy
深拷贝
a = np.arange(12)
b = a.copy()
print(a)
print(b)
b.shape = (3, 4)
# 改变b指向的值，a不会跟着改变
b[0, 3] = 999
print(a is b)
print(id(a))
print(id(b))
print(a)
print(b)
输出如下：
[ 0 1 2 3 4 5 6 7 8 9 10 11]
[ 0 1 2 3 4 5 6 7 8 9 10 11]
False
1916472249200
1916502320672
[ 0 1 2 3 4 5 6 7 8 9 10 11]
[[ 0 1 2 999]
[ 4 5 6 7]
[ 8 9 10 11]]
网友评论