Skip to content

in-Operator in Python (für Liste, String, Wörterbuch, etc.)

Python

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
  • 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.