numpy第三方库

# 导入numpy 并赋予别名 np
import numpy as np
# 创建数组的常用的几种方式(列表，元组，range,arange,linspace(创建的是等差数组),zeros(全为 0 的数组),ones(全为 1 的数组),logspace(创建的是对数数组))
# 列表方式
np.array([1,2,3,4])
# array([1, 2, 3, 4])

# 元组方式
np.array((1,2,3,4))
# array([1, 2, 3, 4])

# range 方式
np.array(range(4)) # 不包含终止数字
# array([0, 1, 2, 3])

# 使用 arange(初始位置=0,末尾,步长=1)
    # 不包含末尾元素
np.arange(1,8,2)
# array([1, 3, 5, 7])

np.arange(8)
# array([0, 1, 2, 3, 4, 5, 6, 7])
# 使用 linspace(起始数字,终止数字，包含数字的个数[,endpoint = False]) 生成等差数组

# 生成等差数组,endpoint 为 True 则包含末尾数字
np.linspace(1,3,4,endpoint=False)
# array([1. , 1.5, 2. , 2.5])
np.linspace(1,3,4,endpoint=True)
# array([1.        , 1.66666667, 2.33333333, 3.        ])

# 创建全为零的一维数组
np.zeros(3)
# 创建全为一的一维数组
np.ones(4)
# array([1., 1., 1., 1.])

np.linspace(1,3,4)
# array([1.        , 1.66666667, 2.33333333, 3.        ])

# np.logspace(起始数字，终止数字，数字个数，base = 10) 对数数组
np.logspace(1,3,4)
# 相当于 10 的 linspace(1,3,4) 次方
# array([  10.        ,   46.41588834,  215.443469  , 1000.        ])
np.logspace(1,3,4,base = 2)
# array([2.       , 3.1748021, 5.0396842, 8.       ])


# 创建二维数组(列表嵌套列表)
np.array([[1,2,3],[4,5,6]])
'''
array([[1, 2, 3],
       [4, 5, 6]])
'''

# 创建全为零的二维数组
# 两行两列
np.zeros((2,2))
'''
array([[0., 0.],
       [0., 0.]])
'''
# 三行三列
np.zeros((3,2))
'''
array([[0., 0.],
       [0., 0.],
       [0., 0.]])
'''

# 创建一个单位数组
np.identity(3)
'''
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
'''
# 创建一个对角矩阵，(参数为对角线上的数字)
np.diag((1,2,3))
'''
array([[1, 0, 0],
       [0, 2, 0],
       [0, 0, 3]])
'''

import numpy as np
x = np.arange(8)
# [0 1 2 3 4 5 6 7]
# 在数组尾部追加一个元素
np.append(x,10)
# array([ 0,  1,  2,  3,  4,  5,  6,  7, 10])

# 在数组尾部追加多个元素
np.append(x,[15,16,17])
# array([ 0,  1,  2,  3,  4,  5,  6,  7, 15, 16, 17])

# 使用 数组下标修改元素的值
x[0] = 99
# array([99,  1,  2,  3,  4,  5,  6,  7])

# 在指定位置插入数据
np.insert(x,0,54)
# array([54, 99,  1,  2,  3,  4,  5,  6,  7])

# 创建一个多维数组
x = np.array([[1,2,3],[11,22,33],[111,222,333]])
'''
array([[  1,   2,   3],
       [ 11,  22,  33],
       [111, 222, 333]])
'''
# 修改第 0 行第 2 列的元素值
x[0,2] = 9
'''
array([[  1,   2,   9],
       [ 11,  22,  33],
       [111, 222, 333]])
'''
# 行数大于等于 1 的，列数大于等于 1 的置为 1
x[1:,1:] = 1
'''
array([[  1,   2,   9],
       [ 11,   1,   1],
       [111,   1,   1]])
'''
# 同时修改多个元素值
x[1:,1:] = [7,8]
'''
array([[  1,   2,   9],
       [ 11,   7,   8],
       [111,   7,   8]])
'''
x[1:,1:] = [[7,8],[9,10]]
'''
array([[  1,   2,   9],
       [ 11,   7,   8],
       [111,   9,  10]])
'''

import numpy as np
n = np.arange(10)
# array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

# 查看数组的大小
n.size
# 10

# 将数组分为两行五列
n.shape = 2,5
'''
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
'''
# 显示数组的维度
n.shape
# (2, 5)

