Wie um zu überprüfen, ob alle Elemente einer Liste entspricht einem Zustand?

Ich habe eine Liste, bestehend aus wie 20000 Listen. Ich nutze jede Liste das 3. element, wie eine fahne. Ich möchte einige Vorgänge auf dieser Liste so lange wie mindestens ein element ist-flag ist 0, es ist wie:

my_list = [["a", "b", 0], ["c", "d", 0], ["e", "f", 0], .....]

In der Anfang, alle flags auf 0. Ich benutze eine while-Schleife, um zu überprüfen, wenn mindestens ein element ist-flag ist 0:

def check(list_):
    for item in list_:
        if item[2] == 0:
            return True
    return False

Wenn check(my_list) zurück True, dann arbeite ich weiter an meiner Liste:

while check(my_list):
    for item in my_list:
        if condition:
            item[2] = 1
        else:
            do_sth()

Eigentlich wollte ich ein element entfernen, in my_list ein als ich der Iteration ist es, aber ich darf nicht, um Elemente zu entfernen, wie ich Durchlaufen.

Original my_list ein nicht-flags:

my_list = [["a", "b"], ["c", "d"], ["e", "f"], .....]

Da konnte ich nicht entfernen, die Elemente wie ich Sie iteriert über es, ich erfand diese Flaggen. Aber die my_list viele Elemente enthält, und while Schleife liest alle von Ihnen an jedem for Schleife, und es verbraucht viel Zeit! Haben Sie irgendwelche Vorschläge?

Sieht aus wie Ihre Datenstruktur ist nicht ideal für dein problem. Wenn Sie erklärt den Kontext ein wenig mehr könnten wir vielleicht vorschlagen, etwas besser geeignet.
Vielleicht könnten Sie ersetzen die Elemente, die mit None oder [] als Sie die Liste Durchlaufen, anstatt Sie zu entfernen. Überprüfen Sie die ganze Liste mit 'check()` Iteration über alle Elemente vor jedem pass auf die innere Schleife ist eine sehr langsame Annäherung.

InformationsquelleAutor alwbtc | 2012-05-19

321

Die beste Antwort ist es, zu all(), die ist vordefiniert für diese situation. Wir kombinieren dies mit einem generator-Ausdruck zu produzieren, das Ergebnis, die Sie wollen, sauber und effizient. Zum Beispiel:
```
>>> items = [[1, 2, 0], [1, 2, 0], [1, 2, 0]]
>>> all(item[2] == 0 for item in items)
True
>>> items = [[1, 2, 0], [1, 2, 1], [1, 2, 0]]
>>> all(item[2] == 0 for item in items)
False
```
Und für seine filter-Beispiel, eine Liste Verständnis:
```
>>> [x for x in items if x[2] == 0]
[[1, 2, 0], [1, 2, 0]]
```
Wenn Sie überprüfen möchten, die mindestens ein element ist 0, die bessere option ist die Verwendung any(), das ist besser lesbar:
```
>>> any(item[2] == 0 for item in items)
True
```
Mein Fehler ist auf die Verwendung von lambda, Python ist alles nicht akzeptieren, eine Funktion als erstes argument wie Haskell et. al., Ich habe meine Antwort auf eine list comprehension als gut. 🙂
Eine Liste Verständnis ist nicht das gleiche wie ein generator-Ausdruck. Als all() und any() Kurzschluss, wenn z.B. der erste Wert auf mine ausgewertet False, all() fehl, und nicht überprüfen, keine Werte mehr, die Rückkehr False. Dein Beispiel wird das gleiche tun, außer es generiert die gesamte Liste der Vergleiche erste, der bedeutet, dass eine Bearbeitung so viel für nichts.

InformationsquelleAutor Gareth Latty
7

Könnten Sie itertools ist takewhile wie diese, es wird aufhören, sobald eine Bedingung erfüllt ist, scheitert Ihre Aussage. Die entgegengesetzte Methode wäre dropwhile
```
for x in itertools.takewhile(lambda x: x[2] == 0, list)
    print x
```
InformationsquelleAutor Hedde van der Heide
6

Wenn Sie möchten, um zu überprüfen, ob ein Element in der Liste verstößt gegen die Bedingung der Nutzung all:
```
if all([x[2] == 0 for x in lista]):
    # Will run if all elements in the list has x[2] = 0 (use not to invert if necessary)
```
Entfernen alle Elemente, die nicht zusammenpassen, verwenden filter
```
# Will remove all elements where x[2] is 0
listb = filter(lambda x: x[2] != 0, listb)
```
Sie können entfernen [...] im all(...) da kann es dann einen generator erzeugen, anstatt eine Liste, die nicht nur spart Sie zwei Zeichen, sondern spart auch Speicher und Zeit. Durch die Verwendung von Generatoren, wird nur ein item berechnet (frühere Ergebnisse werden gelöscht, da nicht mehr benutzt) und wenn einer von Ihnen stellt sich heraus False ist, Stoppt der generator die Berechnung des rest.

InformationsquelleAutor Hampus Nilsson

dieser Weg ist ein bisschen mehr flexible als die Verwendung all():

my_list = [[1, 2, 0], [1, 2, 0], [1, 2, 0]]
all_zeros = False if False in [x[2] == 0 for x in my_list] else True
any_zeros = True if True in [x[2] == 0 for x in my_list] else False

InformationsquelleAutor mulllhausen

-1

Andere Weise zu verwenden itertools.ifilter. Dieser prüft, truthiness und Prozess
(mit lambda)

Probe-
```
for x in itertools.ifilter(lambda x: x[2] == 0, my_list):
    print x
```
InformationsquelleAutor SIslam

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.