Jak pomnożyć każdy element na liście przez liczbę?

Mam listę:

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

Jak mogę pomnożyć każdy element my_listprzez 5? Wynik powinien być:

[5, 10, 15, 20, 25]

Możesz po prostu użyć rozumienia listy:

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]

Zwróć uwagę, że rozumienie listy jest generalnie bardziej wydajnym sposobem wykonania forpętli:

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

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

Jako alternatywę przedstawiam rozwiązanie wykorzystujące popularny pakiet Pandy:

import pandas as pd

s = pd.Series(my_list)

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

Lub, jeśli chcesz tylko listę:

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

Oszałamiająco szybszym podejściem jest wykonywanie mnożenia w sposób zwektoryzowany zamiast zapętlania listy. Numpy zapewnił już bardzo prosty i poręczny sposób, z którego możesz skorzystać.

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

Zauważ, że to nie działa z natywnymi listami Pythona. Jeśli pomnożymy liczbę przez listę, powtórzy się ona jako wielkość tej liczby.

In [15]: my_list *= 1000

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

Jeśli chcesz, aby podejście oparte na Pythonie było oparte na zrozumieniu list, jest to w zasadzie najbardziej Pythonowa droga.

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]

Oprócz rozumienia list, jako czysto funkcjonalnego podejścia, możesz również użyć funkcji wbudowanej w map()następujący sposób:

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

Kod ten przechodzi wszystkich elementów wchodzących w my_listto 5„s __mul__sposobu i powraca iterację jak przedmiotu (w pytona-3.x). Następnie możesz przekonwertować iterator na listę za pomocą list()wbudowanej funkcji (w Pythonie-2.x nie potrzebujesz tego, ponieważ mapdomyślnie zwraca listę).

testy porównawcze:

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)

Możesz to zrobić na miejscu w następujący sposób:

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

Nie wymaga to dodatkowego importu i jest bardzo pytoniczne.

Ponieważ myślę, że jesteś nowy w Pythonie, zróbmy długą drogę, iteruj listę za pomocą pętli for i mnóż i dołączaj każdy element do nowej listy.

używanie pętli for

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

używając rozumienia list, jest to to samo co używanie pętli for, ale bardziej „pythonowe”

lst = [5, 20 ,15]

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

Z mapą (nie tak dobre, ale inne podejście do problemu):

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

również, jeśli używasz tablic numpy lub numpy, możesz użyć tego:

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)

to jeden ze sposobów, w jaki możesz to zrobić ... Twój nauczyciel prawdopodobnie zna znacznie mniej skomplikowany sposób, który prawdopodobnie był omawiany na zajęciach

Mnożenie każdego elementu my_listprzez k:

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

w wyniku: [5, 10, 15, 20]

Najlepszym sposobem jest rozumienie list:

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

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