So prüfen Sie schnell, ob ein Wert in der Python-Liste existiert

  1. in Methode zur Überprüfung der Existenz des Wertes in der Python-Liste
  2. Liste in Set konvertieren und dann die Mitgliedschaftsprüfung in Python durchführen
  3. Performance-Vergleich zwischen List- und Set-Mitgliedschaftsprüfung

Wir werden verschiedene Methoden vorstellen, um zu prüfen, ob ein Wert in der Python-Liste vorhanden ist, und anschließend ihre Performance zu vergleichen.

Die Methoden umfassen,

  1. Methode zur Überprüfung der Mitgliedschaft - in Methode um zu prüfen, ob der Wert existiert
  2. Liste in set konvertieren und dann die Mitgliedschaftsprüfungsmethode in verwenden

in Methode zur Überprüfung der Existenz des Wertes in der Python-Liste

in ist der richtige Weg, die Mitgliedschaft in Python-Liste, Set, Dictionary oder anderen iterierbaren Python-Objekten zu überprüfen.

>>> testList = [1, 2, 3, 4]
>>> 2 in testList
True
>>> 6 in testList
False

Liste in Set konvertieren und dann die Mitgliedschaftsprüfung in Python durchführen

Die Mitgliedschaftsprüfung in der Liste könnte ineffizient sein, wenn die Listengröße zunimmt, insbesondere wenn doppelte Elemente in der Liste vorhanden sind.

Python-Set ist in diesem Szenario ein besserer Datentyp für die Mitgliedschaftsprüfung, da er nur eindeutige Werte enthält.

Performance-Vergleich zwischen List- und Set-Mitgliedschaftsprüfung

Wir werden die Leistungsunterschiede in vier Situationen vergleichen,

  1. Die ursprüngliche Liste hat eindeutige Werte, und der geprüfte Wert ist in der Liste vorhanden
  2. Die ursprüngliche Liste hat eindeutige Werte, und der geprüfte Wert existiert nicht in der Liste.
  3. Die ursprüngliche Liste hat doppelte Werte, und der geprüfte Wert ist in der Liste vorhanden
  4. Die ursprüngliche Liste hat nur doppelte Werte, und der geprüfte Wert existiert nicht in der Liste.

Die ursprüngliche Liste hat nur eindeutige Werte, und der geprüfte Wert existiert in der Liste

Python, ob Wert in der Liste existiert - eindeutige Werte in der Liste und zu prüfender Wert in der list.png

from itertools import chain
import perfplot
import numpy as np

