Я хочу выполнить мудрый умножение элемента, чтобы умножить два списка вместе на значение в Python, как мы можем сделать это в Matlab.
Вот как я буду делать это в Matlab.
a = [1,2,3,4]
b = [2,3,4,5]
a .* b = [2, 6, 12, 20]
Понимание списка даст 16 записей списка для каждой комбинации x * y из x из a и y из b. Невозможно отобразить это.
Если кому-то интересно, у меня есть набор данных и вы хотите его умножить на Numpy.linspace(1.0, 0.5, num=len(dataset)) =).
Используйте понимание списка, смешанное с 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
вы можете умножить с помощью lambda
foo=[1,2,3,4]
bar=[1,2,5,55]
l=map(lambda x,y:x*y,foo,bar)
Еще один ответ:
-1... требуется импорт +1... очень читаем
import operator
a = [1,2,3,4]
b = [10,11,12,13]
list(map(operator.mul, a, b))
выходы [10, 22, 36, 52]
создать массив из них; умножать каждый список раз массив; преобразовать массив в список
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]
Для больших списков мы можем сделать это следующим образом:
product_iter_object = itertools.imap(operator.mul, [1,2,3,4], [2,3,4,5])
product_iter_object.next() дает каждый из элементов в выходном списке.
Выходной сигнал будет длиной более короткого из двух входных списков.
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
то есть. из следующей тестовой программы.
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))
Функция map может быть очень полезна здесь. Используя map мы можем применить любую функцию к каждому элементу итерируемого.
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]
>>>
Конечно:
map(f, iterable)
эквивалентно
[f(x) for x in iterable]
Таким образом, мы можем получить наше решение через:
>>> [my_mul(x,y) for x, y in zip(a,b)]
[2, 6, 12, 20]
>>>
В Python 2.x map() означает: применить функцию к каждому элементу итерируемого и создать новый список. В Python 3.x map строит итераторы вместо списков.
Вместо my_mul мы могли бы использовать оператор mul
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]
>>>
Обратите внимание, что поскольку map() создает итератор, мы используем * итерируемый оператор распаковки, чтобы получить список. Подход распаковки немного быстрее, чем конструктор list:
>>> list(map(mul,a,b))
[2, 6, 12, 20]
>>>
Можно использовать перечисление.
a = [1, 2, 3, 4]
b = [2, 3, 4, 5]
ab = [val * b[i] for i, val in enumerate(a)]
Чтобы сохранить тип списка, и сделать это в одной строке (после импорта numpy как np, конечно):
list(np.array([1,2,3,4]) * np.array([2,3,4,5]))
или же
list(np.array(a) * np.array(b))
Вы можете использовать это для списков одинаковой длины
def lstsum(a, b):
c=0
pos = 0
for element in a:
c+= element*b[pos]
pos+=1
return c
list1 = ['81.5 ', '82.5', '82.6 ',' 81 ', '78.9', '80.7 ', '81.1', '81.5 ', '82.3', '79.4 ', '80.7', '81.8 ', '82.1 ', '80.5', '81.5 ', '83.4', '83.6 ', '79.9 1', '81.8 ', '81.8', '80.5 ', '80.5', '81.1 ', '80.5', "79,6", "82,4", "82,1", "77,7", "80,8", "78,5", "78,4", "79,8", "74,4", "75,5", "76,4", "72,1", "75,4" ', '81.2 1', '79.8 ', '76.8', '79.9 ',' 80 ', '74.6', '79.3 ', '76.6', '74.3 ',' 77 ', '72.2', '76.3 ', '77.2 ', '74.8', '75.2 ', '69.9', '73.8 ', '75.3', '76.6 ',' 68 ', '73.5', '75.4 ', '72.4 1', '76', '75', '73.6 ', '69.9', '77.6 ',' 80 ', '74.6', '79.9 ', '75.3', '66.5 ', '73.2', '77.5 ', '74.3', '73.6 1 ',' 74 ', '70.8', '74.1 ', '73.9', '72.8 ', '74.3', '73.9 ', '74.8', '68.5 ', '75.2', '73.9 ', '76.4', '74.6 ', '69.8', '74.4 ', '75.9', '72.5 ', '75.3', '77.7 1 ',' 71 ', '77.4', '73.5 ', '74.8', '76.5 ', '74', '72.7 ',' 71 ', '73.4', '65.5 ', '67.5', '77.9 ', '73.2', '73.2 ', '70.8', '64.4 2 ', '71.2', ' 72,3 ',' 63.5 ', '67.3', '68.9 ', '72.6', '68.2 ', '68.7', '74.6 ', '56.9', '69.4 ', '75.9', '66.3 ', '75.1', '69', '67.5 ', '72 .1 ', '64.5', '67.5 ', '70.9', '73.8 ', '71.6', '74.8 ', '67.2', '68.9 ', '66.4', '71.9 ', '68.3', '61.1 ', '68.3', '58.8 ', '58.1', '66.3 ', '70.7', '53.1 ', '68.4', '66.6 ', '61.7', '49', '51.9 ', '65.2', '64.1 ', '52.5', '55.1 ', '63.1', '64.7 ', '59.9', '67.7 ', '62.4', '61.5 ', '60.9', '61.6 ', '49.4', '63.5 ', '59.2', '59.3 ', '56.5', '62.1 ', '63.1', '60.9 ', '61.8', '50.7 ', '58.8', '63.6 ', '55.3', '60.6 ', '55', '54.3 ', '50.3', '56.1 ', '54.1', '56.3 ', '62.9', '45.6 ', '51.2', '50.2 ',' 50 ', '58.4', '55.3 ',' 0 ', '55.1', '0', '0', '0', '72.6 ',' 70 ']
list2 = ['81.4 ', '82.4', '82.5 ', '80.9', '78.8 ', '80.6', '81', '81.3 ', '82.2', '79.3 ', '80.5', '81.7 ', '82', '80.4 ', '81.3', '83.2 ', '83.4', '79.8 ', '81.6', '81.7 ', '80.4', '80.4 ',' 81 ', '80.4', ' 79,4 ', '82.2', '82', '77.6 ', '80.6', '78.4 ', '78.2', '79.7 ', '74.3', '75.3 ', '76.2', '71.9 ', '75.3', '81.1 ', '79.6', '76.7 ', '79.7', '79.7 ', '74.5', '79.1 ', '76.5', '74.2 ', '76.9', '72', '76.1 ',' 77,1 ', '74.7', '75.1 ', '69.8', '73.7 ', '75.1', '76.3 ', '67.9', '73.4 ', '75.2', '72.1 ', '75.8', '74.8 ', '73.5 ', '69.8', '77.3 ', '79.7', '74.5 ', '79.7', '74.9 ', '66.4', '73', '77.3 ', '74.1', '73.3 ',' 73,7 ',' 70.7 ', '73.9', '73.7 ', '72.6', '74.2 ', '73.7', '74.5 ', '68.4', '75', '73.7 ', '76.2', '74.5 ', '69.6 ', '74.2', '75.6 ', '72.4', '75.2 ', '77.6', '70.9 ', '77.2', '73.3 ', '74.7', '76.2 ', '73.8', ' 72,5 ',' 70.8 ', '73.2', '65.3 ', '67.3', '77.6 ', '72.9', '73', '70.6 ', '64.2 2', '70.9 ', '72.2', '63.1 ',' 67 ', '68.8', '72.4 ', '68.1', '68.5 ', '74.5', '56.3 ', '69.2', '75.8 ', '66.1', '74.8 ', '68.9', '67.4 ', '71.8', '64', '67', '70.7 ', '73.5', '71.3 ', '74.5', '67.1 ', '68.6', '66.2 ', '71.6', '67.9 ',' 61 ', '67.9 ', '58.3', '57', '66.2 ', '70.3', '52.6 ',' 68 ', '66.4', '61.1 ', '48.9', '51.5 ',' 65 ', '63.6', '52.1 ', '54.6', '62.9 ', '64.3', '58.1 ', '67.5', '62.3 ', '60.9', '60.7 ', '61.4', '48.9 ', '63.3', '58.7 ', '59.2', '56.2 ', '61.9', '62.7 ', '60.5', '61.3 ', '50.4', '58.6 ',' 63 ', '54.8', '60.2 ', '54.6', '54.6 ', '54.1 ', '49.9', '55.9 ', '53.6', '55.9 ', '62.3', '45.3 ', '50.7', '49.5 ', '49.6', '57.9 ', '54.7', '0 ', '54.7', '0', '0', '0', '72.3 ', '69.7']
list3 = ['81.1 ', '82.1', '82.2 ', '80.6', '78.5 ', '80.2', '80.7 ',' 81 ', '81.8', '79', '80.2 ', '81.4', '81.7 ', '80.1', '80.8 ', '82.8', '83.1 ', '79.5', '81.3 ', '81.4', '80', '80', '80.6 ',' 80 ',' 79,1 ', '81.9', '81.7 ', '77.3', '80.2 ',' 78 ',' 78 ', '79.3', '74.1 ', '74.8', '75.9 ', '71.6', '75', '80.8 ', '79.2', '76.3 ', '79.3', '79.2 ', '74.2', '78.7 ', '76.2', '74', '76.5 ', '71.8', '75.8 ',' 76,8 ', '74.5', '74.8 ', '69.6', '73.5 ', '74.7', '75.7 ', '67.6', '73.2 ', '74.9', '71.5 ', '75.4', '74.5 ', '73.1 ', '69.6', '76.9 ', '79.1', '74.2 ', '79.3', '74.3 ', '66.1', '72.7 ', '76.8', '73.8 ', '72.9', ' 73,1 ',' 70.5 ', '73.7', '73.4 ', '72.4', '73.9 ', '73.1', '73.9 ', '68.2', '74.7 ', '73.2', '75.9 ', '74.3', '69.3 ', '73.9', '75.1 ', '72.2', '74.9 ', '77.4', '70.6 ', '76.8', '72.9 ', '74.4', '75.6 ', '73.4', ' 72,2 ',' 70.3 ', '72.7', '65', '66.8 ', '76.8', '72.3 ', '72.6', '70.2 ', '63.4 2', '70.5 ',' 72 ', '62.3 ', '66.4', '68.5 ', '71.9', '67.9 ', '68.2', '74.7 ', '54.5', '68.8 ', '75.5', '65.8 ', '74.1', '68.7 ', '67.1 ', '71.1', '62 .6 ',' 66 ', '70.2', '72.9 ', '70.8', '73.8 ', '66.8', '67.9 ', '65.7', '70.8 ',' 67 ', '60.6', '67 ', '57.2', '54.5 ', '65.9', '69.4 ', '51.5', '67.1 ', '66.1', '59.6 ', '48.4', '50.7 ', '64.7', '62.3 ', '51.3 ', '53.7', '62.5 ', '63.4', '53.7 ',' 67 ',' 62 ', '59.2', '60.2 ', '61.1', '47.6 ', '62.9', '57.3 ', '58.8', '55.5 ', '61.5', '61.9 ', '59.6', '60.3 ', '49.6', '58.1 ', '61.5', '53.5 ', '59.5', '53.8 ', '53.6 ', '49.2', '55.3 ', '52.6', '55.1 ', '61.3', '44.8 ', '49.8', '48.1 ',' 49 ',' 57 ', '53.5', '66.9 ',' 54 ', '81.7', '79.8 ', '82.1', '71.8 ', '69.1']
как я могу умножить эти три списка в list4???
list4 = []