精华内容
下载资源
问答
  • 方法一: 结合zip函数,使用map函数: List1 = [1,2,3,4] List2 = [5,6,7,8] List3 = map(lambda (a,b):a*b,zip(List1,...以上这篇Python 实现两个列表元素对应相乘的方法就是小编分享给大家的全部内容了,希望能
  • 两个列表,有可能长度不一致,如何将其对应相乘呢 可以使用zip()函数打包变成元组的列表,然后将元组中的数字相乘即可 a = [1,2,3] b = [4,5,6,7] ab = zip(a,b) num = 0 for i,j in ab: num += i*j print(num) ...

    两个列表,有可能长度不一致,如何将其对应相乘呢

    可以使用zip()函数打包变成元组的列表,然后将元组中的数字相乘即可

    a = [1,2,3]
    b = [4,5,6,7]
    ab = zip(a,b)
    num = 0
    for i,j in ab:
        num += i*j
    print(num)

    展开全文
  • 1、实现两个列表对应元素相乘,结果生成一个新的列表,两个列表的元素为10个,每个元素均用random下面的randint生成随机整数,randint传入两个参数,分别为生成随机整数的下界和上界

    1、实现两个列表对应元素相乘,结果生成一个新的列表,两个列表的元素为10个,每个元素均用random下面的randint生成随机整数,randint传入两个参数,分别为生成随机整数的下界和上界

    import random
    L1=[]
    L2=[]
    L3=[]
    for i in range(10):
        L1.append(random.randint(0,10))#尾插法
        L2.append(random.randint(0,10))
       # L2.insert(i,random.randint(i,10))#指定位置插入
        t=L1[i]*L2[i]
        L3.insert(i,t)
       # help(L)#通过help查看数组辅助函数
    print(L1)
    print(L2)
    print(L3)
    

    注:python中*表示乘法,**表示平方

    2

    deque:双端队列     collection库:集合类库

     

    import time
    
    from collections import deque
    
    print('List:')
    L=[]
    #列表0号位置插入(模拟头部插入)
    start=time.clock()
    for i in range(100000):
        L.insert(0,i)
    end=time.clock()
    #print(L)
    print('头插法时间;')
    print(end-start)
    
    #头部删除
    start1=time.clock()
    for i in range(100000):
        L.pop(0)
    end1=time.clock()
    print('头部删除时间:')
    print(end1-start1)
    
    
    #尾部插入建立链表
    L=[]
    start=time.clock()
    for i in range(100000):
        L.append(i)
    end=time.clock()
    #print(L)
    print('尾部插入时间:')
    print(end-start)
    
    start1=time.clock()
    for i in range(100000):
        L.pop()
    end1=time.clock()
    print('尾部删除时间:')
    print(end1-start1)
    
    #时间效率相差300倍,尾插更快
    #尾部删除更快
    
    
    
    
    print('Deque:')
    #help(deque)
    #deque的定义
    d=deque()
    start=time.clock()
    for i in range(100000):
        d.append(i)
    end=time.clock()
    print('尾部插入:')
    print(end-start)
    #print(d)
    start1=time.clock()
    for i in range(100000):
        d.pop()
    end1=time.clock()
    print('尾部删除:')
    print(end1-start1)
    
    d=deque()
    start=time.clock()
    for i in range(100000):
        d.appendleft(i)
    end=time.clock()
    print('头部插入:')
    print(end-start)
    #print(d)
    start1=time.clock()
    for i in range(100000):
        d.popleft()
    end1=time.clock()
    print('头部删除:')
    print(end1-start1)
    
    #deque头部插入,尾部插入时间相差不大
    
    

    deque的头部插入与尾部插入时间相差不大;头部删除与尾部删除时间相差不大;deque底层是链表

    展开全文
  • 22,33,44,55,66])b=np.arange(6)print(a)print(b)#输出[11 22 33 44 55 66][0 1 2 3 4 5]上述代码中的 a 和 b 是两个属性为 array 也就是矩阵的变量,而且二者都是1行6列的矩阵, 其中b矩阵中的元素分别是从0到5。...

    1.初始化两个矩阵

    import numpy as np

    a=np.array([11,22,33,44,55,66])

    b=np.arange(6)

    print(a)

    print(b)

    #输出

    [11 22 33 44 55 66]

    [0 1 2 3 4 5]

    上述代码中的 a 和 b 是两个属性为 array 也就是矩阵的变量,而且二者都是1行6列的矩阵, 其中b矩阵中的元素分别是从0到5。

    2.矩阵加法

    c = a + b

    print(c)

    #输出

    [11 23 35 47 59 71]

    3.矩阵减法

    d = a - b

    print(d)

    #输出

    [11 21 31 41 51 61]

    4.矩阵乘法

    e = a * b

    print(e)

    #输出

    [ 0 22 66 132 220 330]

    5.矩阵的乘方

    f = a**2

    print(f)

    #输出

    [ 121 484 1089 1936 3025 4356]

    6.矩阵的三角函数

    g = 2*np.sin(a)

    print(g)

    h = 2*np.cos(a)

    print(h)

    #输出

    [-1.99998041 -0.01770262 1.99982372 0.03540385 -1.99951035 -0.05310231]

    [ 0.0088514 -1.99992165 -0.02655349 1.99968662 0.04425351 -1.99929491]

    7.矩阵的逻辑运算

    print(a < 50)

    print(a == 44)

    #输出

    [ True True True True False False]

    [False False False True False False]

    8.二维矩阵计算

    上述运算均是建立在一维矩阵,即只有一行的矩阵上面的计算,如果我们想要对多行多维度的矩阵进行操作,可以在上面做一些改动。

    a = np.array([[11,22,33],[44,55,66]])

    b = np.arange(6).reshape((3,2))

    print(a)

    print(b)

    #输出

    [[11 22 33]

    [44 55 66]]

    [[0 1]

    [2 3]

    [4 5]]

    此时构造出来的矩阵a和b便是2行3列的,其中 reshape 操作是对矩阵的形状进行重构, 其重构的形状便是括号中给出的数字。 稍显不同的是,Numpy中的矩阵乘法分为两种, 其一是前文中的对应元素相乘,其二是标准的矩阵乘法运算,即对应行乘对应列得到相应元素

    c_dot = np.dot(a,b)

    print(c_dot)

    d_dot = a.dot(b)

    print(d_dot)

    #输出

    [[176 242]

    [374 539]]

    [[176 242]

    [374 539]]

    9.sum(), min(), max()的使用

    import numpy as np

    a=np.random.random((3,5))

    print(a)

    #输出

    [[0.94004266 0.06821417 0.53298969 0.37368218 0.98274263]

    [0.22059055 0.9521291 0.12160635 0.50142968 0.08024663]

    [0.6041042 0.41411029 0.84898433 0.73680101 0.92060592]]

    上面是随机生成数字, 所以你的结果可能会不一样. 在第二行中对a的操作是令a中生成一个3行5列的矩阵,且每一元素均是来自从0到1的随机数

    sum = np.sum(a)

    print(sum)

    min = np.min(a)

    print(min)

    max = np.max(a)

    print(max)

    #输出

    8.298279370480403

    0.06821416737474717

    0.982742627864798

    对应的便是对矩阵中所有元素进行求和,寻找最小值,寻找最大值的操作。 可以通过print()函数对相应值进行打印检验

    10.行和列的查找运算

    如果你需要对行或者列进行查找运算,就需要在上述代码中为 axis 进行赋值。 当axis的值为0的时候,将会以列作为查找单元, 当axis的值为1的时候,将会以行作为查找单元。

    sum_hang = np.sum(a, axis = 1)

    print(sum_hang)

    min_lie = np.min(a, axis = 0)

    print(min_lie)

    max_hang = np.max(a, axis = 1)

    print(max_hang)

    #输出

    [2.89767132 1.87600231 3.52460575]

    [0.22059055 0.06821417 0.12160635 0.37368218 0.08024663]

    [0.98274263 0.9521291 0.92060592]

    11.最大值、最小值的索引

    日常使用中,对应元素的索引也是非常重要的.其中的 argmin() 和 argmax() 两个函数分别对应着求矩阵中最小元素和最大元素的索引

    A = np.array([[11,22,33,44,55],[55,44,33,22,11],[0,22,44,66,88],[11,33,55,77,99]])

    print(A)

    print(np.argmin(A))

    print(np.argmax(A))

    12.均值、平均值、中位数

    A = np.array([[11,22,33,44,55],[55,44,33,22,11],[0,22,44,66,88],[11,33,55,77,99]])

    print(A)

    print(np.mean(A))

    print(np.average(A))

    print(A.mean()) #这种方法也可以,同理内积

    print(np.median(A))

    13.累加、累差

    和matlab中的cumsum()累加函数类似,Numpy中也具有cumsum()函数,

    在cumsum()函数中:生成的每一项矩阵元素均是从原矩阵首项累加到对应项的元素之和。

    【注】diff()函数计算的便是每一行中后一项与前一项之差。故一个4行5列矩阵通过函数计算得到的矩阵便是4行4列的矩阵。

    A = np.array([[11,22,33,44,55],[55,44,33,22,11],[0,22,44,66,88],[11,33,55,77,99]])

    print(A)

    print(np.cumsum(A))

    print(np.diff(A))

    14.排序

    我们可以对所有元素进行仿照列表一样的排序操作,但这里的排序函数仍然仅针对每一行进行从小到大排序操作

    A = np.array([[11,22,33,44,55],[55,44,33,22,11],[0,22,44,66,88],[11,33,55,77,99]])

    print(A)

    print(np.sort(A))

    15.转置

    矩阵的转置有两种表示方法:

    A = np.array([[11,22,33,44,55],[55,44,33,22,11],[0,22,44,66,88],[11,33,55,77,99]])

    print(A)

    print(np.transpose(A))

    print(A.T)

    16.clip()函数

    这个函数的格式是clip(Array,Array_min,Array_max),顾名思义,Array指的是将要被执行用的矩阵,而后面的最小值最大值则用于让函数判断矩阵中元素是否有比最小值小的或者比最大值大的元素,并将这些指定的元素转换为最小值或者最大值。

    A = np.array([[11,22,33,44,55],[55,44,33,22,11],[0,22,44,66,88],[11,33,55,77,99]])

    print(A)

    print(np.clip(A,44,77)) #小于44的都为44,大于77的都为77,其它照写

    展开全文
  • 使用与zip()混合的列表理解:。[a*b for a,b in zip(lista,listb)]由于您... 一旦你做到这一点,你可以免费获得元素明智的产品:In [1]: import numpy as np In [2]: a = np.array([1,2,3,4]) In [3]: b = np.array(...

    使用与zip()混合的列表理解:。

    [a*b for a,b in zip(lista,listb)]

    由于您已经在使用numpy ,所以将数据存储在一个numpy数组而不是列表中是很有意义的。 一旦你做到这一点,你可以免费获得元素明智的产品:

    In [1]: import numpy as np In [2]: a = np.array([1,2,3,4]) In [3]: b = np.array([2,3,4,5]) In [4]: a * b Out[4]: array([ 2, 6, 12, 20])

    使用np.multiply(a,b):

    import numpy as np a = [1,2,3,4] b = [2,3,4,5] np.multiply(a,b)

    你可以尝试在循环中乘以每个元素。 做这个的简短手段是

    ab = [a[i]*b[i] for i in range(len(a))]

    相当直观的做法是:

    a = [1,2,3,4] b = [2,3,4,5] ab = [] #Create empty list for i in range(0, len(a)): ab.append(a[i]*b[i]) #Adds each element to the list

    还有一个答案:

    -1 …需要导入

    +1 …非常可读

    import operator a = [1,2,3,4] b = [10,11,12,13] list(map(operator.mul, a, b))

    输出[10,22,36,52]

    对于大型列表,我们可以这样做:

    product_iter_object = itertools.imap(operator.mul, [1,2,3,4], [2,3,4,5])

    product_iter_object.next()给出输出列表中的每个元素。

    输出将是两个input列表中较短的一个的长度。

    创build一个数组; 将每个列表乘以数组; 将数组转换为列表

    import numpy as np a = [1,2,3,4] b = [2,3,4,5] c = (np.ones(len(a))*a*b).tolist() [2.0, 6.0, 12.0, 20.0]

    你可以用lambda乘法

    foo=[1,2,3,4] bar=[1,2,5,55] l=map(lambda x,y:x*y,foo,bar)

    gahooa的答案是正确的,如标题中所表述的问题,但如果列表已经是numpy格式或大于十,它会快得多(3个数量级),以及更可读,做简单的numpy乘法NPE。 我得到这些时机:

    0.0049ms -> N = 4, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)] 0.0075ms -> N = 4, a = [i for i in range(N)], c = a * b 0.0167ms -> N = 4, a = np.arange(N), c = [a*b for a,b in zip(a, b)] 0.0013ms -> N = 4, a = np.arange(N), c = a * b 0.0171ms -> N = 40, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)] 0.0095ms -> N = 40, a = [i for i in range(N)], c = a * b 0.1077ms -> N = 40, a = np.arange(N), c = [a*b for a,b in zip(a, b)] 0.0013ms -> N = 40, a = np.arange(N), c = a * b 0.1485ms -> N = 400, a = [i for i in range(N)], c = [a*b for a,b in zip(a, b)] 0.0397ms -> N = 400, a = [i for i in range(N)], c = a * b 1.0348ms -> N = 400, a = np.arange(N), c = [a*b for a,b in zip(a, b)] 0.0020ms -> N = 400, a = np.arange(N), c = a * b

    即从下面的testing程序。

    import timeit init = [''' import numpy as np N = {} a = {} b = np.linspace(0.0, 0.5, len(a)) '''.format(i, j) for i in [4, 40, 400] for j in ['[i for i in range(N)]', 'np.arange(N)']] func = ['''c = [a*b for a,b in zip(a, b)]''', '''c = a * b'''] for i in init: for f in func: lines = i.split('\n') print('{:6.4f}ms -> {}, {}, {}'.format( timeit.timeit(f, setup=i, number=1000), lines[2], lines[3], f))

    可以使用枚举。

    [val*b[i] for i, val in enumerate(a)]

    展开全文
  • 解决方案 When you multiply a sequence by X in Python, it doesn't multiply each member of the sequence - what it does is to repeat the sequence X times. That's why X has to be an integer (it can't be ...
  • python的list的各个元素相乘

    千次阅读 2020-10-20 14:00:25
    仅作为操作记录,大佬请跳过。 想让10*[0,1,2,3],想得到[0,10,20,30]的结果,但发现不能直接相乘,需要用np.multiply import numpy as np print(np.multiply(10,[0,1,2,3]))
  • 我的任务是仅使用基本的python函数(而不是numpy)生成以下列表。以下是我所有的代码:#1.Create a list which contains i^2 with i = 1 through 5squares = [pow(i,2) for i in range(1,6)]#print squares#2. Create ...
  • python中,列表列表之间不能直接相乘,需要对其转换成数组后再进行计算,所以我们用到numpy中的multiply()函数将集合转换成数组,再用sum函数求和即可。 代码: import numpy as np a = [1, 2, -2, 4, 2, ...
  • 使用 * 或者 np.multiply() 可实现对应元素相乘 import numpy as np a = [2, 2, 2, 2, 5] b = 2 print(np.multiply(a, b)) print(np.multiply(a, a)) print(np.array(a)*np.array(a)) print(a*a) # 会报错!因为...
  • python列表对应元素的乘积和

    千次阅读 2020-04-10 16:22:25
    那天偶尔看到看到一个小问题:两个不等长列表a=[1,2,3],b=[4,5,6,7],求它们对应元素的乘积的和。 我一开始想到的方法就是选择更小数组作为循环长度然后相乘求和: a = [1,2,3] b = [4,5,6,7] sum = 0 for i in ...
  • 我想执行元素明智的乘法,将两个列表按值在Python相乘,就像我们在Matlab中可以做到的那样。这就是我在Matlab中要做的。123a = [1,2,3,4]b = [2,3,4,5]a .* b = [2, 6, 12, 20]对于a中x的x * y和b中y的每个组合,...
  • Python中数组、矩阵乘法

    千次阅读 2020-11-29 07:50:49
    1. np.multiply()函数数组和矩阵对应位置相乘,输出与相乘数组/矩阵的大小一致1.1 数组场景import numpy as npa = np.array([[1, 2],[3,4]])b = np.array([[5, 6],[7, 8]])c = np.multiply(a, b)print (c)输出:[[ 5...
  • 这个问题已经在这里有了答案:??????????...1个 关于这个问题: 在处理二维数组时,我发现以某种方式对其进行初始化会产生意想不到的结果....将初始化方法更改为列表理解方法后,正方形会正确响应预期的悬停和单击事件.
  • I have a 2D matrix M of shape [batch x dim], I have a vector V of shape [batch]. How can I multiply each of the columns in the matrix by the corresponding element in the V? That is:I know an inefficie...
  • 1. 同线性代数中矩阵乘法的定义: np.dot()np.dot(A, B):对于二维矩阵,计算真正...见如下Python代码:import numpy as np# 2-D array: 2 x 3two_dim_matrix_one = np.array([[1, 2, 3], [4, 5, 6]])# 2-D array...
  • 向量点乘和对应分量相乘: >>> a array([1, 2, 3]) >>> b array([ 1., 1., 1.]) >>> np.multiply(a,b) array([ 1., 2., 3.]) >>> np.dot(a,b) 6.0 矩阵乘法和对应分量相乘: >>> c matrix([[1, 2, 3]]) >>> d matrix...
  • (矩阵的创建,numpy,应元素相乘)具有不错的参考意义,希望能够帮助到大家! 部分代码用图片方式呈现出来,方便各位观看与收藏! 提示: python的numpy库提供矩阵运算的功能,因此我们在需要矩阵运算的时候,需要...
  • (1)map zip 的操作 ...但是并不适合Python3 (2)Python3 zip函数 (3)实例代码: list1 = [1,2,3,4,5,6,7] list2 = [1,2,3,4,5,6,7] [a*b for a,b in zip(list1,list2)] 输出结果: (4) zip 函数 ...
  • ``` def sumAndMul2List(list1, list2): result = sum([a*b for a,b in zip(list1,list2)]) return result ...对一张图片做卷积,除了加载图片以外不能用任何库,上面这个函数跑了很长时间,请问有没有什么...
  • Numpy——numpy的基本运算

    千次阅读 2020-12-23 23:53:28
    22,33,44,55,66])b=np.arange(6)print(a)print(b)#输出[11 22 33 44 55 66][0 1 2 3 4 5]上述代码中的 a 和 b 是两个属性为 array 也就是矩阵的变量,而且二者都是1行6列的矩阵, 其中b矩阵中的元素分别是从0到5。...
  • import numpy as np ...#两个数组上对应位置相乘,有两种方法 a=np.multiply(X,Y) #这种方法也适用于两个计算对象是列表,如X1=[[2,4,5],[5,3,6]],Y1=[[4,6,3],[4,6,3]] b=X*Y print('a=','\n',a,'.
  • #两个列表元素数量相等,两两相乘以后再求和 import numpy as np lstp=[100,200,300,400,500,600,700,800,900,1000,1100,1200,1300,1400,1500,1600] lstc=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16] #方法一 List3...
  • A*B是矩阵(向量)对应元素相乘 np.dot(A,B)是矩阵乘法 A,B形式相同,各个元素相乘=B*A A,B满足矩阵相乘的条件。 A为2x2,B为1x2,所以是A的每一行和B各元素对应相乘 A为2x2,B为2x1,所以是A的每...
  • 对应元素相乘 element-wise product: np.multiply(), 或 * np.dot() 转置 注意一维行数组的转置,无法成功,需要添加[] 格式 列表解析  根据已有列表,高效创建新列表的方式。  列表解析是Python迭代...
  • 对于nd.array()类型而言,数组 arrA * arrB 只能element-wise produt(对应元素相乘) # -*- coding: utf-8 -*- """ Created on Thu Jul 26 14:22:40 2018 @author: Administrator """ import numpy as np a = np...
  • 今天小编就为大家分享一篇python中利用numpy.array()实现俩个数值列表对应相加方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 如下所示: # 求一个列表中所有元素的... 您可能感兴趣的文章:Python 实现两个列表元素对应相乘的方法python计算列表内各元素的个数实例Python列表与元组的乘法操作示例在Python中分别打印列表中的每一个元素方法
  • 对应元素相乘 element-wise product: np.multiply(), 或 * y1 = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2]) y2 = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2]) y1*y2 Out[8]: array([0, 0, 0, 1, 1, 1, 4, 4, 4]) np....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,502
精华内容 5,800
关键字:

python列表对应元素相乘

python 订阅
友情链接: dissectingMFC2epart3.rar