Comment vérifier rapidement si une valeur existe dans une liste Python

  1. Méthode in pour vérifier l’existence de la valeur dans la liste Python
  2. Convertir la liste en set et ensuite faire la vérification de l’appartenance en Python
  3. Comparaison des performances entre le contrôle d’appartenance de la liste et de l’ensemble

Nous allons présenter différentes méthodes pour vérifier si une valeur existe dans la liste Python et comparer leurs performances.

Les méthodes comprennent,

  1. Méthode de vérification de l’appartenance - in Method pour vérifier si la valeur existe
  2. Convertissez la liste en set et utilisez ensuite la méthode de vérification de l’appartenance in.

Méthode in pour vérifier l’existence de la valeur dans la liste Python

in est la bonne façon de faire la vérification des membres dans les listes Python, les ensembles, les dictionnaires ou autres objets Python itérables.

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

Convertir la liste en set et ensuite faire la vérification de l’appartenance en Python

Le contrôle des membres dans la liste pourrait être inefficace si la taille de la liste augmente, surtout s’il y a des éléments en double dans la liste.

Le set Python est un meilleur type de données dans ce scénario pour effectuer le contrôle d’appartenance car il ne contient que des valeurs uniques.

Comparaison des performances entre le contrôle d’appartenance de la liste et de l’ensemble

Nous allons comparer les différences de rendement dans quatre situations,

  1. La liste d’origine a des valeurs uniques et la valeur de contrôle existe dans la liste
  2. La liste originale a des valeurs uniques, et la valeur cochée n’existe pas dans la liste
  3. La liste originale a des valeurs en double, et la valeur vérifiée existe dans la liste
  4. La liste originale n’a que des valeurs dupliquées, et la valeur cochée n’existe pas dans la liste

La liste d’origine n’a que des valeurs uniques et la valeur de contrôle existe dans la liste

Python si la valeur existe dans la liste - les valeurs uniques dans la liste et la valeur à vérifier existent dans le fichier 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)

La liste originale n’a que des valeurs uniques, et la valeur vérifiée n’existe pas dans la liste

Python si la valeur existe dans la liste - les valeurs uniques dans la liste et la valeur à vérifier n'existent pas dans la 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)

La liste originale a des valeurs en double et la valeur de contrôle existe dans la liste

Python si la valeur existe dans la liste - les valeurs en double dans la liste et la valeur à vérifier existent dans la liste

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)

La liste originale n’a que des valeurs dupliquées, et la valeur cochée n’existe pas dans la liste

Python si la valeur existe dans la liste - les valeurs en double dans la liste et la valeur à vérifier n'existent pas dans la liste

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)

Conclusion de la comparaison des performances

Bien que la vérification des membres dans Python set soit plus rapide que celle dans Python list, la conversion depuis list ou set prend du temps. Par conséquent, si les données données sont des listes Python, il n’y a pas de gain de performance si vous convertissez d’abord la liste en set et que vous faites ensuite le contrôle d’appartenance dans set.

Python si la valeur existe dans la liste - vue d'ensemble

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)

Article connexe - Python List

  • Quelle est la différence entre les méthodes de liste append et extend
  • Comment convertir une liste en chaîne de caractères en Python
  • Comment concaténer deux ou plusieurs listes en Python
  • Quelle est la différence entre del, remove et pop sur les listes Python
  • Comment dédupliquer une liste en Python
  • Comment aplatir une liste en Python
  • Comment créer une liste avec une taille spécifique en Python
  • comments powered by Disqus