精华内容
下载资源
问答
  • 今天小编就为大家分享一篇关于Python中的向量相加和numpy中的向量相加效率对比,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 直接使用Python来实现向量的相加# -*-coding:utf-8-*- #向量相加 def pythonsum(n): a = range(n) b = range(n) c = [] for i in range(len(a)): a[i] = i**2 b[i] = i**3 c.append(a[i]+b[i

    直接使用Python来实现向量的相加

    # -*-coding:utf-8-*-
    #向量相加
    def pythonsum(n):
        a = range(n)
        b = range(n)
        c = []
        for i in range(len(a)):
            a[i] = i**2
            b[i] = i**3
            c.append(a[i]+b[i])
        return a,b,c
    
    print pythonsum(4),type(pythonsum(4))
    for arg in pythonsum(4):
        print arg

    从这里这个输出结果可以看得出来,return多个值时,是以列表的形式返回的

    ([0, 1, 4, 9], [0, 1, 8, 27], [0, 2, 12, 36]) <type 'tuple'>
    [0, 1, 4, 9]
    [0, 1, 8, 27]
    [0, 2, 12, 36]

    使用numpy包实现两个向量的相加

    def numpysum(n):
        a = np.arange(n) ** 2
        b = np.arange(n) ** 3
        c = a + b
        return a,b,c
    (array([0, 1, 4, 9]), array([ 0,  1,  8, 27]), array([ 0,  2, 12, 36])) <type 'function'>
    [0 1 4 9]
    [ 0  1  8 27]
    [ 0  2 12 36]

    比较用Python实现两个向量相加和用numpy实现两个向量相加的情况

    size = 1000
    start = datetime.now()
    c = pythonsum(size)
    delta = datetime.now() - start
    # print 'The last 2 elements of the sum',c[-2:]
    print 'pythonSum elapsed time in microseconds',delta.microseconds
    
    size = 1000
    start1 = datetime.now()
    c1 = numpysum(size)
    delta1 = datetime.now() - start1
    # print 'The last 2 elements of the sum',c1[-2:]
    print 'numpySum elapsed time in microseconds',delta1.microseconds

    从下面程序运行结果我们可以看到在处理向量是numpy要比Python计算高出不知道多少倍

    pythonSum elapsed time in microseconds 1000
    numpySum elapsed time in microseconds 0
    展开全文
  • Python向量相加中涉及list元素求和、合并 一、问题描述 Python的向量运算可以使用Python运算逻辑实现,也可以用numpy包实现,这里通过编写相关代码进行演示,同时指出list列表的元素求和、合并的表达 二、向量相加...

    一、问题描述

    Python的向量运算可以使用Python运算逻辑实现,也可以用numpy包实现,这里通过编写相关代码进行演示,同时指出list列表的元素求和、合并的表达

    二、向量相加的两种方法

    这里设计两个向量相加的自定义函数,一个用python运行逻辑实现,一个使用numpy包实现

    # 向量相加-Python
    def pythonsum(n):
        a = list(range(n))
        b = list(range(n))
        c = []
        for i in range(len(a)):
            a[i] = i ** 2
            b[i] = i ** 3
            c.append(a[i] + b[i])
        return c
    
    # 向量相加-NumPy
    import numpy as np
    
    def numpysum(n):
        a = np.arange(n) ** 2
        b = np.arange(n) ** 3
        c = list(a + b)
        return c
    
    print("Python sum list is", pythonsum(10))
    print("numpy sum list is", numpysum(10))
    

    运算结果是一样的
    在这里插入图片描述
    延伸,这里比较测试两种方法的向量运算速度

    # 效率比较
    import sys
    from datetime import datetime
    
    size = 100000
    
    start = datetime.now()
    c = pythonsum(size)
    delta = datetime.now() - start
    print("The last 2 elements of the sum", c[-2:])
    print("PythonSum elapsed time in microseconds", delta.microseconds)
    
    start = datetime.now()
    c = numpysum(size)
    delta = datetime.now() - start
    print("The last 2 elements of the sum", c[-2:])
    print("NumPySum elapsed time in microseconds", delta.microseconds)
    

    运算结果,明显使用numpy包进行向量运算较快
    在这里插入图片描述

    三、示例中list求和及延伸

    示例中使用到的list求和有在python普通运算中和numpy运算中的分别为
    1.Python中a[i] + b[i]

    a = [1, 2]
    b = [3, 4]
    c = []
    for i in range(len(a)):
         c.append(a[i] + b[i])
    print(c)
    

    结果[4, 6]
    2.numpy中list(a + b)

    import numpy as np
    
    a = np.array([1, 2])
    b = np.array([3, 4])
    c = list(a + b)
    print(c)
    

    结果[4, 6]
    3.延伸
    (1)合并,如果表达为a+b,则两个列表将合并

    a = [1, 2]
    b = [3, 4]
    c = a + b
    print(c)
    

    结果为[1, 2, 3, 4]
    (2)numpy的sum求和

    import numpy as np
    
    a = [1, 2]
    b = [3, 4]
    c = list(np.sum([a, b], axis = 0))
    print(c)
    

    结果[4, 6],其中的axis参数表示纵向求和

    以上为个人整理总结的知识,如有遗漏或错误欢迎留言指出、点评,如要引用,请联系通知,未经允许谢绝转载。

    展开全文
  • 原生python与numpy数组向量相加效率对比

    原生python与numpy数组向量相加效率对比


    计算一个数据元素的平方与立方之和

    1、原生python

    #向量相加 - 原生Python
    def pythonvector(n):
        a = range(n)
        b = range(n)
        c = []
        for i in range(len(a)):
            a[i] = i ** 2
            b[i] = i ** 3
            c.append(a[i] + b[i])
        return c
    


    2、numpy实现

    #向量相加 - numpy
    import numpy
    
    def numpyvector(n):
        a = numpy.arange(n) ** 2
        b = numpy.arange(n) ** 3
        c = a + b
        return c

    3、效率对比

    #效率比较
    import sys
    from datetime import datetime
    
    n = 1000
    
    start = datetime.now()
    c = pythonvector(n)
    end = datetime.now() -start
    
    print "The last 3 elements of the result ",c[-3:]
    print "pythonvector elapsed time ",end.microseconds
    
    start = datetime.now()
    c = numpyvector(n)
    end = datetime.now() -start
    
    print "The last 3 elements of the result ",c[-3:]
    print "numpyvector elapsed time ",end.microseconds





    结果是一样的,效率上numpy远快于原生的python,并且写法上更简洁。

    展开全文
  • # 使用Numpy实现两向量的加法 def npsum ( n ) : a = np . arange ( n ) ** 2 b = np . arange ( n ) ** 3 c = a + b return c if __name__ == '__main__' : # print...
    import numpy as np
    import datetime
    
    def pysum(n):
        a = list(range(n))
        b = list(range(n))
        c = []
        for i in range(len(a)):
            a[i] = i ** 2
            b[i] = i ** 3
            c.append(a[i] + b[i])
        return c# 使用Numpy实现两向量的加法
    
    
    
    def npsum(n):
        a = np.arange(n) ** 2
        b = np.arange(n) ** 3
        c = a + b
        return c
    
    
    if __name__ == '__main__':
        # print(pysum(10))
        # print(npsum(10))
    
    
        start = datetime.datetime.now()
        pysum(1000000)
        end = datetime.datetime.now()
        print("{end} - {start} = {sub}".format(start=start , end=end , sub = end - start))
    
    
        start = datetime.datetime.now()
        npsum(1000000)
        end = datetime.datetime.now()
        print("{end} - {start} = {sub}".format(start=start, end=end, sub=end - start))
    
    展开全文
  • data1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] #向量1 data2 = [3, 4, 5, 6, 2, 4, 3, 4, 5, 7] #向量2 方法:thread[i] 执行 Q.put(data1[i]+data2[i]) 源码: # 导入包 import threading from queue impo...
  • pytorch、tensorflow的底层框架很多地方都是用C语言和GPU加速的 其中向量加是最基础的
  • 提升python向量加法的运行速度   在使用python进行深度学习模型训练或预测时,我们经常会使用到向量加法运算。 我们这里比较两个向量相加的两种方法。 一、逐一做标量加法   这里首先定义两个...
  • [img=... 如图,看网上教程说python中的numpy有时候有点莫名其妙,于是举了这个例子,我一试,果然是这样。 那请问大佬们,这个该怎么理解呢?以后写代码如何规避这种莫名其妙的bug呢?
  • python线性代数向量

    千次阅读 2016-09-05 15:56:57
    python线性代数向量 ##-----两个向量相加 def vector_add(v, w): """adds corresponding elements""" return [v_i + w_i for v_i, w_i in zip(v, w)] ##-----两个向量相减 def vector_sub
  • R2R2R^2 所有两个元素的向量的集记为R2R2R^2,RRR表示向量中的元素是实数,而指数2表示每个向量包含...向量相加,是对应位置的元素相加 向量*实数,是元素分别相乘 有时为了方便我们会将: [14][14] \left[ \begin{...
  • 如图所示,对于python广播而言,就比如图中的第一个列向量和100相加,这时候100会自动扩充成一个列向量,同样的道理,其他的例子也是类似,横着扩或者竖着扩,总之是要完成相应的运算。 此图展示了更一般的规律,...
  • 两个二维向量相加,得到新的二维向量(使用__add__方法) 支持数乘运算(使用__mul__方法) 编程 Step 1 初始化 使用__init__和__str__方法,当输入:print V2(1.1, 2.2)时,打印: V2[1.10, 2.20] 程序设计 class
  • 本关任务: 编程实现两个列表向量相加。 相关知识 为了完成本关任务,你需要掌握:1. zip()函数, 2. 列表生成式 3.字符串转换为数值型列表/元组 zip()函数 a = [1,2,3] b = [4,5,6] c = list(zip(a,b)) #...
  • Python3入门机器学习 3.4 向量化 1.向量化运算: 在上一节中,求解参数a时,使用的for...有了这样两个向量,将它们进行点乘,就是两个向量对应的项相乘再相加。这样一来就可以使用numpy中向量的运算法则,非常快速高效

空空如也

空空如也

1 2 3 4 5 6
收藏数 105
精华内容 42
关键字:

python向量相加

python 订阅