# 设置数组的维度，-1 表示自动计算
n.shape = 5,-1
'''
array([[0, 1],
       [2, 3],
       [4, 5],
       [6, 7],
       [8, 9]])
'''
# 将新数组设置为调用数组的两行五列并返回
x = n.reshape(2,5)
'''
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
'''
x = np.arange(5)
# 将数组设置为两行，没有数的设置为 0
x.resize((2,10))
'''
array([[0, 1, 2, 3, 4, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])
'''
# 将 x 数组的两行五列形式显示，不改变 x 的值
np.resize(x,(2,5))
'''
array([[0, 1, 2, 3, 4],
       [0, 0, 0, 0, 0]])
'''

import numpy as np
n = np.array(([1,2,3],[4,5,6],[7,8,9]))
'''
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
'''
# 第一行元素
n[0]
# array([1, 2, 3])

# 第一行第三列元素
n[0,2]
# 3

# 第一行和第二行的元素
n[[0,1]]
'''
array([[1, 2, 3],
       [4, 5, 6]])
'''
# 第一行第三列，第三行第二列，第二行第一列
n[[0,2,1],[2,1,0]]
# array([3, 8, 4])

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

# 将数组倒序
a[::-1]
# array([7, 6, 5, 4, 3, 2, 1, 0])

# 步长为 2
a[::2]
# array([0, 2, 4, 6])

# 从 0 到 4 的元素
a[:5]
# array([0, 1, 2, 3, 4])


c = np.arange(16)
# array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])
c.shape = 4,4
'''
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])
'''

# 第一行，第三个元素到第五个元素(如果没有则输出到末尾截止)
c[0,2:5]
# array([2, 3])

# 第二行元素
c[1]
# array([4, 5, 6, 7])

# 第三行到第六行，第三列到第六列
c[2:5,2:5]
'''
array([[10, 11],
       [14, 15]])
'''
# 第二行第三列元素和第三行第四列元素
c[[1,2],[2,3]]
# array([ 6, 11])

# 第一行和第三行的第二列到第三列的元素
c[[0,2],1:3]
'''
array([[ 1,  2],
       [ 9, 10]])
'''
# 第一列和第三列的所有横行元素
c[:,[0,2]]
'''
array([[ 0,  2],
       [ 4,  6],
       [ 8, 10],
       [12, 14]])
'''
# 第三列所有元素
c[:,2]
# array([ 2,  6, 10, 14])

# 第二行和第四行的所有元素
c[[1,3]]
'''
array([[ 4,  5,  6,  7],
       [12, 13, 14, 15]])
'''
# 第一行的第二列，第四列元素，第四行的第二列，第四列元素
c[[0,3]][:,[1,3]]
'''
array([[ 1,  3],
       [13, 15]])
'''

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

# 使用 * 进行相乘
x*2
# array([ 2,  4,  6,  8, 10])

# 使用 / 进行相除
x / 2
# array([0.5, 1. , 1.5, 2. , 2.5])
2 / x
# array([2.        , 1.        , 0.66666667, 0.5       , 0.4       ])

# 使用 // 进行整除
x//2
# array([0, 1, 1, 2, 2], dtype=int32)
10//x
# array([10,  5,  3,  2,  2], dtype=int32)


# 使用 ** 进行幂运算
x**3
# array([  1,   8,  27,  64, 125], dtype=int32)

2 ** x
# array([ 2,  4,  8, 16, 32], dtype=int32)


# 使用 + 进行相加
x + 2
# array([3, 4, 5, 6, 7])

# 使用 % 进行取模
x % 3
# array([1, 2, 0, 1, 2], dtype=int32)

# 数组与数组之间的运算
# 使用 + 进行相加
np.array([1,2,3,4]) + np.array([11,22,33,44])
# array([12, 24, 36, 48])

np.array([1,2,3,4]) + np.array([3])
# array([4, 5, 6, 7])

n = np.array((1,2,3))
# +
n + n
# array([2, 4, 6])
n + np.array([4])
# array([5, 6, 7])

# *
n * n
# array([1, 4, 9])
n * np.array(([1,2,3],[4,5,6],[7,8,9]))
'''
array([[ 1,  4,  9],
       [ 4, 10, 18],
       [ 7, 16, 27]])
'''

# -
n - n
# array([0, 0, 0])

# /
n/n
# array([1., 1., 1.])

# **
n**n
# array([ 1,  4, 27], dtype=int32)


