精华内容
下载资源
问答
  • Python 矩阵操作

    2018-05-11 16:29:34
    numpy库用于矩阵运算,所以一般先导入它。 import numpy as np 1 矩阵创建 ...当然也可以对矩阵操作: a1.reshape(3,-1) 这会将矩阵转为3*x的矩阵,因为只有3个元素,所以这里x=1。 其他创建...

    numpy库用于矩阵运算,所以一般先导入它。

    from numpy import *
    import numpy as np

    1 矩阵创建

    #创建一维数组
    a1=array([1,2,3])
    #将数组转为矩阵
    a1=mat(a1)
    

    输出a1:matrix([[1, 2, 3]])

    当然也可以对矩阵操作:

    a1.reshape(3,-1)

    这会将矩阵转为3*x的矩阵,因为只有3个元素,所以这里x=1。

    其他创建矩阵方法:

    #创建3×3的0矩阵,zeros函数参数是一个元组
    data1=mat(zeros((3,3)))
    
    #创建4×4的1矩阵,无论是zeros,还是ones都可以设置参数dtype=int/float32修改数据类型,默认是浮点
    data2=mat(ones((4,4)))
    
    #random.rand(3,3)随机生成3×3大小值为0-1之间的数组
    data3=mat(random.rand(3,3))
    
    #随机生成在0-10之间生成3×3大小的整数矩阵,多加一个参数可指定下界
    data4=mat(random.randint(10,size=(3,3)))
    
    #生成的是1-8之间的,3×5大小的整数矩阵
    data5=mat(random.randint(0,10,(4,3)))
    
    #产生一个2*2的对角矩阵
    data6=mat(eye(2,2,dtype=int))
    
    #生成一个对角线为1、2、3的对角矩阵
    a1=[1,2,3];
    a2=mat(diag(a1))
    
    

    2常见矩阵运算
    -矩阵相乘

    #1×2的矩阵乘以2×1的矩阵,得到1×1的矩阵
    #使用matrix,运算符*用于矢量计算(叉乘),若是array,运算符*是数量积(点乘)
    #另外可用np.dot()函数计算叉乘
    a1=mat([1,2])
    a2=mat([[1],[2]])
    a3=a1*a2

    说白了就是1×1+2×2=5。

    -矩阵点乘
    矩阵对应元素相乘:

    a1=mat([1,2])
    a2=mat([1,2])
    a3=multiply(a1,a2)

    输出:matrix([[1, 4]])

    -矩阵求逆和转置

    #求逆
    a1=mat(random.randint(0,10,(4,4)))
    a2=a1.I
    
    #转置
    a1.T

    -计算矩阵对应行列的最大、最小值、和

    a1=mat(random.randint(0,10,(4,4)))
    #列和,这里得到的是1*2的矩阵
    a2=a1.sum(axis=0);
    #行和,这里得到的是3*1的矩阵
    a3=a1.sum(axis=1);
    #计算第二行所有列的和(Python从0开始计数)),这里得到的是一个数值
    a4=sum(a1[1,:]);
    
    #计算最大、最小值和索引
    
    #先用python内置函数
    #计算a1矩阵中所有元素的最大值,这里得到的结果是一个数值
    a1.max()
    
    #计算第二列的最大值,这里得到的是一个1*1的矩阵
    a2=max(a1[:,1])
    
    #计算第二行的最大值,这里得到的是一个一个数值
    a1[1,:].max()
    
    #使用numpy函数
    #计算所有列的最大值,这里使用的是numpy中的max函数,返回每列的最大值,返回值是一个行矩阵
    np.max(a1,0)
    
    #计算所有行的最大值,返回每列最大值,返回值也是一个矩阵,且是一个列矩阵
    np.max(a1,1)
    
    #计算所有列的最大值对应在该列中的索引,返回行矩阵及其数据类型
    np.argmax(a1,0)
    
    #计算所有行的最大值对应在该行的索引,返回一个列矩阵及其数据类型
    np.argmax(a1,1)
    
    #但若这么写,便是计算第二行中最大值对应在改行的索引,返回索引值
    np.argmax(a1[1,:])

    3 矩阵合并与分解

    分割:

    a=mat(random.randint(0,10,(4,4)))
    #分割第二行第二列后的所有元素
    b=a[1:,1:]
    

    合并有俩种方式,按行和按列:

    a=mat(ones((3,3))
    b=mat(random.randint(0,10,(3,3)))
    #按列增加,在列后面合并后增加了行数
    c=vstack((a,b))
    
    #按航增加,在行后面增加了列数
    d=hstack((a,b))

    参考博客:

    https://blog.csdn.net/wuxiaosi808/article/details/78212433

    展开全文
  • 1. 矩阵维度变换 1.1 numpy.reshape(a, newshape, order=’C’) reshape()函数经常用做一维数组维度的变化,也就是将一维数组变化成为指定维度的矩阵。order是指不同的索引规则,一般默认C,按照行进行运算。 ...

    1. 矩阵维度变换

    1.1 numpy.reshape(a, newshape, order=’C’)

    reshape()函数经常用做一维数组维度的变化,也就是将一维数组变化成为指定维度的矩阵。order是指不同的索引规则,一般默认C,按照行进行运算。
    示例:

    print np.reshape(np.arange(10), (2, 5))
    
    [[0 1 2 3 4]
     [5 6 7 8 9]]

    1.2 numpy.ravel(a, order=’C’)

    ravel函数是将矩阵数据进行降维操作,例如,将二维的数据降成一维的
    示例:

    data = np.reshape(np.arange(10), (2, 5))
    print data.reshape(-1)
    print data.ravel()
    
    [0 1 2 3 4 5 6 7 8 9]
    [0 1 2 3 4 5 6 7 8 9]

    1.3 flatten([order])

    该成员函数也是用于降维使用的,起作用与ravel函数类似
    示例:

    data = np.reshape(np.arange(10), (2, 5))
    print data.flatten()
    
    [0 1 2 3 4 5 6 7 8 9]

    与ravel函数的区别:ravel是原始数据的视图,对其进行修改之后原始数据也将会被修改;而flatten函数则返回原始数据的拷贝,对其进行修改并不会对原始数据产生影响。
    示例:

    # ravel函数
    data = np.reshape(np.arange(10), (2, 5))
    data1 = data.ravel()
    data1[0] = 100
    print data
    
    [[100   1   2   3   4]
     [  5   6   7   8   9]]
    
    # flatten函数
    data = np.reshape(np.arange(10), (2, 5))
    data1 = data.flatten()
    data1[0] = 100
    print data
    
    [[0 1 2 3 4]
     [5 6 7 8 9]]

    2. 矩阵组合

    这里使用两个测试用矩阵:

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

    2.1 水平组合

    示例:

    print np.hstack((a, b))
    print np.concatenate((a, b), axis=1)
    
    [[1 2 5 6]
     [3 4 7 8]]

    2.2 垂直组合

    示例:

    print np.vstack((a, b))
    print np.concatenate((a, b), axis=0)
    
    [[1 2]
     [3 4]
     [5 6]
     [7 8]]

    2.3 深度组合

    示例:

    print np.dstack((a, b))
    
    [[[1 5]
      [2 6]]
    
     [[3 7]
      [4 8]]]

    3. 矩阵分割

    这里使用如下数据进行测试:

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

    3.1 水平分割

    在理解了2.1节中的水平组合之后,其逆过程就很容易理解了。
    示例:将示例矩阵分为等分成为三份

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

    3.2 垂直分割

    其过程类似上面的过程
    示例:

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

    3.3 深度分割

    示例:注意,深度分割只对三维以上矩阵有效

    print np.dsplit(np.arange(27).reshape((3, 3, 3)), 3)
    
    [array([[[ 0],
            [ 3],
            [ 6]],
    
           [[ 9],
            [12],
            [15]],
    
           [[18],
            [21],
            [24]]]), array([[[ 1],
            [ 4],
            [ 7]],
    
           [[10],
            [13],
            [16]],
    
           [[19],
            [22],
            [25]]]), array([[[ 2],
            [ 5],
            [ 8]],
    
           [[11],
            [14],
            [17]],
    
           [[20],
            [23],
            [26]]])]

    4. 矩阵的属性

    这里测试用的数据还是3节中的数据

    4.1 矩阵维度

    print np.shape(a)
    
    (3, 3)

    4.2 矩阵数据类型

    print a.dtype
    
    int64

    4.3 矩阵元素个数

    print a.size
    
    9

    4.4 矩阵元素占用字节数

    print a.itemsize
    
    8

    4.5 矩阵总占用字节数

    print a.nbytes
    
    72

    5. 参考

    Python之数组拼接,组合,连接

    展开全文
  • python矩阵操作小例子

    千次阅读 2017-09-11 14:42:08
    因为经常写for所以感觉有点low而且运行效率不高,慢慢学习改进,这个矩阵操作例子还不错可以学学。 用Python实现矩阵的加法运算和乘法运算,写几层for循环,实现矩阵加法和乘法并不困难,但关键是要足够简洁,这个...

    转自:https://www.hustyx.com/python/67/

    因为经常写for所以感觉有点low而且运行效率不高,慢慢学习改进,这个矩阵操作例子还不错可以学学。

    用Python实现矩阵的加法运算和乘法运算,写几层for循环,实现矩阵加法和乘法并不困难,但关键是要足够简洁,这个可让我费了不少脑子。先直接上代码吧。

    #矩阵表示形式
    M = [
       [a1, a2, a3],
       [a4, a5, a6],
       [a7, a8, a9]
    ]
    
    #矩阵加法
    def madd(M1, M2):
        if isinstance(M1, (tuple, list)) and isinstance(M2, (tuple, list)):
            return [[m+n for m,n in zip(i,j)] for i, j in zip(M1,M2)]
    
    #矩阵乘法
    def multi(M1, M2):
        if isinstance(M1, (float, int)) and isinstance(M2, (tuple, list)):
            return [[M1*i for i in j] for j in M2] 
        if isinstance(M1, (tuple, list)) and isinstance(M2, (tuple, list)):
            return [[sum(map(lambda x: x[0]*x[1], zip(i,j)))
                     for j in zip(*M2)] for i in M1] 
    

    加法和乘法实现都只用了一行代码就搞定了,注意,均没有做严格的输入参数合法性检查。乘法处理了常数乘矩阵和矩阵乘矩阵两种情况。

    几个替代for循环的关键字:

    map

    map(funcname, list)
    

    python的map 函数使得函数能直接以list的每个元素作为参数传递到funcname中, 并返回响应的新的list
    如下:

    def sq(x):
        return x*x  #求x的平方
    map(sq, [1,3, 5,7,9]) #[1, 9, 25, 49, 81]
    

    在需要对list中的每个元素做转换的时候, 会很方便

    比如,把list中的每个int 转换成str

    map(str, [23,43,4545,324]) #['23', '43', '4545', '324']
    

    当然, 第二个参数是list, 也可以是tuple 或者是set类list结构的, dict 是不行的,不过返回的结果都是list

    map(sq, (1,3, 5,7,9)) # tuple [1, 9, 25, 49, 81]
    map(sq, set([1,3, 5,3,7,9])) # set [1, 9, 81, 25, 49]
    

    这里顺便说一下, dict的结构是用{} 表示的,如

     {"name": "Yi_Zhi_Yu", "age":25}
    

    是直观的key-value形式, 那么如果{}中的是一个类list的结构呢, 如:

    {"Yi_Zhi_Yu", 25}
    

    其实, 这就是set的最终返回形式, 等价于:

    set(["Yi_Zhi_Yu", 25])# 你会看到最终的输出形式是{25, 'Yi_Zhi_Yu'}
    

    那么, 自然{}有重复值得时候也会去重

       {1,3, 5, 3, 7, 9}  #{1, 3, 5, 7, 9}
    

    reduce

    reduce(funcname, list)
    

    与map相比 , reduce类似于一个聚合类的应用方法, 把list中的参数, 依次传递给funcname, 每次funcname的参数都是上个funcname 执行结果和下一个list中的元素, 所以, funcname 的 参数必须是两个. 从执行过程看, 有点像递归

    例如: 求range(1, 101)(不包括101)的和,

    def c_sum(x, y):
        return x + y;
    reduce(c_sum, range(1,101)) #5050
    

    filter

    filter(funcname, list)
    

    执行过程依次将list中的元素传递到funcname函数中, 根据funcname返回的True或False 保留或丢弃元素

    例: 返回某个list中的所有int数据

     def is_int(x):
        if isinstance(x, (int)):
            return True
        else:
            return False
    
     filter(is_int, ["Yi",2, "3", 4]) #[2, 4]
    

    sorted

    sorted( list, [comp_func])
    

    排序方法, 第二个是可选参数, 根据可选参数返回的值, 对结果进行排序, comp_func 接受两个参数(x, y), 最终返回的结果应该是-1.0,1, 如果返回的是-1, 表示x<y , 0表示x=y, 1表示x>y, 所以, 实际的排序可以自定义
    默认是正序排序:

    sorted([3,4, 12, 5, 9, 1])  #[1, 3, 4, 5, 9, 12]
    

    如果是需要倒序排列, 自定义方法:

     def m_order(x, y):
        if(x > y):
            return -1
        elif(x == y):
            return 0
        else:
            return 1
    sorted([3,4, 12, 5, 9, 1], m_order)  #[12, 9, 5, 4, 3, 1]
    
    PS: 以上为学习笔记, 如有错误, 还望指正
    展开全文
  • python矩阵操作:dot、inv、det、eig

    千次阅读 2020-03-11 10:34:07
    矩阵点乘 在numpy中,*号用来对矩阵进行逐元素乘积。 我们熟悉的矩阵点乘,用dot函数。 举个栗子: import numpy as np x = np.array([[1, 2], [2, 3]]) # 2*2矩阵 y = np.array([[4, 5], [6, 7]]) # 2*2矩阵 ...

    矩阵点乘

    在numpy中,*号用来对矩阵进行逐元素乘积
    我们熟悉的矩阵点乘,用dot函数

    举个栗子:

    import numpy as np
    x = np.array([[1, 2], 
                  [2, 3]])   # 2*2矩阵
    y = np.array([[4, 5], 
                  [6, 7]])   # 2*2矩阵
    print(x * y)             # 逐元素相乘
    # [[ 4 10]
    #  [12 21]]
    print(x.dot(y))          # 点乘
    # [[16 19]
    #  [26 31]]
    

    注意:矩阵点乘时需要保证x的列数与y的行数相等。

    另外,事情一旦牵扯到一维数组,就会变得比较奇怪。
    按一贯的思维,一维数组应该是个行数为1,列数为元素个数的矩阵。
    但在点乘计算时,却好像不是这样子的…`

    import numpy as np
    x = np.array([[1, 2, 3],
                 [4, 5, 6]])   # 2*3矩阵
    y = np.array([1, 2, 3])    # 一维数组
    y_1 = np.array([[1],
                    [2],
                    [3]])      # 3*1矩阵
    print(np.dot(x, y))
    # [14 32]
    print(np.dot(x, y_1))
    # [[14]
    #  [32]]
    

    在这个栗子中,一维数组[1, 2, 3]是作为一个3*1的矩阵来操作的,而且dot函数返回了一个一维数组。

    总结一下:
    一个矩阵和一个长度合适的一维数组之间的矩阵乘积,结果是一个一维数组。

    .

    矩阵的转置、逆、行列式和特征值

    numpy.linalg拥有一个矩阵分解的标准函数集。其中包含常见的求逆、行列式等操作。

    • X.T:返回X的转置
    • inv(X):返回X的逆矩阵
    • det(X):返回X的行列式
    • eig(X):返回X的特征值和特征向量

    下面举个栗子:

    import numpy as np
    from numpy.linalg import inv,eig, det
    x = np.array([[1, 2, 3],
                  [4, 5, 6],
                  [7, 8, 9]])   # 3阶方阵
    trans = x.T
    # [[1 4 7]
    #  [2 5 8]
    #  [3 6 9]]
    inverse = inv(x)
    # [[ 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]]
    determinant = det(x)
    # -9.51619735392994e-16
    eigen_value, eigen_vector = eig(x)
    # [ 1.61168440e+01 -1.11684397e+00 -9.75918483e-16]
    # [[-0.23197069 -0.78583024  0.40824829]
    #  [-0.52532209 -0.08675134 -0.81649658]
    #  [-0.8186735   0.61232756  0.40824829]]
    

    参考资料

    《利用python进行数据分析》

    展开全文
  • python 矩阵操作 X[:, 0]

    千次阅读 2017-12-20 11:17:43
    # Set min and max values and give it some padding  x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5  y_min, y_max = X[:, 1].min() - .5, X[:, 1].max()...原始数据:矩阵 X [[ 1.83145519 0.8939848
  • python矩阵_Python矩阵

    2020-07-14 04:34:52
    python矩阵In this tutorial we will learn about Python Matrix. In our previous tutorial we learnt about Python JSON operations. 在本教程中,我们将学习Python矩阵。 在上一教程中,我们了解了Python JSON...
  • Python 矩阵基本运算【numpy】

    千次阅读 2021-03-31 16:37:34
    python矩阵操作2. python矩阵乘法3. python矩阵转置4. python求方阵的迹5. python方阵的行列式计算方法6. python求逆矩阵/伴随矩阵7. python解多元一次方程 一、实验说明 实验环境 Anaconda + python3.6 + jupyter...
  • python 矩阵乘法

    万次阅读 多人点赞 2019-02-09 13:55:54
    python 矩阵乘法 python 矩阵有两种形式:array 和 matrix 对象(它们的区别在这里就不说了),下面介绍相关乘法 1. np.multiply 对 array 和 matrix 对象的操作相同 (1) a 和 b 维度相同 都是每行对应元素相乘...
  • Python矩阵常见运算操作实例总结

    千次阅读 2018-04-26 18:12:07
    Python矩阵常见运算操作实例总结本文实例讲述了Python矩阵常见运算操作。分享给大家供大家参考,具体如下:python的numpy库提供矩阵运算的功能,因此我们在需要矩阵运算的时候,需要导入numpy的包。一.numpy的导入和...
  • python矩阵对角元操作

    2020-04-05 22:00:26
    对于矩阵的对角元进行操作是在进行矩阵操作前经常进行的一步,比如使矩阵可逆等。可以使用.flat对矩阵对角元进行快速的操作。 X2.flat[::X.shape[1] + 1] += 0.01 以上矩阵,X2为一个方阵,将矩阵进行拉伸之后,再...
  • python 矩阵(mat)操作

    2020-10-07 14:04:19
    1、矩阵的创建 由一维或二维数据创建矩阵 a1=array([1,2,3]); a1=mat(a1); data1=mat(zeros((3,3))); #创建一个3*3的零矩阵矩阵这里zeros函数的参数是一个tuple类型(3,3) data2=mat(ones((2,4))); #创建一个2*4的...
  • Python 矩阵操作2. Python 矩阵乘法3. 矩阵的转置4. Python 求方阵的迹5. Python 方阵的行列式计算方法6. Python 求逆矩阵/伴随矩阵7. Python 解多元一次方程二、梯度下降法1. 微分2. 梯度3. 梯度下降法4. 梯度下降...
  • CUDA PYTHON 矩阵相乘

    2020-07-12 16:05:51
    CUDA PYTHON 矩阵相乘一、CUDA线程索引二、CUDA矩阵计算1、卷积计算2、矩阵相乘三、CUDA共享内存四、CUDA python 矩阵相乘代码实践参考内容 一、CUDA线程索引 线程索引即如何根据线程层次中的blockId,gridId以及...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 73,994
精华内容 29,597
关键字:

python矩阵操作

python 订阅