Listedeki her bir öğeyi bir sayıyla nasıl çarparım?

Bir listem var:

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

Her bir elemanı my_list5 ile nasıl çarpabilirim ? Çıktı şöyle olmalıdır:

[5, 10, 15, 20, 25]

Sadece bir liste anlayışı kullanabilirsiniz:

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]

Bir liste anlamanın genellikle bir fordöngü oluşturmanın daha verimli bir yolu olduğunu unutmayın :

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

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

Alternatif olarak, popüler Pandas paketini kullanan bir çözüm:

import pandas as pd

s = pd.Series(my_list)

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

Veya sadece listeyi istiyorsanız:

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

Çarpıcı bir şekilde daha hızlı bir yaklaşım, liste üzerinde döngü yapmak yerine çarpma işlemini vektörleştirilmiş bir şekilde yapmaktır. Numpy zaten bunun için kullanabileceğiniz çok basit ve kullanışlı bir yol sağladı.

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

Bunun Python'un yerel listeleriyle çalışmadığını unutmayın. Bir sayıyı bir listeyle çarparsanız, o sayının büyüklüğü kadar olan öğeleri tekrarlar.

In [15]: my_list *= 1000

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

Bir liste anlama kullanarak saf Python tabanlı bir yaklaşım istiyorsanız, temelde gidilecek en Pythonic yoldur.

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]

Liste anlamanın yanı sıra, tamamen işlevsel bir yaklaşım olarak, yerleşik map()işlevi aşağıdaki gibi de kullanabilirsiniz :

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

Bu kod, içinde tüm öğeleri geçer my_listiçin 5bireyin __mul__yöntem ve geri dönüş bir yineleyici benzer bir objeye (piton-3.x). Daha sonra list()yerleşik işlevi kullanarak yineleyiciyi listeye dönüştürebilirsiniz (Python-2.x'te buna ihtiyacınız yoktur çünkü mapvarsayılan olarak bir liste döndürür).

kıyaslamalar:

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)

Bunu yerinde şu şekilde yapabilirsiniz:

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

Bu, ek ithalat gerektirmez ve çok pitoniktir.

Python'da yeni olduğunuzu düşündüğüm için, uzun yoldan gidelim, for döngüsünü kullanarak listenizi yineleyin ve her öğeyi çarpın ve yeni bir listeye ekleyin.

for döngüsü kullanmak

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

Liste anlama kullanıldığında, bu aynı zamanda for-döngüsü kullanmakla aynıdır, ancak daha 'pitonik'

lst = [5, 20 ,15]

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

Harita ile (o kadar iyi değil, ancak soruna başka bir yaklaşım):

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

ayrıca, numpy veya numpy diziler kullanıyorsanız, şunu kullanabilirsiniz:

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)

bunu yapmanın bir yolu ... öğretmeniniz muhtemelen sınıfta anlatılan çok daha az karmaşık bir yolu biliyordur

Her bir elemanın çarpımı my_listile k:

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

sonuçlanan: [5, 10, 15, 20]

En iyi yol, liste anlamayı kullanmaktır:

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

Şunu döndürür: [-1, -2, -3]