Comment vérifier si tous les éléments suivants se trouvent dans une liste ?

Question

J'ai découvert qu'il existe une question connexe sur la manière de déterminer si au moins un élément existe dans une liste :
Comment vérifier si l'un des éléments suivants se trouve dans une liste ?

Mais quelle est la meilleure façon de savoir si tous les éléments d'une liste existent ?

En cherchant dans la documentation, j'ai trouvé cette solution :

>>> l = ['a', 'b', 'c']
>>> set(['a', 'b']) <= set(l)
True
>>> set(['a', 'x']) <= set(l)
False

Une autre solution serait la suivante :

>>> l = ['a', 'b', 'c']
>>> all(x in l for x in ['a', 'b'])
True
>>> all(x in l for x in ['a', 'x'])
False

Mais ici, vous devez taper davantage.

Existe-t-il d'autres solutions ?

Answer 1

Les opérateurs tels que <= en Python ne sont généralement pas modifiées pour signifier quelque chose de significativement différent de "inférieur ou égal à". Il est inhabituel que la bibliothèque standard fasse cela - cela sent l'API héritée pour moi.

Utiliser la méthode équivalente et plus clairement nommée, set.issubset . Notez que vous n'avez pas besoin de convertir l'argument en un ensemble ; il le fera pour vous si nécessaire.

set(['a', 'b']).issubset(['a', 'b', 'c'])

Answer 2

J'utiliserais probablement set de la manière suivante :

set(l).issuperset(set(['a','b'])) 

ou l'inverse :

set(['a','b']).issubset(set(l)) 

Je le trouve un peu plus lisible, mais il est peut-être excessif. Les ensembles sont particulièrement utiles pour calculer l'union/l'intersection/les différences entre les collections, mais ce n'est peut-être pas la meilleure option dans cette situation...

Answer 3

Je préfère ces deux-là parce qu'ils me semblent les plus logiques, le dernier étant le plus court et probablement le plus rapide (illustré ici par l'utilisation de set syntaxe littérale qui a été rétroporté à Python 2.7) :

all(x in {'a', 'b', 'c'} for x in ['a', 'b'])
#   or
{'a', 'b'}.issubset({'a', 'b', 'c'})

Answer 4

Que se passe-t-il si vos listes contiennent des doublons comme celui-ci :

v1 = ['s', 'h', 'e', 'e', 'p']
v2 = ['s', 's', 'h']

Les ensembles ne contiennent pas de doublons. La ligne suivante renvoie donc True.

set(v2).issubset(v1)

Pour compter les doublons, vous pouvez utiliser le code :

v1 = sorted(v1)
v2 = sorted(v2)

def is_subseq(v2, v1):
    """Check whether v2 is a subsequence of v1."""
    it = iter(v1)
    return all(c in it for c in v2) 

La ligne suivante renvoie donc False.

is_subseq(v2, v1)

Answer 5

Ce n'est pas le cas de l'OP, mais - pour tous ceux qui veulent affirmer l'intersection en dicts et que vous avez atterri ici à cause d'une mauvaise recherche sur Google (par exemple, moi) - vous devez travailler avec dict.items :

>>> a = {'key': 'value'}
>>> b = {'key': 'value', 'extra_key': 'extra_value'}
>>> all(item in a.items() for item in b.items())
True
>>> all(item in b.items() for item in a.items())
False

C'est parce que dict.items renvoie des tuples de paires clé/valeur, et comme tout objet en Python, ils sont comparables de manière interchangeable