x = np.array((1,2,3))
y = np.array((4,5,6))
# 数组的内积运算(对应位置上元素相乘)
np.dot(x,y)
# 32
sum(x*y)
# 32

# 布尔运算
n = np.random.rand(4)
# array([0.53583849, 0.09401473, 0.07829069, 0.09363152])

# 判断数组中的元素是否大于 0.5
n > 0.5
# array([ True, False, False, False])

# 将数组中大于 0.5 的元素显示
n[n>0.5]
# array([0.53583849])

# 找到数组中 0.05 ~ 0.4 的元素总数
sum((n > 0.05)&(n < 0.4))
# 3

# 是否都大于 0.2
np.all(n > 0.2)
# False

# 是否有元素小于 0.1
np.any(n < 0.1)
# True

# 数组与数组之间的布尔运算
a = np.array([1,4,7])
# array([1, 4, 7])
b = np.array([4,3,7])
# array([4, 3, 7])

# 在 a 中是否有大于 b 的元素
a > b
# array([False,  True, False])

# 在 a 中是否有等于 b 的元素
a == b
# array([False, False,  True])

# 显示 a 中 a 的元素等于 b 的元素
a[a == b]
# array([7])

# 显示 a 中的偶数且小于 5 的元素
a[(a%2 == 0) & (a < 5)]
# array([4])

import numpy as np
# 将 0~100 10等分
x = np.arange(0,100,10)
# array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])

# 每个数组元素对应的正弦值
np.sin(x)
'''
array([ 0.        , -0.54402111,  0.91294525, -0.98803162,  0.74511316,
       -0.26237485, -0.30481062,  0.77389068, -0.99388865,  0.89399666])
'''
# 每个数组元素对应的余弦值
np.cos(x)
'''
array([ 1.        , -0.83907153,  0.40808206,  0.15425145, -0.66693806,
        0.96496603, -0.95241298,  0.6333192 , -0.11038724, -0.44807362])
'''
# 对参数进行四舍五入
np.round(np.cos(x))
# array([ 1., -1.,  0.,  0., -1.,  1., -1.,  1., -0., -0.])

# 对参数进行上入整数 3.3->4
np.ceil(x/3)
# array([ 0.,  4.,  7., 10., 14., 17., 20., 24., 27., 30.])


# 分段函数
x = np.random.randint(0,10,size=(1,10))
# array([[0, 3, 6, 7, 9, 4, 9, 8, 1, 8]])

# 大于 4 的置为 0
np.where(x > 4,0,1)
# array([[1, 1, 0, 0, 0, 1, 0, 0, 1, 0]])

# 小于 4 的乘 2 ，大于 7 的乘3
np.piecewise(x,[x<4,x>7],[lambda x:x*2,lambda x:x*3])
# array([[ 0,  6,  0,  0, 27,  0, 27, 24,  2, 24]])


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

# 返回排序后元素的原下标
np.argsort(x)
# array([0, 3, 1, 2], dtype=int64)

# 输出最大值的下标
x.argmax( )
# 2

# 输出最小值的下标
x.argmin( )
# 0

# 对数组进行排序
x.sort( )

import numpy as np
# 生成一个随机数组
np.random.randint(0,6,3)
# array([1, 1, 3])

# 生成一个随机数组(二维数组)
np.random.randint(0,6,(3,3))
'''
array([[4, 4, 1],
       [2, 1, 0],
       [5, 0, 0]])
'''
# 生成十个随机数在[0,1)之间
np.random.rand(10)
'''
array([0.9283789 , 0.43515554, 0.27117021, 0.94829333, 0.31733981,
       0.42314939, 0.81838647, 0.39091899, 0.33571004, 0.90240897])
'''
# 从标准正态分布中随机抽选出3个数
np.random.standard_normal(3)
# array([0.34660435, 0.63543859, 0.1307822 ])
# 返回三页四行两列的标准正态分布数
np.random.standard_normal((3,4,2))
'''
array([[[-0.24880261, -1.17453957],
        [ 0.0295264 ,  1.04038047],
        [-1.45201783,  0.57672288],
        [ 1.10282747, -2.08699482]],

       [[-0.3813943 ,  0.47845782],
        [ 0.97708005,  1.1760147 ],
        [ 1.3414987 , -0.629902  ],
        [-0.29780567,  0.60288726]],

       [[ 1.43991349, -1.6757028 ],
        [-1.97956809, -1.18713495],
        [-1.39662811,  0.34174275],
        [ 0.56457553, -0.83224426]]])
'''
# 创建矩阵
import numpy as np
x = np.matrix([[1,2,3],[4,5,6]])
'''
matrix([[1, 2, 3],
        [4, 5, 6]])
'''
y = np.matrix([1,2,3,4,5,6])
# matrix([[1, 2, 3, 4, 5, 6]])

