Ersetzen von ausgewählten Elementen in einer Liste in Python

Habe ich eine Liste: mylist = [0, 0, 0, 0, 0]

Ich möchte nur das ersetzt den ausgewählten Elementen, sagen wir die erste, zweite und vierte durch eine gemeinsame Nummer A = 100.

Einen Weg, dies zu tun:

mylist[:2] = [A]*2
mylist[3] = A
mylist
[100, 100, 0, 100, 0]

Ich bin auf der Suche nach einem one-liner, oder eine einfachere Methode, dies zu tun. Eine mehr Allgemeine und flexible Antwort vorzuziehen ist.

  • Wie wäre es damit? mylist[:2],mylist[3] = [A]*2,
InformationsquelleAutor elwc | 2013-01-16
  1. 8

    Zumal Sie ersetzen einen beträchtlichen Teil der list, ich würde dies tun immutably:

    mylist = [100 if i in (0, 1, 3) else e for i, e in enumerate(mylist)]

    Absichtlich in Python, das die Herstellung einer neuen list ist ein one-liner, während mutierend eine list erfordert eine explizite Schleife. In der Regel, wenn Sie nicht wissen, welche Sie wollen, Sie wollen die neue list. (In einigen Fällen ist es langsamer oder komplizierter, oder hast du noch ein paar andere Codes, die eine Referenz auf die gleiche list und sehen muss, es mutiert, oder was auch immer, das ist der Grund, warum das "meistens" statt "immer".)

    Wenn Sie dies tun wollen, mehr als einmal, ich würde es einpacken in Funktion, wie die Volatilität suggeriert:

    def elements_replaced(lst, new_element, indices):
    return [new_element if i in indices else e for i, e in enumerate(lst)]

    Ich persönlich würde wahrscheinlich machen es zu einem generator, so dass es liefert eine iteration statt zurückgeben einer Liste, auch wenn ich nie gehen zu müssen, einfach, weil ich dumm bin, dass Art und Weise. Aber wenn Sie tatsächlich tun es brauchen:

    myiter = (100 if i in (0, 1, 3) else e for i, e in enumerate(mylist))

    Oder:

    def elements_replaced(lst, new_element, indices):
    for i, e in enumerate(lst):
        if i in indices:
            yield new_element
        else:
            yield e
    • Gute Erklärung in Bezug auf die neue Liste und mutation.
    • Manchmal vermisse ich die valarray::gslice
    • Naja, fast jedem Fall, wo valarray macht Sinn, in C++ numpy Sinn macht, in Python—und numpy's erweiterte slicing ist sogar noch einfacher als gslice für fast alle Fälle. Zum Beispiel, sehen Sie mgilson Antwort auf diese Frage. (Natürlich "fast jeden" und "fast alle" sind nicht ganz dasselbe wie "jeder" und "alle"... aber es ist selten, dass ich mich schriftlich einige numpy code und fehlt ein C++ - feature...)
    InformationsquelleAutor abarnert
  2. 2
    def replace_element(lst, new_element, indices):
    for i in indices:
        lst[i] = new_element
    return lst

    Es ist definitiv eine allgemeinere Lösung, kein one-liner, obwohl. Zum Beispiel, in Ihrem Fall, würden Sie rufen:

    mylist = replace_element(mylist, 100, [0, 1, 3])
    • +1. Auf der Oberseite der mehr Allgemeinen, ich denke, dies ist die lesbare Art und Weise zu tun, die veränderlich Ersatz, trotz (oder, eher, wohl, weil) nicht einen one-liner.
    InformationsquelleAutor Volatility
  3. 1

    Numpy unterstützt diese, wenn Sie nicht gegen die Verwendung eines np.ndarray:

    >>> a = np.zeros(5)
>>> a[[0,1,3]] = 100
>>> a
array([ 100.,  100.,    0.,  100.,    0.])
    • +1. Selbst wenn dies nicht direkt beantworten die OP ' s Frage (und ich bin nicht sicher, dass es nicht), wenn Sie sich den Umgang mit Zahlenreihen und etwas scheint schwieriger, als es sein sollte, die erste Frage, die Sie stellen sollten, ist wahrscheinlich "bin ich nicht mit einem np.ndarray hier?"
    InformationsquelleAutor mgilson
  4. 0

    Ist es das, was du suchst? Machen Sie eine Liste der Indizes, die Sie ändern möchten, und dann eine Schleife durch diese Liste, um die Werte zu ändern.

    els_to_replace = [0, 1, 3]

