Extrahieren und Ersetzen von Elementen, die die Bedingungen einer Liste (Array) von Zeichenketten in Python erfüllen

Um aus einer Liste (Array), deren Elemente Zeichenketten sind, eine neue Liste zu erzeugen, indem nur die Elemente von Zeichenketten extrahiert werden, die bestimmte Bedingungen erfüllen, oder indem Substitutionen, Konvertierungen usw. durchgeführt werden, verwenden Sie List Comprehensions.

Nach einer kurzen Erläuterung von List Comprehensions werden die folgenden Inhalte mit Beispielcode erklärt.

• Extraktion auf der Grundlage, ob eine bestimmte Zeichenfolge enthalten ist oder nicht (Teilübereinstimmung)
• Ersetzen einer bestimmten Zeichenfolge
• Extrahieren durch Starten oder Nichtstarten mit einer bestimmten Zeichenfolge
• Extrahieren nach Endung oder Nicht-Endung mit einer bestimmten Zeichenfolge
• Beurteilt und extrahiert nach Fall
• Groß- und Kleinbuchstaben umwandeln
• Ermittelt, ob alphabetische oder numerische Zeichen verwendet werden, und extrahiert sie
• Mehrere Bedingungen
• (Computer) Regulärer Ausdruck

Beachten Sie, dass Listen verschiedene Datentypen speichern können und sich streng von Arrays unterscheiden. Wenn Sie Arrays in Prozessen behandeln wollen, die Speichergröße und Speicheradressen oder numerische Verarbeitung großer Daten erfordern, verwenden Sie array (Standardbibliothek) oder NumPy.

Notation der Listenaufnahme

Bei der Erzeugung einer neuen Liste aus einer Liste sind Listenauffassungen einfacher zu schreiben als for-Schleifen.

• VERBUNDEN:Wie man Python-Listenauflösungen verwendet

[expression for any variable name in iterable object if conditional expression]

Wenn das Element nur durch einen bedingten Ausdruck ausgewählt werden soll, wird es nicht durch einen Ausdruck verarbeitet, so dass es die folgende Form hat

[variable name for variable name in original list if conditional expression]

Wenn der bedingte Ausdruck if in einen bedingten Ausdruck if not umgewandelt wird, wird er zu einer Negation, und Elemente, die den bedingten Ausdruck nicht erfüllen, können extrahiert werden.

Enthält eine bestimmte Zeichenfolge (Teilübereinstimmung) \ Enthält nicht: in

Bei “bestimmte Zeichenfolge in ursprünglicher Zeichenfolge” wird True zurückgegeben, wenn die ursprüngliche Zeichenfolge die bestimmte Zeichenfolge enthält. Dies ist ein bedingter Ausdruck.

Die Negation von in wird mit not in vorgenommen.

l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']

l_in = [s for s in l if 'XXX' in s]
print(l_in)
# ['oneXXXaaa', 'twoXXXbbb']

l_in_not = [s for s in l if 'XXX' not in s]
print(l_in_not)
# ['three999aaa', '000111222']

Ersetzen einer bestimmten Zeichenfolge

Wenn Sie eine Zeichenkette von Listenelementen ersetzen wollen, verwenden Sie die String-Methode replace() für jedes Element in der Listenauffassungsnotation.

Wenn es keine zu ersetzende Zeichenfolge gibt, muss das Element im bedingten Ausdruck if nicht ausgewählt werden, da es durch die Anwendung von replace() nicht verändert wird.

l_replace = [s.replace('XXX', 'ZZZ') for s in l]
print(l_replace)
# ['oneZZZaaa', 'twoZZZbbb', 'three999aaa', '000111222']

Wenn Sie ein ganzes Element, das eine bestimmte Zeichenfolge enthält, ersetzen wollen, extrahieren Sie es mit in und verarbeiten es mit dem ternären Operator. Der ternäre Operator wird in der folgenden Form geschrieben.
True Value if Conditional Expression else False Value

Es ist in Ordnung, wenn der Ausdrucksteil der Listenauffassungsnotation ein ternärer Operator ist.

l_replace_all = ['ZZZ' if 'XXX' in s else s for s in l]
print(l_replace_all)
# ['ZZZ', 'ZZZ', 'three999aaa', '000111222']

Im Folgenden finden Sie eine Zusammenfassung der Ergebnisse, die in Klammern gesetzt sind. Wenn Sie es nicht gewohnt sind, Klammern zu verwenden, ist es vielleicht einfacher zu verstehen und Fehler zu vermeiden. Grammatikalisch ist es kein Problem, auch wenn Sie Klammern schreiben.

[('ZZZ' if ('XXX' in s) else s) for s in l]

Die Verwendung von in als Bedingung ist im Zusammenhang mit der Listenverständnisnotation in verwirrend, aber es ist nicht schwierig, wenn Sie die syntaktische Form der Listenverständnisnotation und der ternären Operatoren kennen.

