精华内容
下载资源
问答
  • 2.数组和数值算术运算 >>> x = np.array((1, 2, 3, 4, 5)) # 创建数组对象 >>> x array([1, 2, 3, 4, 5]) >>> x * 2 # 数组与数值相乘,返回新数组 array([ 2, 4, 6, 8, 10]) >>....

    2.数组和数值的算术运算

    >>> x = np.array((1, 2, 3, 4, 5))    # 创建数组对象
    >>> x
    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])
    >>> x // 2                           # 数组与数值整除
    array([0, 1, 1, 2, 2], dtype=int32)
    >>> x ** 3                           # 幂运算
    array([1, 8, 27, 64, 125], dtype=int32)
    >>> x + 2                            # 数组与数值相加
    array([3, 4, 5, 6, 7])
    >>> x % 3                            # 余数
    array([1, 2, 0, 1, 2], dtype=int32)
    >>> 2 ** x
    array([2, 4, 8, 16, 32], dtype=int32)
    >>> 2 / x
    array([2. ,1. ,0.66666667, 0.5, 0.4])
    >>> 63 // x
    array([63, 31, 21, 15, 12], dtype=int32)
    

    3.数组和数组的算术运算

    >>> a = np.array((1, 2, 3))
    >>> b = np.array(([1, 2, 3], [4, 5, 6], [7, 8, 9]))
    >>> c = a * b                   # 数组与数组相乘
    >>> c                           # a中的每个元素乘以b中的对应列元素
    array([[ 1, 4, 9],
           [ 4, 10, 18],
           [ 7, 16, 27]])
    >>> c / b                       # 数组之间的除法运算
    array([[ 1.,  2.,  3.],
           [ 1.,  2.,  3.],
           [ 1.,  2.,  3.]])
    >>> c / a
    array([[ 1.,  2.,  3.],
           [ 4.,  5.,  6.],
           [ 7.,  8.,  9.]])
    
    
    >>> a + a                         # 数组之间的加法运算
    array([2, 4, 6])
    >>> a * a                         # 数组之间的乘法运算
    array([1, 4, 9])
    >>> a - a                         # 数组之间的减法运算
    array([0, 0, 0])
    >>> a / a                         # 数组之间的除法运算
    array([ 1.,  1.,  1.])
    >>> a+b                           # a中每个元素加b中的每一列元素
    array([[ 2,  4,  6],
           [ 5,  7,  9],
           [ 8, 10, 12]])
    >>> np.array([1, 2, 3, 4]) + np.array([4, 3, 2, 1])
    array([5, 5, 5, 5])
    >>> np.array([1, 2, 3, 4]) + np.array([4])
    array([5, 6, 7, 8])
    

    4.二维数组转置

    >>> b = np.array(([1, 2, 3], [4, 5, 6], [7, 8, 9]))
    >>> b
    array([[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9]])
    >>> b.T                           # 转置
    array([[1, 4, 7],
           [2, 5, 8],
           [3, 6, 9]])
    >>> a = np.array((1, 2, 3, 4))
    >>> a
    array([1, 2, 3, 4])
    >>> a.T                           # 一维数组转置以后和原来是一样的
    array([1, 2, 3, 4])
    

    5.向量点积

    点积/内积
    >>> a = np.array((5, 6, 7))
    >>> b = np.array((6, 6, 6))
    >>> a.dot(b)                                    # 向量内积
    108  #  5*5+6*6+7*6
    >>> np.dot(a,b)
    108
    >>> sum(a*b)
    108
    >>> c = np.array(([1,2,3],[4,5,6],[7,8,9]))     # 二维数组
    >>> c.dot(a)                    # 二维数组的每行与一维向量计算内积
    array([ 38, 92, 146])
    >>> c[0].dot(a)                 # 验证一下,两个一维向量计算内积
    38
    >>> c[1].dot(a)
    92
    >>> c[2].dot(a)
    146
    >>> a.dot(c)                # 一维向量与二维向量的每列计算内积
    array([78, 96, 114])
    >>> cT = c.T                # 转置
    >>> a.dot(cT[0])
    78
    >>> a.dot(cT[1])
    96
    >>> a.dot(cT[2])
    114
    
    展开全文
  • 比较运算重载 class Vector2: """ 二维向量 """ def __init__(self, x, y): self.x = x self.y = y # + :创建新数据 def __add__(self, other): return Vector2(self.x + other.x, self.y + other.y)...

    算数运算符
    复合运算符重载
    比较运算重载

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    class Vector2:
        """
            二维向量
        """
    
        def __init__(self, x, y):
            self.x = x
            self.y = y
    
        # + :创建新数据
        def __add__(self, other):
            return Vector2(self.x + other.x, self.y + other.y)
    
        # +=:尽量在原有基础上改变(不可变对象只能创建新,可变对象不创建新)
        def __iadd__(self, other):
            self.x += other.x
            self.y += other.y
            return self
    
    
    v01 = Vector2(1, 2)
    v02 = Vector2(3, 4)
    print(id(v01))
    v01 += v02  # v01.__iadd__(v02)
    print(id(v01))
    print(v01.__dict__)
    
    # +=:可变对象不创建新
    list01 = [1]
    print(id(list01))
    list01+=[2]
    print(id(list01))
    
    # +=:不可变对象创建新
    tuple01 = (1,)
    print(id(tuple01))
    tuple01+=(2,)
    print(id(tuple01))
    
    """
    
    """
    
    
    class Skill:
        def __init__(self, name="", atk_rate=0, cost_sp=0, duration=0):
            self.name = name
            self.atk_rate = atk_rate
            self.cost_sp = cost_sp
            self.duration = duration
    
        # 相同的比较规则:技能名称
        def __eq__(self, other):
            return self.name == other.name
    
        # 大小的比较规则:持续时间
        def __lt__(self, other):
            return self.duration < other.duration
    
    
    s01 = Skill("乾坤大挪移", 2, 50, 55)
    s02 = Skill("乾坤大挪移", 2, 50, 55)
    # s01.__eq__(s02)
    print(s01 == s02)  # False  比较的是内存地址
    list_skills = [
        Skill("乾坤大挪移", 2, 50, 55),
        Skill("九阳神功", 3, 40, 50),
        Skill("九阳神功", 3, 40, 50),
        Skill("玉女心经", 1, 60, 35),
    ]
    print(list_skills.count(Skill("九阳神功", 3, 40, 50)))
    print(Skill("玉女心经", 1, 60, 35) in list_skills)
    list_skills.remove(Skill("玉女心经", 1, 60, 35))
    
    list_skills.sort()
    for item in list_skills:
        print(item.__dict__)
    

    多态
    设计角度讲
    定义
    父类的同一种动作或者行为,在不同的子类上有不同的实现。
    作用
    1.在继承的基础上,体现类型的个性化(一个行为有不同的实现)。
    2.增强程序扩展性,体现开闭原则。
    语法角度讲
    重写
    子类实现了父类中相同的方法(方法名、参数)。
    在调用该方法时,实际执行的是子类的方法。
    快捷键
    Ctrl + O
    设计原则
    开-闭原则(目标、总的指导思想)
    Open Closed Principle
    对扩展开放,对修改关闭。
    增加新功能,不改变原有代码。
    类的单一职责(一个类的定义)
    Single Responsibility Principle
    一个类有且只有一个改变它的原因。
    依赖倒置(依赖抽象)
    Dependency Inversion Principle
    客户端代码(调用的类)尽量依赖(使用)抽象。
    抽象不应该依赖细节,细节应该依赖抽象。
    组合复用原则(复用的最佳实践)
    Composite Reuse Principle
    如果仅仅为了代码复用优先选择组合复用,而非继承复用。
    组合的耦合性相对继承低。
    里氏替换(继承后的重写,指导继承的设计)
    Liskov Substitution Principle
    父类出现的地方可以被子类替换,在替换后依然保持原功能。
    子类要拥有父类的所有功能。
    子类在重写父类方法时,尽量选择扩展重写,防止改变了功能。
    迪米特法则(类与类交互的原则)
    Law of Demeter
    不要和陌生人说话。
    类与类交互时,在满足功能要求的基础上,传递的数据量越少越好。因为这样可能降低耦合度。

    """
        变化点:增加飞机、火车、自行车....
        缺点:违反了面向对象设计原则 -- 开闭原则
              -- 允许增加新功能,但是不能修改客户端代码.
    """
    class Person:
        def __init__(self,name):
            self.name = name
    
        def go_to(self,position,a):
            print(self.name + "去"+position)
            if type(a) == Car:
                a.run()
            elif type(a) == Airplane:
                a.fly()
    
    class Car:
        def run(self):
            print("汽车在行驶")
    
    class Airplane:
        def fly(self):
            print("飞机在飞行")
    
    lz = Person("老张")
    car = Car()
    air = Airplane()
    lz.go_to("东北",car)
    lz.go_to("东北",air)
    
    
    """
        变化点:增加飞机、火车、自行车....
    
        三大特征:
            封装:创建人类,汽车类,飞机类         [分]
            继承:创建交通工具隔离火车、飞机等变化 [隔]
            多态:人调用交通工具,         [做]   
               火车、飞机重写运输方法,
               创建火车飞机对象
        练习:
            情景:手雷爆炸,可能伤害敌人或者玩家的生命。
            变化:还可能伤害房子、树、鸭子....
            要求:增加新事物,不影响手雷.
            体会:开闭原则
            写出:封装继承多态具体体现
                画出架构设计图
    
    
    """
    class Person:
        def __init__(self,name):
            self.name = name
    
        def go_to(self,position,vehicle):
            print(self.name + "去"+position)
            # 1. 编码时 调用父 transport 方法
            #   运行时 执行子
            vehicle.transport()
    
    class Vehicle:
        def transport(self):
            pass
    
    # -----------以上代码是框架--以下代码是实现-----------------
    class Car(Vehicle):
        # 2. 子重写
        def transport(self):
            print("汽车在行驶")
    
    class Airplane(Vehicle):
        def transport(self):
            print("飞机在飞行")
    
    
    # -----------测试-------------
    lz = Person("老张")
    car = Car()
    air = Airplane()
    # 3. 创建子
    lz.go_to("东北",car)
    lz.go_to("东北",air)
    
    
    """
        创建图形管理器
            1. 记录多种图形(圆形、矩形....)
            2. 提供计算总面积的方法.
        满足:
            开闭原则、依赖倒置
        测试:
            创建图形管理器,存储多个图形对象。
            通过图形管理器,调用计算总面积方法.
        写出具体体现:
            封装:GraphicManager、Circle、Rectanle
            继承:创建Graphic、隔离GraphicManager与Circle、Rectanle
            多态:GraphicManager调用Graphic,
                 Circle、Rectanle重写get_area方法、
                 创建Circle、Rectanle对象
            开闭原则:
                增加具体类型(三角形),图形GraphicManager不变
            依赖倒置
                GraphicManager使用Graphic,不使用Circle、Rectanle
            组合复用
                GraphicManager通过变量调用图形,而不是继承。
    """
    
    
    class GraphicManager:
        def __init__(self):
            self.list_graphics = []
    
        def add_graphic(self, graphic):
            self.list_graphics.append(graphic)
    
        def calculate_total_area(self):
            total_area = 0
            for item in self.list_graphics:
                # 1. 编写代码时调用父
                total_area += item.get_area()
            return total_area
    
    
    class Graphic:
        def get_area(self):
            pass
    
    
    # -------------------
    
    class Circle(Graphic):
        def __init__(self, r):
            self.r = r
    
        # 2. 编写代码时子重写
        def get_area(self):
            return 3.14 * self.r
    
    
    class Rectanle(Graphic):
        def __init__(self, l, w):
            self.l = l
            self.w = w
    
        def get_area(self):
            return self.l * self.w
    
    # 测试
    manager = GraphicManager()
    # 3. 运行时创建子
    manager.add_graphic(Circle(5))
    manager.add_graphic(Rectanle(5, 6))
    print(manager.calculate_total_area())
    
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    矩阵转置原理
    在这里插入图片描述

    展开全文
  • 向量组构成基的条件:线性无关,且该线性空间中所有向量都能够由这组向量表示(线性空间中所有向量的极大无关组)。 矩阵 矩阵的定义 几种特殊的矩阵:零矩阵OO,单位矩阵EE,对角阵Λ\Lambda。 矩阵的运算:...

    向量

    向量的定义
    向量的运算法则:加法、数乘、转置
    向量的运算律:加法交换律、加法结合律、数乘结合律
    零向量的定义:所有元素都是0
    向量的几何解释
    基的概念
    向量组构成基的条件:线性无关,且该线性空间中所有向量都能够由这组向量表示(线性空间中所有向量的极大无关组)。

    矩阵

    矩阵的定义
    几种特殊的矩阵:零矩阵O,单位矩阵E,对角阵Λ
    矩阵的运算:加法、数乘、矩阵乘法、转置、逆(AA1=E)。
    矩阵的几何意义:讨论方阵Ann=(α1,α2,...,αn),则在空间Rn中,向量(1,0,...,0)T被变换成α1(0,1,0,...,0)Tα2,…,(0,0,...,0,1)T被变换成αn。对于列向量xAx就是对向量x作这样的变换。
    矩阵乘法的几何意义,设ABx有意义,就是先作B再作A的变换。

    行列式

    行列式对应扩大率:方阵的二阶行列式对应变换后面积的扩大率,三阶行列式对应变换后体积的扩大率
    行列式的一些性质:|E|=1
    |AB|=|A||B|
    |A1|=1|A|(当方阵A可逆时)
    |AT|=|A|(行列式的转置)
    用于行列式计算的三条性质:行(列)提取公因子;某一行(列)乘以一个常数加到另一行(列);交换行(列)。
    有全零行(列)的行列式为0,有相同或者成比例的行(列)的行列式为零。
    行列式按行按列展开定理(余子式的概念)。
    按行按列展开与逆矩阵的关系(理解伴随矩阵的概念)。

    展开全文
  • 文章目录变量赋值复杂数据块数向量向量初始化矩阵初始化向量命令长度保存与清除运算运算符基本函数 变量赋值 matlab无需声明变量类型。对变量赋值只要使用=即可。支持显式和隐式赋值。 注意: matlab中...

    变量赋值

    matlab无需声明变量类型。对变量的赋值只要使用=即可。支持显式和隐式的赋值。
    注意:
    matlab中的保留字。
    在这里插入图片描述

    复杂数据块

    数组

    行向量

    用空格或逗号分隔。
    注意:
    字符串是特殊的向量。

    row=[1 2 3];
    row1=[1,2,3];
    

    列向量

    用分号分隔。

    col=[1;2;3]
    

    注意:
    使用a.'来转置矩阵。

    初始化矩阵

    在这里插入图片描述

    初始化向量

    在这里插入图片描述

    命令

    长度

    在这里插入图片描述

    保存与清除

    在这里插入图片描述

    运算

    运算符

    +,-,*,/,^(指数)

    基本函数

    exp: exe^x
    round:四舍五入
    angle:复数相角
    abs:复数的模/绝对值
    在这里插入图片描述

    展开全文
  • 2、矩阵运算:嵌套、转置、求逆、乘积、线性方程求解 3、向量运算:外积、内积、叉积、特征值、特征向量 Numpy库矩阵运算 1、行列式运算 1)行列式计算:行数与列数一致 D = np.array([[1, 2], [3, 4]]) v1 = np....
  • 前面我们学习了行列式和矩阵,主要研究了:行列式的计算,包括:2,3阶行列式的计算,n阶行列式的计算;关于矩阵,主要包括:矩阵的线性运算,矩阵的乘法运算...2. 向量组的线性相关 3. 相关性判定定理 4. 相关性判...
  • 我们可以用x = [0(初值):2(步长*可以为负):10(终止值)]来创造一个从0到10点偶数向量组: >> x = [ 0; 2; 10] x = 0 2 4 6 8 10 .^表示向量乘方,而不能直接用^符号 linspace(a,b,n)可以创建a、b...
  • 算法导论之矩阵运算

    千次阅读 2016-11-09 09:18:49
    矩阵运算的重要性应该不亚于图算法。先重温下矩阵相关概念和性质,为后续矩阵运算奠定数据理论基础。...向量(Vector):是数字一维向量,列向量看成是nX1矩阵,转置成行向量就是1Xn矩阵。 单位向
  • 矩阵_矩阵运算

    2017-10-09 22:27:34
    数乘矩阵矩阵加法运算矩阵乘法运算矩阵运算基本性质单位阵逆矩阵转置矩阵正交矩阵秩线性方程高斯消元舒尔补LU分解坐标空间变换 一个m×n矩阵 当m=n时,A叫做n阶方阵(或n阶矩阵)。 只有一行矩阵...
  • 文章目录1 numpy矩阵运算1.1 矩阵加法1.2 矩阵数乘1.3 矩阵星乘1.4 矩阵乘法1.5 向量内积1.6 矩阵转置1.7 逆矩阵1.8 求解矩阵行列式1.9 求解伴随矩阵1.10 求解矩阵秩1.11 求解线性方程1.12 求矩阵特征值及对应...
  • 矩阵的运算(包括加、减、数乘、乘法、转置、逆等的混合运算);求矩阵的秩、逆(两种方法);解矩阵方程;含参数的线性方程组解的情况的讨论;齐次、非齐次线性方程组的求解(包括唯一、无穷多解);讨论一个向量能否用和...
  • 矩阵 1.矩阵和向量 矩阵:理解-二维数组 ...7.转置 行列互换 数组间运算 1.数组与数字是直接可以进行运算* 2.数组和数 需要满足广播机制 纬度相同 shape对应位置为1 3.矩阵乘法api np.dot – 点乘 np.ma
  • 并 行 计 算 中国科学技术大学计算机科学与技术系 中国科学技术...稠密矩阵运算 第十章 线性方程组的求解 第十一章 快速傅里叶变换 第九章 稠密矩阵运算 9.1 矩阵的划分 9.2 矩阵转置 9.3 矩阵-向量乘法 9.4 矩阵乘法
  • 提出一种新颖的稀疏矩阵相乘算法,算法实现中将计算单元由单个元素扩展至行向量,避免了矩阵的转置,减少了扫描次数。利用三元和少量的额外辅助空间实现稀疏矩阵的相乘。实验结果表明了该算法的有效性。
  • 三角矩阵,对称矩阵向量内积,相关性正交向量组,标准正交基,正交矩阵特征值分解概率论事件关系与运算条件概率,全概率公式,贝叶斯公式随机变量期望,方差协方差,相关系数,协方差矩阵概率分布:0-1分...
  • 矩阵范数与函数

    千次阅读 2017-12-22 19:33:38
    集合的运算 范数 向量空间线性空间 矩阵的标量函数 二次型 迹 行列式 秩 参考资料矩阵与线性方程记号: A的转置:AT/A′A^T/A'(在不至于混淆的情况下采用第二种记法) A的复数共轭: A∗A^* A的复共轭转置: AHA^H,又...
  • 矩阵就是一套数学运算地封装语言,一个矩阵乘一个数,就是这个矩阵里面数据都乘以这个数.所谓矩阵系数矩阵.就是将矩阵系数每一行矩阵转置之后每一列 矩阵X: (封装好的向量X) 向量X (X中数字为X特征) X[30,...
  • 线性代数基础知识

    千次阅读 2015-12-11 18:33:03
    第一节矩阵及其运算一、矩阵...单位矩阵 矩阵的转置 矩阵转置的运算性质 对角矩阵 三角矩阵 对称矩阵 四、矩阵的分块 第二节 正交矩阵一、向量的内积 单位向量 向量的正交 向量组 正交基 正交矩阵
  • 5.1.2矩阵的加法、乘法和矩阵的转置 5.1.3矩阵的除法——矩阵求逆 5.1.4矩阵的特征值和特征向量 5.2求行列式值 5.2.1求3阶行列式值 5.2.2求4阶行列式值 5.2.3求5阶行列式值 5.2.4求6阶行列式值 5.3矩阵转置 ...
  • 1.2.3 向量组的线性组合 1.2.4 向量组的线性相关性 1.3 内积和范数 1.3.1 内积的定义 1.3.2 范数的定义 1.3.3 内积的几何解释 1.4 矩阵和线性变换 1.4.1 矩阵和线性变换 1.4.2 线性变换 1.4.3 矩阵的运算 1.4.4 矩阵...
  • 线性代数 | 复习笔记

    2020-07-26 18:36:49
    Schwarz 不等式三角不等式2 矩阵与线性方程组对矩阵与向量乘积的理解对线性方程组的理解可逆矩阵线性方程组的行图和列图3 高斯消元法矩阵的初等行变换增广矩阵消去矩阵置换阵4 矩阵的运算矩阵乘法的性质分块矩阵矩阵...
  • 初等变换与矩阵、向量组的秩 零矩阵的判定方法 向量空间、正交矩阵与线性变换 方阵的迹及其性质 矩阵的特征值 相似变换与相似对角化 复数的运算法则、复矩阵的共轭与共轭转置 复数的运算法则 ...
  • 一、矩阵维度二、矩阵元素表示方法三、列向量索引方法四、矩阵加法五、矩阵乘除加减基本运算六、矩阵乘法七、利用矩阵计算八、矩阵与矩阵相乘九、矩阵相乘不符合交换律十、矩阵相乘符合结合律十一、单位矩阵十二...
  • 一招搞定线性代数

    2021-01-13 16:56:17
    矩阵的运算(包括加、减、数乘、乘法、转置、逆等的混合运算); 求矩阵的秩、逆(两种方法);解矩阵方程; 含参数的线性方程组解的情况的讨论; 齐次、非齐次线性方程组的求解(包括唯一、无穷多解); ...
  • 除了上述简单的转置操作之外,Matlab还提供了一个带前置点号的转置操作符。这时, 可以把点-转置操作符解释成非复数共辄转置。当数组为复数数组时,转置(,)给出的结果 是复共貌转置,也就是说,在进行转置操作过程...
  • Eigen简化版使用手册

    2020-12-10 11:10:51
    文章目录简介Matrix类Matrix初始化逗号初始化组合多个向量/矩阵特殊矩阵和数临时对象Matrix尺寸调整矩阵和向量的运算加减标量乘除矩阵乘法/向量乘法转置和共轭点积(数量积)和叉积矩阵按元素相乘矩阵基础运算...
  •  3.2.2 向量组的线性相关与线性无关   3.3 向量组的秩   3.3.1 向量组之间的等价关系   3.3.2 向量组秩的概念   3.3.3 向量组秩的求法   3.4 正交向量组与正交矩阵   3.4.1 向量内积的...
  • (b)向量或矩阵共轭转置符 .' 一般转置符 ... 表示MATLAB表达式继续到下一行,增强代码可读性 = 赋值符号 == 等于关系运算符 ,> 小于,大于关系运算符 详细说明help relop & 逻辑与 | 逻辑或 ~ 逻辑非 ...
  • matlab 数组 创建

    2021-04-02 20:23:56
    对数进行索引一个数值end提取多个元素更改数组中值对向量执行数组运算 创建向量 创建等间距向量 对于长向量,输入单个数值是不实际。可用来创建等间距向量的替代便捷方法是使用 : 运算符并仅指定起始值和最终...
  • 【R入门】——多维数组和矩阵生成数组或矩阵将向量定义成数用array()函数构造多维数组用matrix()函数构造矩阵数组下标矩阵的运算矩阵的转置方阵的行列式矩阵的维数矩阵的拉直数组的维名字向量的内积向量的外积矩阵...

空空如也

空空如也

1 2 3 4
收藏数 71
精华内容 28
关键字:

向量组的转置的运算