mylist = [0, 0, 0, 0, 0]

for index in els_to_replace:
    mylist[index] = 100


mylist
Out[9]: [100, 100, 0, 100, 0]
    InformationsquelleAutor Marius
  5. 0

    Ich, wie eine list comprehension:

    [100 if index in [1, 4] else 0 for index, x in enumerate(mylist) ]
    InformationsquelleAutor Jesse Briggs
  6. 0

    Kein großer fan von diesem, aber Sie könnten versuchen, diese (obwohl ich denke, dass alle der oben genannten sind viel mehr prägnant und einfach zu Lesen):

    In [22]: from operator import setitem

In [23]: mylist = [0, 0, 0, 0, 0]

In [24]: indeces_to_replace = [0, 1, 3]

In [25]: _ = map(lambda x: setitem(mylist, x, 100), indeces_to_replace)

In [26]: mylist
Out[26]: [100, 100, 0, 100, 0]

    Abgesehen von der fragwürdigen Lesbarkeit und müssen für einen import, @abarnert wies darauf hin ein paar weitere Probleme, nämlich, dass map noch schafft eine unnötige Liste (die ist verworfen, mit der _ aber trotzdem erstellt) und, dass es nicht funktionieren in Python 3, da map gibt einen iterator in Python 3.x. Sie können die sechs Modul für die Simulation des Verhaltens von map in Python 3.x von Python 2.x, und in Kombination mit collections.deque (wieder-so der Vorschlag von @abarnert), erzielen Sie dieselbe Leistung ohne die Schaffung der zusätzlichen Liste im Speicher, da ein deque enthalten können maximal 0 Elemente verwerfen alles, was es erhält von der map iterator (beachten Sie, dass mit six, map wird simuliert durch die Verwendung von itertools.imap).

    Wieder, es gibt absolut keine müssen dies jemals verwendet - jede Lösung oben/unten ist besser 🙂

    In [1]: from collections import deque

In [2]: from six.moves import map

In [3]: from operator import setitem

In [4]: mylist = [0, 0, 0, 0, 0]

In [5]: indeces_to_replace = [0, 1, 3]

In [6]: deque(map(lambda x: setitem(mylist, x, 100), indeces_to_replace), maxlen=0)
Out[6]: deque([], maxlen=0)

In [7]: mylist
Out[7]: [100, 100, 0, 100, 0]
    • Das Hauptproblem dabei ist, dass in Python 3 funktioniert es nicht, weil Sie gerade wieder einen iterator, dass Sie niemals Durchlaufen. Das kleinere problem ist, dass in Python 2 wird, erstellt Sie eine Liste, die Sie haben keine Notwendigkeit für. Können Sie lösen das erste problem, indem Sie explizit tun list(map(…)). Oder Sie können beide lösen mithilfe six.map und übergeben das Ergebnis an eine iter_discard - Funktion, die Sie implementieren können, als collections.deque(it, max_size=0). Das ist alles eine ganze Menge mehr Gedanken, als sollten Sie jemals in eine Lösung, die Sie waren nicht ein großer fan von in den ersten Platz, natürlich...
    • Verspätetes +1 auf deine Antwort (informativ wie immer), und die großen Punkte zu dieser Umsetzung (hätte nie gedacht, über die Weitergabe der Ergebnisse der map zu einem iter_discard - Funktion). Ich werde in einem update für die Nachwelt Willen, und Dank wie immer für die hilfreichen Infos 🙂
    • Ich wünschte wirklich iter_discard waren Teil der 3.x standard-Bibliothek. Das argument gegen Sie war, würde dies wollen die Menschen motivieren, mit map für Nebenwirkungen statt der Ergebnisse (und, wenn Sie es wirklich wollen, die deque trick wurde Hinzugefügt, um die Dokumentation für itertools irgendwo). Kann ich die kaufen... aber für diese Art von Fragen, die Leute wollen immer, dass sowieso (und dann wollen timeit die Ergebnisse mit jeder version von Python Sie finden kann).
    • Recht hast du, sieht aus wie der consume Rezept. Das ist interessant - ich habe immer gefühlt, wie ich etwas Tat, was nicht ganz Recht ist, wenn mit map für die Nebenwirkungen, die Sie erwähnen (die unnötige Liste Nebenprodukt als der stärkste Indikator). Dass deque Technik lindert definitiv das Gefühl, also danke für den neuen Stich hinzufügen, um die Drehung 🙂
    InformationsquelleAutor RocketDonkey
Schreibe einen Kommentar