Wie multipliziere ich jedes Element in einer Liste mit einer Zahl?

Ich habe eine Liste:

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

Wie kann ich jedes Element my_listmit 5 multiplizieren ? Die Ausgabe sollte sein:

[5, 10, 15, 20, 25]

Sie können einfach ein Listenverständnis verwenden:

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]

Beachten Sie, dass ein Listenverständnis im Allgemeinen eine effizientere Möglichkeit ist, eine forSchleife zu erstellen:

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

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

Als Alternative finden Sie hier eine Lösung mit dem beliebten Pandas-Paket:

import pandas as pd

s = pd.Series(my_list)

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

Oder wenn Sie nur die Liste wollen:

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

Ein erstaunlich schnellerer Ansatz besteht darin, die Multiplikation vektorisiert durchzuführen, anstatt die Liste zu durchlaufen. Numpy hat dafür bereits eine sehr einfache und praktische Möglichkeit bereitgestellt, die Sie verwenden können.

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

Beachten Sie, dass dies mit den nativen Listen von Python nicht funktioniert. Wenn Sie eine Zahl mit einer Liste multiplizieren, werden die Elemente von als Größe dieser Zahl wiederholt.

In [15]: my_list *= 1000

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

Wenn Sie einen reinen Python-basierten Ansatz mit Listenverständnis wünschen, ist dies im Grunde der pythonischste Weg.

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]

Neben dem Listenverständnis können Sie als rein funktionalen Ansatz auch die integrierte map()Funktion wie folgt verwenden:

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

Dieser Code übergibt alle Einzelteile innerhalb des my_listzu 5‚s __mul__Verfahren und gibt einen Iterator-ähnliches Objekt (in Python-3.x). Sie können den Iterator dann mithilfe der list()integrierten Funktion in mapeine Liste konvertieren (in Python-2.x benötigen Sie dies nicht, da standardmäßig eine Liste zurückgegeben wird).

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)

Sie können dies vor Ort wie folgt tun:

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

Dies erfordert keine zusätzlichen Importe und ist sehr pythonisch.

Da ich denke, dass Sie neu in Python sind, können Sie den langen Weg gehen, Ihre Liste mit der for-Schleife durchlaufen und jedes Element multiplizieren und an eine neue Liste anhängen.

Verwenden der for-Schleife

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

Bei Verwendung des Listenverständnisses ist dies auch dasselbe wie bei Verwendung der for-Schleife, jedoch eher "pythonisch".

lst = [5, 20 ,15]

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

Mit Karte (nicht so gut, aber eine andere Herangehensweise an das Problem):

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

Wenn Sie zufällig Numpy- oder Numpy-Arrays verwenden, können Sie Folgendes verwenden:

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)

ist eine Möglichkeit, wie Sie es tun könnten ... Ihr Lehrer kennt wahrscheinlich eine viel weniger komplizierte Art und Weise, die wahrscheinlich im Unterricht behandelt wurde

Multiplizieren Sie jedes Element my_listmit k:

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

ergebend: [5, 10, 15, 20]

Der beste Weg ist das Listenverständnis:

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

Rückgabe: [-1, -2, -3]