if / else na liście

Konkretny problem został już rozwiązany w poprzednich odpowiedziach, więc poruszę ogólną ideę korzystania z warunkow wewnątrz list comprehensions.

Oto przykład, który pokazuje, jak warunkowe mogą być zapisane wewnątrz listy:

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

Zauważ, że na pierwszej liście dla X_non_str Kolejność jest następująca:

wyrażenie na pozycja W iterable if warunek

I na ostatniej liście dla X_str_changed kolejność jest następująca:

ekspresja1 jeśli Stan else ekspresja2 na pozycja W iterable

Zawsze trudno mi pamiętać, że ekspresja1 musi być przed if i ekspresja2 musi być po else. My head wants both to be albo przed, albo po.

Myślę, że jest tak zaprojektowany, ponieważ przypomina normalny język, np. "chcę zostać w środku jeśli pada deszcz, else {[16] } chcę wyjść na zewnątrz"

W prostym języku angielskim dwa wymienione powyżej typy zestawień list można określić jako:

Tylko if:

extract_apple na jabłko W apple_box if apple_is_ripe

I z if/else

mark_apple jeśli apple_is_ripe else leave_it_unmarked na jabłko W apple_box

W Jedną Stronę:

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

row = [change(x) for x in row]

Chociaż wtedy masz:

row = map(change, row)

Lub możesz użyć lambda inline.

Oto kolejny przykład:

>>> print(", ".join(["ha" if i else "Ha" for i in range(3)]) + "!")
Ha, ha, ha!

Wykorzystuje fakt, że if i ocenia na False dla 0 i na True dla wszystkich innych wartości generowanych przez funkcję range(). Dlatego lista jest oceniana w następujący sposób:

>>> ["ha" if i else "Ha" for i in range(3)]
['Ha', 'ha', 'ha']

Inne rozwiązania są świetne dla pojedynczego if / else konstruuj. Jednak trójargumentowe stwierdzenia w obrębie listy są prawdopodobnie trudne do odczytania.

Korzystanie z funkcji ułatwia czytelność, ale takie rozwiązanie jest trudne do rozszerzenia lub dostosowania w obiegu pracy, w którym mapowanie jest wejściem. Słownik może złagodzić te obawy:

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', '']

Ma to związek z tym, jak wykonuje się zrozumienie listy.

Należy pamiętać, co następuje:

[ expression for item in list if conditional ]

Jest równoważne:

for item in list:
    if conditional:
        expression

Gdzie {[4] } jest w nieco innym formacie(pomyśl o zmianie kolejności podmiotu i czasownika w zdaniu).

Dlatego Twój kod [x+1 for x in l if x >= 45] robi tak:

for x in l:
    if x >= 45:
        x+1

Jednak ten kod [x+1 if x >= 45 else x+5 for x in l] robi to (po przestawianiu expression):

for x in l:
    if x>=45: x+1
    else: x+5

Tworzenie listy z elementów w iterable

Wydaje się, że najlepiej najpierw uogólnić wszystkie możliwe formy, a nie udzielać konkretnych odpowiedzi na pytania. W przeciwnym razie czytelnik nie będzie wiedział, w jaki sposób ustalono odpowiedź. Oto kilka uogólnionych form, które wymyśliłem, zanim dostałem bólu głowy, próbując zdecydować, czy ostateczna klauzula else może być używana w ostatniej formie.

[expression1(item)                                        for item in iterable]

[expression1(item) if conditional1                        for item in iterable]

[expression1(item) if conditional1 else expression2(item) for item in iterable]

[expression1(item) if conditional1 else expression2(item) for item in iterable if conditional2]

Wartość item nie musi być używana w żadnej z klauzul warunkowych. A conditional3 może być używany jako przełącznik do dodawania lub nie dodawania wartości do listy wyjściowej.

Na przykład, aby utworzyć nową listę, która eliminuje puste łańcuchy lub białe znaki z oryginalnej listy łańcuchów:

newlist = [s for s in firstlist if s.strip()]

Możesz to zrobić

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

Niektóre składnie do rozumienia listy:

[item if condition else item for item in items]
[f(item) if condition else value for item in items]
[item if condition for item in items]
[value if condition else value1 if condition1 else value2]

Nie ma potrzeby stosowania ternary if / then / else. Moim zdaniem twoje pytanie wymaga tej odpowiedzi:

row = [unicode((x or '').strip()) for x in row]

Można łączyć logikę warunkową w sposób zrozumiały:

 ps = PorterStemmer()
 stop_words_english = stopwords.words('english')
 best = sorted(word_scores.items(), key=lambda x: x[1], reverse=True)[:10000]
 bestwords = set([w for w, s in best])


 def best_word_feats(words):
   return dict([(word, True) for word in words if word in bestwords])

 # with stemmer
 def best_word_feats_stem(words):
   return dict([(ps.stem(word), True) for word in words if word in bestwords])

 # with stemmer and not stopwords
 def best_word_feats_stem_stop(words):
   return dict([(ps.stem(word), True) for word in words if word in bestwords and word not in stop_words_english])

# 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 [0, 1, 2, 3, 4, 5]
Affichage de my_result_list [0, 5, 4, 7, 8, 9]