if/else in einer list comprehension?

Wie kann ich den folgenden Code in Python?

row = [unicode(x.strip()) for x in row if x is not None else '']

Im wesentlichen:

ersetzen Sie alle den Nonen mit leeren Saiten, und dann
eine Funktion auszuführen.

möglich, Duplikat der Ist es möglich mit 'else' in python list comprehension?

InformationsquelleAutor AP257 | 2010-11-23

list-comprehension python

1108

Können Sie ganz tun, es ist einfach eine Bestellung Problem:
```
[unicode(x.strip()) if x is not None else '' for x in row]
```
Im Allgemeinen,
```
[f(x) if condition else g(x) for x in sequence]
```
Und für die Liste Verstehens mit if nur Bedingungen
```
[f(x) for x in sequence if condition]
```
Beachten Sie, dass dies tatsächlich eine andere Sprache verwendet Konstrukt, eine bedingten Ausdruck, die selbst nicht Teil des Verständnis der syntax, während die if nach der for…in ist Teil der Liste Verstehens und verwendet, um filter Elementen aus der Quelle durchsuchbar.

Bedingte Ausdrücke können verwendet werden, in allen Arten von Situationen, wo Sie wollen, zu wählen zwischen zwei expression-Werte, basierend auf einer Bedingung. Dieser macht das gleiche wie die ternärer operator ?: existiert auch in anderen Sprachen. Zum Beispiel:
```
value = 123
print(value, 'is', 'even' if value % 2 == 0 else 'odd')
```
- Beachten Sie, dass die if/else, hier ist jetzt "ternärer operator" - syntax und nicht list comprehension syntax.
- Gegeben OP ' s die Vorherige Frage, @Adam die Bemerkung ist sehr wichtig!
- Das ist, warum ich lieber den ternären operator in Klammern, es macht deutlicher, dass es nur eine normale expression, kein Verständnis.
- Also der trick ist "In der Liste Komprimierung ich Schreibe, wenn, bevor, dann muss ich hinzufügen else-Teil zu". weil wenn mein l = [ 2, 3, 4, 5] dann [x if x % 2 == 0 for x in l] geben Sie mir Fehler in der Erwägung, dass [x if x % 2 == 0 else 200 for x in l] funktioniert. Ja, ich weiß, um es zu filtern ich schreiben soll [ x for x in l if x % 2 == 0]. Sorry für botheration. Danke für deine Antwort.
- python-docs schweigen von den ternären operator. Beachten Sie, dass es erfordert, den anderen, oder es funktioniert nicht.
- Also, die Antwort mit einer Bedingung-Ausdruck in einer Liste Verständnis... Ist das richtig? Oder, können wir nicht nennen es eine Liste Verständnis mehr?
- Ja, es ist immer noch eine Liste Verständnis, nur mit einem bedingten Ausdruck.
- Es gibt eine Unterscheidung zwischen den beiden Schreibweisen: [final-expr for x in start-expr if cond-expr] ist die Abkürzung für "sind das Ergebnis von final-expr für jedes element in start-expr, solange die cond-expr wahr ist im Kontext dieses Elements. Es passiert einfach so, dass beide Ausdrücke können auch Gebrauch machen von den ternären operator. Nur im Kopf behalten, dass das "wenn" in der Verständnis hat die Fähigkeit der filtern, die Ergebnisse, D. H. am Ende mit weniger Elemente als in start-expr. Dies ist nicht der Fall mit einem expr1 if cond else expr2 ternären Ausdruck.
- Ein Beispiel: [x for x in range(50) if (x%3)==0] gibt eine Liste von ganzen zahlen durch 3 teilbar. [x if (x%3)==0 for x in range(50)] ungültig ist, als x if (x%3)==0 ist kein Gültiger Ausdruck. @Grijesh, hier ist ein Gegenbeispiel zu deiner Regel (wenn vor/nach für): [x for x in range(50) if ((x%3)==0 if x>20 else False)]. Dieses Verständnis ist Kriterium wird nur entsprechen, ganzen zahlen, sind beide durch drei teilbar und größer als 20 sein.
- Wie wäre es, wenn ich wollte, die Schleife zu brechen, basierend auf einem Wert, wenn ich versuchte, die, wenn mit Pause in der sonst funktioniert es nicht. Irgendwelche Vorschläge? Dank
- Liste Verstehens nicht unterstützen, brechen während der iteration. Sie wird also mit einer normalen Schleife.
- Also, das ist ternär, gemischt mit list comprehension..
- Es ist ein " bedingter Ausdruck verwendet, die in einer Liste erfassen. Ein conditional expression in Python ist äquivalent zu ternärer operator in C.
InformationsquelleAutor poke
40

Einen Weg:
```
def change(f):
    if f is None:
        return unicode(f.strip())
    else:
        return ''

row = [change(x) for x in row]
```
Obwohl dann haben Sie:
```
row = map(change, row)
```
Oder Sie können eine lambda-inline.
- Dies ist auch eine gute (vielleicht nur) Technik zu verwenden, wenn Sie behandeln müssen mögliche Ausnahmen von der if Ausdruck oder code in Ihre oder die elses Anweisungsblock. Die akzeptierte Antwort ist besser für einfache Fälle.
InformationsquelleAutor Adam Vandenberg
37

