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

90

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]
DJ Bigdawg
quelle
2
Verwenden mapist besser als for-loop.
Tony
9
Und das Listenverständnis ist (fast immer) besser alsmap (und immer besser, wenn a maperforderlich wäre lambda).
ShadowRanger

Antworten:

132

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]
Alexander
quelle
Der Variablenname, der mit Großbuchstaben beginnt, ist nicht Pythonic. Und es sind Listen, keine Zahlen. Also würde ich vorschlagen, l1und l2als Variablenname zu verwenden.
Casimir Crystal
4
Von der Verwendung von 'l' als Variable wird ebenfalls abgeraten, da der Buchstabe 'l' und die Zahl 1 leicht verwechselt werden können. Ich habe die Variablen in der ursprünglichen Frage des OP verwendet, und ich glaube, Ihre Bearbeitung der Frage hat mehr geschadet als geholfen.
Alexander
1
Wenn Sie der Meinung sind, dass meine Bearbeitung schlecht ist, können Sie die Frage bearbeiten, um sie zu verbessern. Auch wir können andere Variable auswählen , anstatt l1wie l_1, list_1usw. Diese sind alle besser als Num_1.
Casimir Crystal
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)
Kasravnd
quelle
Mich interessiert, warum die Numpy-Methode "unglaublich schneller" ist. Könnten Sie mich möglicherweise näher erläutern oder auf einige Ressourcen hinweisen? Ich bin mir nicht sicher, was Vektorisierung ist.
Aerinmund Fagelson
1
@AerinmundFagelson Hier -> stackoverflow.com/questions/35091979/…
Kasravnd
@ Kasramvd Dieser Link ist falsch. Der Link beschreibt eine andere Bedeutung der Vektorisierung als Einzelbefehl-Mehrfachdaten (Anwenden einer Operation auf viele Daten gleichzeitig, wie dies bei GPUs der Fall ist). Im Kontext von NumPy bezieht sich Vektorisierung auf die Verwendung schneller vorkompilierter C-Schleifen, um eine Datensequenz anstelle von reinem Python zu bearbeiten.
5.
19

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.

David Hoelzer
quelle
Außerdem: Das Konzept wird als Listenverständnis bezeichnet, wenn Sie weitere Informationen dazu nachschlagen möchten.
Michael
1
Ich wäre lieber l = [x * 5 for x in l]vorbei l[:] = [x * 5 for x in l]. Letzterer erstellt eine neue Liste und verwendet sie dann, um den Inhalt von zu überschreiben, anstatt lnur die Referenz neu zuzuweisen, was billiger ist. Wenn Sie sich tatsächlich Sorgen um den Speicherplatz machen, iterieren Sie einfach mit einer Schleife und mutieren Sie an Ort und Stelle.
CS95
6

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
wasp8898
quelle
Wie ist der "lange Weg" in irgendeiner Weise besser? Es ist länger - daher schwieriger zu lesen - und nicht einfacher zu schreiben.
Lirtosiast
1
Okay, vielleicht hast du einen falschen Eindruck auf meinen Titel bekommen und ich habe nie gesagt, dass es besser ist. Ich habe nur versucht, ihm zu zeigen, wie es geht, ohne Verständnis zu verwenden. weil ich aufgrund meiner Erfahrung als Neuling in Python das Konzept des Verstehens nicht leicht verstehen konnte.
wasp8898
Oh ok. Ich kann mich nicht direkt darauf beziehen, weil ich mit funktionalen Sprachen angefangen habe.
Lirtosiast
Ich verstehe, gut da. Ich habe die Antwort so bearbeitet, dass sie auch die effiziente Vorgehensweise enthält.
wasp8898
4

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)
whackamadoodle3000
quelle
Warum nicht ein Lambda verwenden, anstatt die Timesfive-Funktion zu definieren?
Vimanyu
2
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

Joran Beasley
quelle
Sie können dies ohne die import-Anweisungen mit einem Lambda-Ausdruck tun. Außerdem gibt Ihr Snippet ein Kartenobjekt zurück, das unbrauchbar ist, wenn es nicht in eine Liste umgewandelt wird. Liste (Karte (Lambda x: 5 * x, my_list)).
Castle-Bravo
@ Castle-Bravo seine Nützlichkeit hängt davon ab, was Sie damit tun müssen ... es gibt viele Möglichkeiten, diese Lösung zu erreichen (wie ich erwähne ...)
Joran Beasley
4
Bitte bringen Sie den Leuten nicht bei, mapmit ihnen lambdaumzugehen. In dem Moment, in dem Sie einen benötigen lambda, wären Sie mit einem Listenverständnis oder einem Generatorausdruck besser dran gewesen. Wenn Sie klug, Sie können machen mapArbeit ohne lambdasa viel, zum Beispiel in diesem Fall map((5).__mul__, my_list), auch wenn in diesem speziellen Fall, dank einiger Optimierungen in den Byte - Code - Interpreter für die einfache intMathematik, [x * 5 for x in my_list]ist schneller, als auch als mehr Pythonic und einfacher .
ShadowRanger
1

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]

Vityata
quelle
-1

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]

Oberst John Hannibal Smith
quelle
Dies nimmt nur die akzeptierte Antwort und verwandelt sie in eine Funktion. Sie könnten das wahrscheinlich mit mehr als der Hälfte der Antworten auf SO tun, aber es fügt nichts hinzu und ist nicht das, was das OP verlangt hat.
Alexander