def setupTest(n):
  a = np.arange(n)
  np.random.shuffle(a)
  randomlist = a[:n//2].tolist()
  randomvalue = randomlist[len(randomlist)//2]
  return [randomlist, randomvalue]

def inListMethod(L):
  x, y = L
  return (y in x)

def inSetMethod(L):
  x, y = L
  x = set(x)
  return (y in x)


perfplot.show(
    setup=setupTest,
    kernels=[inListMethod, inSetMethod],
    labels=['in list', 'in set'],
    n_range=[2**k for k in range(1, 20)],
    xlabel='Data Length',
    title='unique values in list and to-be-checked value exists in the list',
    logx=True,
    logy=True)

Die ursprüngliche Liste hat nur eindeutige Werte, und der geprüfte Wert existiert nicht in der Liste

Python, ob Wert in der Liste existiert - eindeutige Werte in der Liste und zu prüfender Wert nicht in der Liste

from itertools import chain
import perfplot
import numpy as np

def setupTest(n):
  a = np.arange(n)
  np.random.shuffle(a)
  randomlist = a[:n//2].tolist()
  randomvalue = n+1
  return [randomlist, randomvalue]

def inListMethod(L):
  x, y = L
  return (y in x)

def inSetMethod(L):
  x, y = L
  x = set(x)
  return (y in x)


perfplot.show(
    setup=setupTest,
    kernels=[inListMethod, inSetMethod],
    labels=['in list', 'in set'],
    n_range=[2**k for k in range(1, 20)],
    xlabel='Data Length',
    title='unique values in list and to-be-checked value does not exist in the list',
    logx=True,
    logy=True)

Die ursprüngliche Liste hat doppelte Werte, und der geprüfte Wert existiert in der Liste

Python, ob Wert in Liste vorhanden ist - doppelte Werte in Liste und zu überprüfender Wert in der Liste vorhanden

from itertools import chain
import perfplot
import numpy as np

def setupTest(n):
  a = np.arange(n)
  np.random.shuffle(a)
  randomlist = np.random.choice(n, n//2).tolist()
  randomvalue = randomlist[len(randomlist)//2]
  return [randomlist, randomvalue]

def inListMethod(L):
  x, y = L
  return (y in x)

def inSetMethod(L):
  x, y = L
  x = set(x)
  return (y in x)


perfplot.show(
    setup=setupTest,
    kernels=[inListMethod, inSetMethod],
    labels=['in list', 'in set'],
    n_range=[2**k for k in range(2, 20)],
    xlabel='Data Length',
    title='duplicate values in list and to-be-checked value exists in the list',
    logx=True,
    logy=True)

Die ursprüngliche Liste hat nur doppelte Werte, und der geprüfte Wert existiert nicht in der Liste

Python, ob Wert in Liste vorhanden ist - doppelte Werte in Liste und zu überprüfender Wert nicht in der Liste vorhanden

from itertools import chain
import perfplot
import numpy as np

def setupTest(n):
  a = np.arange(n)
  np.random.shuffle(a)
  randomlist = np.random.choice(n, n//2).tolist()
  randomvalue = n+1
  return [randomlist, randomvalue]

def inListMethod(L):
  x, y = L
  return (y in x)

def inSetMethod(L):
  x, y = L
  x = set(x)
  return (y in x)


perfplot.show(
    setup=setupTest,
    kernels=[inListMethod, inSetMethod],
    labels=['in list', 'in set'],
    n_range=[2**k for k in range(2, 20)],
    xlabel='Data Length',
    title='duplicate values in list and to-be-checked value does not exist in the list',
    logx=True,
    logy=True)

Schlussfolgerung des Leistungsvergleichs

Obwohl die Mitgliedschaftsprüfung in Python set schneller ist als die in Python list, ist die Konvertierung von list oder set zeitaufwendig. Wenn es sich bei den angegebenen Daten um Python-Listen handelt, hat es daher keine Performance-Vorteile, wenn Sie die Liste zuerst in set konvertieren und dann die Mitgliedschaftsprüfung in set durchführen.

Python, ob Wert in der Liste existiert - Übersicht

from itertools import chain
import perfplot
import numpy as np

def setupTest(n):
  a = np.arange(n)
  np.random.shuffle(a)
  unique_randomlist = a[:n//2].tolist()
  duplicate_randomlist = np.random.choice(n, n//2).tolist()
  existing_randomvalue = unique_randomlist[len(unique_randomlist)//2]
  nonexisting_randomvalue = n+1
  return [unique_randomlist, duplicate_randomlist,
          existing_randomvalue, nonexisting_randomvalue]

def inListMethod_UniqueValue_ValueExisting(L):
  u, d, ex, ne = L
  return (ex in u)

def inListMethod_DuplicateValue_ValueExisting(L):
  u, d, ex, ne = L
  return (ex in d)

def inListMethod_UniqueValue_ValueNotExisting(L):
  u, d, ex, ne = L
  return (ne in u)

def inListMethod_DuplicateValue_ValueNotExisting(L):
  u, d, ex, ne = L
  return (ne in d)

def inSetMethod_UniqueValue_ValueExisting(L):
  u, d, ex, ne = L
  u = set(u)
  return (ex in u)

def inSetMethod_DuplicateValue_ValueExisting(L):
  u, d, ex, ne = L
  d = set(d)                                  
  return (ex in d)

def inSetMethod_UniqueValue_ValueNotExisting(L):
  u, d, ex, ne = L
  u = set(u)                                  
  return (ne in u)

def inSetMethod_DuplicateValue_ValueNotExisting(L):
  u, d, ex, ne = L
  d = set(d)                                  
  return (ne in d)


perfplot.show(
    setup=setupTest,
    equality_check=None,
    kernels=[inListMethod_UniqueValue_ValueExisting,
             inListMethod_DuplicateValue_ValueExisting,
             inListMethod_UniqueValue_ValueNotExisting,
             inListMethod_DuplicateValue_ValueNotExisting,
             inSetMethod_UniqueValue_ValueExisting,
             inSetMethod_DuplicateValue_ValueExisting,
             inSetMethod_UniqueValue_ValueNotExisting,
             inSetMethod_DuplicateValue_ValueNotExisting],
    labels=[ 'inListMethod_UniqueValue_ValueExisting',
             'inListMethod_DuplicateValue_ValueExisting',
             'inListMethod_UniqueValue_ValueNotExisting',
             'inListMethod_DuplicateValue_ValueNotExisting',
             'inSetMethod_UniqueValue_ValueExisting',
             'inSetMethod_DuplicateValue_ValueExisting',
             'inSetMethod_UniqueValue_ValueNotExisting',
             'inSetMethod_DuplicateValue_ValueNotExisting'],
    n_range=[2**k for k in range(2, 20)],
    xlabel='Data Length',
    logx=True,
    logy=True)

Verwandter Artikel - Python List

  • Holen Sie sich den Unterschied zwischen zwei Listen in Python
  • Wie man einzigartige Werte in Python-Liste zählt