numpy 常用总结

一个栗子

>>> import numpy as np
>>> a = np.arange(15).reshape(3, 5)
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> a.shape
(3, 5)
>>> a.ndim  # 数组轴的个数,在python的世界中,轴的个数被称作秩
2
>>> a.dtype.name
'int64'
>>> a.itemsize  # 数组中每个元素的字节大小。
8
>>> a.size
15
>>> type(a)
<type 'numpy.ndarray'>

随机数

np.random.normal

生成标准正态分布,在-1.96~+1.96范围内曲线下的面积等于0.95

samples = np.random.normal(size=(4,4))

array([[ 1.84543397,  0.91407872,  0.83926424,  0.05128908],
       [ 0.89142489,  0.38926367,  0.22890831, -1.63944174],
       [ 0.50097211,  1.0324319 ,  1.12945725, -0.66500686],
       [-0.13809704,  1.72104946,  0.4812083 , -2.35993971]])

np.random.normal(0,1,[3,2])
array([[-0.89197774, -0.23395082],
       [ 1.31110604,  1.25929054],
       [ 0.22351615, -0.38488545]])

np.random.uniform

可以生成[low,high)中的随机数,可以是单个值,也可以是一维数组,也可以是多维数组

np.random.uniform(1,5,(4,3)) #生成4x3的数组

array([[ 2.33083328, 1.592934 , 2.38072  ],
    [ 1.07485686, 4.93224857, 1.42584919],
    [ 3.2667912 , 4.57868281, 1.53218578],
    [ 4.17965117, 3.63912616, 2.83516143]])

np.random.randint

生成[low,high)整型随机数,可以是单个随机数,也可以是多维的随机数构成的数组

np.random.randint(4,10,size=(2,2),dtype='int32')

array([[7, 4],
    [6, 9]])

#生成0-1之间的浮点数
np.random.randn(2,3)

array([[ 0.59892845,  0.35535291,  0.53566027],
       [-0.09791823,  1.50595013, -0.5044485 ]])

np.random.rand

返回[0,1)内的浮点数,没有输入时,则返回[0,1)内的一个随机值

np.random.rand(3,3)

array([[ 0.47507608, 0.64225621, 0.9926529 ],
    [ 0.95028412, 0.18413813, 0.91879723],
    [ 0.89995217, 0.42356103, 0.81312942]])

创建矩阵

arange

import numpy as np
a = np.arange(10) # 默认从0开始到10(不包括10),步长为1
print(a) # 返回 [0 1 2 3 4 5 6 7 8 9]
a1 = np.arange(5,10) # 从5开始到10(不包括10),步长为1
print(a1) # 返回 [5 6 7 8 9]
a2 = np.arange(5,20,2) # 从5开始到20(不包括20),步长为2
print(a2) # 返回 [ 5  7  9 11 13 15 17 19]

linspace

import numpy as np
# 类似于matlab
a = np.linspace(0,10,7) # 生成首位是0,末位是10,含7个数的等差数列
# 结果 
[  0.   1.66666667   3.33333333   5.  6.66666667  8.33333333  10.]

ones、zeros、eye、empty

ones创建全1矩阵 ,zeros创建全0矩阵 ,eye创建单位矩阵 ,empty创建空矩阵(实际有值)

ones 全1矩阵

a_ones = np.ones((3,4)) # 创建3*4的全1矩阵
# 结果
[[ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]
 [ 1.  1.  1.  1.]]

np.ones((2,3,4), dtype=np.int16 )   # dtype can also be specified
# 结果
array([[[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]],
       [[ 1, 1, 1, 1],
        [ 1, 1, 1, 1],
        [ 1, 1, 1, 1]]], dtype=int16)

zeros 全0矩阵

a_zeros = np.zeros((3,4)) # 创建3*4的全0矩阵
print(a_zeros)
# 结果
[[ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]
 [ 0.  0.  0.  0.]]

eye 单位矩阵

