
In Python testen die Operatoren in und nicht in die Mitgliedschaft in Listen, Tupeln, Wörterbüchern usw.
Dieser Artikel hat folgenden Inhalt.
- Also verwenden Sie den in-Operator
- Grundlegende Verwendung
- Geprüft, ob sie gleichwertig sind
- Mit der if-Anweisung
- ins Wörterbuch (dict)
- in für die Saite (str)
- nicht in (Negation von in)
- in für mehrere Elemente
- Zeitkomplexität von in
- Langsam für die Liste:
O(n)
- Schnell zum Set:
O(1)
- Für das Wörterbuch
- Langsam für die Liste:
- in in für Statements und List Comprehensions
Das Wort in WIRD auch in für Aussagen und Listenverständnisse verwendet. Nichts finden Sie in den folgenden Artikeln.
Also verwenden Sie den in-Operator
Grundlegende Verwendung
x in y gibt True zurück, wenn x in y enthalten ist, und False, wenn dies nicht der Fall ist.
print(1 in [0, 1, 2])
# True
print(100 in [0, 1, 2])
# False
Nicht nur Liste, sondern auch Tuple, Set, Range und andere iterierbare Objekte können bedient werden.
print(1 in (0, 1, 2))
# True
print(1 in {0, 1, 2})
# True
print(1 in range(3))
# True
Das Wörterbuch (dict) und die Zeichenkette (str) werden später beschrieben.
Geprüft, ob sie gleichwertig sind
Test by basiert darauf, ob die Werte gleich sind oder nicht, sowie ==. Es ist wahr, wenn der Wert gleich ist, auch wenn der Typ unterschiedlich ist.
print(1.0 == 1)
# True
print(1.0 in [0, 1, 2])
# True
print(True == 1)
# True
print(True in [0, 1, 2])
# True
Beachten Sie, dass bool eine Unterklasse von integer int ist, also entsprechen True und False 1 bzw. 0.
Mit der if-Anweisung
in gibt einen boolschen Wert (True, False) zurück und kann direkt in der if-Anweisung verwendet werden.
l = [0, 1, 2]
i = 0
if i in l:
print(f'{i} is a member of {l}.')
else:
print(f'{i} is not a member of {l}.')
# 0 is a member of [0, 1, 2].
l = [0, 1, 2]
i = 100
if i in l:
print(f'{i} is a member of {l}.')
else:
print(f'{i} is not a member of {l}.')
# 100 is not a member of [0, 1, 2].
Beachten Sie, dass Listen, Tupel, Strings usw. als False bewertet Werden, wenn sie leer sind, und als True, wenn sie es nicht sind. Wenn SIE überprüfen möchten, ob ein Objekt leer ist oder nicht, can SIE das Objekt so verwenden, wie es ist.
l = [0, 1, 2]
if l:
print(f'{l} is not empty.')
else:
print(f'{l} is empty.')
# [0, 1, 2] is not empty.
l = []
if l:
print(f'{l} is not empty.')
else:
print(f'{l} is empty.')
# [] is empty.
Siehe auch die following Artikel für Wahrheitswerttests für jeden Typ.
ins Wörterbuch (dict)
Der Betrieb für das Wörterbuch (dict) testet auf der Taste.
d = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}
print('key1' in d)
# True
print('value1' in d)
# False
Verwenden Sie values(), items(), wenn Sie Werte oder Schlüssel-Wert-Paare testen möchten.
print('value1' in d.values())
# True
print(('key1', 'value1') in d.items())
# True
print(('key1', 'value2') in d.items())
# False
Nichts finden Sie im folgenden Artikel.
in für die Saite (str)
Die In-Operation für den String (str) testet die Existenz eines Teilstrings.
print('a' in 'abc')
# True
print('x' in 'abc')
# False
print('ab' in 'abc')
# True
print('ac' in 'abc')
# False
nicht in (Negation von in)
x nicht in y gibt die Negation von x in y zurück.
print(10 in [1, 2, 3])
# False
print(10 not in [1, 2, 3])
# True
Dasselbe Ergebnis WIRD durch Hinzufügen von nicht zum gesamten Eingang zurückerstattet.
print(not 10 in [1, 2, 3])
# True
Wenn Sie jedoch nicht zum gesamten Vorgang hinzufügen, wird dies auf zwei Arten interpretiert, wie unten gezeigt, daher wird empfohlen, das explizitere nicht in zu verwenden.
print(not (10 in [1, 2, 3]))
# True
print((not 10) in [1, 2, 3])
# False
Da in einem höheren Vorrang hat als Nicht, wird es als ersteres behandelt, wenn keine Klammern vorhanden sind.
Der letzte Fall wird wie folgt erkannt.
print(not 10)
# False
print(False in [1, 2, 3])
# False
in für mehrere Elemente
Wenn SIE überprüfen möchten, ob mehrere Elemente enthalten sind, funktioniert die Verwendung einer Liste dieser Elemente wie folgt nicht. Es wird getestet, ob die Liste selbst enthalten ist oder nicht.
print([0, 1] in [0, 1, 2])
# False
print([0, 1] in [[0, 1], [1, 0]])
# True
Verwenden Sie und, oder oder Sets.
Verwenden Sie und, oder
Kombinieren Sie mehrere in Operationen mit und und oder. Es WIRD GETESTET, ob beides oder eines von beiden enthalten ist.
l = [0, 1, 2]
v1 = 0
v2 = 100
print(v1 in l and v2 in l)
# False
print(v1 in l or v2 in l)
# True
print((v1 in l) or (v2 in l))
# True
Da in und nicht im Vorrang vor und oder haben, sind Klammern unnötig. Wenn es schwer zu lesen ist, können Sie es natürlich wie im letzten Beispiel in Klammern setzen.
Satz verwenden
Wenn SIE viele Elemente überprüfen möchten, ist es, sterben Menge zu verwenden als und, oder.
Ob Liste A beispielsweise alle Elemente von Liste B enthält, ist äquivalent dazu, ob Liste B eine Teilmenge von Liste A ist.
l1 = [0, 1, 2, 3, 4]
l2 = [0, 1, 2]
l3 = [0, 1, 5]
l4 = [5, 6, 7]
print(set(l2) <= set(l1))
# True
print(set(l3) <= set(l1))
# False
Ob Liste A die Elemente von Liste B nicht enthält, ist äquivalent dazu, ob Liste A und Liste B teilerfremd sind.
print(set(l1).isdisjoint(set(l4)))
# True
Wenn Liste A und Liste B nicht teilerfremd sind, bedeutet dies, dass Liste A mindestens ein Element von Liste B enthält.
print(not set(l1).isdisjoint(set(l3)))
# True
Zeitkomplexität von in
Die Ausführungsgeschwindigkeit des Operators hängt vom Typ des Zielobjekts ab.
Die Messergebnisse der Ausführungszeit von in für Listen, Mengen und Wörterbücher werden unten angezeigt.
Beachten Sie, dass der folgende Code den magischen Jupyter Notebook-Befehl %%timeit used und nicht funktioniert, wenn er als Python-Skript ausgeführt WIRD.
Informationen zur Zeitkomplexität finden Sie im following Artikel.
Nehmen Sie als Beispiel eine Liste mit 10 Elementen und 10000 Elementen.
n_small = 10
n_large = 10000
l_small = list(range(n_small))
l_large = list(range(n_large))
Der folgende Beispielcode WIRD in CPython 3.7.4 ausgeführt, und natürlich can sterben Ergebnisse je nach Umgebung variieren.
Langsam für die Liste: O(n)
Die durchschnittliche Zeitkomplexität des In-Operators für Listen ist O(n). Es wird langsamer, wenn viele Elemente vorhanden sind.
%%timeit
-1 in l_small
# 178 ns ± 4.78 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)
%%timeit
-1 in l_large
# 128 µs ± 11.5 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
Die Ausführungszeit variiert stark je nach Position des zu suchenden Wertes. Es dauert am längsten, wenn sein Wert am Ende ist oder nicht existiert.
%%timeit
0 in l_large
# 33.4 ns ± 0.397 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
%%timeit
5000 in l_large
# 66.1 µs ± 4.38 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
%%timeit
9999 in l_large
# 127 µs ± 2.17 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)
Schnell zum Satz: O(1)
Die durchschnittliche Zeitkomplexität des In-Operators für Mengen ist O(1). Es kommt nicht auf die Anzahl der Elemente an.
s_small = set(l_small)
s_large = set(l_large)
%%timeit
-1 in s_small
# 40.4 ns ± 0.572 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
%%timeit
-1 in s_large
# 39.4 ns ± 1.1 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
Die Ausführungszeit ändert sich nicht in Abhängigkeit von dem zu suchenden Wert.
%%timeit
0 in s_large
# 39.7 ns ± 1.27 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
%%timeit
5000 in s_large
# 53.1 ns ± 0.974 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
%%timeit
9999 in s_large
# 52.4 ns ± 0.403 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
Wenn Sie den Vorgang für eine Liste mit vielen Elementen wiederholen möchten, ist es schneller, sie im Voraus in einer Menge umzuwandeln.
%%timeit
for i in range(n_large):
i in l_large
# 643 ms ± 29.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
%%timeit
s_large_ = set(l_large)
for i in range(n_large):
i in s_large_
# 746 µs ± 6.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Beachten Sie, dass das Konvertieren Einer Liste in einer Menge einige Zeit in Anspruch nimmt. Daher kann es schneller sein, sie als Liste beizubehalten, wenn die Anzahl der In-Operationen gering ist.
Für das Wörterbuch
Nehmen Sie das folgende Wörterbuch als Beispiel.
d = dict(zip(l_large, l_large))
print(len(d))
# 10000
print(d[0])
# 0
print(d[9999])
# 9999
Wie oben erwähnt, werden die im Betrieb für die Wörterbuchtests auf Tasten.
Der Schlüssel des Wörterbuchs ist ebenso wie die Menge ein eindeutiger Wert, und die Ausführungszeit ist ungefähr dieselbe wie für Mengen.
%%timeit
for i in range(n_large):
i in d
# 756 µs ± 24.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
Wörterbuch dürfen Werte wie eine Liste dupliziert werden. Die Ausführungszeit von in for values() ist ungefähr die gleiche wie für Listen.
dv = d.values()
%%timeit
for i in range(n_large):
i in dv
# 990 ms ± 28.8 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
Schlüssel-Wert-Paare sind eindeutig. Die Ausführungszeit von in for items() beträgt etwa set + α.
di = d.items()
%%timeit
for i in range(n_large):
(i, i) in di
# 1.18 ms ± 26.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
in in für Statements und List Comprehensions
Das Wort in WIRD auch in für Aussagen und Listenverständnisse verwendet.
l = [0, 1, 2]
for i in l:
print(i)
# 0
# 1
# 2
print([i * 10 for i in l])
# [0, 10, 20]
In den following Artikeln FINDEN SIE Laptops zu for-Anweisungen und Listenverständnissen.
Hinweis SIE, dass der in-Operator als Bedingung in Listenverständnissen used Werden can, was verwirrend IST.
l = ['oneXXXaaa', 'twoXXXbbb', 'three999aaa', '000111222']
l_in = [s for s in l if 'XXX' in s]
print(l_in)
# ['oneXXXaaa', 'twoXXXbbb']
Das erste in ist für die Listenverständnisse und das zweite in ist der In-Operator.