O nome das variáveis que começa com maiúsculas não é Pythônico. E são listas, não números. Portanto, sugiro usar l1e l2como o nome da variável.
Casimir Crystal
4
O uso de 'l' como variável também é desencorajado porque a letra 'l' e o número 1 são facilmente confundidos. Usei as variáveis na pergunta original do OP e acredito que sua edição da pergunta fez mais mal do que bem.
Alexander
1
Se você acha que minha edição é ruim, você pode editar a pergunta para melhorá-la. Além disso, podemos escolher outra variável, em vez de l1, como l_1, list_1, etc. Estes são todos melhor do que Num_1.
Casimir Crystal
26
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.
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 * 5899 µs ± 4.98 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Estou interessado em saber por que o método numpy é 'incrivelmente mais rápido'? Você poderia elaborar ou me indicar alguns recursos? Não tenho certeza do que é vetorização.
@Kasramvd Esse link está incorreto. O link discute um significado diferente de vetorização como instrução única e múltiplos dados (aplicando uma operação a muitos dados de uma vez, como fazem as GPUs). No contexto do NumPy, a vetorização se refere ao uso de loops C pré-compilados rápidos para operar em uma sequência de dados, em vez de Python puro.
Além disso: o conceito é chamado de compreensão de lista se você quiser pesquisar mais informações sobre ele.
Michael
1
Eu prefiro l = [x * 5 for x in l]terminar l[:] = [x * 5 for x in l]. Este último cria uma nova lista e a usa para sobrescrever o conteúdo de, lem vez de apenas reatribuir a referência, o que é mais barato. Se você estiver realmente preocupado com o espaço, apenas itere com um loop e mude no local.
cs95 de
6
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 * 5for i in lst]
print prod
Como o "caminho longo" é melhor de alguma forma? É mais longo - portanto, mais difícil de ler - e não é mais fácil de escrever.
lirtosiast
1
ok, talvez você tenha tido uma impressão errada sobre o meu título e eu nunca disse que era melhor, apenas tentando mostrar a ele como fazer isso sem usar compreensão. porque na minha experiência, quando eu era novo em python, não era capaz de compreender o conceito de compreensão facilmente.
ellaRT
Oh, ok. Não consigo me relacionar diretamente porque comecei com linguagens funcionais.
lirtosiast
Eu vejo, bem aí. Eu editei a resposta para incluir também a maneira eficiente de fazer isso.
ellaRT
4
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:
Você pode fazer isso sem as instruções de importação usando uma expressão lambda. Além disso, seu snippet retorna um objeto de mapa, que é inútil a menos que seja lançado em uma lista. lista (mapa (lambda x: 5 * x, minha_lista)).
castelo-bravo
@ castle-bravo sua utilidade depende do que você precisa fazer com ele ... há muitas maneiras de realizar essa solução (como mencionei ...)
Joran Beasley
4
Por favor, não ensinam as pessoas a usam mapcom lambda; no instante em que você precisa de um lambda, você se sairia melhor com uma compreensão de lista ou expressão de gerador. Se você é inteligente, você pode fazer mapo trabalho sem lambdamuita sa, por exemplo, neste caso, map((5).__mul__, my_list), embora, neste caso particular, graças a algumas otimizações no interpretador bytecode para simples intmatemática, [x * 5 for x in my_list]é mais rápido, bem como sendo mais Pythonic e mais simples .
ShadowRanger
1
Multiplicando cada elemento em my_listpor k:
k = 5
my_list = [1,2,3,4]
result = list(map(lambda x: x * k, my_list))
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 reassigned2707834976576
x = list(map(lambda x : 2 * x / 3, x))
x
[1.0, 2.0, 3.0]
id(x)
2707834980928
defmap_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))
Isso apenas pega a resposta aceita e a transforma em uma função. Você provavelmente poderia fazer isso com mais da metade das respostas no SO, mas não acrescenta nada e não é o que o OP pediu.
mapé melhor do quefor-loop.map(e sempre melhor semapexigiria alambda).Respostas:
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: int64Ou, se você quiser apenas a lista:
>>> (s * 5).tolist() [5, 10, 15, 20, 25]fonte
l1el2como o nome da variável.l1, comol_1,list_1, etc. Estes são todos melhor do queNum_1.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]: 5000Se 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_lista5'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 alist()função embutida (em Python-2.x você não precisa disso porquemapretorna 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)fonte
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.
fonte
l = [x * 5 for x in l]terminarl[:] = [x * 5 for x in l]. Este último cria uma nova lista e a usa para sobrescrever o conteúdo de,lem vez de apenas reatribuir a referência, o que é mais barato. Se você estiver realmente preocupado com o espaço, apenas itere com um loop e mude no local.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 productusando 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 prodfonte
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)fonte
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
fonte
mapcomlambda; no instante em que você precisa de umlambda, você se sairia melhor com uma compreensão de lista ou expressão de gerador. Se você é inteligente, você pode fazermapo trabalho semlambdamuita sa, por exemplo, neste caso,map((5).__mul__, my_list), embora, neste caso particular, graças a algumas otimizações no interpretador bytecode para simplesintmatemática,[x * 5 for x in my_list]é mais rápido, bem como sendo mais Pythonic e mais simples .Multiplicando cada elemento em
my_listpork:k = 5 my_list = [1,2,3,4] result = list(map(lambda x: x * k, my_list))resultando em:
[5, 10, 15, 20]fonte
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) 2707834980928fonte
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]
fonte