a_eye = np.eye(3) # 创建3阶单位矩阵
print(a_eye)
# 结果
[[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]

empty 空矩阵

a_empty = np.empty((3,4)) # 创建3*4的空矩阵 
print(a_empty)
# 结果
[[  1.78006111e-306  -3.13259416e-294   4.71524461e-309   1.94927842e+289]
 [  2.10230387e-309   5.42870216e+294   6.73606381e-310   3.82265219e-297]
 [  6.24242356e-309   1.07034394e-296   2.12687797e+183   6.88703165e-315]]

矩阵运算符

+矩阵对应元素相加

-矩阵对应元素相减

*矩阵对应元素相乘

/矩阵对应元素相除

import numpy as np
a1 = np.array([[4,5,6],[1,2,3]])
a2 = np.array([[6,5,4],[3,2,1]])

print(a1+a2) # 相加
# 结果
[[10 10 10]
 [ 4  4  4]]

print(a1/a2) # 整数相除取商
# 结果
[[0.66666667 1.         1.5       ]
 [0.33333333 1.         3.        ]]

print(a1%a2) # 相除取余数
# 结果
[[4 0 2]
 [1 0 0]]

矩阵乘法

import numpy as np

a1 = np.array([[1,2,3],[4,5,6]]) # a1为2*3矩阵
a2 = np.array([[1,2],[3,4],[5,6]]) # a2为3*2矩阵
print(a1.dot(a2)) 
# 结果
[[22 28]
 [49 64]]

矩阵的转置 a.T

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.transpose())
# 或者 print(a.T)
# 结果
[[1 4]
 [2 5]
 [3 6]]

矩阵的逆

设A是数域上的一个n阶方阵,若在相同数域上存在另一个n阶矩阵B,使得: *AB*=BA=E。 则我们称B是A的逆矩阵,而A则被称为可逆矩阵。

单位矩阵的逆为他本身

import numpy as np
import numpy.linalg as lg

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

print(lg.inv(a))
# 结果
[[ 3.15251974e+15 -6.30503948e+15  3.15251974e+15]
 [-6.30503948e+15  1.26100790e+16 -6.30503948e+15]
 [ 3.15251974e+15 -6.30503948e+15  3.15251974e+15]]

最值

矩阵中元素最大最小值的函数分别是maxmin

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(a.max()) #获取整个矩阵的最大值 结果: 6
print(a.min()) #结果:1

# axis=0 行方向最大(小)值,即获得每列的最大(小)值
print(a.max(axis=0))
# 结果为 [4 5 6]

# axis=1 列方向最大(小)值,即获得每行的最大(小)值
print(a.max(axis=1))
# 结果为 [3 6]

# 要想获得最大最小值元素所在的位置,可以通过argmax函数来获得
print(a.argmax(axis=1))
# 结果为 [2 2]

平均值

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(a.mean()) #结果为: 3.5

# 同样地,可以通过关键字axis参数指定沿哪个方向获取平均值
print(a.mean(axis=0)) # 结果 [ 2.5  3.5  4.5]
print(a.mean(axis=1)) # 结果 [ 2.  5.]

方差相关

方差的函数为var()相当于函数mean(abs(x - x.mean())**2)

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(a.var()) # 结果 2.91666666667

print(a.var(axis=0)) # 结果 [ 2.25  2.25  2.25]
print(a.var(axis=1)) # 结果 [ 0.66666667  0.66666667]

标准差的函数为std()相当于sqrt(mean(abs(x - x.mean())**2))

import numpy as np

a = np.array([[1,2,3],[4,5,6]])
print(a.std()) # 结果 1.70782512766

print(a.std(axis=0)) # 结果 [ 1.5  1.5  1.5]
print(a.std(axis=1)) # 结果 [ 0.81649658  0.81649658]

中值

中值指的是将序列按大小顺序排列中间的那个值,如果有偶数个数,则是排在中间两个数的平均值。中值的函数是median()

import numpy as np
x = np.array([[1,2,3],[4,5,6]])

print(np.median(x))  # 对所有数取中值
# 结果
3.5

print(np.median(x,axis=0))  # 沿行方向取中值
# 结果
[ 2.5  3.5  4.5]

print(np.median(x,axis=1))  # 沿列方向取中值
# 结果
[ 2.  5.]

求和

import numpy as np

a = np.array([[1,2,3],[4,5,6]])

print(a.sum())           # 对整个矩阵求和
# 结果 21

print(a.sum(axis=0)) # 对行方向求和
# 结果 [5 7 9]

print(a.sum(axis=1)) # 对列方向求和
# 结果 [ 6 15]

累积和

某位置累积和指的是该位置之前(包括该位置)所有元素的和。例如序列[1,2,3,4,5],其累计和为[1,3,6,10,15]

import numpy as np

a = np.array([[1,2,3],[4,5,6]])

print(a.cumsum())     # 对整个矩阵求累积和
# 结果 [ 1  3  6 10 15 21]

print(a.cumsum(axis=0))  # 对列方向求累积和
# 结果
[[1 2 3]
 [5 7 9]]

print(  a.cumsum(axis=1))  # 对行方向求累积和
# 结果
[[ 1  3  6]
 [ 4  9 15]]

极差

import numpy as np
a = np.arange(100)
a.ptp()
# 结果是
99