# x 的第二行第二列元素
x[1,1]
# 5

# 矩阵的函数
import numpy as np
# 矩阵的转置
x = np.matrix([[1,2,3],[4,5,6]])
'''
matrix([[1, 2, 3],
        [4, 5, 6]])
'''
y = np.matrix([1,2,3,4,5,6])
# matrix([[1, 2, 3, 4, 5, 6]])

# 实现矩阵的转置
x.T
'''
matrix([[1, 4],
        [2, 5],
        [3, 6]])
'''
y.T
'''
matrix([[1],
        [2],
        [3],
        [4],
        [5],
        [6]])
'''
# 元素平均值
x.mean()
# 3.5

# 纵向平均值
x.mean(axis = 0)
# matrix([[2.5, 3.5, 4.5]])

# 横向平均值
x.mean(axis = 1)
'''
matrix([[2.],
        [5.]])
'''

# 所有元素之和
x.sum()
# 21

# 横向最大值
x.max(axis = 1)
'''
matrix([[3],
        [6]])
'''
# 横向最大值的索引下标
x.argmax(axis = 1)
'''
matrix([[2],
        [2]], dtype=int64)
'''

# 对角线元素
x.diagonal()
# matrix([[1, 5]])

# 非零元素下标
x.nonzero()
# (array([0, 0, 0, 1, 1, 1], dtype=int64),
# array([0, 1, 2, 0, 1, 2], dtype=int64))


# 矩阵的运算
import numpy as np
x = np.matrix([[1,2,3],[4,5,6]])
'''
matrix([[1, 2, 3],
        [4, 5, 6]])
'''
y = np.matrix([[1,2],[4,5],[7,8]])
'''
matrix([[1, 2],
        [4, 5],
        [7, 8]])
'''
# 矩阵的乘法
x*y
'''
matrix([[30, 36],
        [66, 81]])
'''
# 相关系数矩阵,可使用在列表元素数组矩阵
# 负相关
np.corrcoef([1,2,3],[8,5,4])
'''
array([[ 1.        , -0.96076892],
       [-0.96076892,  1.        ]])
'''
# 正相关
np.corrcoef([1,2,3],[4,5,7])
'''
array([[1.        , 0.98198051],
       [0.98198051, 1.        ]])
'''
# 矩阵的方差
np.cov([1,1,1,1,1])
# array(0.)

# 矩阵的标准差
np.std([1,1,1,1,1])
# 0.0

x = [-2.1,-1,4.3]
y = [3,1.1,0.12]

# 垂直堆叠矩阵
z = np.vstack((x,y))
'''
array([[-2.1 , -1.  ,  4.3 ],
       [ 3.  ,  1.1 ,  0.12]])
'''
# 矩阵的协方差
np.cov(z)
'''
array([[11.71      , -4.286     ],
       [-4.286     ,  2.14413333]])
'''
np.cov(x,y)
'''
array([[11.71      , -4.286     ],
       [-4.286     ,  2.14413333]])
'''
# 标准差
np.std(z)
# 2.2071223094538484

# 列向标准差
np.std(z,axis = 1)
# array([2.79404128, 1.19558447])

# 方差
np.cov(x)
# array(11.71)

