Bagaimana cara melakukan perkalian elemen-bijaksana dari dua daftar?

Saya ingin melakukan perkalian bijak elemen, untuk mengalikan dua daftar bersama dengan nilai di Python, seperti yang bisa kita lakukan di Matlab.

Beginilah cara saya melakukannya di Matlab.

a = [1,2,3,4]
b = [2,3,4,5]
a .* b = [2, 6, 12, 20]

Sebuah pemahaman daftar akan memberikan 16 entri daftar, untuk setiap kombinasi x * ydari xdari adan ydari b. Tidak yakin bagaimana memetakan ini.

Jika ada yang tertarik kenapa, saya punya dataset, dan ingin mengalikannya dengan Numpy.linspace(1.0, 0.5, num=len(dataset)) =).

Gunakan pemahaman daftar yang dicampur dengan zip():.

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

Karena Anda sudah menggunakan numpy, masuk akal untuk menyimpan data Anda dalam numpylarik daripada daftar. Setelah Anda melakukan ini, Anda mendapatkan hal-hal seperti produk elemen-bijaksana secara gratis:

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])

Gunakan np.multiply (a, b):

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

Anda dapat mencoba mengalikan setiap elemen dalam satu putaran. Tangan pendek untuk melakukan itu adalah

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

Namun jawaban lain:

-1... membutuhkan impor
+1... sangat mudah dibaca

import operator
a = [1,2,3,4]
b = [10,11,12,13]

list(map(operator.mul, a, b))

keluaran [10, 22, 36, 52]

Cara yang cukup intuitif untuk melakukan ini:

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

Anda bisa perkalian menggunakan lambda

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

Untuk list yang besar, kita bisa melakukannya dengan cara iter:

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

product_iter_object.next() memberikan setiap elemen dalam daftar keluaran.

Outputnya adalah panjang yang lebih pendek dari dua daftar input.

membuat sebuah array; kalikan setiap daftar dikalikan dengan larik; mengonversi larik menjadi daftar

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]

jawaban gahooa benar untuk pertanyaan seperti yang diutarakan pada judul, tetapi jika daftar sudah dalam format numpy atau lebih besar dari sepuluh akan JAUH lebih cepat (3 lipat) serta lebih mudah dibaca, untuk melakukan perkalian numpy sederhana seperti yang disarankan oleh NPE. Saya mendapatkan pengaturan waktu ini:

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

yaitu dari program pengujian berikut.

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))

Bisa menggunakan enumerate.

a = [1, 2, 3, 4]
b = [2, 3, 4, 5]

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

The mapFungsi bisa sangat berguna di sini. Menggunakan mapkita dapat menerapkan fungsi apa pun ke setiap elemen iterable.

Python 3.x

>>> def my_mul(x,y):
...     return x*y
...
>>> a = [1,2,3,4]
>>> b = [2,3,4,5]
>>>
>>> list(map(my_mul,a,b))
[2, 6, 12, 20]
>>>

Tentu saja:

map(f, iterable)

setara dengan

[f(x) for x in iterable]

Jadi kami bisa mendapatkan solusi kami melalui:

>>> [my_mul(x,y) for x, y in zip(a,b)]
[2, 6, 12, 20]
>>>

Dalam Python 2.x map()artinya: terapkan fungsi ke setiap elemen iterable dan buat daftar baru. Di Python 3.x, mapbuat iterator alih-alih daftar.

Daripada my_mulkita bisa menggunakan muloperator

Python 2.7

>>>from operator import mul # import mul operator
>>>a = [1,2,3,4]
>>>b = [2,3,4,5]
>>>map(mul,a,b)
[2, 6, 12, 20]
>>>

Python 3.5+

>>> from operator import mul
>>> a = [1,2,3,4]
>>> b = [2,3,4,5]
>>> [*map(mul,a,b)]
[2, 6, 12, 20]
>>>

Harap dicatat bahwa karena map()membangun sebuah iterator kami menggunakan *operator unpacking iterable untuk mendapatkan daftar. Pendekatan unpacking sedikit lebih cepat daripada listkonstruktor:

>>> list(map(mul,a,b))
[2, 6, 12, 20]
>>>

Untuk mempertahankan tipe daftar, dan melakukannya dalam satu baris (setelah mengimpor numpy sebagai np, tentunya):

list(np.array([1,2,3,4]) * np.array([2,3,4,5]))

atau

list(np.array(a) * np.array(b))

Anda dapat menggunakan ini untuk daftar dengan panjang yang sama

def lstsum(a, b):
    c=0
    pos = 0
for element in a:
   c+= element*b[pos]
   pos+=1
return c