zoukankan      html  css  js  c++  java
  • numpy包

    numpy

    矩阵

    导入库

    from numpy import *  # 导入numpy的库函数
    import numpy as np  # 使用numpy的函数时以np.开头。
    

    创建矩阵

    数组创建矩阵

    from numpy import *
    a1 = array([1, 2, 3])  # a1 = np.array([1,2,3], dtype=int) 
    a1 = mat(a1)  # mat转化为矩阵
    

    常见矩阵

    data1 = mat(zeros((3, 3)))  # 创建一个3*3的零矩阵
    b1 = np.zeros((2, 3))  # 完整的形式为:zeros(shape,dtype=)
    data2 = mat(ones((2, 4)))  # 创建一个2*4的1矩阵,默认是浮点型的数据
    data7 = mat(ones((2, 4), dtype = int))  # 创建一个2*4的1的int类型矩阵
    data3 = mat(random.rand(2, 2))  # 创建的是一个二维数组,需要将其转换成矩阵
    data4 = mat(random.randint(10, size=(3, 3)))  # 生成一个3*3的0-10之间的随机整数矩阵
    data5 = mat(random.randint(2, 8, size=(2, 5))  # 产生一个2-8之间的随机整数矩阵
    data6 = mat(eye(2, 2, dtype = int))  # 产生一个2*2的对角矩阵
    
    a1 = [1, 2, 3]
    a2 = mat(diag(a1))  # 生成一个对角线为1、2、3的对角矩阵
    

    常见矩阵运算

    乘法

    a1 = mat([1,2])  # 1*2的矩阵,行矩阵
    a2 = mat([[1],[2]])  # 2*1的矩阵,列矩阵
    a3 = a1*a2  # 1*2的矩阵乘以2*1的矩阵,得到1*1的矩阵
    
    np.dot(a, b) # 计算点积
    vdot(a, b)  # 专门计算矢量的点积,和dot()的区别在于对complex数据类型的处理不一样; 
    innner(a, b)  # 用来计算内积
    outer(a, b)  # 计算外积
    

    点乘

    a1 = mat([1, 1])
    a2 = mat([2, 2])
    a3 = multiply(a1, a2)  # 矩阵对应元素相乘
    a4 = mat([2, 2])
    a5 = a4 * 2  # 矩阵点乘
    

    求逆

    a1 = mat(eye(2, 2) * 0.5) 
    a2 = a1.I  # .I表示矩阵的逆
    

    转置

    a1 = mat([[1, 1], [0, 0]])
    a2 = a1.T  # .T表示矩阵转置
    

    求行列和

    a1 = mat([[1, 1], [2, 3], [4, 2]])
    a2 = a1.sum(axis = 0)  # 列和,这里得到的是1*2的矩阵
    a3 = a1.sum(axis = 1)  # 行和,这里得到的是3*1的矩阵
    a4 = sum(a1[1, :])  # 计算第一行所有列的和,这里得到的是一个数值
    

    最大最小值

    a1 = mat([[1, 1], [2, 3], [4, 2]])
    a1.max()  # 计算a1矩阵中所有元素的最大值,这里得到的结果是一个数值
    a2 = max(a1[:, 1])  # 计算第二列的最大值,这里得到的是一个1*1的矩阵
    a1[1, :].max()  # 计算第二行的最大值,这里得到的是一个一个数值
    
    np.max(a1, 0)  # 计算所有列的最大值,这里使用的是numpy中的max函数
    np.max(a1, 1)  # 计算所有行的最大值,这里得到是一个矩阵
    
    np.argmax(a1, 0)  # 计算所有列的最大值对应在该列中的索引
    np.argmax(a1[1, :])  # 计算第二行中最大值对应在改行的索引
    

    分割合并

    # 分割 
    a = mat(ones((3, 3)))
    b = a[1:, 1:]  # 分割出第二行以后的行和第二列以后的列的所有元素
    
    # 合并 
    a = mat(ones((2, 2)))
    b = mat(eye(2))
    c = vstack((a, b))  # 按列合并,即增加行数
    d = hstack((a, b))  # 按行合并,即行数不变,扩展列数
    

    类型转换

    l1 = [[1], 'hello', 3]  # 列表中元素可以使不同类型的数据
    
    a = array([[2], [1]])  # numpy中同一个数组中所有元素必须为同一个类型
    dimension = a.ndim
    m, n = a.shape
    number = a.size  # 元素总个数
    str = a.dtype  # 元素的类型
    
    a1 = [[1, 2], [3, 2], [5, 2]]  # 列表
    a2 = array(a1)  # 将列表转换成二维数组
    a3 = array(a1)  # 将列表转化成矩阵
    a4 = array(a3)  # 将矩阵转换成数组
    a5 = a3.tolist()  # 将矩阵转换成列表
    a6 = a2.tolist()  # 将数组转换成列表
    
    a1 = [1, 2, 3]
    a2 = array(a1)
    a3 = mat(a1)
    a4 = a2.tolist()  # 这里得到的是[1,2,3]
    a5 = a3.tolist()  # 这里得到的是[[1,2,3]]
    a6 = (a4 == a5)  # a6=False
    a7 = (a4 is a5[0])  # a7=True,a5[0]=[1,2,3]
    
    dataMat = mat([1])
    val = dataMat[0, 0]  # 这个时候获取的就是矩阵的元素的数值,而不再是矩阵的类型
    

    其他

    from numpy import *  # 导入numpy的库函数
    
    # 将Python的列表转换成NumPy的矩阵
    list = [1, 2, 3]
    mat(list)
    
    # 矩阵相乘
    m1 = mat([1, 2, 3])  # 1行3列
    m2 = mat([4, 5, 6])
    m1 * m2.T  # 注意左列与右行相等 m2.T为转置操作
    
    multiply(m1, m2)  # 执行点乘操作,要使用函数,特别注意
    
    # 排序
    m = mat([[2, 5, 1], [4, 6, 2]])  # 创建2行3列矩阵
    m.sort()  # 对每一行进行排序
    
    m.shape  # 获得矩阵的行列数
    m.shape[0]  # 获得矩阵的行数
    m.shape[1]  # 获得矩阵的列数
    
    # 索引取值
    m[1, :]  # 取得第一行的所有元素
    m[1, 0:1]  # 第一行第0个元素,注意左闭右开
    m[1, 0:3]
    m[1, 0:2]
    

    数组

    定义数组

    from numpy import *
    
    # 数组定义 
    a1 = array([1, 1, 1])  # 定义一个数组
    a2 = array([2, 2, 2])
    
    # 定义多维数组 
    a3 = array([[1, 2, 3], [4, 5, 6]])
    a3[0]  # 取出第一行的数据
    a3[0, 0]  # 第一行第一个数据
    a3[0][0]  # 也可用这种方式
    
    # 指定数组类型
    c = array( [ [1,2], [3,4] ], dtype=complex )
    

    常见函数

    import numpy as np
    
    a = np.zeros((2, 2))  # 创建一个全0的数组,或者不加.np直接 zeros((2, 2))
    b = np.ones((1, 2))  # 创建一个全1的数组,或者不加.np直接 ones((1, 2))
    c = np.full((2, 2), 7)  # 创建一个全为7的2*2的数组
    d = np.eye(2)  # 创建一个对角矩阵,对角线全为1
    e = np.random.random((2, 2))  # 创建一个2*2的矩阵,元素值随机浮点数
    f = enpty((2, 3))  # 内容随机的的2*3的数组
    g = arange(10, 30, 5)  # 返回一个首项为10,公差为5的数列,尾项不超过30
    

    数组特征信息

    X.flags  # 数组的存储情况信息。
    X.shape  # 结果是一个tuple,返回本数组的行数、列数、……
    X.ndim  # 数组的维数,结果是一个数
    X.size  # 数组中元素的总个数
    X.itemsize  # 数组中的每个元素的所占内存空间大小,,单位是字节
    X.dtype  # 数据类型
    X.data  # 包含实际数组元素的缓冲区,不建议使用
    X.T  # 如果X是矩阵,发挥的是X的转置矩阵
    X.trace()  # 计算X的迹
    np.linalg.det(a)  # 返回的是矩阵a的行列式
    np.linalg.norm(a, ord=None)  # 计算矩阵a的范数
    np.linalg.eig(a)  # 矩阵a的特征值和特征向量
    np.linalg.cond(a, p=None)  # 矩阵a的条件数
    np.linalg.inv(a)  # 矩阵a的逆矩阵
    

    数组运算

    from numpy import *
    
    # 数组定义 
    a1 = array([1, 1, 1])  # 定义一个数组
    a2 = array([2, 2, 2])
    a1 + a2  # 对应元素相加,也可以是add(a1, a2)
    a1 - a2  # 对应元素相减
    a1 * 2  # 对应元素乘一个数->rray([2, 2, 2])
    
    # 乘方 
    a1 = array([1, 2, 3])
    a1 ** 3  # 表示对数组中的每个数做平方->array([1, 8, 27])
    
    # 定义多维数组 
    a3 = array([[1, 2, 3], [4, 5, 6]])
    a3[0]  # 取出第一行的数据
    a3[0, 0]  # 第一行第一个数据
    a3[0][0]  # 也可用这种方式
    
    # 指定数组类型
    c = array( [ [1,2], [3,4] ], dtype=complex )
    
    # 矩阵点乘 
    a1 = array([1, 2, 3])
    a2 = array([4, 5, 6])
    a3 = dot(a1, a2)
    
    # 计算列和行和,累计和
    a1 = array([
           [ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    a2 = a1.sum(axis=0)  # 计算列和
    a3 = a1.sum(axis=1)  # 计算行和
    a4 = a1.cumsum(axis=1)  # 计算每行累积和,axis=0计算每列累积和
    >>>a4 = array([[ 0,  1,  3,  6],
           [ 4,  9, 15, 22],
           [ 8, 17, 27, 38]]) 
    
    # 通用函数
    b1 = array([0, 1, 2])
    b2 = exp(b1)
    b3 = sqrt(b1)
    b4 = sin(b1)
    

    索引

    from numpy import *
    
    a = arange(10) ** 3
    a = arange(10) ** 3  # a = array([0,1,8,27,64,125,216,343,512,729])
    a[2]  # = 8
    a[2:5]  # = array([8,27,64])
    a[:6:2] = -1000  # = array([-1000,1,-1000,27, -1000,125, 216,343,512,729])
    a[::-1]  # = array([729,512,343,216,125,-1000,27,-1000,1,-1000]) 反向排序
    # 省略点(…)代表许多产生一个完整的索引元组必要的分号
    # b[i]中括号中的表达式被当作i和一系列
    # :来代表剩下的轴
    # x[1,2,…] 等同于 x[1,2,:,:,:],
    # x[…,3] 等同于 x[:,:,:,:,3]
    # x[4,…,5,:] 等同 x[4,:,:,5,:].
    

    组合

    a = array([[ 1.,  1.],
           [ 5.,  8.]])
    b = array([[ 3.,  3.],
           [ 6.,  0.]])
    c1 = vstack((a,b))  # 合并行
    c2 = hstack((a,b))  # 合并列
    

    矩阵和数组的区别

    matrix是array的分支,matrix和array在很多时候都是通用的,官方建议大家如果两个可以通用,那就选择array,因为array更灵活,速度更快。
    matrix的优势就是相对简单的运算符号,比如两个矩阵相乘,就是用符号*,但是array相乘不能这么用,得用方法.dot()
    array的优势就是不仅仅表示二维,还能表示3、4、5…维,而且在大部分Python程序里,array也是更常用的。

    在python中,可以使用numpy中array创建一个narray对象,我们可以使用dot(a,b)或者@进行普通矩阵乘法,或者使用multipy(a,b)或者*进行数量积操作。

    在python创建一个numpy.array([1,2,3])他是一个行向量,shape = (3,)具体来说退化成一个数组,他是可以看做一个行向量或者列向量,具体要看他是在矩阵乘法的左边还是右边,下面进行测试

    参考文献

    https://blog.csdn.net/qq_31409555/article/details/51436180

    https://blog.csdn.net/taxueguilai1992/article/details/46581861

    https://blog.csdn.net/alxe_made/article/details/80492649

    https://blog.csdn.net/alxe_made/article/details/80492649

    致谢

    感谢上述博主的分享!

  • 相关阅读:
    some tips
    ORA00847: MEMORY_TARGET/MEMORY_MAX_TARGET and LOCK_SGA cannot be set together
    Chapter 01Overview of Oracle 9i Database Perfomrmance Tuning
    Chapter 02Diagnostic and Tuning Tools
    变量与常用符号
    Chapter 18Tuning the Operating System
    标准输入输出
    Trace files
    DBADeveloped Tools
    Chapter 03Database Configuration and IO Issues
  • 原文地址:https://www.cnblogs.com/niubidexiebiao/p/10521727.html
Copyright © 2011-2022 走看看