Beginnt mit einer bestimmten Zeichenkette \ fängt nicht an: startswith()

Die String-Methode startswith() gibt true zurück, wenn die Zeichenkette mit der im Argument angegebenen Zeichenkette beginnt.

l_start = [s for s in l if s.startswith('t')]
print(l_start)
# ['twoXXXbbb', 'three999aaa']

l_start_not = [s for s in l if not s.startswith('t')]
print(l_start_not)
# ['oneXXXaaa', '000111222']

Endet mit einer bestimmten Zeichenkette \ nicht enden: endswith()

Die String-Methode endswith() gibt true zurück, wenn die Zeichenkette mit der im Argument angegebenen Zeichenkette endet.

l_end = [s for s in l if s.endswith('aaa')]
print(l_end)
# ['oneXXXaaa', 'three999aaa']

l_end_not = [s for s in l if not s.endswith('aaa')]
print(l_end_not)
# ['twoXXXbbb', '000111222']

Beurteilt und extrahiert nach Fall

Die String-Methoden isupper() und islower() können verwendet werden, um festzustellen, ob eine Zeichenkette ganz groß oder ganz klein geschrieben ist.

l_lower = [s for s in l if s.islower()]
print(l_lower)
# ['three999aaa']

Groß- und Kleinbuchstaben umwandeln

Wenn Sie alle Zeichen in Groß- oder Kleinschreibung umwandeln wollen, verwenden Sie die String-Methoden upper() und lower(). Andere Methoden sind capitalize(), die nur den ersten Buchstaben groß schreibt, und swapcase(), die Groß- und Kleinbuchstaben vertauscht.

Wie im obigen Substitutionsbeispiel verwenden Sie den ternären Operator, wenn Sie nur Elemente verarbeiten wollen, die die Bedingung erfüllen.

l_upper_all = [s.upper() for s in l]
print(l_upper_all)
# ['ONEXXXAAA', 'TWOXXXBBB', 'THREE999AAA', '000111222']

l_lower_to_upper = [s.upper() if s.islower() else s for s in l]
print(l_lower_to_upper)
# ['oneXXXaaa', 'twoXXXbbb', 'THREE999AAA', '000111222']

Ermittelt, ob alphabetische oder numerische Zeichen verwendet werden, und extrahiert sie

Die String-Methoden isalpha() und isnumeric() können verwendet werden, um festzustellen, ob eine Zeichenkette ausschließlich aus Buchstaben, Zahlen usw. besteht.

l_isalpha = [s for s in l if s.isalpha()]
print(l_isalpha)
# ['oneXXXaaa', 'twoXXXbbb']

l_isnumeric = [s for s in l if s.isnumeric()]
print(l_isnumeric)
# ['000111222']

Mehrere Bedingungen

Der Teil des bedingten Ausdrucks von Listenauffassungen kann aus mehreren Bedingungen bestehen. Es können auch negative “not”-Bedingungen verwendet werden.

Bei der Verwendung von drei oder mehr bedingten Ausdrücken ist es sicherer, jede Gruppe in Klammern () einzuschließen, da das Ergebnis je nach Reihenfolge variiert.

l_multi = [s for s in l if s.isalpha() and not s.startswith('t')]
print(l_multi)
# ['oneXXXaaa']

l_multi_or = [s for s in l if (s.isalpha() and not s.startswith('t')) or ('bbb' in s)]
print(l_multi_or)
# ['oneXXXaaa', 'twoXXXbbb']

(Computer) Regulärer Ausdruck

Reguläre Ausdrücke ermöglichen eine äußerst flexible Verarbeitung.

Das Match-Objekt, das von re.match() zurückgegeben wird, wenn es passt, wird immer als wahr bestimmt, wenn es mit einem bedingten Ausdruck ausgewertet wird. Wenn es nicht passt, wird None zurückgegeben, was im bedingten Ausdruck false ist. Wenn Sie also nur die Elemente extrahieren möchten, die mit dem regulären Ausdruck übereinstimmen, wenden Sie re.match() wie zuvor auf den Teil des bedingten Ausdrucks des Listenverständnisses an.

import re

l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']

l_re_match = [s for s in l if re.match('.*XXX.*', s)]
print(l_re_match)
# ['oneXXXaaa', 'twoXXXbbb']

re.sub(), das den übereinstimmenden Teil eines regulären Ausdrucks ersetzt, ist ebenfalls nützlich. Um nur die übereinstimmenden Elemente zu extrahieren und zu ersetzen, fügen Sie einfach “if conditional expression” hinzu.

l_re_sub_all = [re.sub('(.*)XXX(.*)', r'\2---\1', s) for s in l]
print(l_re_sub_all)
# ['aaa---one', 'bbb---two', 'three999aaa', '000111222']

l_re_sub = [re.sub('(.*)XXX(.*)', r'\2---\1', s) for s in l if re.match('.*XXX.*', s)]
print(l_re_sub)
# ['aaa---one', 'bbb---two']