Como faço para multiplicar cada elemento em uma lista por um número?

Eu tenho uma lista:

my_list = [1, 2, 3, 4, 5]

Como posso multiplicar cada elemento my_listpor 5? A saída deve ser:

[5, 10, 15, 20, 25]

Você pode apenas usar uma compreensão de lista:

my_list = [1, 2, 3, 4, 5]
my_new_list = [i * 5 for i in my_list]

>>> print(my_new_list)
[5, 10, 15, 20, 25]

Observe que a compreensão de uma lista geralmente é uma maneira mais eficiente de fazer um forloop:

my_new_list = []
for i in my_list:
    my_new_list.append(i * 5)

>>> print(my_new_list)
[5, 10, 15, 20, 25]

Como alternativa, aqui está uma solução usando o pacote Pandas popular:

import pandas as pd

s = pd.Series(my_list)

>>> s * 5
0     5
1    10
2    15
3    20
4    25
dtype: int64

Ou, se você quiser apenas a lista:

>>> (s * 5).tolist()
[5, 10, 15, 20, 25]

Uma abordagem incrivelmente mais rápida é fazer a multiplicação de maneira vetorial, em vez de repetir a lista. O Numpy já forneceu uma maneira muito simples e prática para isso que você pode usar.

>>> import numpy as np
>>> 
>>> my_list = np.array([1, 2, 3, 4, 5])
>>> 
>>> my_list * 5
array([ 5, 10, 15, 20, 25])

Observe que isso não funciona com as listas nativas do Python. Se você multiplicar um número por uma lista, ele repetirá os itens de conforme o tamanho desse número.

In [15]: my_list *= 1000

In [16]: len(my_list)
Out[16]: 5000

Se você deseja uma abordagem puramente baseada em Python, o uso de compreensão de lista é basicamente o caminho mais Pythônico a seguir.

In [6]: my_list = [1, 2, 3, 4, 5]

In [7]: [5 * i for i in my_list]
Out[7]: [5, 10, 15, 20, 25]

Além da compreensão de lista, como uma abordagem puramente funcional, você também pode usar a map()função integrada da seguinte maneira:

In [10]: list(map((5).__mul__, my_list))
Out[10]: [5, 10, 15, 20, 25]

Este código passa todos os itens dentro da my_lista 5's __mul__método e retorna uma iteração do tipo objeto (em python-3.x). Você pode então converter o iterador em lista usando a list()função embutida (em Python-2.x você não precisa disso porque mapretorna uma lista por padrão).

benchmarks:

In [18]: %timeit [5 * i for i in my_list]
463 ns ± 10.6 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [19]: %timeit list(map((5).__mul__, my_list))
784 ns ± 10.7 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [20]: %timeit [5 * i for i in my_list * 100000]
20.8 ms ± 115 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)

In [21]: %timeit list(map((5).__mul__, my_list * 100000))
30.6 ms ± 169 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)


In [24]: arr = np.array(my_list * 100000)

In [25]: %timeit arr * 5
899 µs ± 4.98 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Você pode fazer isso no local, assim:

 l = [1, 2, 3, 4, 5]
 l[:] = [x * 5 for x in l]

Isso não requer importações adicionais e é muito pitônico.

Como acho que você é novo no Python, vamos fazer o caminho mais longo, iterar por meio de sua lista usando o loop for e multiplicar e anexar cada elemento a uma nova lista.

usando for loop

lst = [5, 20 ,15]
product = []
for i in lst:
    product.append(i*5)
print product

usando a compreensão de lista, isso também é o mesmo que usar for-loop, mas mais 'pythônico'

lst = [5, 20 ,15]

prod = [i * 5 for i in lst]
print prod

Com mapa (não tão bom, mas outra abordagem para o problema):

list(map(lambda x: x*5,[5, 10, 15, 20, 25]))

Além disso, se você estiver usando matrizes numpy ou numpy, poderá usar isto:

import numpy as np
list(np.array(x) * 5)

from functools import partial as p
from operator import mul
map(p(mul,5),my_list)

é uma maneira de você fazer isso ... seu professor provavelmente conhece uma maneira muito menos complicada que provavelmente foi abordada na aula

Multiplicando cada elemento em my_listpor k:

k = 5
my_list = [1,2,3,4]
result = list(map(lambda x: x * k, my_list))

resultando em: [5, 10, 15, 20]

Achei interessante usar a compreensão de lista ou mapa com apenas um nome de objeto x. Observe que sempre que x é reatribuído , seu id (x) muda, ou seja, aponta para um objeto diferente.

x = [1, 2, 3]
id(x)
2707834975552
x = [1.5 * x for x in x]
id(x)
2707834976576
x
[1.5, 3.0, 4.5]
list(map(lambda x : 2 * x / 3, x))
[1.0, 2.0, 3.0]
id(x) # not reassigned
2707834976576
x = list(map(lambda x : 2 * x / 3, x))
x
[1.0, 2.0, 3.0]
id(x)
2707834980928

A melhor maneira é usar a compreensão de lista:

def map_to_list(my_list, n):
# multiply every value in my_list by n
# Use list comprehension!
    my_new_list = [i * n for i in my_list]
    return my_new_list
# To test:
print(map_to_list([1,2,3], -1))

Retorna: [-1, -2, -3]