Hier ist ein weiteres anschauliches Beispiel:
```
>>> print(", ".join(["ha" if i else "Ha" for i in range(3)]) + "!")
Ha, ha, ha!
```
Es nutzt die Tatsache, dass if i ausgewertet False für 0 und zu True für alle anderen Werte, erzeugt durch die Funktion range(). Daher ist die Liste Verständnis wertet wie folgt:
```
>>> ["ha" if i else "Ha" for i in range(3)]
['Ha', 'ha', 'ha']
```
InformationsquelleAutor Bengt
27

Das spezifische problem bereits gelöst in den vorherigen Antworten, also ich komme auf die Allgemeine Idee der Verwendung von Vergleichsoperatoren in Liste Verstehens.

Hier ist ein Beispiel, das zeigt, wie konditionalen geschrieben werden kann, in einer Liste Verständnis:
```
X = [1.5, 2.3, 4.4, 5.4, 'n', 1.5, 5.1, 'a']     # Original list

# Extract non-strings from X to new list
X_non_str = [el for el in X if not isinstance(el, str)]  # When using only 'if', put 'for' in the beginning

# Change all strings in X to 'b', preserve everything else as is
X_str_changed = ['b' if isinstance(el, str) else el for el in X]  # When using 'if' and 'else', put 'for' in the end
```
Beachten Sie, dass in der ersten Liste das Verständnis für X_non_str, die Reihenfolge ist:

Ausdruck für Element in iterierbar wenn Zustand

in der letzten Liste Verständnis für X_str_changed, die Reihenfolge ist:

expression1 wenn Zustand sonst expression2 für Element in iterierbar

Ich finde es immer schwer sich zu erinnern, dass expresseion1 sein, bevor wenn und expression2 nach sonst. Mein Kopf will, dass beide entweder vor oder nach.

Ich denke, es ist entworfen, denn es ähnelt der normalen Sprache, z.B. "ich will drinnen bleiben wenn es regnet, sonst ich will nach draußen gehen"

InformationsquelleAutor Tim Skov Jacobsen
4

Die anderen Lösungen sind ideal für eine einzelne if /else konstruieren. Allerdings ternären Aussagen innerhalb der Liste Verstehens sind wohl schwer zu Lesen.

Mithilfe einer Funktion aids Lesbarkeit, aber solch eine Lösung ist schwierig zu erweitern oder anzupassen, in einem workflow, bei dem die Zuordnung einer Eingabe. Ein Wörterbuch kann lindern diese Bedenken:
```
row = [None, 'This', 'is', 'a', 'filler', 'test', 'string', None]

d = {None: '', 'filler': 'manipulated'}

res = [d.get(x, x) for x in row]

print(res)

['', 'This', 'is', 'a', 'manipulated', 'test', 'string', '']
```
InformationsquelleAutor jpp
0

keine Notwendigkeit für ternäre wenn/dann/sonst. meiner Meinung nach deine Frage fordert diese Antwort:
```
row = [unicode((x or '').strip()) for x in row]
```
InformationsquelleAutor mariotomo
0

"Machen Sie eine Liste von Elementen in einem wiederholenden"

Scheint es am besten zuerst verallgemeinern allen möglichen Formen, anstatt konkrete Antworten auf Fragen. Sonst der Leser nicht weiß, wie die Antwort ermittelt wurde. Hier ein paar generalisierte Formen, die ich dachte, bevor ich bekam Kopfschmerzen versuchen zu entscheiden, wenn eine abschließende else-Klausel verwendet werden könnte, in der letzten form.

[expression1(item) for item in iterierbar]

[expression1(den Punkt) wenn conditional1 für Element in iterierbar]

[expression1(den Punkt) wenn conditional1 else expression2(item) for item in iterierbar]

[expression1(den Punkt) wenn conditional1 else expression2(item) for item in iterierbar, wenn conditional2]

Den Wert "Artikel" muss nicht benutzt werden in der bedingten Klauseln. Ein 'condition3" werden als Schalter verwendet, um entweder fügen oder nicht fügen Sie einen Wert, um die Ausgabe-Liste.

Zum Beispiel, um eine neue Liste erstellen, die beseitigt leere Zeichenfolgen oder Leerzeichen-strings aus der ursprünglichen Liste von strings:

newlist = [s s in firstlist, wenn en.strip()]

InformationsquelleAutor Hewey Dewey

-1

# coding=utf-8

def my_function_get_list():
    my_list = [0, 1, 2, 3, 4, 5]

    # You may use map() to convert each item in the list to a string, 
    # and then join them to print my_list

    print("Affichage de my_list [{0}]".format(', '.join(map(str, my_list))))

    return my_list


my_result_list = [
   (
       number_in_my_list + 4,  # Condition is False : append number_in_my_list + 4 in my_result_list
       number_in_my_list * 2  # Condition is True : append number_in_my_list * 2 in my_result_list
   )

   [number_in_my_list % 2 == 0]  # [Condition] If the number in my list is even

   for number_in_my_list in my_function_get_list()  # For each number in my list
]

print("Affichage de my_result_list [{0}]".format(', '.join(map(str, my_result_list))))

(venv) $ python list_comp.py

Affichage de my_list ein [0, 1, 2, 3, 4, 5]

Affichage de my_result_list [0, 5, 4, 7, 8, 9]

Also, für Sie:
row = [('', unicode(x.strip()))[x is not None] for x in row]

InformationsquelleAutor Trop Freshloïc

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.