# 特征值和特征向量
A = np.array([[1,-3,3],[3,-5,3],[6,-6,4]])
'''
array([[ 1, -3,  3],
       [ 3, -5,  3],
       [ 6, -6,  4]])
'''
e,v = np.linalg.eig(A)
# e 为特征值, v 为特征向量
'''
e
    array([ 4.+0.00000000e+00j, -2.+1.10465796e-15j, -2.-1.10465796e-15j])
v
    array([[-0.40824829+0.j        ,  0.24400118-0.40702229j,
         0.24400118+0.40702229j],
       [-0.40824829+0.j        , -0.41621909-0.40702229j,
        -0.41621909+0.40702229j],
       [-0.81649658+0.j        , -0.66022027+0.j        ,
        -0.66022027-0.j        ]])
'''
# 矩阵与特征向量的乘积
np.dot(A,v)
'''
array([[-1.63299316+0.00000000e+00j, -0.48800237+8.14044580e-01j,
        -0.48800237-8.14044580e-01j],
       [-1.63299316+0.00000000e+00j,  0.83243817+8.14044580e-01j,
         0.83243817-8.14044580e-01j],
       [-3.26598632+0.00000000e+00j,  1.32044054-5.55111512e-16j,
         1.32044054+5.55111512e-16j]])
'''
# 特征值与特征向量的乘积
e * v
'''
array([[-1.63299316+0.00000000e+00j, -0.48800237+8.14044580e-01j,
        -0.48800237-8.14044580e-01j],
       [-1.63299316+0.00000000e+00j,  0.83243817+8.14044580e-01j,
         0.83243817-8.14044580e-01j],
       [-3.26598632+0.00000000e+00j,  1.32044054-7.29317578e-16j,
         1.32044054+7.29317578e-16j]])
'''
# 验证两个乘积是否相等
np.isclose(np.dot(A,v),(e * v))
'''
array([[ True,  True,  True],
       [ True,  True,  True],
       [ True,  True,  True]])
'''
# 行列式 |A - λE| 的值应为 0
np.linalg.det(A-np.eye(3,3)*e)
# 5.965152994198125e-14j


x = np.matrix([[1,2,3],[4,5,6],[7,8,0]])
'''
matrix([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 0]])
'''
# 逆矩阵
y = np.linalg.inv(x)
'''

matrix([[-1.77777778,  0.88888889, -0.11111111],
        [ 1.55555556, -0.77777778,  0.22222222],
        [-0.11111111,  0.22222222, -0.11111111]])
注：numpy.linalg.LinAlgError: Singular matrix 矩阵不存在逆矩阵
'''
# 矩阵的乘法
x * y
'''
matrix([[ 1.00000000e+00,  5.55111512e-17,  1.38777878e-17],
        [ 5.55111512e-17,  1.00000000e+00,  2.77555756e-17],
        [ 1.77635684e-15, -8.88178420e-16,  1.00000000e+00]])
'''
y * x
'''
matrix([[ 1.00000000e+00, -1.11022302e-16,  0.00000000e+00],
        [ 8.32667268e-17,  1.00000000e+00,  2.22044605e-16],
        [ 6.93889390e-17,  0.00000000e+00,  1.00000000e+00]])
'''
# 求解线性方程组
a = np.array([[3,1],[1,2]])
'''
array([[3, 1],
       [1, 2]])
'''
b = np.array([9,8])
# array([9, 8])

# 求解
x = np.linalg.solve(a,b)
# array([2., 3.])

# 验证
np.dot(a,x)
# array([9., 8.])

# 最小二乘解：返回解，余项，a 的秩，a 的奇异值
np.linalg.lstsq(a,b)
# (array([2., 3.]), array([], dtype=float64), 2, array([3.61803399, 1.38196601]))

# 计算向量和矩阵的范数
x = np.matrix([[1,2],[3,-4]])
'''
matrix([[ 1,  2],
        [ 3, -4]])
'''
np.linalg.norm(x)
# 5.477225575051661
np.linalg.norm(x,-2)
# 1.9543950758485487
np.linalg.norm(x,-1)
# 4.0
np.linalg.norm(x,1)
# 6.0
np.linalg.norm([1,2,0,3,4,0],0)
# 4.0
np.linalg.norm([1,2,0,3,4,0],2)
# 5.477225575051661

# 奇异值分解
a = np.matrix([[1,2,3],[4,5,6],[7,8,9]])
'''
matrix([[1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]])
'''
u,s,v = np.linalg.svd(a)
u
'''
matrix([[-0.21483724,  0.88723069,  0.40824829],
        [-0.52058739,  0.24964395, -0.81649658],
        [-0.82633754, -0.38794278,  0.40824829]])
'''
s
'''
array([1.68481034e+01, 1.06836951e+00, 4.41842475e-16])
'''
v
'''
matrix([[-0.47967118, -0.57236779, -0.66506441],
        [-0.77669099, -0.07568647,  0.62531805],
        [-0.40824829,  0.81649658, -0.40824829]])
'''
# 验证
u * np.diag(s) * v
'''
matrix([[1., 2., 3.],
        [4., 5., 6.],
        [7., 8., 9.]])
'''

---

2020-05-03