百分位数

百分位数是统计中使用的度量,表示小于这个值的观察值占总数q的百分比。

a = np.array([[10, 7, 4], [3, 2, 1]])
np.percentile(a, 50)    #50%的分位数,就是a里排序之后的中位数
# 结果是
3.5

np.percentile(a, 50, axis=0) 
array([[ 6.5,  4.5,  2.5]])

加权平均值

import numpy as np
a = np.arange(15).reshape(3,5)
np.average(a, axis=0,weights=(10, 5, 1))
# 结果是
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
#35/16=2.1875
array([2.1875, 3.1875, 4.1875, 5.1875, 6.1875])

形状操纵

numpy中的ravel()、flatten()、squeeze()都有将多维数组转换为一维数组的功能,区别:

  • ravel():如果没有必要,不会产生源数据的副本

  • flatten():返回源数据的副本

  • squeeze():只能对维数为1的维度降维

    np.resize()和np.reshape()的区别

  • resize:直接修改原始数组的数据。np.resize(a,(2,3))或者a.resize((1,9))

  • reshape:在不改变原数组数据的情况下,将它reshape成一个新的维度。如果给定的数组数据和需要reshape的形状不符合时,将会报错。np.reshape(a, (3,-1))

a = np.floor(10*np.random.random((3,4)))
a
array([[ 2.,  8.,  0.,  6.],
       [ 4.,  5.,  1.,  1.],
       [ 8.,  9.,  3.,  6.]])

a.shape
(3, 4)

a.ravel()  # 转换为一维数组
array([ 2.,  8.,  0.,  6.,  4.,  5.,  1.,  1.,  8.,  9.,  3.,  6.])

a.reshape(6,2)  # 返回改变后数组形状
array([[ 2.,  8.],
       [ 0.,  6.],
       [ 4.,  5.],
       [ 1.,  1.],
       [ 8.,  9.],
       [ 3.,  6.]])

a.T  # 转正数组
array([[ 2.,  4.,  8.],
       [ 8.,  5.,  9.],
       [ 0.,  1.,  3.],
       [ 6.,  1.,  6.]])

a.T.shape
(4, 3)

Fancy Indexing

切片索引:通过[start: end: steps]

import numpy as np

#Fancy Indexing
x = np.arange(16)
np.random.shuffle(x)
print(x) #打印所有的元素
#[14  1  7 10 11 15  9  4  2 13 12  0  3  8  5  6]


print(x[2])         
print(x[1:3])        #切片,1到2
print(x[3:9:2])        #指定间距切片
#结果
7
[1 7]
[10 15  4]

布尔索引:通过布尔类型的数组进行索引

通过一个布尔数组来索引目标数组,以此找出与布尔数组中值为True的对应的目标数组中的数据。需要注意的是,布尔数组的长度必须与目标数组对应的轴的长度一致。

import numpy as np

names = np.array(['Bob', 'Joe', 'Will'])
scores = np.random.randint(0, 100, (3, 4)) # 3名学生的4科成绩
#结果
array([[58, 52, 97, 76],
       [91, 86, 80, 78],
       [26, 35, 75, 78]])

print(names == 'Bob')
[ True False False]
print(scores[names == 'Bob']) # 获取Bob的四科成绩
[[58 52 97 76]]

花式索引:通过整型数组进行索引

花式索引根据索引整型数组的值作为目标数组的某个轴的下标来取值。

import numpy as np

arr3d = np.arange(12).reshape(2, 2, 3) #2个2行三列数组
#结果
array([
    [[ 0,  1,  2],
    [ 3,  4,  5]],

    [[ 6,  7,  8],
    [ 9, 10, 11]]
])
# 使用两个整数数组来对axis= 0,1两个轴进行花式索引
print(arr3d[[0, 1], [1, 1]])
#结果
[[ 3  4  5]
 [ 9 10 11]]
print(arr3d[[0, 1], [0, 1, 2]]) # error



x = np.arange(16)
X = x.reshape(4,-1)
print(X)
#结果
[[14  1  7 10]
 [11 15  9  4]
 [ 2 13 12  0]
 [ 3  8  5  6]]
ind1 = np.array([1,3]) #行的索引
ind2 = np.array([2,0]) #列的索引
print(X[ind1,ind2])
#结果 (1,2)和(3,0)
[9 3]
本作品采用《CC 协议》,转载必须注明作者和本文链接
如果可以,我要变成光
讨论数量: 0
(= ̄ω ̄=)··· 暂无内容!

请勿发布不友善或者负能量的内容。与人为善,比聪明更重要!